Vectors are fixed-size, O(1) accessible sequence of values. Scheme has traditionally offered a vector of arbitrary objects, which is described in Vectors.

In R7RS-large, there’re also homogeneous numeric vectors (uvectors), which can contain fixed range of numeric objects efficiently. We explain them in Uniform vectors.

Gauche also supports bitvectors, which can contain sequence of bits. See Bitvectors, for the details.

Finally, weak vectors are a vector of arbitrary objects using weak pointers. See Weak vectors.

• Vectors: | ||

• Uniform vectors: | ||

• Bitvectors: | ||

• Weak vectors: |

- Builtin Class:
**<vector>**¶ -
A vector is a simple 1-dimensional array of Scheme objects. You can access its element by index in constant time. Once created, a vector can’t be resized.

Class

`<vector>`

inherits`<sequence>`

and you can use various generic functions such as`map`

and`fold`

on it. See`gauche.collection`

- Collection framework, and See`gauche.sequence`

- Sequence framework.If you keep only a homogeneous numeric type, you may be able to use uniform vectors (see Uniform vectors).

R7RS defines bytevectors; in Gauche, they’re just

`u8vector`

s in`gauche.uvector`

module (r7rs modules defines aliases. see`scheme.base`

- R7RS base library).See

`scheme.vector`

- R7RS vectors, for additional operations on vectors.

- Function:
**vector?**`obj`¶ [R7RS base] Returns

`#t`

if`obj`is a vector,`#f`

otherwise.

- Function:
**make-vector**`k :optional fill`¶ [R7RS base] Creates and returns a vector with length

`k`. If optional argument`fill`is given, each element of the vector is initialized by it. Otherwise, the initial value of each element is undefined.

- Function:
**vector**`obj …`¶ [R7RS base] Creates a vector whose elements are

`obj`….

- Function:
**vector-tabulate**`len proc`¶ Creates a vector of length

`len`, initializing`i`-th element of which by`(`

for all`proc``i`)`i`between`0`

and`len`(vector-tabulate 5 (^x (* x x))) ⇒ #(0 1 4 9 16)

- Function:
**vector-length**`vector`¶ [R7RS base] Returns the length of a vector

`vector`.With

`gauche.collection`

module, you can also use a method`size-of`

.

- Function:
**vector-ref**`vector k :optional fallback`¶ [R7RS+ base] Returns

`k`-th element of vector`vector`.By default,

`vector-ref`

signals an error if`k`is negative, or greater than or equal to the length of`vector`. However, if an optional argument`fallback`is given, it is returned for such case. This is an extension of Gauche.With

`gauche.sequence`

module, you can also use a method`ref`

.

- Function:
**vector-set!**`vector k obj`¶ [R7RS base] Sets

`k`-th element of the vector`vector`to`obj`. It is an error if`k`is negative or greater than or equal to the length of`vector`.With

`gauche.sequence`

module, you can also use a setter method of`ref`

.

- Function:
**vector->list**`vector :optional start end`¶ - Function:
**list->vector**`list :optional start end`¶ [R7RS+ base] Converts a vector to a list, or vice versa.

The optional

`start`and`end`arguments limit the range of the source. (R7RS don’t define`start`and`end`arguments for`list->vector`

.)(vector->list '#(1 2 3 4 5)) ⇒ (1 2 3 4 5) (list->vector '(1 2 3 4 5)) ⇒ #(1 2 3 4 5) (vector->list '#(1 2 3 4 5) 2 4) ⇒ (3 4) (list->vector (circular-list 'a 'b 'c) 1 6) ⇒ #(b c a b c)

With

`gauche.collection`module, you can use`(coerce-to <list>`

and`vector`)`(coerce-to <vector>`

as well.`list`)

- Function:
**reverse-list->vector**`list :optional start end`¶ [R7RS vector] Without optional arguments, it returns the same thing as

`(list->vector (reverse list))`

