n>> ( object -- value )

Vocabulary

accessors

Inputs

object

an object

Outputs

value

an object

Definition

IN: accessors

GENERIC: n>> ( object -- value )

Methods

USING: accessors compiler.cfg.instructions slots.private ;

M: ##select-vector n>> 4 slot ; inline


USING: accessors cuda.ptx kernel.private math slots.private ;

M: .maxnreg n>> 2 slot { integer } declare ; inline


USING: accessors io.files.acls.macos slots.private ;

M: acl-init-failed n>> 2 slot ; inline


USING: accessors io.sockets slots.private ;

M: addrinfo-error n>> 2 slot ; inline


USING: accessors regexp.ast slots.private ;

M: at-least n>> 2 slot ; inline


USING: accessors io.files.acls.macos.ffi slots.private ;

M: bad-acl-tag-t n>> 2 slot ; inline


USING: accessors bit-arrays slots.private ;

M: bad-array-length n>> 2 slot ; inline


USING: accessors nibble-arrays slots.private ;

M: bad-array-length n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-compression n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-extra-samples n>> 2 slot ; inline


USING: accessors images.png slots.private ;

M: bad-filter n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-jpeg-proc n>> 2 slot ; inline


USING: accessors endian.private slots.private ;

M: bad-length n>> 3 slot ; inline


USING: accessors io.mmap slots.private ;

M: bad-mmap-size n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-photometric-interpretation n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-planar-configuration n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-predictor n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-resolution-unit n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-sample-format n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: bad-small-ifd-type n>> 2 slot ; inline


USING: accessors gml.parser slots.private ;

M: bad-vector-length n>> 3 slot ; inline


USING: accessors random slots.private ;

M: binomial-distribution n>> 2 slot ; inline


USING: accessors random.blum-blum-shub slots.private ;

M: blum-blum-shub n>> 3 slot ; inline


USING: accessors images.bitmap slots.private ;

M: bmp-not-supported n>> 2 slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math tools.image.analyzer.vm.64 ;

M: boxed-float n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 8 }
        { class float }
        { initial 0.0 }
        { type double }
    } read-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private math tools.image.analyzer.vm.32 ;

M: boxed-float n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 16 }
        { class float }
        { initial 0.0 }
        { type double }
    } read-struct-slot ; inline


USING: accessors slots.private ulid ;

M: bytes>ulid-bad-length n>> 2 slot ; inline


USING: accessors cairo slots.private ;

M: cairo-error n>> 2 slot ; inline


USING: accessors project-euler.064.private slots.private ;

M: cfrac n>> 2 slot ; inline


USING: accessors openai slots.private ;

M: chat-completion n>> 6 slot ; inline


USING: accessors grouping.private slots.private ;

M: chunking n>> 3 slot ; inline


USING: accessors grouping slots.private ;

M: circular-clumps n>> 3 slot ; inline


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

M: circular-iterator n>> 3 slot { integer } declare ; inline


USING: accessors modern slots.private ;

M: colon-word-must-be-all-uppercase-or-lowercase n>> 2 slot
    ; inline


USING: accessors openai slots.private ;

M: completion n>> 8 slot ; inline


USING: accessors modern slots.private ;

M: compound-syntax-disallowed n>> 2 slot ; inline


USING: accessors core-foundation.launch-services slots.private ;

M: core-foundation-error n>> 2 slot ; inline


USING: accessors concurrency.count-downs slots.private ;

M: count-down-tuple n>> 2 slot ; inline


USING: accessors quiz slots.private ;

M: country-code-from-flag n>> 2 slot ; inline


USING: accessors quiz slots.private ;

M: country-name-from-flag n>> 2 slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpContact n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 16 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpDampedSpring n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 176 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpPinJoint n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 128 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpPolyShapeAxis n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 0 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpSegmentQueryInfo n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 16 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpSegmentShape n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 144 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors chipmunk.ffi classes.struct
classes.struct.private ;

M: cpSlideJoint n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 136 }
        { class cpVect }
        { initial S{ cpVect { x 0.0 } { y 0.0 } } }
        { type cpVect }
    } read-struct-slot ; inline


USING: accessors benchmark.chameneos-redux slots.private ;

M: creature n>> 2 slot ; inline


USING: accessors slots.private units ;

M: dimensioned-power-op-expects-integer n>> 3 slot ; inline


USING: accessors generic.single slots.private ;

M: echelon-dispatch-engine n>> 2 slot ; inline


USING: accessors openai slots.private ;

M: edit n>> 5 slot ; inline


USING: accessors gml.runtime kernel.private math slots.private ;

M: exec-register n>> 3 slot { fixnum } declare ; inline


USING: accessors modern slots.private ;

M: expected-length-tokens n>> 2 slot ; inline


USING: accessors bootstrap.image.private slots.private ;

