underlying>> ( object -- value )

Vocabulary

accessors

Inputs

object

an object

Outputs

value

an object

Definition

IN: accessors

GENERIC: underlying>> ( object -- value )

Methods

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

M: BoneInfo-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: Elf32_Phdr-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Elf32_Shdr-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Elf32_Sym-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Elf64_Phdr-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Elf64_Shdr-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Elf64_Sym-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Material-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: MaterialMap-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: Matrix-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: Mesh-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: Vector2-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: Vector3-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors alien kernel.private slots.private ;

M: alien underlying>> 1 slot { c-ptr } declare ; inline


USING: accessors sequences.inserters slots.private ;

M: appender underlying>> 2 slot ; inline


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

M: bit-array underlying>> 3 slot { byte-array } declare ; inline


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

M: bit-vector underlying>> 2 slot { bit-array } declare ; inline


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

M: blas-matrix-base underlying>> 2 slot ; inline


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

M: blas-vector-base underlying>> 2 slot ; inline


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

M: body-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: bunny-vertex-struct-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: bunny-vertex-struct-vector underlying>>
    2 slot { bunny-vertex-struct-array } declare ; inline


USING: accessors byte-arrays io.streams.byte-array
kernel.private slots.private ;

M: byte-reader underlying>> 2 slot { byte-array } declare ;
    inline


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

M: byte-vector underlying>> 2 slot { byte-array } declare ;
    inline


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

M: c-string-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: char-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: complex-double-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: complex-float-array underlying>> 2 slot { c-ptr } declare
    ; inline


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

M: cpContact-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: cpPolyShapeAxis-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: cpVect-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors io.crlf slots.private ;

M: crlf-stream underlying>> 2 slot ; inline


USING: accessors descriptive slots.private ;

M: descriptive-error underlying>> 3 slot ; inline


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

M: double-4-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: double-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: fat_arch-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: fftw_complex-array underlying>> 2 slot { c-ptr } declare
    ; inline


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

M: float-4-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: float-4-vector underlying>>
    2 slot { float-4-array } declare ; inline


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

M: float-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: game-loop-benchmark-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: game-loop-benchmark-vector underlying>>
    2 slot { game-loop-benchmark-array } declare ; inline


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

M: half-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors hash-sets.identity.private slots.private ;

M: identity-wrapper underlying>> 2 slot ; inline


USING: accessors hashtables.identity.private slots.private ;

M: identity-wrapper underlying>> 2 slot ; inline


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

M: int-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: int32_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: kauth_ace-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: kevent-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: keys-array underlying>> 2 slot { sequence } declare ; inline


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

M: libusb_iso_packet_descriptor-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: long-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: longlong-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: nibble-array underlying>> 3 slot { byte-array } declare ;
    inline


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

M: nlist-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: nlist_64-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors arrays.shaped slots.private ;

M: no-abnormally-shaped-arrays underlying>> 2 slot ; inline


USING: accessors hash-sets.numbers.private kernel.private math
slots.private ;

M: number-wrapper underlying>> 2 slot { number } declare ;
    inline


USING: accessors hashtables.numbers.private kernel.private math
slots.private ;

M: number-wrapper underlying>> 2 slot { number } declare ;
    inline


USING: accessors sequences.inserters slots.private ;

M: offset-growable underlying>> 2 slot ; inline


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

M: padded underlying>> 2 slot { sequence } declare ; inline


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

M: papier-vertex-struct-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: particle_t-array underlying>> 2 slot { c-ptr } declare ;
    inline


USING: accessors alien kernel.private memory.piles slots.private
;

M: pile underlying>> 2 slot { c-ptr } declare ; inline


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

M: point-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors sequences.inserters slots.private ;

M: replacer underlying>> 2 slot ; inline


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

M: rlDrawCall-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: rlVertexBuffer-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: sbuf underlying>> 2 slot { string } declare ; inline


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

M: section-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: section_64-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: sequence-wrapper underlying>> 2 slot { sequence } declare
    ; inline


USING: accessors hash-sets.sequences.private kernel.private
sequences slots.private ;

M: sequence-wrapper underlying>> 2 slot { sequence } declare
    ; inline


USING: accessors arrays.shaped slots.private ;

M: shaped-array underlying>> 2 slot ; inline


USING: accessors sequences.shifted slots.private ;

M: shifted underlying>> 2 slot ; inline


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

M: short-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: short-vector underlying>> 2 slot { short-array } declare
    ; inline


USING: accessors byte-arrays kernel.private math.vectors.simd
slots.private ;

M: simd-128 underlying>> 2 slot { byte-array } declare ; inline


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

M: size_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: statfs64-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors io.streams.string kernel.private slots.private
strings ;

M: string-reader underlying>> 2 slot { string } declare ; inline


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

M: th-quant-ranges-array underlying>>
    2 slot { c-ptr } declare ; inline


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

M: timeval-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: u16-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: u32-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: u64-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: u8-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uchar-16-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uchar-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint-4-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint-vector underlying>> 2 slot { uint-array } declare ;
    inline


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

M: uint16_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint32_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint64_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uint8_t-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: uintptr_t-array underlying>> 2 slot { c-ptr } declare ;
    inline


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

M: ulong-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: ulonglong-array underlying>> 2 slot { c-ptr } declare ;
    inline


USING: accessors arrays.shaped slots.private ;

M: underlying-shape-mismatch underlying>> 2 slot ; inline


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

M: ushort-array underlying>> 2 slot { c-ptr } declare ; inline


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

M: ushort-vector underlying>>
    2 slot { ushort-array } declare ; inline


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

M: vector underlying>> 2 slot { array } declare ; inline


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

M: void*-array underlying>> 2 slot { c-ptr } declare ; inline


USING: accessors hash-sets hash-sets.wrapped kernel.private
slots.private ;

M: wrapped-hash-set underlying>> 2 slot { hash-set } declare
    ; inline


USING: accessors hashtables hashtables.wrapped kernel.private
slots.private ;

M: wrapped-hashtable underlying>>
    2 slot { hashtable } declare ; inline


USING: accessors slots.private zeromq ;

M: zmq-context underlying>> 2 slot ; inline


USING: accessors slots.private zeromq ;

M: zmq-message underlying>> 2 slot ; inline


USING: accessors slots.private zeromq ;

M: zmq-socket underlying>> 2 slot ; inline