sig
val blank : ?
val binop : (int * int -> int) -> ?
val unop : (int -> int) -> ?
val const : int -> ?
val eval : ?
end
and implement it in a structure S such that the following makes sense:
open S (* expression with holes: [ ] + (~[ ] + (2 * [ ])) *) val f = eval (binop (op+) blank (binop (op+) (unop (op~) blank) (binop (op *) blank (const 2)))) val _ = print (Int.toString (f 100 2 3000)) (* prints 100 + (~2 + (2 * 3000)) = 6098 *) val _ = print "\n"
What's going on here is f builds up an expression tree out of binary and unary operators and integer constants and blank holes, calls eval on it, and this has the type
int -> int -> int -> int
which is a curried type with three integer arguments, equal to the number of occurrences of "blank" in the definition of f.
But how can you get eval to have a type that always has one curried argument for each blank, and in fact evaluates the right expression?
The essential trick is taken from some Janest code sean showed me as a hint:
https://bitbucket.org/yminsky/ocaml-core/src/8808e3a2571f/base/core/extended/lib/core_command.mli
I think it's a really cute cps-y thing to do. I think I remember this sort of thing being done to make a type-safe printf.
structure S :>
sig
type ('a, 'b) t
val blank : (int -> 'a, 'a) t
val binop : (int * int -> int) -> ('a, 'b) t -> ('b, 'c) t -> ('a, 'c) t
val unop : (int -> int) -> ('a, 'b) t -> ('a, 'b) t
val const : int -> ('a, 'a) t
val eval : ('a, int) t -> 'a
end
=
struct
type ('a, 'b) t = (int -> 'b) -> 'a
fun blank x = x
fun binop f t1 t2 k = t1 (fn x => t2 (fn y => k (f (x, y))))
fun unop f t k = t (fn x => k (f x))
fun const n k = k n
fun eval f = f (fn x => x)
end
structure T =
struct
open S
val f = eval (binop (op+) blank (binop (op+) (unop (op~) blank) (binop (op * ) blank (const 2))))
val _ = print (Int.toString (f 100 2 3000))
val _ = print "\n"
end
