► |  | Guide: Racket

1 | Welcome to Racket
2 | Racket Essentials
3 | Built-In Datatypes
4 | Expressions and Definitions
5 | Programmer-Defined Datatypes
6 | Modules
7 | Contracts
8 | Input and Output
9 | Regular Expressions
10 | Exceptions and Control
11 | Iterations and Comprehensions
12 | Pattern Matching
13 | Classes and Objects
14 | Units (Components)
15 | Reflection and Dynamic Evaluation
16 | Macros
17 | Creating Languages
18 | Performance
19 | Running and Creating Executables
20 | Compilation and Configuration
21 | More Libraries
22 | Dialects of Racket and Scheme
| Bibliography
| Index

▼ | 3 | Built-In Datatypes

3.1 | Booleans
3.2 | Numbers
3.3 | Characters
3.4 | Strings (Unicode)
3.5 | Bytes and Byte Strings
3.6 | Symbols
3.7 | Keywords
3.8 | Pairs and Lists
3.9 | Vectors
3.10 | Hash Tables
3.11 | Boxes
3.12 | Void and Undefined

top ← prev up next →

#### 3.8`` Pairs and Lists

A pair joins two arbitrary values. The cons procedure constructs pairs, and the car and cdr procedures extract the first and second elements of the pair, respectively. The pair? predicate recognizes pairs.

Some pairs print by wrapping parentheses around the printed forms of the two pair elements, putting a ' at the beginning and a . between the elements.

Examples:
> ( cons 1 2)
'(1 . 2)
> ( cons ( cons 1 2) 3)
'((1 . 2) . 3)
> ( car ( cons 1 2))
1
> ( cdr ( cons 1 2))
2
> ( pair? ( cons 1 2))
#t

A list is a combination of pairs that creates a linked list. More precisely, a list is either the empty list null, or it is a pair whose first element is a list element and whose second element is a list. The list? predicate recognizes lists. The null? predicate recognizes the empty list.

A list normally prints as a ' followed by a pair of parentheses wrapped around the list elements.

Examples:
> null
'()
> ( cons 0 ( cons 1 ( cons 2 null )))
'(0 1 2)
> ( list? null )
#t
> ( list? ( cons 1 ( cons 2 null )))
#t
> ( list? ( cons 1 2))
#f

A list or pair prints using list or cons when one of its elements cannot be written as a quoted value. For example, a value constructed with srcloc cannot be written using quote, and it prints using srcloc:

> ( srcloc "file.rkt" 1 0 1 ( + 4 4))
(srcloc "file.rkt" 1 0 1 8)
> ( list 'here ( srcloc "file.rkt" 1 0 1 8) 'there)
(list 'here (srcloc "file.rkt" 1 0 1 8) 'there)
> ( cons 1 ( srcloc "file.rkt" 1 0 1 8))
(cons 1 (srcloc "file.rkt" 1 0 1 8))
> ( cons 1 ( cons 2 ( srcloc "file.rkt" 1 0 1 8)))
(list* 1 2 (srcloc "file.rkt" 1 0 1 8))

> > > See also list*.

As shown in the last example, list* is used to abbreviate a series of conses that cannot be abbreviated using list.

The write and display functions print a pair or list without a leading ', cons, list, or list*. There is no difference between write and display for a pair or list, except as they apply to elements of the list:

Examples:
> ( write ( cons 1 2))
(1 . 2)
> ( display ( cons 1 2))
(1 . 2)
> ( write null )
()
> ( display null )
()
> ( write ( list 1 2 "3"))
(1 2 "3")
> ( display ( list 1 2 "3"))
(1 2 3)

Among the most important predefined procedures on lists are those that iterate through the list’s elements:

> ( map ( lambda (i) ( / 1 i))
'(1 2 3))

'(1 1/2 1/3)

> ( andmap ( lambda (i) (i . < . 3))
'(1 2 3))

#f

> ( ormap ( lambda (i) (i . < . 3))
'(1 2 3))

#t

> ( filter ( lambda (i) (i . < . 3))
'(1 2 3))

'(1 2)

> ( foldl ( lambda (v i) ( + v i))
10
'(1 2 3))

16

> ( for-each ( lambda (i) ( display i))
'(1 2 3))

123

> ( member "Keys"
'("Florida" "Keys" "U.S.A."))

'("Keys" "U.S.A.")

> ( assoc 'where
'((when "3:30") (where "Florida") (who "Mickey")))

'(where "Florida")

> > > Pairs and Lists in Reference: Racket provides more on pairs and lists.

Pairs are immutable (contrary to Lisp tradition), and pair? and list? recognize immutable pairs and lists, only. The mcons procedure creates a mutable pair, which works with set-mcar! and set-mcdr!, as well as mcar and mcdr. A mutable pair prints using mcons, while write and display print mutable pairs with { and }:

Examples:
> ( define p ( mcons 1 2))
> p
(mcons 1 2)
> ( pair? p)
#f
> ( mpair? p)
#t
> ( set-mcar! p 0)
> p
(mcons 0 2)
> ( write p)
{0 . 2}

> > > Mutable Pairs and Lists in Reference: Racket provides more on mutable pairs.

top ← prev up next →