M: fake-bignum n>> 2 slot ; inline


USING: accessors quiz slots.private ;

M: flag-from-country-code n>> 2 slot ; inline


USING: accessors quiz slots.private ;

M: flag-from-country-name n>> 2 slot ; inline


USING: accessors regexp.ast slots.private ;

M: from-to n>> 2 slot ; inline


USING: accessors ftp slots.private ;

M: ftp-response n>> 2 slot ; inline


USING: accessors grouping slots.private ;

M: groups-error n>> 3 slot ; inline


USING: accessors slots.private synth ;

M: harmonic n>> 2 slot ; inline


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

M: hash-set-cursor n>> 3 slot { fixnum } declare ; inline


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

M: hashtable-cursor n>> 3 slot { fixnum } declare ; inline


USING: accessors benchmark.typecheck3 slots.private ;

M: hello n>> 2 slot ; inline


USING: accessors benchmark.typecheck2 slots.private ;

M: hello n>> 2 slot ; inline


USING: accessors benchmark.typecheck1 slots.private ;

M: hello n>> 2 slot ; inline


USING: accessors cpu.arm.64.assembler.private slots.private ;

M: illegal-bitmask-element n>> 2 slot ; inline


USING: accessors cpu.arm.64.assembler.private slots.private ;

M: illegal-bitmask-immediate n>> 2 slot ; inline


USING: accessors openai slots.private ;

M: image-edit n>> 5 slot ; inline


USING: accessors openai slots.private ;

M: image-generation n>> 3 slot ; inline


USING: accessors openai slots.private ;

M: image-variation n>> 3 slot ; inline


USING: accessors slots.private webapps.imagebin ;

M: imagebin n>> 5 slot ; inline


USING: accessors cpu.arm.64.assembler.private slots.private ;

M: imm-out-of-range n>> 3 slot ; inline


USING: accessors io.streams.zeros slots.private ;

M: invalid-file-size n>> 2 slot ; inline


USING: accessors hex-strings slots.private ;

M: invalid-hex-string-length n>> 2 slot ; inline


USING: accessors slots.private tinyvg ;

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


USING: accessors slots.private tools.annotations.assertions ;

M: invalid-nth-unsafe n>> 2 slot ; inline


USING: accessors alien.endian slots.private ;

M: invalid-signed-conversion n>> 2 slot ; inline


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

M: iota n>> 2 slot { integer } declare ; inline


USING: accessors compiler.cfg.ssa.interference.private
slots.private ;

M: iterator n>> 3 slot ; inline


USING: accessors lists.lazy slots.private ;

M: lazy-from-by n>> 2 slot ; inline


USING: accessors lists.lazy slots.private ;

M: lazy-take n>> 3 slot ; inline


USING: accessors modern slots.private ;

M: lex-expected-but-got-eof n>> 2 slot ; inline


USING: accessors io.streams.limited slots.private ;

M: limit-exceeded n>> 2 slot ; inline


USING: accessors compiler.cfg.registers kernel.private math
slots.private ;

M: loc n>> 2 slot { integer } declare ; inline


USING: accessors modern slots.private ;

M: long-opening-mismatch n>> 4 slot ; inline


USING: accessors quiz slots.private ;

M: math-multiplication n>> 3 slot ; inline


USING: accessors quiz slots.private ;

M: multiple-choice-question n>> 8 slot ; inline


USING: accessors math slots.private ;

M: negative-number-expected n>> 2 slot ; inline


USING: accessors kernel.private math math.matrices.extras
slots.private ;

M: negative-power-matrix n>> 3 slot { integer } declare ; inline


USING: accessors math.polynomials slots.private ;

M: negative-power-polynomial n>> 3 slot ; inline


USING: accessors modern slots.private ;

M: no-backslash-payload n>> 2 slot ; inline


USING: accessors math.primes slots.private ;

M: no-relative-prime n>> 2 slot ; inline


USING: accessors math slots.private ;

M: non-negative-number-expected n>> 2 slot ; inline


USING: accessors kernel.private math math.matrices.extras
slots.private ;

M: non-square-determinant n>> 3 slot { integer } declare ;
    inline


USING: accessors math.functions slots.private ;

M: non-trivial-divisor n>> 2 slot ; inline


USING: accessors bitstreams slots.private ;

M: not-enough-bits n>> 2 slot ; inline


USING: accessors bitstreams.private slots.private ;

M: not-enough-widthed-bits n>> 3 slot ; inline


USING: accessors cuda.nvcc slots.private ;

M: nvcc-failed n>> 2 slot ; inline


USING: accessors sequences.modified slots.private ;

M: offset n>> 3 slot ; inline


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

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


USING: accessors math slots.private ;

M: positive-number-expected n>> 2 slot ; inline


