6.13.1 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 u8vectors 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 (proc i) for all 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> vector) and (coerce-to <vector> list) as well.

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> vector) and (coerce-to <vector> string) as well.

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).

6.13.2 Uniform vectors ¶

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.

Uvector classes ¶

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)

Uvector literals ¶

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)

Uvector constructors ¶

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)

Uvector generic operations ¶

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.

Uvector type-specific operations ¶

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)

Conversion between strings and uvectors ¶

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"

6.13.3 Bitvectors ¶

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 (#*b... where 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

6.13.4 Weak vectors ¶

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.