resize ( n seq -- newseq )
Factor handbook » The language » Collections » Resizable sequence implementation

Prev:

growable

Vocabulary
sequences.private

Inputs

n	a non-negative integer
seq	a sequence

Outputs

newseq

a new sequence

Word description
Creates a new sequence of the same type as seq with n elements, and copies the contents of seq into the new sequence. If n exceeds the length of seq, the remaining elements are filled with 0.

Notes
This generic word is only implemented for strings and arrays.

Definition

IN: sequences.private

GENERIC: resize ( n seq -- newseq ) flushable

Methods

USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.BoneInfo ;

M: BoneInfo-array resize
    [
        [ \ BoneInfo heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-BoneInfo-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf32_Phdr ;

M: Elf32_Phdr-array resize
    [
        [ \ Elf32_Phdr heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf32_Phdr-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf32_Shdr ;

M: Elf32_Shdr-array resize
    [
        [ \ Elf32_Shdr heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf32_Shdr-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf32_Sym ;

M: Elf32_Sym-array resize
    [
        [ \ Elf32_Sym heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf32_Sym-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf64_Phdr ;

M: Elf64_Phdr-array resize
    [
        [ \ Elf64_Phdr heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf64_Phdr-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf64_Shdr ;

M: Elf64_Shdr-array resize
    [
        [ \ Elf64_Shdr heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf64_Shdr-array> ; inline


USING: accessors alien.c-types byte-arrays elf kernel math
sequences.private specialized-arrays.instances.elf.Elf64_Sym ;

M: Elf64_Sym-array resize
    [
        [ \ Elf64_Sym heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Elf64_Sym-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.Material ;

M: Material-array resize
    [
        [ \ Material heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Material-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private
specialized-arrays.instances.raylib.MaterialMap ;

M: MaterialMap-array resize
    [
        [ \ MaterialMap heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-MaterialMap-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.Matrix ;

M: Matrix-array resize
    [
        [ \ Matrix heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Matrix-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.Mesh ;

M: Mesh-array resize
    [
        [ \ Mesh heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Mesh-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.Vector2 ;

M: Vector2-array resize
    [
        [ \ Vector2 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Vector2-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math raylib
sequences.private specialized-arrays.instances.raylib.Vector3 ;

M: Vector3-array resize
    [
        [ \ Vector3 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-Vector3-array> ; inline


USING: arrays sequences.private ;

M: array resize resize-array ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.floats.small.c-types sequences.private
specialized-arrays.instances.math.floats.small.c-types.bfloat ;

M: bfloat-array resize
    [
        [ \ bfloat heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-bfloat-array> ; inline


USING: accessors bit-arrays bit-arrays.private byte-arrays
kernel sequences.private ;

M: bit-array resize
    over integer-array-capacity?
    [ over bad-array-length ] unless dupd
    [ bits>bytes ] [ underlying>> ] bi* resize-byte-array
    bit-array boa zero-end-bits ; inline


USING: accessors alien.c-types benchmark.nbody-simd byte-arrays
kernel math sequences.private
specialized-arrays.instances.benchmark.nbody-simd.body ;

M: body-array resize
    [
        [ \ body heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-body-array> ; inline


USING: accessors alien.c-types byte-arrays gpu.demos.bunny
kernel math sequences.private
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-array resize
    [
        [ \ bunny-vertex-struct heap-size * ] [ underlying>> ]
        bi* resize-byte-array
    ] keepd <direct-bunny-vertex-struct-array> ; inline


USING: byte-arrays sequences.private ;

M: byte-array resize resize-byte-array ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.c-string ;

M: c-string-array resize
    [
        [ \ c-string heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-c-string-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.char ;

M: char-array resize
    [
        [ \ char heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-char-array> ; inline


USING: accessors alien.c-types alien.complex byte-arrays kernel
math sequences.private
specialized-arrays.instances.alien.complex.complex-double ;

M: complex-double-array resize
    [
        [ \ complex-double heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-complex-double-array> ; inline


USING: accessors alien.c-types alien.complex byte-arrays kernel
math sequences.private
specialized-arrays.instances.alien.complex.complex-float ;

M: complex-float-array resize
    [
        [ \ complex-float heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-complex-float-array> ; inline


USING: accessors alien.c-types byte-arrays chipmunk.ffi kernel
math sequences.private
specialized-arrays.instances.chipmunk.ffi.cpContact ;

M: cpContact-array resize
    [
        [ \ cpContact heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-cpContact-array> ; inline


USING: accessors alien.c-types byte-arrays chipmunk.ffi kernel
math sequences.private
specialized-arrays.instances.chipmunk.ffi.cpPolyShapeAxis ;

M: cpPolyShapeAxis-array resize
    [
        [ \ cpPolyShapeAxis heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-cpPolyShapeAxis-array> ; inline


USING: accessors alien.c-types byte-arrays chipmunk.ffi kernel
math sequences.private
specialized-arrays.instances.chipmunk.ffi.cpVect ;

M: cpVect-array resize
    [
        [ \ cpVect heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-cpVect-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.vectors.simd.cords sequences.private
specialized-arrays.instances.math.vectors.simd.cords.double-4 ;

M: double-4-array resize
    [
        [ \ double-4 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-double-4-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.double ;

M: double-array resize
    [
        [ \ double heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-double-array> ; inline


USING: accessors alien.c-types byte-arrays kernel macho math
sequences.private specialized-arrays.instances.macho.fat_arch ;

M: fat_arch-array resize
    [
        [ \ fat_arch heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-fat_arch-array> ; inline


USING: accessors alien.c-types byte-arrays fftw.ffi kernel math
sequences.private
specialized-arrays.instances.fftw.ffi.fftw_complex ;

M: fftw_complex-array resize
    [
        [ \ fftw_complex heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-fftw_complex-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.vectors.simd sequences.private
specialized-arrays.instances.math.vectors.simd.float-4 ;

M: float-4-array resize
    [
        [ \ float-4 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-float-4-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.float ;

M: float-array resize
    [
        [ \ float heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-float-array> ; inline


USING: accessors alien.c-types byte-arrays game.loop.benchmark
kernel math sequences.private
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-array resize
    [
        [ \ game-loop-benchmark heap-size * ] [ underlying>> ]
        bi* resize-byte-array
    ] keepd <direct-game-loop-benchmark-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.floats.half sequences.private
specialized-arrays.instances.math.floats.half.half ;

M: half-array resize
    [
        [ \ half heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-half-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.floats.small.c-types sequences.private
specialized-arrays.instances.math.floats.small.c-types.half ;

M: half-array resize
    [
        [ \ half heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-half-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.alien.c-types.int
;

M: int-array resize
    [
        [ \ int heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-int-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.int32_t ;

M: int32_t-array resize
    [
        [ \ int32_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-int32_t-array> ; inline


USING: accessors alien.c-types byte-arrays
io.files.acls.macos.ffi kernel math sequences.private
specialized-arrays.instances.io.files.acls.macos.ffi.kauth_ace ;

M: kauth_ace-array resize
    [
        [ \ kauth_ace heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-kauth_ace-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.unix.kqueue.kevent unix.kqueue ;

M: kevent-array resize
    [
        [ \ kevent heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-kevent-array> ; inline


USING: accessors alien.c-types byte-arrays kernel libusb math
sequences.private
specialized-arrays.instances.libusb.libusb_iso_packet_descriptor
;

M: libusb_iso_packet_descriptor-array resize
    [
        [ \ libusb_iso_packet_descriptor heap-size * ]
        [ underlying>> ] bi* resize-byte-array
    ] keepd <direct-libusb_iso_packet_descriptor-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.long ;

M: long-array resize
    [
        [ \ long heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-long-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.longlong ;

M: longlong-array resize
    [
        [ \ longlong heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-longlong-array> ; inline


USING: accessors byte-arrays kernel nibble-arrays
nibble-arrays.private sequences.private ;

M: nibble-array resize
    [ drop ]
    [ [ nibbles>bytes ] [ underlying>> ] bi* resize-byte-array ]
    2bi nibble-array boa ;


USING: accessors alien.c-types byte-arrays kernel macho math
sequences.private specialized-arrays.instances.macho.nlist ;

M: nlist-array resize
    [
        [ \ nlist heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-nlist-array> ; inline


USING: accessors alien.c-types byte-arrays kernel macho math
sequences.private specialized-arrays.instances.macho.nlist_64 ;

M: nlist_64-array resize
    [
        [ \ nlist_64 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-nlist_64-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
papier.map sequences.private
specialized-arrays.instances.papier.map.papier-vertex-struct ;

M: papier-vertex-struct-array resize
    [
        [ \ papier-vertex-struct heap-size * ] [ underlying>> ]
        bi* resize-byte-array
    ] keepd <direct-papier-vertex-struct-array> ; inline


USING: accessors alien.c-types byte-arrays fluids kernel math
sequences.private specialized-arrays.instances.fluids.particle_t
;

M: particle_t-array resize
    [
        [ \ particle_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-particle_t-array> ; inline


USING: accessors alien.c-types benchmark.struct-arrays
byte-arrays kernel math sequences.private
specialized-arrays.instances.benchmark.struct-arrays.point ;

M: point-array resize
    [
        [ \ point heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-point-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math rlgl
sequences.private specialized-arrays.instances.rlgl.rlDrawCall ;

M: rlDrawCall-array resize
    [
        [ \ rlDrawCall heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-rlDrawCall-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math rlgl
sequences.private
specialized-arrays.instances.rlgl.rlVertexBuffer ;

M: rlVertexBuffer-array resize
    [
        [ \ rlVertexBuffer heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-rlVertexBuffer-array> ; inline


USING: accessors alien.c-types byte-arrays kernel macho math
sequences.private specialized-arrays.instances.macho.section ;

M: section-array resize
    [
        [ \ section heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-section-array> ; inline


USING: accessors alien.c-types byte-arrays kernel macho math
sequences.private specialized-arrays.instances.macho.section_64
;

M: section_64-array resize
    [
        [ \ section_64 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-section_64-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.short ;

M: short-array resize
    [
        [ \ short heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-short-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.size_t ;

M: size_t-array resize
    [
        [ \ size_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-size_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.unix.statfs.macos.statfs64
unix.statfs.macos ;

M: statfs64-array resize
    [
        [ \ statfs64 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-statfs64-array> ; inline


USING: sequences.private strings ;

M: string resize resize-string ; inline


USING: accessors alien.c-types byte-arrays kernel math
ogg.theora sequences.private
specialized-arrays.instances.ogg.theora.th-quant-ranges ;

M: th-quant-ranges-array resize
    [
        [ \ th-quant-ranges heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-th-quant-ranges-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.unix.time.timeval
unix.time ;

M: timeval-array resize
    [
        [ \ timeval heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-timeval-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.alien.c-types.u16
;

M: u16-array resize
    [
        [ \ u16 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-u16-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.alien.c-types.u32
;

M: u32-array resize
    [
        [ \ u32 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-u32-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.alien.c-types.u64
;

M: u64-array resize
    [
        [ \ u64 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-u64-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private specialized-arrays.instances.alien.c-types.u8
;

M: u8-array resize
    [
        [ \ u8 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-u8-array> ; inline


USING: accessors alien.c-types alien.endian byte-arrays kernel
math sequences.private
specialized-arrays.instances.alien.endian.ube32 ;

M: ube32-array resize
    [
        [ \ ube32 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-ube32-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.vectors.simd sequences.private
specialized-arrays.instances.math.vectors.simd.uchar-16 ;

M: uchar-16-array resize
    [
        [ \ uchar-16 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uchar-16-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uchar ;

M: uchar-array resize
    [
        [ \ uchar heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uchar-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
math.vectors.simd sequences.private
specialized-arrays.instances.math.vectors.simd.uint-4 ;

M: uint-4-array resize
    [
        [ \ uint-4 heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint-4-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uint ;

M: uint-array resize
    [
        [ \ uint heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uint16_t ;

M: uint16_t-array resize
    [
        [ \ uint16_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint16_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uint32_t ;

M: uint32_t-array resize
    [
        [ \ uint32_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint32_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uint64_t ;

M: uint64_t-array resize
    [
        [ \ uint64_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint64_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uint8_t ;

M: uint8_t-array resize
    [
        [ \ uint8_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uint8_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.uintptr_t ;

M: uintptr_t-array resize
    [
        [ \ uintptr_t heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-uintptr_t-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.ulong ;

M: ulong-array resize
    [
        [ \ ulong heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-ulong-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.ulonglong ;

M: ulonglong-array resize
    [
        [ \ ulonglong heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-ulonglong-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.ushort ;

M: ushort-array resize
    [
        [ \ ushort heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-ushort-array> ; inline


USING: accessors alien.c-types byte-arrays kernel math
sequences.private
specialized-arrays.instances.alien.c-types.void* ;

M: void*-array resize
    [
        [ \ void* heap-size * ] [ underlying>> ] bi*
        resize-byte-array
    ] keepd <direct-void*-array> ; inline