► |  | Reference: PLT Scheme

1 | Language Model
2 | Syntactic Forms
3 | Datatypes
4 | Structures
5 | Classes and Objects
6 | Units
7 | Contracts
8 | Pattern Matching
9 | Control Flow
10 | Concurrency
11 | Macros
12 | Input and Output
13 | Reflection and Security
14 | Operating System
15 | Memory Management
16 | Unsafe Operations
17 | Running PLT Scheme
| Bibliography
| Index

▼ | 3 | Datatypes

3.1 | Booleans and Equality
3.2 | Numbers
3.3 | Strings
3.4 | Byte Strings
3.5 | Characters
3.6 | Symbols
3.7 | Regular Expressions
3.8 | Keywords
3.9 | Pairs and Lists
3.10 | Mutable Pairs and Lists
3.11 | Vectors
3.12 | Boxes
3.13 | Hash Tables
3.14 | Sequences
3.15 | Dictionaries
3.16 | Procedures
3.17 | Void and Undefined

► | 3.10 | Mutable Pairs and Lists

3.10.1 | Mutable Pair Constructors and Selectors
3.10.2 | Mutable List Functions

On this page:

3.10.1`` Mutable Pair Constructors and Selectors
mpair?
mcons
mcar
mcdr
set-mcar!
set-mcdr!
3.10.2`` Mutable List Functions
mlist?
mlist
list->mlist
mlist->list
mlength
mlist-ref
mlist-tail
mappend
mappend!
mreverse
mreverse!
mmap
mfor-each
mmember
mmemv
mmemq
massoc
massv
massq
mlistof

top ← prev up next →

#### 3.10`` Mutable Pairs and Lists

A mutable pair is like a pair created by cons, but it supports set-mcar! and set-mcdr! mutation operations to change the parts of the pair (like traditional Lisp and Scheme pairs).

A mutable list is analogous to a list created with pairs, but instead created with mutable pairs.

##### 3.10.1`` Mutable Pair Constructors and Selectors

( mpair? v) → boolean?
v : any/c

Returns #t if v is a mutable pair, #f otherwise.

( mcons a d) → pair?
a : any/c
d : any/c

Returns a mutable pair whose first element is a and second element is d.

( mcar p) → any/c
p : mpair?

Returns the first element of the mutable pair p.

( mcdr p) → any/c
p : mpair?

Returns the second element of the mutable pair p.

( set-mcar! p v) → void?
p : mpair?
v : any/v

Changes the mutable pair p so that its first element is v.

( set-mcdr! p v) → void?
p : mpair?
v : any/v

Changes the mutable pair p so that its second element is v.

##### 3.10.2`` Mutable List Functions

( require scheme/mpair )

The bindings documented in this section are provided by the scheme/mpair library, not scheme/base or scheme.

For functions described in this section, contracts are not directly enforced. In particular, when a mutable list is expected, supplying any other kind of value (or mutating a value that starts as a list) tends to produce an exception from mcar or mcdr.

( mlist? v) → boolean?
v : any/c

Returns #t if v is a mutable list: either the empty list, or a mutable pair whose second element is a mutable list.

( mlist v ...) → mlist?
v : any/c

Returns a newly allocated mutable list containing the vs as its elements.

( list->mlist lst) → mlist?
lst : list?

Returns a newly allocated mutable list with the same elements as lst.

( mlist->list mlst) → list?
mlst : mlist?

Returns a newly allocated list with the same elements as nlst.

( mlength mlst) → exact-nonnegative-integer?
mlst : mlist?

Returns the number of elements in mlst.

( mlist-ref mlst pos) → any/c
mlst : mlist?
pos : exact-nonnegative-integer?

Like list-ref, but for mutable lists.

( mlist-tail mlst pos) → any/c
mlst : mlist?
pos : exact-nonnegative-integer?

Like list-tail, but for mutable lists.

( mappend mlst ...) → mlist?
mlst : mlist?
( mappend mlst ... v) → any/c
mlst : mlist?
v : any/c

Like append, but for mutable lists.

( mappend! mlst ...) → mlist?
mlst : mlist?
( mappend! mlst ... v) → any/c
mlst : mlist?
v : any/c

The mappend! procedure appends the given lists by mutating the tail of each to refer to the next, using set-mcdr!. Empty lists are dropped; in particular, the result of calling mappend! with one or more empty lists is the same as the result of the call with the empty lists removed from the set of arguments.

( mreverse mlst) → mlist?
mlst : mlist?

Like reverse, but for mutable lists.

( mreverse! mlst) → mlist?
mlst : mlist?

Like mreverse, but destructively reverses the list by using all of the mutable pairs in mlst and changing them with set-mcdr!.

( mmap proc mlst ...+) → mlist?
proc : procedure?
mlst : mlist?

Like map, but for mutable lists.

( mfor-each proc mlst ...+) → void?
proc : procedure?
mlst : mlist?

Like for-each, but for mutable lists.

( mmember v mlst) → ( or/c mlist? #f)
v : any/c
mlst : mlist?

Like member, but for mutable lists.

( mmemv v mlst) → ( or/c mlist? #f)
v : any/c
mlst : mlist?

Like memv, but for mutable lists.

( mmemq v mlst) → ( or/c list? #f)
v : any/c
mlst : mlist?

Like memq, but for mutable lists.

( massoc v mlst) → ( or/c mpair? #f)
v : any/c
mlst : ( mlistof mpair? )

Like assoc, but for mutable lists of mutable pairs.

( massv v mlst) → ( or/c mpair? #f)
v : any/c
mlst : ( mlistof mpair? )

Like assv, but for mutable lists of mutable pairs.

( massq v mlst) → ( or/c mpair? #f)
v : any/c
mlst : ( mlistof mpair? )

Like assq, but for mutable lists of mutable pairs.

( mlistof pred) → ( any/c . -> . boolean? )
pred : ( any/c . -> . any/c )

Returns a procedure that returns #t when given a mutable list for which pred returns a true value for all elements.
top ← prev up next →