We start with

or

And make some natural and/or unnatural numbers:

And a less-than-or-equal-to function:

(`<=`

is a function with parameters `a`

and `b`

: If `a`

is zero then true else if `b`

is zero then false else try with one-less-than-`a`

and one-less-than-`b`

instead.)

Okay. We can try to apply the function to some arguments. The following are are fine and evaluate to `#t`

and `#f`

.

If we started with `#lang racket`

the next two will run forever and we won’t get values back. If we started with `#lang lazy`

they’re fine and evaluate to `#t`

and `#f`

.

The next one will run forever in both `#lang racket`

and `#lang lazy`

.

(Forever means until we are out of memory or something.)

Anyway. We can choose:

- If we want as many expressions as possible to give back values, we might prefer
`#lang lazy`

- If we want as many applications as possible of
`<=`

to give back values, we might prefer`#lang racket`

(In `#lang racket`

the forever happens when evaluating the `(inf)`

-arguments before the `<=`

-function is applied. In `#lang lazy`

we might have to decide: Is it the `(inf)`

or the `<=`

that causes forever? Is it reasonably to expect there to be a base case?)