value<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: value<< ( value object -- )

Methods

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

M: EntryNew value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 8 }
        { class fixnum }
        { initial 0 }
        { type uint32_t }
    } write-struct-slot ; inline


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

M: EntryOld value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 8 }
        { class fixnum }
        { initial 0 }
        { type uint32_t }
    } write-struct-slot ; inline


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

M: GlyphInfo value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


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

M: MaterialMap value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 24 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


USING: accessors alien alien.syntax classes.struct
classes.struct.private openssl.libssl ;

M: X509_EXTENSION value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 16 }
        { class c-ptr }
        { type pointer: ASN1_OCTET_STRING }
    } write-struct-slot ; inline


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

M: XIValuatorClassInfo value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 40 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: alias_token_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


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

M: anchor_token_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


USING: accessors slots.private smalltalk.ast ;

M: ast-assignment value<< 3 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-binding value<< 3 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-get value<< 2 set-slot ; inline


USING: accessors fjsc slots.private ;

M: ast-identifier value<< 2 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-keyword value<< 2 set-slot ; inline


USING: accessors llvm.examples.kaleidoscope slots.private ;

M: ast-name value<< 2 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-name value<< 2 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-number value<< 2 set-slot ; inline


USING: accessors fjsc slots.private ;

M: ast-number value<< 2 set-slot ; inline


USING: accessors llvm.examples.kaleidoscope slots.private ;

M: ast-number value<< 2 set-slot ; inline


USING: accessors slots.private smalltalk.ast ;

M: ast-return value<< 2 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-string value<< 2 set-slot ; inline


USING: accessors fjsc slots.private ;

M: ast-string value<< 2 set-slot ; inline


USING: accessors infix.ast slots.private ;

M: ast-value value<< 2 set-slot ; inline


USING: accessors peg.javascript.private slots.private ;

M: ast-var value<< 3 set-slot ; inline


USING: accessors fjsc slots.private ;

M: ast-word value<< 2 set-slot ; inline


USING: accessors boxes slots.private ;

M: box value<< 2 set-slot ; inline


USING: accessors persistent.heaps.private slots.private ;

M: branch value<< 2 set-slot ; inline


USING: accessors llvm.wrappers slots.private ;

M: buffer value<< 2 set-slot ; inline


USING: accessors llvm.wrappers slots.private ;

M: builder value<< 2 set-slot ; inline


USING: accessors cpu.x86.assembler.operands slots.private ;

M: byte value<< 2 set-slot ; inline


USING: accessors cache.private slots.private ;

M: cache-entry value<< 2 set-slot ; inline


USING: accessors cbor slots.private ;

M: cbor-simple value<< 2 set-slot ; inline


USING: accessors modern.html slots.private ;

M: cdata value<< 4 set-slot ; inline


USING: accessors compiler.tree.propagation.constraints
slots.private ;

M: class-constraint value<< 2 set-slot ; inline


USING: accessors benchmark.hashtables slots.private ;

M: collision value<< 2 set-slot ; inline


USING: accessors mongodb.tuple.persistent.private slots.private
;

M: cond-value value<< 2 set-slot ; inline


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

M: const value<< 3 set-slot ; inline


USING: accessors http slots.private ;

M: cookie value<< 3 set-slot ; inline


USING: accessors slots.private webapps.mason.backend ;

M: counter value<< 3 set-slot ; inline


USING: accessors compiler.tree.def-use slots.private ;

M: definition value<< 2 set-slot ; inline


USING: accessors slots.private units ;

M: dimensioned value<< 2 set-slot ; inline


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

M: duckdb_decimal value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 8 }
        { class duckdb_hugeint }
        { initial S{ duckdb_hugeint { lower 0 } { upper 0 } } }
        { type duckdb_hugeint }
    } write-struct-slot ; inline


USING: accessors llvm.wrappers slots.private ;

M: engine value<< 2 set-slot ; inline


USING: accessors slots.private toml.private ;

M: entry value<< 3 set-slot ; inline


USING: accessors heaps.private slots.private ;

M: entry value<< 2 set-slot ; inline


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

M: enum-member value<< 3 set-slot ; inline


USING: accessors compiler.tree.propagation.constraints
slots.private ;

M: false-constraint value<< 2 set-slot ; inline


USING: accessors odbc slots.private ;

M: field value<< 2 set-slot ; inline


USING: accessors concurrency.flags slots.private ;

M: flag value<< 2 set-slot ; inline


USING: accessors slots.private variables ;

M: global-box value<< 2 set-slot ; inline


USING: accessors namespaces.private slots.private ;

M: global-box value<< 2 set-slot ; inline


USING: accessors compression.huffman.private kernel math
slots.private ;

M: huffman-code value<<
    [ integer>fixnum-strict ] dip 2 set-slot ; inline


USING: accessors monads slots.private ;

M: identity value<< 2 set-slot ; inline