, but does not allocate the intermediate list. The optional`start`and`end`argument limits the range of the input list.(reverse-list->vector '(a b c d e f g) 1 5) ⇒ #(e d c b)

- Function:
**vector->string**`vector :optional start end`¶ - Function:
**string->vector**`string :optional start end`¶ [R7RS base] Converts a vector of characters to a string, or vice versa. It is an error to pass a vector that contains other than characters to

`vector->string`

.The optional

`start`and`end`arguments limit the range of the source.(vector->string '#(#\a #\b #\c #\d #\e)) ⇒ "abcde" (string->vector "abcde") ⇒ #(#\a #\b #\c #\d #\e) (vector->string '#(#\a #\b #\c #\d #\e) 2 4) ⇒ ("cd")

With

`gauche.collection`module, you can use`(coerce-to <string>`

and`vector`)`(coerce-to <vector>`

as well.`string`)

- Function:
**vector-fill!**`vector fill :optional start end`¶ [R7RS base] Sets all elements in a vector

`vector`to`fill`.Optional

`start`and`end`limits the range of effect between`start`-th index (inclusive) to`end`-th index (exclusive).`Start`defaults to zero, and`end`defaults to the length of`vector`.

- Function:
**vector-copy**`vector :optional start end fill`¶ [R7RS base] Copies a vector