USING: accessors gml.runtime kernel.private math slots.private ;

M: read-register n>> 3 slot { fixnum } declare ; inline


USING: accessors db slots.private ;

M: result-set n>> 8 slot ; inline


USING: accessors gml.core slots.private ;

M: roll-out-of-bounds n>> 2 slot ; inline


USING: accessors project-euler.059.private slots.private ;

M: rollover n>> 3 slot ; inline


USING: accessors roman.private slots.private ;

M: roman-range-error n>> 2 slot ; inline


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

M: rotated n>> 3 slot { integer } declare ; inline


USING: accessors math.statistics.running slots.private ;

M: running-regress n>> 2 slot ; inline


USING: accessors math.statistics.running slots.private ;

M: running-stats n>> 2 slot ; inline


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

M: sequence-cursor n>> 3 slot { fixnum } declare ; inline


USING: accessors sequences.parser slots.private ;

M: sequence-parser n>> 3 slot ; inline


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

M: sfmt-state n>>
    T{ struct-slot-spec
        { name "n" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type uint }
    } read-struct-slot ; inline


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

M: shifted n>> 3 slot { integer } declare ; inline


USING: accessors slots.private unix.signals ;

M: signal n>> 2 slot ; inline


USING: accessors compiler.cfg.instructions kernel.private math
slots.private ;

M: spill-slot n>> 2 slot { integer } declare ; inline


USING: accessors db.sqlite.lib slots.private ;

M: sqlite-error n>> 2 slot ; inline


USING: accessors interpolate.private slots.private ;

M: stack-var n>> 2 slot ; inline


USING: accessors io.streams.throwing slots.private ;

M: stream-exhausted n>> 2 slot ; inline


USING: accessors modern slots.private ;

M: string-expected-got-eof n>> 2 slot ; inline


USING: accessors modern.slices slots.private ;

M: subseq-expected-but-got-eof n>> 2 slot ; inline


USING: accessors compiler.cfg.linear-scan.live-intervals
slots.private ;

M: sync-point n>> 2 slot ; inline


USING: accessors modern.slices slots.private ;

M: take-slice-error n>> 2 slot ; inline


USING: accessors modern slots.private ;

M: token-expected n>> 2 slot ; inline


USING: accessors math.primes slots.private ;

M: too-few-primes n>> 2 slot ; inline


USING: accessors random slots.private ;

M: too-many-samples n>> 3 slot ; inline


USING: accessors io.files.links slots.private ;

M: too-many-symlinks n>> 3 slot ; inline


USING: accessors slots.private ulid ;

M: ulid>bytes-bad-length n>> 2 slot ; inline


USING: accessors cpu.8080.emulator slots.private ;

M: undefined-8080-opcode n>> 2 slot ; inline


USING: accessors kernel.private math math.matrices.extras
slots.private ;

M: undefined-inverse n>> 3 slot { integer } declare ; inline


USING: accessors modern.slices slots.private ;

M: unexpected-end n>> 2 slot ; inline


USING: accessors modern slots.private ;

M: unexpected-terminator n>> 2 slot ; inline


USING: accessors git slots.private ;

M: unhandled-git-version n>> 2 slot ; inline


USING: accessors images.bitmap slots.private ;

M: unknown-bitmap-header n>> 2 slot ; inline


USING: accessors images.png slots.private ;

M: unknown-color-type n>> 2 slot ; inline


USING: accessors images.png slots.private ;

M: unknown-component-type n>> 2 slot ; inline


USING: accessors images.gif slots.private ;

M: unknown-extension n>> 2 slot ; inline


USING: accessors msgpack slots.private ;

M: unknown-format n>> 2 slot ; inline


USING: accessors images.tiff slots.private ;

M: unknown-ifd-type n>> 2 slot ; inline


USING: accessors images.bitmap slots.private ;

M: unsupported-bitfield-widths n>> 2 slot ; inline


USING: accessors prettyprint.backend slots.private ;

M: unsupported-number-base n>> 2 slot ; inline


USING: accessors gml.runtime kernel.private math slots.private ;

M: use-registers n>> 2 slot { fixnum } declare ; inline


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

M: vose n>> 2 slot { fixnum } declare ; inline


USING: accessors compiler.cfg.linear-scan.live-intervals
slots.private ;

M: vreg-use n>> 2 slot ; inline


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

M: windowed-sequence n>> 3 slot { integer } declare ; inline


USING: accessors gml.runtime kernel.private math slots.private ;

M: write-register n>> 3 slot { fixnum } declare ; inline


USING: accessors compression.zlib slots.private ;

M: zlib-failed n>> 2 slot ; inline


USING: accessors slots.private zeromq ;

M: zmq-error n>> 2 slot ; inline


USING: accessors compression.zstd slots.private ;

M: zstd-error n>> 2 slot ; inline