User loginNavigation 
Does these constructs solve the expression problem?While thinking about the expression problem and toying with (toy) language design, a simple solution to the problem came to mind. The expression problem is about extending datatypes and adding functions without recompiling the orignal code, so why not have a simple construct to extend each of these? Every time you add a constructor to an algebraric datatype, you need to extend each of the functions on the type with a case covering the constructor. The two construcs are thus: 1) extend a datatype and 2) extend a function. Addition of completely new functions comes for free in a functional setting. Here is some pseudocode illustrating the idea: # declare a new algebraric datatype Expr with one constructor type Expr: case CONST(Int) # declare a new function eval function eval Expr > Int: case CONST(x): x # extend the algebraric datatype Expr with another constructor extend type Expr: case ADD(Expr, Expr) # extend the function eval with another case extend function eval Expr > Int: case ADD(x, y): eval(x) + eval(y) # declare an additional operation on Expr function toString Expr > String: case CONST(x): intToString(x) case ADD(x, y): eval(x) ++ "+" ++ eval(y) I realize that the implementation of extendable functions would need indirection (so no inlining), but other than that I don't see any problems with it. My formal education in PL theory is very limited still, and I'd appreciate any comments that visualize weakness in the above constructs, or any references to languages that have similar constructs. By Ahnfelt at 20070525 13:03  LtU Forum  previous forum topic  next forum topic  other blogs  4310 reads

Browse archivesActive forum topics 
Recent comments
1 hour 52 min ago
4 hours 41 min ago
5 hours 17 min ago
6 hours 7 min ago
12 hours 43 min ago
12 hours 49 min ago
13 hours 5 min ago
1 day 1 hour ago
1 day 5 hours ago
1 day 7 hours ago