length>> ( object -- value )

Vocabulary

accessors

Inputs

object

an object

Outputs

value

an object

Definition

IN: accessors

GENERIC: length>> ( object -- value )

Methods

USING: accessors alien.c-types classes.struct
classes.struct.private math openssl.libssl ;

M: ASN1_STRING length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type int }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.BoneInfo ;

M: BoneInfo-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors classes.struct classes.struct.private
core-foundation math ;

M: CFRange length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type CFIndex }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf32_Phdr ;

M: Elf32_Phdr-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf32_Shdr ;

M: Elf32_Shdr-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf32_Sym ;

M: Elf32_Sym-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf64_Phdr ;

M: Elf64_Phdr-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf64_Shdr ;

M: Elf64_Shdr-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.elf.Elf64_Sym ;

M: Elf64_Sym-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors classes.struct classes.struct.private gdk2.ffi
gobject-introspection.standard-types math ;

M: GdkEventKey length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 32 }
        { class fixnum }
        { initial 0 }
        { type gint }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math readline.ffi ;

M: HISTORY_STATE length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 12 }
        { class fixnum }
        { initial 0 }
        { type int }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.Material ;

M: Material-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.MaterialMap ;

M: MaterialMap-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.Matrix ;

M: Matrix-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.Mesh ;

M: Mesh-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors classes.struct classes.struct.private
cocoa.types math ;

M: NSRange length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type NSUInteger }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.Vector2 ;

M: Vector2-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.raylib.Vector3 ;

M: Vector3-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors gobject-introspection.repository slots.private
;

M: array-type length>> 5 slot ; inline


USING: accessors arrays kernel.private sequences.private
slots.private ;

M: array length>> 1 slot { array-capacity } declare ; inline


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

M: bit-array length>> 2 slot { array-capacity } declare ; inline


USING: accessors bit-vectors kernel.private sequences.private
slots.private ;

M: bit-vector length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors math.bits slots.private ;

M: bits length>> 3 slot ; inline


USING: accessors math.blas.matrices slots.private ;

M: blas-matrix-rowcol-sequence length>> 6 slot ; inline


USING: accessors math.blas.vectors slots.private ;

M: blas-vector-base length>> 3 slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.benchmark.nbody-simd.body ;

M: body-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-vector length>>
    3 slot { array-capacity } declare ; inline


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

M: byte-array length>> 1 slot { array-capacity } declare ;
    inline


USING: accessors byte-vectors kernel.private sequences.private
slots.private ;

M: byte-vector length>> 3 slot { array-capacity } declare ;
    inline


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

M: c-string-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors alien.c-types cairo.ffi classes.struct
classes.struct.private math ;

M: cairo_path_data_t-header length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type int }
    } read-struct-slot ; inline


USING: accessors classes.struct classes.struct.private math
tools.image.analyzer.vm vm ;

M: callstack length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } read-struct-slot ; inline


USING: accessors bittorrent slots.private ;

M: cancel length>> 4 slot ; inline


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

M: char-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors math.combinatorics slots.private ;

M: combinations length>> 4 slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.alien.complex.complex-double ;

M: complex-double-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.alien.complex.complex-float ;

M: complex-float-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors gpu.textures kernel.private math slots.private
;

M: compressed-texture-data length>>
    4 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.chipmunk.ffi.cpContact ;

M: cpContact-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.chipmunk.ffi.cpPolyShapeAxis ;

M: cpPolyShapeAxis-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.chipmunk.ffi.cpVect ;

M: cpVect-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private math sequences.repeating
slots.private ;

M: cycles length>> 3 slot { integer } declare ; inline


USING: accessors bare slots.private ;

M: data length>> 2 slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private macho math ;

M: data_in_code_entry length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type uint16_t }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private dbf math ;

M: db4-memo-header length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private dbf math ;

M: dbf-field-header length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 16 }
        { class fixnum }
        { initial 0 }
        { type uint8_t }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.math.vectors.simd.cords.double-4 ;

M: double-4-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: double-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors alien.c-types classes.struct
classes.struct.private duckdb.ffi math ;

M: duckdb-string-pointer length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type uint32_t }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private duckdb.ffi math ;

M: duckdb_list_entry length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type uint64_t }
    } read-struct-slot ; inline


USING: accessors modern slots.private ;

M: expected-length-tokens length>> 4 slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.macho.fat_arch ;

M: fat_arch-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.fftw.ffi.fftw_complex ;

M: fftw_complex-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.math.vectors.simd.float-4 ;

M: float-4-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.math.vectors.simd.float-4 ;

M: float-4-vector length>> 3 slot { array-capacity } declare
    ; inline


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

M: float-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-vector length>>
    3 slot { array-capacity } declare ; inline


USING: accessors circular kernel.private math slots.private ;

M: growing-circular length>> 4 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.math.floats.half.half ;

M: half-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors alien.c-types classes.struct
classes.struct.private duckdb.ffi math ;

M: inlined-duckdb-string length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type uint32_t }
    } read-struct-slot ; inline


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

M: int-array length>> 3 slot { array-capacity } declare ; inline


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

M: int32_t-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors dns slots.private ;

M: invalid-hinfo-record length>> 2 slot ; inline


USING: accessors bare slots.private ;

M: invalid-length length>> 2 slot ; inline


USING: accessors images.jpeg.private slots.private ;

M: jpeg-chunk length>> 2 slot ; inline


USING: accessors math.combinatorics slots.private ;

M: k-permutations length>> 2 slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.io.files.acls.macos.ffi.kauth_ace ;