`vector`. Optional`start`and`end`arguments can be used to limit the range of`vector`to be copied. If the range specified by`start`and`end`falls outside of the original`vector`, the`fill`value is used to fill the result vector.(vector-copy '#(1 2 3 4 5)) ⇒ #(1 2 3 4 5) (vector-copy '#(1 2 3 4 5) 2 4) ⇒ #(3 4) (vector-copy '#(1 2 3 4 5) 3 7 #f) ⇒ #(4 5 #f #f)

- Function:
**vector-copy!**`target tstart source :optional sstart send`¶ [R7RS base] Copies the content of

`source`vector into the`target`vector starting from`tstart`in the target. The`target`vector must be mutable. Optional`sstart`and`send`limits the range of source vector.(rlet1 v (vector 'a 'b 'c 'd 'e) (vector-copy! v 2 '#(1 2))) ⇒ #(a b 1 2 e) (rlet1 v (vector 'a 'b 'c 'd 'e) (vector-copy! v 2 '#(1 2 3 4) 1 3)) ⇒ #(a b 2 3 e)

An error is raised if the portion to be copied is greater than the room in the target (that is, between

`tstart`to the end).It is ok to pass the same vector to

`target`and`source`; it always works even if the regions of source and destination are overlapping.

- Function:
**vector-append**`vec …`¶ [R7RS base] Returns a newly allocated vector whose contents are concatenation of elements of

`vec`in order.(vector-append '#(1 2 3) '#(a b)) ⇒ #(1 2 3 a b) (vector-append) ⇒ #()

- Function:
**vector-map**`proc vec1 vec2 …`¶ [R7RS base] Returns a new vector,

`i`-th of which is calculated by applying`proc`on the list of each`i`-th element of`vec1``vec2`…. The length of the result vector is the same as the shortest vector of the arguments.(vector-map + '#(1 2 3) '#(4 5 6 7)) ⇒ #(5 7 9)

The actual order

`proc`is called is undefined, and may change in the future versions, so`proc`shouldn’t use side effects affected by the order.Note: If you use

`gauche.collection`

, you can get the same function by`(map-to <vector> proc vec1 vec2 …)`

.

- Function:
**vector-map-with-index**`proc vec1 vec2 …`¶ Like

`vector-map`

, but`proc`receives the current index as the first argument.(vector-map-with-index list '#(a b c d e) '#(A B C)) ⇒ #((0 a A) (1 b B) (2 c C))

This is what SRFI-43 calls

`vector-map`

. See`srfi.43`

- Vector library (legacy).Note: If you use

`gauche.collection`

, you can get the same function by`(map-to-with-index <vector> proc vec1 vec2 …)`

.

- Function:
**vector-map!**`proc vec1 vec2 …`¶ [R7RS vector] For each index

`i`, calls`proc`with`i`-th index of`vec1``vec2`…, and set the result back to`vec1`. The value is calculated up to the minimum length of input vectors.(rlet1 v (vector 1 2 3) (vector-map! ($ + 1 $) v)) ⇒ #(2 3 4) (rlet1 v (vector 1 2 3 4) (vector-map! + v '#(10 20))) ⇒ #(11 22 3 4)

- Function:
**vector-map-with-index!**`proc vec1 vec2 …`¶ Like

`vector-map!`

, but`proc`receives the current index as the first argument. This is equivalent to SRFI-43’s`vector-map!`

(see`srfi.43`

- Vector library (legacy)).(rlet1 v (vector 'a 'b 'c) (vector-map-with-index! list v)) ⇒ #((0 a) (1 b) (2 c))

- Function:
**vector-for-each**`proc vec1 vec2 …`¶ [R7RS base] For all

`i`below the minimum length of input vectors, calls`proc`with`i`-th elements of`vec1``vec2`…, in increasing order of`i`.`(vector-for-each print '#(a b c)) ⇒ prints`

`a`

,`b`

and`c`

.

- Function:
**vector-for-each-with-index**`proc vec1 vec2 …`¶ Like

`vector-for-each`

, but`proc`receives the current index in the first argument.This is equivalent to SRFI-43’s

`vector-for-each`

. See`srfi.43`

- Vector library (legacy).

Uniform vectors, or homogeneous numeric vectors, are a special
type of vectors whose elements are of the same numeric type.
It was introduced originally as SRFI-4, revised by SRFI-160,
and now a part of R7RS large (as `scheme.vector.@`

).

The `@`

part is actually one of the following tags, indicating
the type of elements:

`u8`

Unsigned 8-bit integer - an exact integer between 0 and 255.

`s8`

Signed 8-bit integer - an exact integer between -128 and 127.

`u16`

Unsigned 16-bit integer - an exact integer between 0 and 65535.

`s16`

Signed 16-bit integer - an exact integer between -32678 and 32767.

`u32`

Unsigned 32-bit integer - an exact integer between 0 and 2^32 - 1.

`s32`

Signed 32-bit integer - an exact integer between -(2^31) and 2^31 - 1.

`u64`

Unsigned 64-bit integer - an exact integer between 0 and 2^64 - 1.

`s64`

Signed 64-bit integer - an exact integer between -(2^63) and 2^63 - 1.

`f16`

16-bit floating point number (10-bit mantissa and 5-bit exponent), as inexact real.

`f32`

IEEE single-precision floating point number as inexact real.

`f64`

IEEE double-precision floating point number as inexact real.

`c32`

Inexact complex, consists of a pair of 16-bit floating point numbers.

`c64`

Inexact complex, consists of a pair of IEEE single-precision floating point numbers.

`c128`

Inexact complex, consists of a pair of IEEE double-precision floating point numbers.

There are some advantages of using uniform vectors over normal (heterogeneous) vectors. It may be more compact than the normal vectors. Some operations (especially Gauche’s extension of vector arithmetic operations) can bypass type check and conversion of individual elements, thus be more efficient. And it is much easier and efficient to communicate with external libraries that require homogeneous array of numbers; for example, OpenGL binding of Gauche uses uniform vectors extensively.

Gauche has only a handful primitive operations on uniform vectors
as a built-in, but the `gauche.uvector`

module, or
`scheme.vector.@`

module (`(scheme vector @)`

library
in R7RS programs), provide a complehensive set of operations.
See `gauche.uvector`

- Uniform vector library, and see `scheme.vector.@`

- R7RS uniform vectors.

- Abstract Class:
**<uvector>**¶ The base class of uniform vector classes. It inherits

`<sequence>`

(see`gauche.sequence`

- Sequence framework).

- Builtin Class:
**<@vector>**¶ -
{

`gauche.uvector`

} A class for @vector, where`@`

is one of the uvector tags (`u8`

,`s8`

, …). It inherits`<uvector>`

.It implements sequence protocol (see

`gauche.sequence`

- Sequence framework)), so you can convert a sequence of real numbers into a uvector using`coerce-to`

, if every elements is valid for the uvector.(use gauche.sequence) (coerce-to <u8vector> '(1 2 3)) ⇒ #u8(1 2 3)

- Reader Syntax:
¶`#u8(`

`n`…) - Reader Syntax:
¶`#s8(`

`n`…) - Reader Syntax:
¶`#u16(`

`n`…) - Reader Syntax:
¶`#s16(`

`n`…) - Reader Syntax:
¶`#u32(`

`n`…) - Reader Syntax:
¶`#s32(`

`n`…) - Reader Syntax:
¶`#u64(`

`n`…) - Reader Syntax:
¶`#s64(`

`n`…) - Reader Syntax:
¶`#f16(`

