n<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: n<< ( value object -- )

Methods

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

M: ##select-vector n<< 4 set-slot ; inline


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

M: .maxnreg n<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors regexp.ast slots.private ;

M: at-least n<< 2 set-slot ; inline


USING: accessors random slots.private ;

M: binomial-distribution n<< 2 set-slot ; inline


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

M: blum-blum-shub n<< 3 set-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 }
    } write-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 }
    } write-struct-slot ; inline


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

M: cfrac n<< 2 set-slot ; inline


USING: accessors openai slots.private ;

M: chat-completion n<< 6 set-slot ; inline


USING: accessors circular kernel math slots slots.private ;

M: circular-iterator n<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors openai slots.private ;

M: completion n<< 8 set-slot ; inline


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

M: count-down-tuple n<< 2 set-slot ; inline


USING: accessors quiz slots.private ;

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


USING: accessors quiz slots.private ;

M: country-name-from-flag n<< 2 set-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 }
    } write-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 }
    } write-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 }
    } write-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 }
    } write-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 }
    } write-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 }
    } write-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 }
    } write-struct-slot ; inline


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

M: creature n<< 2 set-slot ; inline


USING: accessors generic.single slots.private ;

M: echelon-dispatch-engine n<< 2 set-slot ; inline


USING: accessors openai slots.private ;

M: edit n<< 5 set-slot ; inline


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

M: exec-register n<<
    [ integer>fixnum-strict ] dip 3 set-slot ; inline


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

M: fake-bignum n<< 2 set-slot ; inline


USING: accessors quiz slots.private ;

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


USING: accessors quiz slots.private ;

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


USING: accessors regexp.ast slots.private ;

M: from-to n<< 2 set-slot ; inline


USING: accessors ftp slots.private ;

M: ftp-response n<< 2 set-slot ; inline


USING: accessors slots.private synth ;

M: harmonic n<< 2 set-slot ; inline


USING: accessors benchmark.typecheck1 slots.private ;

M: hello n<< 2 set-slot ; inline


USING: accessors benchmark.typecheck3 slots.private ;

M: hello n<< 2 set-slot ; inline


USING: accessors benchmark.typecheck2 slots.private ;

M: hello n<< 2 set-slot ; inline


USING: accessors openai slots.private ;

M: image-edit n<< 5 set-slot ; inline


USING: accessors openai slots.private ;

M: image-generation n<< 3 set-slot ; inline


USING: accessors openai slots.private ;

M: image-variation n<< 3 set-slot ; inline


USING: accessors slots.private webapps.imagebin ;

M: imagebin n<< 5 set-slot ; inline


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

M: iterator n<< 3 set-slot ; inline


USING: accessors lists.lazy slots.private ;

M: lazy-from-by n<< 2 set-slot ; inline


USING: accessors lists.lazy slots.private ;

M: lazy-take n<< 3 set-slot ; inline


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

M: loc n<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors quiz slots.private ;

M: math-multiplication n<< 3 set-slot ; inline


USING: accessors quiz slots.private ;

M: multiple-choice-question n<< 8 set-slot ; inline


USING: accessors sequences.modified slots.private ;

M: offset n<< 3 set-slot ; inline


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

M: read-register n<<
    [ integer>fixnum-strict ] dip 3 set-slot ; inline


USING: accessors db slots.private ;

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


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

M: rollover n<< 3 set-slot ; inline


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

M: running-regress n<< 2 set-slot ; inline


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

M: running-stats n<< 2 set-slot ; inline


USING: accessors sequences.parser slots.private ;

M: sequence-parser n<< 3 set-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 }
    } write-struct-slot ; inline


USING: accessors slots.private unix.signals ;

M: signal n<< 2 set-slot ; inline


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

M: spill-slot n<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors interpolate.private slots.private ;

M: stack-var n<< 2 set-slot ; inline


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

M: sync-point n<< 2 set-slot ; inline


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

M: use-registers n<<
    [ integer>fixnum-strict ] dip 2 set-slot ; inline


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

M: vose n<< [ integer>fixnum-strict ] dip 2 set-slot ; inline


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

M: vreg-use n<< 2 set-slot ; inline


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

M: windowed-sequence n<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    3 set-slot ; inline


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

M: write-register n<<
    [ integer>fixnum-strict ] dip 3 set-slot ; inline