M: kauth_ace-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.unix.kqueue.kevent ;

M: kevent-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors game.input.dinput.keys-array kernel.private
math slots.private ;

M: keys-array length>> 3 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.libusb.libusb_iso_packet_descriptor
;

M: libusb_iso_packet_descriptor-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private libusb math ;

M: libusb_iso_packet_descriptor length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private libusb math ;

M: libusb_transfer length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 20 }
        { class fixnum }
        { initial 0 }
        { type int }
    } read-struct-slot ; inline


USING: accessors bare slots.private ;

M: list length>> 3 slot ; inline


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

M: long-array length>> 3 slot { array-capacity } declare ;
    inline


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

M: longlong-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors io.mmap slots.private ;

M: mapped-file length>> 6 slot ; inline


USING: accessors kernel.private math mongodb.msg slots.private ;

M: mdb-msg length>> 5 slot { integer } declare ; inline


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

M: nibble-array length>> 2 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.macho.nlist ;

M: nlist-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.macho.nlist_64 ;

M: nlist_64-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private math math.parser.private
slots.private ;

M: number-parse length>> 3 slot { fixnum } declare ; inline


USING: accessors kernel.private math sequences.padded
slots.private ;

M: padded length>> 3 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.papier.map.papier-vertex-struct ;

M: papier-vertex-struct-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.fluids.particle_t ;

M: particle_t-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors math.combinatorics slots.private ;

M: permutations length>> 2 slot ; inline


USING: accessors benchmark.tuple-arrays kernel.private
sequences.private slots.private ;

M: point-array length>> 4 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.benchmark.struct-arrays.point ;

M: point-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private math ranges slots.private ;

M: range length>> 3 slot { integer } declare ; inline


USING: accessors bittorrent slots.private ;

M: reject-request length>> 4 slot ; inline


USING: accessors kernel.private math sequences slots.private ;

M: repetition length>> 2 slot { integer } declare ; inline


USING: accessors bittorrent slots.private ;

M: request length>> 4 slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.rlgl.rlDrawCall ;

M: rlDrawCall-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.rlgl.rlVertexBuffer ;

M: rlVertexBuffer-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sbufs sequences.private
slots.private ;

M: sbuf length>> 3 slot { array-capacity } declare ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math yaml.ffi ;

M: scalar_event_data length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 24 }
        { class integer }
        { initial 0 }
        { type size_t }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math yaml.ffi ;

M: scalar_node_data length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math yaml.ffi ;

M: scalar_token_data length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.macho.section ;

M: section-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.macho.section_64 ;

M: section_64-array length>>
    3 slot { array-capacity } declare ; inline


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

M: short-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.alien.c-types.short ;

M: short-vector length>> 3 slot { array-capacity } declare ;
    inline


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

M: size_t-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private math sequences.snipped
slots.private ;

M: snipped length>> 4 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.unix.statfs.macos.statfs64 ;

M: statfs64-array length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors classes.struct classes.struct.private math
tools.image.analyzer.vm vm ;

M: string length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
strings ;

M: string length>> 1 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.ogg.theora.th-quant-ranges ;

M: th-quant-ranges-array length>>
    3 slot { array-capacity } declare ; inline


USING: accessors calendar.ranges kernel.private math
slots.private ;

M: timestamp-range length>> 3 slot { integer } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.unix.time.timeval ;

M: timeval-array length>> 3 slot { array-capacity } declare
    ; inline


USING: L-system accessors slots.private ;

M: turtle length>> 5 slot ; inline


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

M: u16-array length>> 3 slot { array-capacity } declare ; inline


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

M: u32-array length>> 3 slot { array-capacity } declare ; inline


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

M: u64-array length>> 3 slot { array-capacity } declare ; inline


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

M: u8-array length>> 3 slot { array-capacity } declare ; inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.math.vectors.simd.uchar-16 ;

M: uchar-16-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: uchar-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-arrays.instances.math.vectors.simd.uint-4 ;

M: uint-4-array length>> 3 slot { array-capacity } declare ;
    inline


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

M: uint-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.alien.c-types.uint ;

M: uint-vector length>> 3 slot { array-capacity } declare ;
    inline


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

M: uint16_t-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: uint32_t-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: uint64_t-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: uint8_t-array length>> 3 slot { array-capacity } declare
    ; inline


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

M: uintptr_t-array length>>
    3 slot { array-capacity } declare ; inline


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

M: ulong-array length>> 3 slot { array-capacity } declare ;
    inline


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

M: ulonglong-array length>>
    3 slot { array-capacity } declare ; inline


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

M: ushort-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors kernel.private sequences.private slots.private
specialized-vectors.instances.alien.c-types.ushort ;

M: ushort-vector length>> 3 slot { array-capacity } declare
    ; inline


USING: accessors kernel.private sequences.private slots.private
vectors ;

M: vector length>> 3 slot { array-capacity } declare ; inline


USING: accessors alien.endian classes.struct
classes.struct.private dbf math ;

M: vfp-memo-header length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type ube32 }
    } read-struct-slot ; inline


USING: accessors kernel.private sequences.private slots.private
vlists ;

M: vlist length>> 2 slot { array-capacity } declare ; inline


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

M: void*-array length>> 3 slot { array-capacity } declare ;
    inline


USING: accessors alien.c-types classes.struct
classes.struct.private math yaml.ffi ;

M: yaml_emitter_scalar_data length>>
    T{ struct-slot-spec
        { name "length" }
        { offset 8 }
        { class integer }
        { initial 0 }
        { type size_t }
    } read-struct-slot ; inline