For Gauche 0.9.10

Next: , Previous: , Up: Library modules - SRFIs   [Contents][Index]

### 11.11 `srfi-43` - Vector library (legacy)

Module: srfi-43

This module is effectively superseded by R7RS and `srfi-133`. There are a few procedures that are not compatible with R7RS and `srfi-133`, and this module remains to support legacy code that depends on them.

See Vectors, and see R7RS vectors, for the “modern” versions of vector library. New code should use them.

The following procedures in srfi-43 are built-in. See Vectors, for the description.

```make-vector     vector          vector?         vector-ref
vector-set!     vector-length   vector-fill!    vector-copy
vector-copy!    vector-append   vector->list    list->vector
reverse-list->vector
```

The following procedures in srfi-43 are supported by srfi-133. See R7RS vectors, for the description.

```vector-unfold         vector-unfold-right   vector-reverse-copy
vector-reverse-copy!  vector-concatenate    vector-empty?
vector=               vector-index          vector-index-right
vector-skip           vector-skip-right     vector-binary-search
vector-any            vector-every          vector-swap!
reverse-vector->list
```

We explain the procedures that are not listed above.

Function: vector-fold kons knil vec1 vec2 …
Function: vector-fold-right kons knil vec1 vec2 …

[SRFI-43] {srfi-43} Like `vector-fold` and `vector-fold-right` in `srfi-133`, but kons takes an extra argument, the current index, as its first argument. So kons must accept n+2 arguments, where n is the number of given vectors. It is called as `(kons <index> <cumulated-value> <elt1> <elt2> ...)`.

Gauche has `fold-with-index` (see Mapping over sequences) that can be used to fold vectors with index, but the argument order of kons is slightly different: It passes the index, each element from argument vectors, then cumulated values.

```(use srfi-43)
(vector-fold list '() '#(a b c) '#(d e f))
⇒ (2 (1 (0 () a d) b e) c f)

(use gauche.sequence)
(fold-with-index list '() '#(a b c) '#(d e f))
⇒ (2 c f (1 b e (0 a d ())))
```
Function: vector-map f vec1 vec2 …
Function: vector-map! f vec1 vec2 …
Function: vector-for-each f vec1 vec2 …
Function: vector-count f vec1 vec2 …

[SRFI-43] {srfi-43} Like `vector-map` and `vector-for-each` of R7RS, and `vector-map!` and `vector-count` in `srfi-133`, except f takes an extra argument, the current index, as its first argument.

Gauche provides `vector-map-with-index`, `vector-map-with-index!` and `vector-for-each-with-index` which are the same as `srfi-43`’s `vector-map`, `vector-map!` and `vector-for-each`, respectively. See Vectors.

```(vector-map list '#(a b c))
⇒ #((0 a) (1 b) (2 c))
(vector-map list '#(a b c) '#(d e f g))
⇒ #((0 a d) (1 b e) (2 c f))
(vector-count = '#(0 2 2 4 4))
⇒ 3
```

(Note: The `vector-count` example calls `=` with two arguments, the current index and the element, for each element of the input vector. So it counts the number of occasions when the element is equal to the index.)

The generic `map` and `for-each` in `gauche.collection` can be used on vectors, but the mapped procedure is called without index, and the result is returned as a list. `(vector-map f vec1 vec2 …)` is operationally equivalent to `(map-to-with-index <vector> f vec1 vec2 …)`. See Collection framework and Sequence framework.

Next: , Previous: , Up: Library modules - SRFIs   [Contents][Index]