CODEWITHSUNDEEP
functional-programmingocamllazy-evaluation
Chris
Chris

Reputation: 963

OCaml lazy evaluation: 'a lazy_t vs unit -> 'a

Both achieve the same thing

# let x = fun () -> begin print_endline "Hello"; 1 end;;
val x : unit -> int = <fun>
# x ();;
Hello
- : int = 1
# let y = lazy begin print_endline "World"; 2 end;;
val y : int lazy_t = <lazy>
# Lazy.force y;;
World
- : int = 2

Is there any reason one should be preferred over the other? Which one is more efficient?

Upvotes: 6

Views: 851

Answers (2)

V. Michel
V. Michel

Reputation: 1619

Lazy.force returns the same value again without recomputing it.

Exemple

let ra = ref 0 ;;
let y = lazy (ra:= !ra+1);;
Lazy.force y;;
# Lazy.force y;;
- : unit = ()
# !ra;;
- : int = 1
# Lazy.force y;;
- : unit = ()
# !ra;;
- : int = 1

Upvotes: 2

ivg
ivg

Reputation: 35210

First of all, they do not behave the same, try to do Lazy.force y yet another time, and you will notice the difference, the "World" message is no longer printed, so the computation is not repeated, as the result was remembered in the lazy value.

This is the main difference between lazy computations and thunks. They both defer the computation until the time when they are forced. But the thunk will evaluate its body every time, where the lazy value will be evaluated once, and the result of the computation will be memoized.

Underneath the hood, the lazy value is implemented as a thunk object with a special flag. When runtime first calls the lazy value, it substitutes the body of the thunk with the result of computation. So, after the first call to Lazy.force y, the y object actually became an integer 2. So the consequent calls to Lazy.force do nothing.

Upvotes: 8

Related Questions