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  4427 reads

Browse archivesActive forum topics 
Recent comments
6 hours 33 min ago
8 hours 30 min ago
16 hours 11 min ago
16 hours 14 min ago
16 hours 54 min ago
17 hours 13 min ago
1 day 1 hour ago
1 day 3 hours ago
1 day 4 hours ago
1 day 5 hours ago