Haskell s Take on the Expression Problem

Transcription

1 Haskell s Take on the Expression Problem Ralf Lämmel Universität Koblenz-Landau, Software Languages Team, Koblenz, Germany joint work with Oleg Kiselyov Fleet Numerical Meteorology and Oceanography Center, Monterey, CA 1

2 Elevator speech Suppose you have some data variants (say apples and oranges ) and you have some operations on such data (say drink and squeeze ), how would you go about the design of data and operations so that you can hopefully add new data variants and new operations later on? 2

3 Expression problem: Why the name? Consider such data: Expressions as in programming languages: Literals Addition Consider such operations: Pretty print expressions Evaluate expressions Consider such extension scenarios: Add another expression form Cases for all existing operations must be added. Add another operation Cases for all existing expression forms must be added. The name goes back to Phil Wadler who defined the expression problem in an sent to mailing lists and individuals in November

4 Expression problem: What problem? In basic OO programming: It is easy to add new data variants. It is hard to add new operations. In basic functional programming: It is easy to add new operations. It is hard to add new data variants. In OO programming with visitors:... It is easy to add new operations. It is hard to add new data variants. 4

5 Data extensibility based on simple inheritance class Expr: The base class of all expression forms Virtual methods: method prettyprint: operation for pretty-printing method evaluate: operation for expression evaluation Subclasses: class Lit: The expression form of "literals" class Add: The expression form of "addition"... Data extensibility 5

