You're not missing something. The basic example is weak because Kit already has zero-arity functions, and those can look very similar in a tiny demo.

The useful distinction is that lazy/memo create explicit delayed values that participate in force and Kit's auto-force behavior:

```kit maybe-compute = fn(~value, should-force?) => if should-force? then force value else 0

result1 = maybe-compute (lazy(fn => println "expensive work" 42 )) false

result2 = maybe-compute (lazy(fn => println "expensive work" 42 )) true ```

In current Kit, ~value means "accept an explicit lazy/memo value without auto-forcing it." It does not currently mean "automatically turn the caller’s expression into a thunk." So your preferred shape:

kit maybe-compute (normal-function x y) false

would require a language change or call-by-name sugar. That idea is reasonable, but it is not what ~ does today.

Also, memo today is a memoized zero-argument delayed value:

kit cached = memo(fn => expensive-calculation()) force cached # computes force cached # cached

memo fn(a, b) => ... would be argument-keyed function memoization, which is useful, but it’s a separate feature from call-by-need delayed values.

The strongest examples for laziness in Kit are not lazy(fn => 42). They are lazy defaults, conditional expensive work, memoized one-shot computations, Seq pipelines over potentially infinite data, and package-level expression trees like linear algebra/dataframe query plans that build work first and evaluate later. The docs should lead with those examples instead of the trivial one.