`n`…) - Reader Syntax:
¶`#f32(`

`n`…) - Reader Syntax:
¶`#f64(`

`n`…) - Reader Syntax:
¶`#c32(`

`n`…) - Reader Syntax:
¶`#c64(`

`n`…) - Reader Syntax:
¶`#c128(`

`n`…) -
Denotes a literal homogeneous vector.

(Note: R7RS bytevector is the same as u8vector, and can be written as

`#u8(…)`

.)#s8(3 -2 4) #u32(4154 88357 2 323) #f32(3.14 0.554525 -3.342)

Gauche also supports SRFI-207 (String-notated bytevector) style bytevector literal. It is a prefix

`#u8`

followed by a string literal, in which only ASCII characters and escaped single-octets (i.e.`\xNN;`

where`N`

is a hexadecimal digit) are allowed. It allows to naturally use bytevectors as a bytestring. See`srfi.207`

- String-notated bytevectors, for operations on bytestrings.#u8"ABC\x00;D" ⇒ #u8(65 66 67 0 68)

- Function:
**make-s8vector**`len :optional fill`¶ - Function:
**make-s8vector**`len :optional fill`¶ - Function:
**make-u8vector**`len :optional fill`¶ - Function:
**make-s16vector**`len :optional fill`¶ - Function:
**make-u16vector**`len :optional fill`¶ - Function:
**make-s32vector**`len :optional fill`¶ - Function:
**make-u32vector**`len :optional fill`¶ - Function:
**make-s64vector**`len :optional fill`¶ - Function:
**make-u64vector**`len :optional fill`¶ - Function:
**make-f16vector**`len :optional fill`¶ - Function:
**make-f32vector**`len :optional fill`¶ - Function:
**make-f64vector**`len :optional fill`¶ - Function:
**make-c32vector**`len :optional fill`¶ - Function:
**make-c64vector**`len :optional fill`¶ - Function:
**make-c128vector**`len :optional fill`¶ [R7RS vector.@] Constructs a @vector of length

`len`. The elements are initialized by a number`fill`. For exact integer vectors,`fill`must be an exact integer and in the valid range. If`fill`is omitted, the content of the vector is undefined.(make-u8vector 4 0) ⇒ #u8(0 0 0 0)

- Function:
**uvector?**`obj`¶ Returns

`#t`

iff`obj`is one of the uniform vectors. See below for predicates for specific type of uvector.

- Function:
**uvector-length**`uv`¶ Returns the length (the number of elements) of uvector

`uv`. An error is raised if`uv`is not a uvector.Type specific length procedures are provided in

`scheme.vector.@`

and`gauche.uvector`

(see`gauche.uvector`

- Uniform vector library).To get the size of the binary data the content of the uvector actually occupies, use

`uvector-size`

in`gauche.uvector`

.

- Function:
**uvector-ref**`uv k :optional fallback`¶ Generic uvector accessor. Returns

`k`-th element of a uniform vector`uv`. If`k`is out-of-range,`fallback`is returned if provided, or an error is thrown otherwise.This is handy to write a generic code that works on any kind of uniform vector, but this is slower than the specific versions. Gauche’s compiler recognizes the specific versions of referencer and generate very efficient code for them, while this generic version becomes a normal procedure call. In inner-loop it can make a big difference.

See below for the type-specific accessors.

`(setter uvector-ref)`

is`uvector-set!`

.

- Function:
**uvector-set!**`uv k val :optional clamp`¶ Generic uvector setter. Mutate

`k`-th element of uvector`uv`with`val`. An error is thrown if`k`is out-of-range, or`uv`is immutable.Optional

`clamp`argument specifies the behavior when`val`is out of valid range. It can be`#f`