6 The class rooting all data variants /** * The base class of all expression forms */ public abstract class Expr { /* * Operation for pretty printing */ public abstract String prettyprint(); /* * Operation for expression evaluation */ public abstract int evaluate(); Beware of code bloat! 6

7 /** * The expression form of "literals" (i.e., constants) */ public class Lit extends Expr { private int info; public int getinfo() { return info; public void setinfo(int info) { this.info = info; public String prettyprint() { return Integer.toString(getInfo()); public int evaluate() { return getinfo(); Beware of code bloat! A class for a data variant 7

8 /** * The expression form of "addition" */ public class Add extends Expr { That is, another data variant but with the same operations. private Expr left, right; public Expr getleft() { return left; public void setleft(expr left) { this.left = left; public Expr getright() { return right; public void setright(expr right) { this.right = right; public String prettyprint() {... public int evaluate() { return getleft().evaluate() + getright().evaluate(); Beware of code bloat! 8

9 /** * The expression form of "negation" */ public class Neg extends Expr { That is, yet another data variant but, again, with the same operations. private Expr expr; public Expr getexpr() { return expr; public void setexpr(expr expr) { this.expr = expr; public String prettyprint() { return "-(" + getexpr().prettyprint() + ")"; public int evaluate() { return - getexpr().evaluate(); Beware of code bloat! 9

10 Operation extensibility based on public data and pattern matching data type Expr: The union of all expression forms Public constructors: Lit: The expression form of "literals" Add: The expression form of "addition" Functions defined by pattern matching on Expr: function prettyprint: operation for pretty-printing function evaluate: operation for expression evaluation... Operation extensibility 10

11 Algebraic data types of Haskell are closed! module Data where -- A data type of expression forms 2 constructor components data Exp = Lit Int Add Exp Exp Algebraic data type Constructor Constructor component Constructor 11

12 A new module can be designated to each new operation. module PrettyPrinter where import Data Argument type -- Operation for pretty printing Result type side effect prettyprint :: Exp -> IO () prettyprint (Lit i) = putstr (show i) prettyprint (Add l r) = do prettyprint l; putstr " + "; prettyprint r Operation defined by case discrimination 12

13 Another operation; another module. module Evaluator where import Data -- Operation for expression evaluation evaluate :: Exp -> Int evaluate (Lit i) = i evaluate (Add l r) = evaluate l + evaluate r 13

14 Operation extensibility based on visitors class Expr: The base class of all expression forms Subclasses as before. Virtual methods: Accept a visitor ( apply an operation ) Visitors: class PrettyPrinter: operation for pretty-printing class Evaluator: operation for expression evaluation... Operation extensibility 14

15 Domain operations are no longer hosted in domain classes. /** * The base class of all expression forms */ public abstract class Expr { /* * Accept a visitor (i.e., apply an operation) */ public abstract <R> R accept(visitor<r> v); 15

16 Requires folklore knowledge on design patterns. /** * A concrete visitor describe a concrete operation on expressions. * There is one visit method per type in the class hierarchy. */ public abstract class Visitor<R> { public abstract R visit(lit x); public abstract R visit(add x); public abstract R visit(neg x); 16

17 One visitor-enabled data variant. /** * The expression form of "literals" (i.e., constants) */ public class Lit extends Expr { private int info; public int getinfo() { return info; public void setinfo(int info) { this.info = info; public <R> R accept(visitor<r> v) { return v.visit(this); 17

18 /** * The expression form of "addition" */ public class Add extends Expr { Another visitor-enabled data variant. private Expr left, right; public Expr getleft() { return left; public void setleft(expr left) { this.left = left; public Expr getright() { return right; public void setright(expr right) { this.right = right; public <R> R accept(visitor<r> v) { return v.visit(this); Beware of code bloat! 18

19 Yet another visitor-enabled data variant. /** * The expression form of "negation" */ public class Neg extends Expr { private Expr expr; public Expr getexpr() { return expr; public void setexpr(expr expr) { this.expr = expr; public <R> R accept(visitor<r> v) { return v.visit(this); Beware of code bloat! 19

20 /** * Operation for pretty printing */ public class PrettyPrinter extends Visitor<String> { public String visit(lit x) { return Integer.toString(x.getInfo()); public String visit(add x) { return x.getleft().accept(this) + " + " + x.getright().accept(this); public String visit(neg x) { return "- (" + x.getexpr().accept(this) + ")"; Beware of code bloat! An operation represented as a concrete visitor. 20

21 Another operation represented as a concrete visitor. /** * Operation for expression evaluation */ public class Evaluator extends Visitor<Integer> { public Integer visit(lit x) { return x.getinfo(); public Integer visit(add x) { return x.getleft().accept(this) + x.getright().accept(this); public Integer visit(neg x) { return - x.getexpr().accept(this); Beware of code bloat! 21

22 A final Java experiment: poor men s full extensibility We use instanceof tests and casts to dispatch functionality on data. We use a specific exception and try-catch blocks to extend operations. We encapsulate operations in objects so that extensions are self-aware. This is approach is weakly typed. In particular, there is no guarantee that we have covered all cases. 22

23 Domain classes are nothing but data capsules. public abstract class Expr { public class Lit extends Expr { private int info; public int getinfo() { return info; public void setinfo(int info) { this.info = info; public class Add extends Expr { private Expr left, right; public Expr getleft() { return left; public void setleft(expr left) { this.left = left; public Expr getright() { return right; public void setright(expr right) { this.right = right; 23

24 public class EvaluatorBase { We simulate pattern matching by instanceof and cast. public int evaluate(expr e) { if (e instanceof Lit) { Lit l = (Lit)e; return l.getinfo(); if (e instanceof Add) { Add a = (Add)e; return evaluate(a.getleft()) + evaluate(a.getright()); throw new FallThrouhException(); We anticipate failure of such operations as a means to compose them. 24

25 public class EvaluatorExtension extends EvaluatorBase { An extended operation first attempts the basic implementation. public int evaluate(expr e) { try { return super.evaluate(e); catch (FallThrouhException x) { if (e instanceof Neg) { Neg n = (Neg)e; return -evaluate(n.getexpr()); throw new FallThrouhException(); Recursive calls are properly dispatched through this to the extended operation. 25

26 The notion of extensibility The initial system I: Provides operations o 1,, o m. Handles data variants d 1,, d n. Consider any number of extensions e 1,, e k : e i could be a data extension: Introduce a new data variant. Provide cases for all existing operations. e i could be an operation extension: Introduce a new operation. Provide cases for all existing data variants. Any extension can be factored into such primitive ones. The fully extended system e k ( (e 1 (I))) 26

27 More on extensibility Code-level extensibility: Extensions can be modeled as code units. Existing code units are never edited or cloned. Separate compilation: The extensions are compiled separately. Statically type-checked extensibility: The extension are statically type-checked separately. 27

28 Solutions of the expression problem Open classes in more dynamic languages (Smalltalk, etc.) Extensible predicates in Prolog (code-level extensibility only) Java, C# & Co. Clever encodings (Torgersen, ECOOP 2004) AOP-like Open classes (introductions).net-like partial classes (code-level extensibility only) Expanders (Warth et al., OOPSLA 2006) JavaGI (Wehr et al., ECOOP 2007)... 28

29 Haskell supernatural type system at work: full extensibility based on type classes Open (extensible) datatypes Haskell 98 is sufficient at this point! Designate one type constructor per original data constructor. Use a type class to describe the open union of data constructors. Open (extensible) functions Designate one type class per operation. Designate one instance of that class per data variant. See also Lämmel and Ostermann s GPCE '06 paper: Software extension and integration with type classes 29

30 The initial data variants data Exp = Lit Int Add Exp Exp module DataBase where Non-extensible Extensible -- Data variants for literals and addition data Lit = Lit Int data Add l r = Add l r One designated data type per data variant -- The open union of data variants class Exp x instance Exp Lit instance Exp (Add l r) Type class ( set of types ) Type-class instances 30

31 The initial data variants data Exp = Lit Int Add Exp Exp module DataBase where Non-extensible Extensible -- Data variants for literals and addition data Lit = Lit Int data Add l r = Add l r -- The open union of data variants That s not precise! class Exp x instance Exp Lit instance Exp (Add l r) 31

32 The initial data variants data Exp = Lit Int Add Exp Exp module DataBase where Non-extensible Extensible -- Data variants for literals and addition data Lit = Lit Int data Add l r = Add l r -- The open union of data variants Constraints for operands of add class Exp x instance Exp Lit instance (Exp l, Exp r) => Exp (Add l r) 32

33 The initial data variants data Exp = Lit Int Add Exp Exp module DataBase where Non-extensible Extensible -- Data variants for literals and addition data Lit = Lit Int data (Exp l, Exp r) => Add l r = Add l r -- The open union of data variants Constraints for operands of add class Exp x instance Exp Lit instance (Exp l, Exp r) => Exp (Add l r) 33

34 Fact sheet on single-parameter type classes Type class = nominal set of types with common operations (Type-class) instances add a type to the set To be seen! define operations specifically for the type at hand Comparison to Java/C# interfaces Interfaces are implemented with classes. Instances may be added retroactively. 34

35 The initial pretty printing operation prettyprint :: Exp -> IO () prettyprint (Lit i) = putstr (show i) prettyprint (Add l r) = do prettyprint l; putstr " + "; prettyprint r module PrettyPrinterBase where import DataBase Non-extensible Extensible -- Operation for pretty printing class Exp x => PrettyPrint x where prettyprint :: x -> IO () instance PrettyPrint Lit where prettyprint (Lit i) = putstr (show i) A type class for pretty-printing all expressions The operation is a member of the type class instance (PrettyPrint l, PrettyPrint r) => PrettyPrint (Add l r) where prettyprint (Add l r) = do prettyprint l; putstr " + "; prettyprint r 35

36 The initial evaluation operation evaluate :: Exp -> Int evaluate (Lit i) = i evaluate (Add l r) = evaluate l + evaluate r module EvaluatorBase where Non-extensible Extensible import DataBase -- Operation for expression evaluation class Exp x => Evaluate x where evaluate :: x -> Int instance Evaluate Lit where evaluate (Lit i) = i 36 instance (Evaluate l, Evaluate r) => Evaluate (Add l r) where evaluate (Add l r) = evaluate l + evaluate r

37 A data extension module DataExtension where import DataBase import PrettyPrinterBase import EvaluatorBase -- Data extension for negation data Exp x => Neg x = Neg x instance Exp x => Exp (Neg x) -- Extending operation for pretty printing instance PrettyPrint x => PrettyPrint (Neg x) where prettyprint (Neg x) = do putstr "(- "; prettyprint x; putstr ")" -- Extending operation for expression evaluation instance Evaluate x => Evaluate (Neg x) where evaluate (Neg x) = 0 - evaluate x 37

38 An operation extension: class Show x where show :: x -> String show expressions in prefix notation module OperationExtension1 where import DataBase import DataExtension Type class Show is predefined. instance Show Lit where show (Lit i) = "Lit " ++ show i instance (Exp x, Exp y, Show x, Show y) => Show (Add x y) where show (Add x y) = "Add (" ++ show x ++ ") (" ++ show y ++ ")" instance (Exp x, Show x) => Show (Neg x) where show (Neg x) = "Neg (" ++ show x ++ ")" 38

39 Another operation extension: treealize expression terms module OperationExtension2 where > totree $ Add (Lit 1) (Lit 2) Node "Add" [Node "Lit" ["1"], Node "Lit" ["2"]] import Data.Tree import DataBase import DataExtension class ToTree x where totree :: x -> Tree String instance ToTree Lit where totree (Lit i) = Node "Lit" [] instance (Exp x, Exp y, ToTree x, ToTree y) => ToTree (Add x y) where totree (Add x y) = Node "Add" [totree x, totree y] instance (Exp x, ToTree x) => ToTree (Neg x) where totree (Neg x) = Node "Neg" [totree x] 39

40 Noteworthy Haskell constructs and idioms covered. (This is merely a check list: all of these constructs and idioms should have been explained through the previous slides.) Algebraic data types Pattern matching (Data) constructors Type constructors Constrained type constructors (Single-parameter) type classes Type-class instances Instance constraints Type-class-bounded polymorphism Super-class constraints Type-class-based open data types Modules Haskell 98 has bee sufficient so far! 40

41 Summary The Expression Problem and software extension Dimensions of software extensibility Data extensibility Operation extensibility Major qualities Discussed Code-level extensibility (Soft) static type checking Separate compilation / deployment Not discussed Performance ( No distributed fat ) Configurability 41