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 pseudo-code 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 2007-05-25 13:03 | LtU Forum | previous forum topic | next forum topic | other blogs | 5565 reads
|
Browse archivesActive forum topics |
Recent comments
7 weeks 3 hours ago
7 weeks 1 day ago
7 weeks 3 days ago
14 weeks 3 days ago
20 weeks 1 day ago
20 weeks 2 days ago
21 weeks 1 day ago
23 weeks 6 days ago
25 weeks 2 days ago
25 weeks 2 days ago