or one of the symbols`low`

,`high`

, or`both`

. See`gauche.uvector`

- Uniform vector library, for the meanings of the clamp argument. The default is`#f`

, which raises an error on out-of-range value.

Type-specific predicates, accessors and modifiers are provided in the core
library; all the rest are in `scheme.vector.@`

or `gauche.uvector`

(see `gauche.uvector`

- Uniform vector library).

- Function:
**@vector?**`obj`¶ -
[R7RS vector.@] Returns

`#t`

iff`obj`is a @vector,`#f`

otherwise. The`@`

part is one of the uvector tags (`u8`

etc.).

- Function:
**@vector-ref**`vec k :optional fallback`¶ -
[R7RS vector.@] Returns the

`k`-th element of @vector`vec`. The`@`

part is one of the uvector tags (`u8`

etc.).If the index

`k`is out of the valid range, an error is signaled unless an optional argument`fallback`is given; in that case,`fallback`is returned.Note that the generic function

`ref`

can be used as well, if you import`gauche.collection`

.(u16vector-ref '#u16(111 222 333) 1) ⇒ 222 (use gauche.collection) (ref '#u16(111 222 333) 1) ⇒ 222

Setter of

`@vector-ref`

is`@vector-set!`

.(use gauche.uvector) (define v (u8vector 1 2 3)) (set! (u8vector-ref v 1) 99) v ⇒ #u8(1 99 3)

- Function:
**@vector-set!**`vec k n :optional clamp`¶ -
[R7RS vector.@] Sets a number

`n`to the`k`-th element of @vector`vec`. The`@`

part is one of the uvector tags (`u8`

etc.).Optional

`clamp`argument specifies the behavior when`n`is out of valid range. It can be`#f`

or one of the symbols`low`

,`high`

, or`both`

. See`gauche.uvector`

- Uniform vector library, for the meanings of the clamp argument. The default is`#f`

, which raises an error on out-of-range value.Note that the setter of the generic function

`ref`

can be used as well, if you import`gauche.collection`

.(let ((v (s32vector -439 852 8933))) (s32vector-set! v 1 4) v) ⇒ #s32vector(-439 4 8933) (use gauche.collection) (let ((v (s32vector -439 852 8933))) (set! (ref v 1) 4) v) ⇒ #s32vector(-439 4 8933)

Two sets of conversion procedures are provided. The first set is to convert strings to u8/s8 vector and vice versa, taking multibyte representation of a string as a byte vector. The second set is to convert strings to u32/s32 vector and vice versa, regarding a string as a sequence of Unicode codepoints.

For portable Scheme code, SRFI-181 provides conversion between strings and bytevectors, specifying character encodings (see Transcoded ports).

- Function:
**string->s8vector**`string :optional start end immutable?`¶ - Function:
**string->u8vector**`string :optional start end immutable?`¶ Returns an s8vector or u8vector whose byte sequence is the same as the internal representation of the given string. Optional range arguments

`start`and`end`specifies the*character position*(not the byte position) inside`string`to be converted.By default, the content of the string is copied to a newly created mutable uvector. However, if a true value is given to the optional

`immutable?`argument, the result is an immutable uvector, and it may avoid copying the string body (note that in Gauche, the body of string is immutable;`string-set!`

creates a new body, so changing the original string won’t affect the uvector created by`string->u8vector`

with`immutable?`

flag.)These procedures are useful when you want to access byte sequence of the string randomly.

(string->u8vector "abc") ⇒ #u8(97 98 99)

`(string->u8vector "very large string .... " 0 -1 #t) ⇒ #u8(...) ; immutable, sharing content with the original string`

- Function:
**string->s8vector!**`target tstart string :optional start end`¶ - Function:
**string->u8vector!**`target tstart string :optional start end`¶ `Target`must be an s8vector or a u8vector, respectively.`Target`must be mutable. Like copies the raw byte representation of`string`into`target`beginning from index`tstart`.Returns

`target`.(let ((target (make-u8vector 10 0))) (string->u8vector! target 3 "abcde")) ⇒ #u8(0 0 0 97 98 99 100 101 0 0)

- Function:
**s8vector->string**`vec :optional start end terminator`¶ - Function:
**u8vector->string**`vec :optional start end terminator`¶ Converts a byte sequence in s8vector or u8vector to a string that has the same byte sequence. Optional range arguments

`start`and`end`specifies the byte position in`vec`to be converted.The optional

`terminator`argument can be an exact integer or`#f`

(default). If it is an exact integer, and it appears in`vec`, the string terminates right before it. For example, you can give 0 as`terminator`to read a NUL-terminated string from a buffer.(u8vector->string '#u8(65 66 0 67 68) 0 5) ⇒ "AB\0CD" (u8vector->string '#u8(65 66 0 67 68) 0 5 0) ⇒ "AB"

Note that these procedure may result an incomplete string if

`vec`contains a byte sequence invalid as utf-8 encoding.

- Function:
**string->s32vector**`string :optional start end endian`¶ - Function:
**string->u32vector**`string :optional start end endian`¶ Returns an s32vector or u32vector whose elements are the internal codes of the characters in the string. Optional range arguments

`start`and`end`specifies the*character position*inside`string`to be converted.The optional

`endian`argument specifies the endianness to store codepoint value into the uvector. When omitted or`#f`

, we use the platform’s native endianness. You can give a symbol`big-endian`

,`big`

,`little-endian`

,`little`

or`arm-little-endian`

to use a specific endianness. Note that when you access the resulting uvector, the platform’s native endianness is used.These procedures are useful when you want to access the characters in the string randomly.

- Function:
**string->s32vector!**`target tstart string :optional start end endian`¶ - Function:
**string->u32vector!**`target tstart string :optional start end endian`¶ `Target`must be a mutable s32vector or u32vector, respectively. Fill the`target`from position`tstart`with the codepoint of each character of`string`, until either`string`is exhausted or`target`is filled to the end.Optional range arguments

`start`and`end`specifies the*character position*inside`string`to be considered.The optional

`endian`argument specifies the endianness to store codepoint value into the uvector. When omitted or`#f`

, we use the platform’s native endianness. You can give a symbol`big-endian`

,`big`

,`little-endian`

,`little`

or`arm-little-endian`

to use a specific endianness. Note that when you access the resulting uvector, the platform’s native endianness is used.

- Function:
**s32vector->string**`vec :optional start end terminator endian`¶ - Function:
**u32vector->string**`vec :optional start end terminator endian`¶ Without

`start`and`end`, these procedures work like this:(lambda (vec) (map-to <string> integer->char vec)))

Optional range arguments

`start`and`end`limits the range of conversion between them.The optional

`terminator`argument must be an exact integer or`#f`

(default). If an integer is given, and the integer is found in the input, the output string terminates right before it.The optional

`endian`argument specifies the endianness to store codepoint value into the uvector. When omitted or`#f`

, we use the platform’s native endianness. You can give a symbol`big-endian`

,`big`

,`little-endian`

,`little`

or`arm-little-endian`

to use a specific endianness.(u32vector->string '#u32(65 66 0 67 68) 0 5 0) ⇒ "AB"

A bitvector is a sequence of bits. Each bit can be considered either
an exact integer 0/1, or a boolean values `#f`

/`#t`

.
In the former view, it is similar to a uniform vector, but it has the
interface sufficiently different from uvectors and we provided it as
a disjoint type.

Gauche provides a handful of procedures in the core,
and `gauche.bitvector`

provides comprehensive utilities.
See `gauche.bitvector`

- Bitvector utilities, for the details.
For the portable programs, SRFI-178 defines bitvector library,
which is a subset of what Gauche provides (see `srfi.178`

- Bitvector library).

- Builtin class:
**<bitvector>**¶ -
Bitvector class. Inherits

`<sequence>`

, so generic sequence opertaions can be used. (Generic`ref`

uses`bitvector-ref/int`

, for it matches the external representation of a bitvector.)

- Reader Syntax:
¶`#*`

`b`… -
[SRFI-178] A bitvector literal is

`#*`

followed by zero or more binary digits`0`

or`1`

.#*10010010 ; bitvector of length 8 #* ; bitvector of length 0

A bitvector literal is delimited by one of delimiter character or an EOF.

#*10010abc ; error #*10001(a b c) ; a bitvector, followed by a list

Note: With this rule,

`#*"..."`

should be read as a zero-length bitvector followed by a string, for`"`

is a delimiter. However, Gauche used that syntax for incomplete strings (our overlook!). Since incomplete string literals is rare (incomplete strings are something that unexpectedly happen in the practical situation, but not to be used actively), we changed incomplete string literals to`#**"..."`

since 0.9.10 (see Incomplete strings).For the backward compatibility, the current version reads

`#*"..."`

as an incomplete string. If the reader lexical mode is`warn-legacy`

(see Reader lexical mode), such literals are warned. We’ll gradually migrate to make`#*"..."`

read as a bytevector followed by a string.

- Function:
**bit->integer**`bit`¶ - Function:
**bit->boolean**`bit`¶ [SRFI-178] Many bitvector operations can accept bit as a boolean (

`#f`

/`#t`

) or an exact integer (0/1). These are utility procedures to obtain desired type. The`bit`argument must be either one of`#f`

,`#t`

, 0 or 1. They return 0/1 and`#f`

/`#t`

, respectively. An error is signalled if`bit`is other than those values.

- Function:
**bitvector**`b …`¶ [SRFI-178] Creates and returns a bitvector whose elements are

`b`…. Each argument must be a bit (boolean or 0 or 1).(bitvector 0 1 0 0 1 0 0 0 1) ⇒ #*010010001 (bitvector) ⇒ #*

- Function:
**make-bitvector**`len :optional init`¶ [SRFI-178] Creates and returns a bitvector with length

`len`, and all elements being initialized by`init`, which must be a bit (boolean or 0 or 1).If

`init`is omitted, the content of the bitvector is undefined (currently we fill it with 0, but don’t count on it.)(make-bitvector 5 #f) ⇒ #*00000 (make-bitvector 7 1) ⇒ #*1111111

- Function:
**bitvector?**`obj`¶ [SRFI-178] Return

`#t`

iff`obj`is an bitvector.

- Function:
**list->bitvector**`lis`¶ [SRFI-178]

`Lis`must be a list of bits (0, 1 or booleans). Returns a bitvector whose elements consist of elements of`lis`.(list->bitvector '(#t #f #t #t #f)) ⇒ #*10110 (list->bitvector '(0 1 1 1 0 1 0 1)) ⇒ #*01110101

- Function:
**string->bitvector**`s`¶ [SRFI-178] If

`s`is a valid bitvector literal (`#*`

where`b`...`b`is either`0`

or`1`

), returns a bitvector represented by the string. Otherwise,`#f`

is returned.(string->bitvector "#*1010001") ⇒ #*1010001 (string->bitvector "#*1001020") ⇒ #f

Note that this isn’t a sequence-conversion, but rather a conversion from external representation.

- Function:
**bitvector->string**`bv`¶ [SRFI-178] Convert a bitvector

`bv`to a string representation`#*`

.`b`...(bitvector->string #*1001010) ⇒ "#*1001010"

Note that this isn’t a sequence-conversion, but rather a conversion to external representation.

- Function:
**bitvector-ref/int**`bv k :optional fallback`¶ - Function:
**bitvector-ref/bool**`bv k :optional fallback`¶ [SRFI-178+] Retrieves the

`k`-th bit of a bitvector`bv`as an integer or a boolean value, respectively. If`k`is out of range,`fallback`is returned if it is given, or an error is raised otherwise. The`fallback`argument is Gauche’s extension.(bitvector-ref/int #*1010001 0) ⇒ 1 (bitvector-ref/bool #*1010001 0) ⇒ #t

If you use a universal accessor

`ref`

/`~`

, it returns the bit value as an integer (see Universal accessor).(~ #*11001001 1) ⇒ 1

- Function:
**bitvector-set!**`bv k bit`¶ [SRFI-178] Sets the

`k`-th bit of a bitvector`bv`with`bit`, which must be either one of 0, 1,`#f`

or`#t`

. An error is raised if`k`is out of range.This procedure is set as the setter of

`bitvector-ref/int`

and`bitvector-ref/bool`

. Since a bitvector is a sequence, you can also use`(setter ref)`

/`(setter ~)`

:(rlet1 z (make-bitvector 5 0) (set! (~ z 2) #t)) ⇒ #00100

- Function:
**bitvector-copy**`bv :optional start end`¶ [SRFI-178] Returns a copy of a bitvector

`bv`. If optional`start`and`end`indexes are given, the copy is limited in that range, where`start`is inclusive and`end`is exclusive.(bitvector-copy #*101001000 3) ⇒ #*001000 (bitvector-copy #*100101000 2 7) ⇒ #*01010

- Function:
**bitvector-copy!**`target tstart src :optional sstart send`¶ [SRFI-178] Copy a bitvector

`src`into a mutable bitvector`target`starting from`tstart`, mutating`target`. Optional`sstart`and`send`delimits the range in`src`.(rlet1 v (make-bitvector 10 0) (bitvector-copy! v 3 #*101101110 2 6)) ⇒ #*0001101000

- Function:
**bitvector-any-value?**`bv bit :optional start end`¶ - Function:
**bitvector-every-value?**`bv bit :optional start end`¶ Check if any or every bit of a bitvector

`bv`is`bit`, respectively. You can pass a boolean value or an exact integer 0 or 1 as`bit`.Optional

`start`/`end`arguments limit the range of bitvector to look at.;; See if at least one '1' (bitvector-any-value? #*000100 1) ⇒ #t (bitvector-any-value? #*000000 #t) ⇒ #f ;; See if at least one '0' (bitvector-any-value? #*110111 #f) ⇒ #t (bitvector-any-value? #*111111 0) ⇒ #f ;; See if all bits are '1' (bitvector-every-value? #*11111 #t) ⇒ #t (bitvector-every-value? #*00000 1) ⇒ #f ;; See if all bits are '0' (bitvector-every-value? #*11111 #f) ⇒ #f (bitvector-every-value? #*00000 0) ⇒ #t

A weak pointer is a reference to an object that doesn’t prevent
the object from being garbage-collected.
Gauche provides weak pointers as a *weak vector* object.
A weak vector is like a vector of objects, except each object
can be garbage collected if it is not referenced from objects
other than weak vectors. If the object is collected, the
entry of the weak vector is replaced for `#f.`

gosh> (define v (make-weak-vector 1)) v gosh> (weak-vector-ref v 0) #f gosh> (weak-vector-set! v 0 (cons 1 1)) #<undef> gosh> (weak-vector-ref v 0) (1 . 1) gosh> (gc) #<undef> gosh> (gc) #<undef> gosh> (weak-vector-ref v 0) #f

See `scheme.ephemeron`

- R7RS ephemeron, for R7RS-large way of weak pointers.

- Builtin Class:
**<weak-vector>**¶ -
The weak vector class. Inherits

`<sequence>`

and`<collection>`

, so you can use`gauche.collection`

(see`gauche.collection`

- Collection framework) and`gauche.sequence`

(see`gauche.sequence`

- Sequence framework).(coerce-to <weak-vector> '(1 2 3 4)) ⇒ a weak vector with four elements

- Function:
**make-weak-vector**`size`¶ Creates and returns a weak vector of size

`size`.

- Function:
**weak-vector-length**`wvec`¶ Returns the length of a weak vector

`wvec`.

- Function:
**weak-vector-ref**`wvec k :optional fallback`¶ Returns

`k`-th element of a weak vector`wvec`.By default,

`weak-vector-ref`

signals an error if`k`is negative, or greater than or equal to the size of`wvec`. However, if an optional argument`fallback`is given, it is returned for such case.If the element has been garbage collected, this procedure returns

`fallback`if it is provided,`#f`

otherwise.With

`gauche.sequence`

module, you can also use a method`ref`

.

- Function:
**weak-vector-set!**`wvec k obj`¶ Sets

`k`-th element of the weak vector`wvec`to`obj`. It is an error if`k`is negative or greater than or equal to the size of`wec`.

DRAFT