► |  | Lazy Racket

1 | Lazy Forms and Functions
2 | Forcing Values

Lazy Racket
1`` Lazy Forms and Functions
lambda
define
let
let*
letrec
parameterize
define-values
let-values
let*-values
letrec-values
if
set!
begin
begin0
when
unless
cond
case
values
make-struct-type
cons
list
list*
vector
box
and
or
set-mcar!
set-mcdr!
vector-set!
set-box!
error
printf
fprintf
display
write
print
eq?
eqv?
equal?
list?
length
list-ref
list-tail
append
map
for-each
andmap
ormap
member
memq
memv
assoc
assq
assv
reverse
caar
cadr
cdar
cddr
caaar
caadr
cadar
caddr
cdaar
cdadr
cddar
cdddr
caaaar
caaadr
caadar
caaddr
cadaar
cadadr
caddar
cadddr
cdaaar
cdaadr
cdadar
cdaddr
cddaar
cddadr
cdddar
cddddr
first
second
third
fourth
fifth
sixth
seventh
eighth
rest
cons?
empty
empty?
foldl
foldr
last-pair
remove
remq
remv
remove*
remq*
remv*
memf
assf
filter
sort
true
false
boolean=?
symbol=?
compose
build-list
take
identity
cycle
2`` Forcing Values
!
!!
!list
!!list

7.2
top ← prev up next →

## Lazy Racket

Eli Barzilay

#lang lazy | package: lazy

Lazy Racket is available as both a language level and a module that can be used to write lazy code. To write lazy code, simply use lazy as your module’s language:

> #lang lazy
> ... lazy code here...

Function applications are delayed, and promises are automatically forced. The language provides bindings that are equivalent to most of the racket/base and racket/list libraries. Primitives are strict in the expected places; struct constructors are lazy; if, and, or etc. are plain (lazy) functions. Strict functionality is provided as-is: begin, I/O, mutation, parameterization, etc. To have your code make sense, you should chain side effects in begins, which will sequence things properly. (Note: This is similar to threading monads through your code—only use begin where order matters.)

Mixing lazy and strict code is simple: you just write the lazy code in the lazy language, and strict code as usual. The lazy language treats imported functions (those that were not defined in the lazy language) as strict, and on the strict side you only need to force (possibly recursively) through promises.

A few side-effect bindings are provided as-is. For example, read and printf do the obvious thing—but note that the language is a call-by-need, and you need to be aware when promises are forced. There are also bindings for begin (delays a computation that forces all sub-expressions), when, unless, etc. There are, however, less reliable and might change (or be dropped) in the future.

There are a few additional bindings, the important ones are special forms that force strict behaviour—there are several of these that are useful in forcing different parts of a value in different ways, as described in Forcing Values.

### 1`` Lazy Forms and Functions

> > syntax

> > lambda

Lazy variant of lambda.

> > syntax

> > define

Lazy variant of define.

> > syntax

> > let

Lazy variant of let.

> > syntax

> > let*

Lazy variant of let*.

> > syntax

> > letrec

Lazy variant of letrec.

> > syntax

> > parameterize

Lazy variant of parameterize.

> > syntax

> > define-values

Lazy variant of define-values.

> > syntax

> > let-values

Lazy variant of let-values.

> > syntax

> > let*-values

Lazy variant of let*-values.

> > syntax

> > letrec-values

Lazy variant of letrec-values.

> > syntax

> > if

Lazy variant of if.

> > syntax

> > set!

Lazy variant of set!.

> > syntax

> > begin

Lazy variant of begin.

> > syntax

> > begin0

Lazy variant of begin0.

> > syntax

> > when

Lazy variant of when.

> > syntax

> > unless

Lazy variant of unless.

> > syntax

> > cond

Lazy variant of cond.

> > syntax

> > case

Lazy variant of case.

> > value

> > values : procedure?

Lazy variant of values.

> > value

> > make-struct-type : procedure?

Lazy variant of make-struct-type.

> > value

> > cons : procedure?

Lazy variant of cons.

> > value

> > list : procedure?

Lazy variant of list.

> > value

> > list* : procedure?

Lazy variant of list*.

> > value

> > vector : procedure?

Lazy variant of vector.

> > value

> > box : procedure?

Lazy variant of box.

> > value

> > and : procedure?

Lazy variant of and.

> > value

> > or : procedure?

Lazy variant of or.

> > value

> > set-mcar! : procedure?

Lazy variant of set-mcar!.

> > value

> > set-mcdr! : procedure?

Lazy variant of set-mcdr!.

> > value

> > vector-set! : procedure?

Lazy variant of vector-set!.

> > value

> > set-box! : procedure?

Lazy variant of set-box!.

> > value

> > error : procedure?

Lazy variant of error.

> > value

> > printf : procedure?

Lazy variant of printf.

> > value

> > fprintf : procedure?

Lazy variant of fprintf.

> > value

> > display : procedure?

Lazy variant of display.

> > value

> > write : procedure?

Lazy variant of write.

> > value

> > print : procedure?

Lazy variant of print.

> > value

> > eq? : procedure?

Lazy variant of eq?.

> > value

> > eqv? : procedure?

Lazy variant of eqv?.

> > value

> > equal? : procedure?

Lazy variant of equal?.

> > value

> > list? : procedure?

Lazy variant of list?.

> > value

> > length : procedure?

Lazy variant of length.

> > value

> > list-ref : procedure?

Lazy variant of list-ref.

> > value

> > list-tail : procedure?

Lazy variant of list-tail.

> > value

> > append : procedure?

Lazy variant of append.

> > value

> > map : procedure?

Lazy variant of map.