USING: accessors compiler.tree.propagation.call-effect
slots.private ;

M: inline-cache value<< 2 set-slot ; inline


USING: accessors compiler.cfg.value-numbering.expressions
slots.private ;

M: integer-expr value<< 2 set-slot ; inline


USING: accessors compiler.cfg.gvn.expressions slots.private ;

M: integer-expr value<< 2 set-slot ; inline


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

M: integer-literal value<< 2 set-slot ; inline


USING: accessors compiler.tree.propagation.constraints
slots.private ;

M: interval-constraint value<< 2 set-slot ; inline


USING: accessors monads slots.private ;

M: just value<< 2 set-slot ; inline


USING: accessors lazy slots.private ;

M: lazy value<< 4 set-slot ; inline


USING: accessors ldcache.private slots.private ;

M: ldcache-entry value<< 7 set-slot ; inline


USING: accessors monads slots.private ;

M: left value<< 2 set-slot ; inline


USING: accessors db.types slots.private ;

M: literal-bind value<< 4 set-slot ; inline


USING: accessors compiler.tree.propagation.constraints
slots.private ;

M: literal-constraint value<< 2 set-slot ; inline


USING: accessors slots.private stack-checker.values ;

M: literal-tuple value<< 2 set-slot ; inline


USING: accessors db.types slots.private ;

M: low-level-binding value<< 2 set-slot ; inline


USING: accessors libc.private slots.private ;

M: malloc-ptr value<< 2 set-slot ; inline


USING: accessors midi slots.private ;

M: meta-event value<< 4 set-slot ; inline


USING: accessors midi slots.private ;

M: midi-event value<< 4 set-slot ; inline


USING: accessors mime.multipart slots.private ;

M: mime-variable value<< 4 set-slot ; inline


USING: accessors slots.private ui.gadgets.controls ;

M: model-btn value<< 29 set-slot ; inline


USING: accessors models slots.private ;

M: model value<< 2 set-slot ; inline


USING: accessors llvm.wrappers slots.private ;

M: module value<< 2 set-slot ; inline


USING: accessors slots.private trees.private ;

M: node value<< 3 set-slot ; inline


USING: accessors slots.private ui.traverse ;

M: node value<< 2 set-slot ; inline


USING: accessors slots.private
stack-checker.recursive-state.tree ;

M: node value<< 2 set-slot ; inline


USING: accessors pairs slots.private ;

M: pair value<< 2 set-slot ; inline


USING: accessors colors slots.private ;

M: parsed-color value<< 3 set-slot ; inline


USING: accessors persistency slots.private ;

M: pattern value<< 2 set-slot ; inline


USING: accessors kernel math slots slots.private
ui.pixel-formats ;

M: pixel-format-attribute value<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors llvm.wrappers slots.private ;

M: provider value<< 2 set-slot ; inline


USING: accessors rpn slots.private ;

M: push-insn value<< 2 set-slot ; inline


USING: accessors quadtrees slots.private ;

M: quadtree value<< 4 set-slot ; inline


USING: accessors slots.private ui.gadgets.buttons.private ;

M: radio-control value<< 28 set-slot ; inline


USING: accessors compiler.tree.def-use.simplified slots.private
;

M: real-usage value<< 2 set-slot ; inline


USING: accessors compiler.cfg.value-numbering.expressions
slots.private ;

M: reference-expr value<< 2 set-slot ; inline


USING: accessors compiler.cfg.gvn.expressions slots.private ;

M: reference-expr value<< 2 set-slot ; inline


USING: accessors monads slots.private ;

M: right value<< 2 set-slot ; inline


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

M: scalar_event_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 16 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


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

M: scalar_node_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


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

M: scalar_token_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


USING: accessors compiler.tree.escape-analysis.allocations
slots.private ;

M: slot-access value<< 3 set-slot ; inline


USING: accessors slots.private ui.tools.inspector ;

M: slot-description value<< 4 set-slot ; inline


USING: accessors asn1 slots.private ;

M: tag value<< 2 set-slot ; inline


USING: accessors channels.remote.private slots.private ;

M: to-message value<< 3 set-slot ; inline


USING: accessors mongodb.tuple.collection slots.private ;

M: toid value<< 3 set-slot ; inline


USING: accessors compiler.tree.propagation.constraints
slots.private ;

M: true-constraint value<< 2 set-slot ; inline


USING: accessors html.forms slots.private ;

M: validation-error-state value<< 2 set-slot ; inline


USING: accessors digraphs slots.private ;

M: vertex value<< 2 set-slot ; inline


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

M: vreg-info value<< 3 set-slot ; inline


USING: accessors monads slots.private ;

M: writer value<< 2 set-slot ; inline


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

M: yaml_emitter_scalar_data value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 0 }
        { class object }
        { type c-string }
    } write-struct-slot ; inline


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

M: yaml_node_pair_t value<<
    T{ struct-slot-spec
        { name "value" }
        { offset 4 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline