29 Multiple Values

▼ |  | Unstable

1 | Guidelines for developing unstable libraries
2 | Bytes
3 | Classes and Objects
4 | Contracts
5 | Definitions
6 | Dictionaries
7 | Directories
8 | Exceptions
9 | Filesystem
10 | Functions
11 | Lists
12 | Net
13 | Path
14 | PLane T Packages
15 | Ports
16 | Pretty-Printing
17 | Regular Expressions
18 | Requiring Modules
19 | Sandboxed Evaluation
20 | Scribble Documentation
21 | Sets
22 | S-Expression Diff
23 | Source Locations
24 | Strings
25 | Structs
26 | Syntax
27 | Planet Package Macros
28 | Text Representations
29 | Multiple Values
30 | XML and CSS
31 | Polymorphic Contracts
32 | Finding Mutated Variables
33 | Find
34 | Interface-Oriented Programming for Classes
35 | Sequences
36 | Hash Tables
37 | Match
38 | Generics
39 | Mark Parameters
40 | Debugging
41 | Contracts for macro subexpressions
42 | GUI libraries

On this page:

values->list
map2
map/ values
foldr/ values
foldl/ values

Version: 5.0.1.5
top← prev up next →

### 29`` Multiple Values

Carl Eastlund <cce@racket-lang.org>

( require unstable/values)

This library is unstable; compatibility will not be maintained. See Unstable for more information.

This module provides tools for manipulating functions and expressions that produce multiple values.

( values->list expr)

Produces a list of the values returned by expr.

Example:
> ( values->list ( values 1 2 3))
'(1 2 3)

( map2 f lst ...)

→

( listof B) |  | ( listof C)

f : (-> A ... ( values B C))
lst : ( listof A)

Produces a pair of lists of the respective values of f applied to the elements in lst ... sequentially.

Example:
> ( map2 ( lambda (x) ( values (+ x 1) (- x 1))) ( list 1 2 3))
'(2 3 4)
'(0 1 2)

( map/values n f lst ...)

→

( listof B_1) |  | ... |  | ( listof B_n)

n : natural-number/c
f : (-> A ... ( values B_1 ... B_n))
lst : ( listof A)

Produces lists of the respective values of f applied to the elements in lst ... sequentially.

Example:

> ( map/values
3
( lambda (x)
( values (+ x 1) x (- x 1)))
( list 1 2 3))

'(2 3 4)
'(1 2 3)
'(0 1 2)

( foldr/values f vs lst ...)

→

B |  | ...

f : (-> A ... B ... ( values B ...))
vs : ( list/c B ...)
lst : ( listof A)

( foldl/values f vs lst ...)

→

B |  | ...

f : (-> A ... B ... ( values B ...))
vs : ( list/c B ...)
lst : ( listof A)

These functions combine the values in the lists lst ... using the multiple-valued function f; foldr/values traverses the lists right to left and foldl/values traverses left to right.

Examples:

( define (add/cons a b c d)
( values (+ a c) ( cons b d)))

> ( foldr/values add/cons ( list 0 null)
( list 1 2 3 4) ( list 5 6 7 8))

10
'(5 6 7 8)

> ( foldl/values add/cons ( list 0 null)
( list 1 2 3 4) ( list 5 6 7 8))

10
'(8 7 6 5)

top← prev up next →