> > value

> > for-each : procedure?

Lazy variant of for-each.

> > value

> > andmap : procedure?

Lazy variant of andmap.

> > value

> > ormap : procedure?

Lazy variant of ormap.

> > value

> > member : procedure?

Lazy variant of member.

> > value

> > memq : procedure?

Lazy variant of memq.

> > value

> > memv : procedure?

Lazy variant of memv.

> > value

> > assoc : procedure?

Lazy variant of assoc.

> > value

> > assq : procedure?

Lazy variant of assq.

> > value

> > assv : procedure?

Lazy variant of assv.

> > value

> > reverse : procedure?

Lazy variant of reverse.

> > value

> > caar : procedure?

Lazy variant of caar.

> > value

> > cadr : procedure?

Lazy variant of cadr.

> > value

> > cdar : procedure?

Lazy variant of cdar.

> > value

> > cddr : procedure?

Lazy variant of cddr.

> > value

> > caaar : procedure?

Lazy variant of caaar.

> > value

> > caadr : procedure?

Lazy variant of caadr.

> > value

> > cadar : procedure?

Lazy variant of cadar.

> > value

> > caddr : procedure?

Lazy variant of caddr.

> > value

> > cdaar : procedure?

Lazy variant of cdaar.

> > value

> > cdadr : procedure?

Lazy variant of cdadr.

> > value

> > cddar : procedure?

Lazy variant of cddar.

> > value

> > cdddr : procedure?

Lazy variant of cdddr.

> > value

> > caaaar : procedure?

Lazy variant of caaaar.

> > value

> > caaadr : procedure?

Lazy variant of caaadr.

> > value

> > caadar : procedure?

Lazy variant of caadar.

> > value

> > caaddr : procedure?

Lazy variant of caaddr.

> > value

> > cadaar : procedure?

Lazy variant of cadaar.

> > value

> > cadadr : procedure?

Lazy variant of cadadr.

> > value

> > caddar : procedure?

Lazy variant of caddar.

> > value

> > cadddr : procedure?

Lazy variant of cadddr.

> > value

> > cdaaar : procedure?

Lazy variant of cdaaar.

> > value

> > cdaadr : procedure?

Lazy variant of cdaadr.

> > value

> > cdadar : procedure?

Lazy variant of cdadar.

> > value

> > cdaddr : procedure?

Lazy variant of cdaddr.

> > value

> > cddaar : procedure?

Lazy variant of cddaar.

> > value

> > cddadr : procedure?

Lazy variant of cddadr.

> > value

> > cdddar : procedure?

Lazy variant of cdddar.

> > value

> > cddddr : procedure?

Lazy variant of cddddr.

> > value

> > first : procedure?

Lazy variant of first.

> > value

> > second : procedure?

Lazy variant of second.

> > value

> > third : procedure?

Lazy variant of third.

> > value

> > fourth : procedure?

Lazy variant of fourth.

> > value

> > fifth : procedure?

Lazy variant of fifth.

> > value

> > sixth : procedure?

Lazy variant of sixth.

> > value

> > seventh : procedure?

Lazy variant of seventh.

> > value

> > eighth : procedure?

Lazy variant of eighth.

> > value

> > rest : procedure?

Lazy variant of rest.

> > value

> > cons? : procedure?

Lazy variant of cons?.

> > value

> > empty : procedure?

Lazy variant of empty.

> > value

> > empty? : procedure?

Lazy variant of empty?.

> > value

> > foldl : procedure?

Lazy variant of foldl.

> > value

> > foldr : procedure?

Lazy variant of foldr.

> > value

> > last-pair : procedure?

Lazy variant of last-pair.

> > value

> > remove : procedure?

Lazy variant of remove.

> > value

> > remq : procedure?

Lazy variant of remq.

> > value

> > remv : procedure?

Lazy variant of remv.

> > value

> > remove* : procedure?

Lazy variant of remove*.

> > value

> > remq* : procedure?

Lazy variant of remq*.

> > value

> > remv* : procedure?

Lazy variant of remv*.

> > value

> > memf : procedure?

Lazy variant of memf.

> > value

> > assf : procedure?

Lazy variant of assf.

> > value

> > filter : procedure?

Lazy variant of filter.

> > value

> > sort : procedure?

Lazy variant of sort.

> > value

> > true : procedure?

Lazy variant of true.

> > value

> > false : procedure?

Lazy variant of false.

> > value

> > boolean=? : procedure?

Lazy variant of boolean=?.

> > value

> > symbol=? : procedure?

Lazy variant of symbol=?.

> > value

> > compose : procedure?

Lazy variant of compose.

> > value

> > build-list : procedure?

Lazy variant of build-list.

> > value

> > take : procedure?

Lazy variant of take.

> > value

> > identity : procedure?

Lazy identity function.

> > value

> > cycle : procedure?

Creates a lazy infinite list that repeats its input arguments in order.

### 2`` Forcing Values

(require lazy/force) | package: lazy

The bindings of lazy/force are re-provided by lazy.

> > procedure

> > (! expr) → any/c

> expr : any/c

Evaluates expr strictly. The result is always forced, over and over until it gets a non-promise value.

> > procedure

> > (!! expr) → any/c

> expr : any/c

Similar to !, but recursively forces a structure (e.g: lists).

> > procedure

> > (!list expr) → list?

> expr : (or/c promise? list?)

Forces the expr which is expected to be a list, and forces the cdrs recursively to expose a proper list structure.

> > procedure

> > (!!list expr) → list?

> expr : (or/c promise? list?)

Similar to !list but also forces (using !) the elements of the list.
top ← prev up next →