Hi,

I am wondering what would be the efforts to *JIT* an evaluation loop with some constant arguments?

I would expect it to be simpler and have less dependencies than full OCaml compilation code. Maybe it already exists off-the-shelf in the compiler.

Here is a basic example:

```
type op = A | B
let eval_a x = x + 1
let eval_b x = x + x
let rec eval x = function
| [] -> x
| A :: l -> eval (eval_a x) l
| B :: l -> eval (eval_b x) l
let const_eval x = eval x [ B; A; B; A ]
```

With *JIT*, I would like to achieve what would have been the result of the compilation of the following:

```
let const_eval x =
let x1 = eval_b x in
let x2 = eval_a x1 in
let x3 = eval_b x2 in
eval_a x3
```

I think it would mainly require three primitives – `lambda`

, `apply`

and `return`

– in order to create *custom jit functions*:

```
type 'a t
val lambda : ('a t -> 'b t) -> ('a -> 'b) t
val apply : ('a -> 'b) -> 'a t -> 'b t
val return : 'a t -> 'a
```

```
let comp_eval l : int -> int =
let rec unroll l x = match l with
| [] -> x
| A :: l -> unroll l (apply eval_a x)
| B :: l -> unroll l (apply eval_b x) in
return (lambda (unroll l))
```

```
let const_eval = comp_eval [ B; A; B; A ]
```

Regards,