In a lazy (or non-strict) language, the arguments to a function are not evaluated before calling the function. Instead, the arguments are suspended and only evaluated by the function if needed.
Standard ML is an eager (or strict) language, not a lazy language. However, it is easy to delay evaluation of an expression in SML by creating a thunk, which is a nullary function. In SML, a thunk is written fn () => e. Another essential feature of laziness is memoization, meaning that once a suspended argument is evaluated, subsequent references look up the value. We can express this in SML with a function that maps a thunk to a memoized thunk.
signature LAZY = sig val lazy: (unit -> 'a) -> unit -> 'a end
This is easy to implement in SML.
structure Lazy: LAZY = struct fun lazy (th: unit -> 'a): unit -> 'a = let datatype 'a lazy_result = Unevaluated of (unit -> 'a) | Evaluated of 'a | Failed of exn val r = ref (Unevaluated th) in fn () => case !r of Unevaluated th => let val a = th () handle x => (r := Failed x; raise x) val () = r := Evaluated a in a end | Evaluated a => a | Failed x => raise x end end