name<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: name<< ( value object -- )

Methods

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

M: .struct name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

M: BoneInfo name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 0 }
        { class object }
        { type { char 32 } }
    } write-struct-slot ; inline


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

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


USING: accessors alien alien.syntax classes.struct
classes.struct.private glib.ffi
gobject-introspection.standard-types ;

M: GSource name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 80 }
        { class c-ptr }
        { type pointer: gchar }
    } write-struct-slot ; inline


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

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


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

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


USING: accessors dns slots.private ;

M: a name<< 2 set-slot ; inline


USING: accessors dns slots.private ;

M: aaaa name<< 2 set-slot ; inline


USING: accessors bank slots.private ;

M: account name<< 2 set-slot ; inline


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

M: alias name<< 2 set-slot ; inline


USING: accessors slots.private vocabs.parser ;

M: ambiguous-use-error name<< 2 set-slot ; inline


USING: accessors infix.ast slots.private ;

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


USING: accessors kernel slots slots.private smalltalk.ast ;

M: ast-assignment name<<
    [ dup ast-name? [ \ ast-name bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

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


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

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


USING: accessors kernel slots slots.private smalltalk.ast
strings ;

M: ast-class name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

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


USING: accessors fjsc slots.private ;

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


USING: accessors kernel slots slots.private smalltalk.ast
strings ;

M: ast-foreign name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors infix.ast slots.private ;

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


USING: accessors fjsc slots.private ;

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


USING: accessors infix.ast slots.private ;

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


USING: accessors kernel slots slots.private smalltalk.ast
strings ;

M: ast-method name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors kernel slots slots.private smalltalk.ast
strings ;

M: ast-name name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

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


USING: accessors infix.ast slots.private ;

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


USING: accessors fjsc slots.private ;

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


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

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


USING: accessors kernel slots slots.private strings xml.data ;

M: attlist-decl name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors binhex slots.private ;

M: binhex name<< 2 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private openssl.libcrypto ;

M: bio-method name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 8 }
        { class c-ptr }
        { type pointer: void }
    } write-struct-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private kernel openssl.libcrypto ;

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


USING: accessors slots.private webapps.planet ;

M: blog name<< 3 set-slot ; inline


USING: accessors s3 slots.private ;

M: bucket name<< 2 set-slot ; inline


USING: accessors slots.private usa-cities ;

M: city name<< 3 set-slot ; inline


USING: accessors opencl slots.private ;

M: cl-device name<< 48 set-slot ; inline


USING: accessors opencl slots.private ;

M: cl-platform name<< 5 set-slot ; inline


USING: accessors modern.html slots.private ;

M: close-tag name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private xml.data ;

M: closer name<<
    [ dup name? [ \ name bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors dns slots.private ;

M: cname name<< 2 set-slot ; inline


USING: accessors cocoa.subclassing slots.private ;

M: cocoa-protocol name<< 2 set-slot ; inline


USING: accessors codebook slots.private ;

M: code-file name<< 2 set-slot ; inline


USING: accessors odbc slots.private ;

M: column name<< 6 set-slot ; inline


USING: accessors command-loop slots.private ;

M: command name<< 2 set-slot ; inline


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

M: const name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private xml.data ;

M: contained name<<
    [ dup name? [ \ name bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors continuations slots.private ;

M: continuation name<< 5 set-slot ; inline


USING: accessors http slots.private ;

M: cookie name<< 2 set-slot ; inline


USING: accessors cuda.libraries slots.private ;

M: cuda-library name<< 2 set-slot ; inline


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

M: data-type name<< 2 set-slot ; inline


USING: accessors couchdb kernel slots slots.private strings ;

M: db name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    3 set-slot ; inline


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

M: dbf-field-header name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 0 }
        { class object }
        { type { uint8_t 11 } }
    } write-struct-slot ; inline


USING: accessors io.directories slots.private ;

M: directory-entry name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private strings xml.data ;

M: doctype-decl name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors html5 slots.private ;

M: doctype name<< 2 set-slot ; inline


USING: accessors classes.struct classes.struct.private macho ;

M: dylib name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 0 }
        { class lc_str }
        { initial S{ lc_str { offset 0 } { ptr f } } }
        { type lc_str }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private macho ;

M: dylinker_command name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 8 }
        { class lc_str }
        { initial S{ lc_str { offset 0 } { ptr f } } }
        { type lc_str }
    } write-struct-slot ; inline


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

M: ebnf-var name<< 3 set-slot ; inline


USING: accessors kernel slots slots.private strings xml.data ;

M: element-decl name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors rosetta-code.top-rank slots.private ;

M: employee name<< 2 set-slot ; inline


USING: accessors html5 slots.private ;

M: end-tag name<< 3 set-slot ; inline


USING: accessors kernel slots slots.private strings xml.data ;

M: entity-decl name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

M: enum-member name<< 2 set-slot ; inline


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

M: exec-register name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

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


USING: accessors cuesheet slots.private ;

M: file name<< 2 set-slot ; inline


USING: accessors fonts slots.private ;

M: font name<< 2 set-slot ; inline


USING: accessors alien.libraries.finder.macosx.private
slots.private ;

M: framework-info name<< 3 set-slot ; inline


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

M: function name<< 2 set-slot ; inline


USING: accessors classes.struct classes.struct.private macho ;

M: fvmfile_command name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 8 }
        { class lc_str }
        { initial S{ lc_str { offset 0 } { ptr f } } }
        { type lc_str }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private macho ;

M: fvmlib name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 0 }
        { class lc_str }
        { initial S{ lc_str { offset 0 } { ptr f } } }
        { type lc_str }
    } write-struct-slot ; inline


USING: accessors gdbm kernel slots slots.private strings ;

M: gdbm name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors gml.runtime slots.private ;

M: gml-exec-name name<< 2 set-slot ; inline


USING: accessors gopher.private slots.private ;

M: gopher-link name<< 3 set-slot ; inline


USING: accessors slots.private unix.groups ;

M: group name<< 3 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private compression.zlib.ffi ;

M: gz_header name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 40 }
        { class c-ptr }
        { type pointer: uchar }
    } write-struct-slot ; inline


USING: accessors slots.private tar ;

M: hard-link name<< 3 set-slot ; inline


USING: accessors raylib.demo.mesh-picking slots.private ;

M: hit-state name<< 2 set-slot ; inline


USING: accessors images.png slots.private ;

M: icc-profile name<< 2 set-slot ; inline


USING: accessors git slots.private ;

M: index-entry name<< 12 set-slot ; inline


USING: accessors kernel mongodb.driver slots slots.private
strings ;

M: index-spec name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors gravatar slots.private ;

M: info name<< 10 set-slot ; inline


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

M: insn-slot-spec name<< 3 set-slot ; inline


USING: accessors irc.client.chats slots.private ;

M: irc-channel-chat name<< 4 set-slot ; inline


USING: accessors irc.client.chats slots.private ;

M: irc-nick-chat name<< 4 set-slot ; inline


USING: accessors rosetta-code.knapsack slots.private ;

M: item name<< 2 set-slot ; inline


USING: accessors s3 slots.private ;

M: key name<< 2 set-slot ; inline


USING: accessors help.topics slots.private ;

M: link name<< 2 set-slot ; inline


USING: accessors logic.private slots.private ;

M: logic-pred name<< 2 set-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private lua ;

M: luaL_Reg name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 0 }
        { class c-ptr }
        { type pointer: char }
    } write-struct-slot ; inline


USING: accessors alien alien.c-types alien.syntax classes.struct
classes.struct.private lua ;

M: lua_Debug name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 8 }
        { class c-ptr }
        { type pointer: char }
    } write-struct-slot ; inline


USING: accessors game.models.obj.private slots.private ;

M: material name<< 2 set-slot ; inline


USING: accessors kernel mongodb.driver slots slots.private
strings ;

M: mdb-collection name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors mongodb.connection slots.private ;

M: mdb-db name<< 2 set-slot ; inline


USING: accessors midi slots.private ;

M: meta-event name<< 3 set-slot ; inline


USING: accessors midi slots.private ;

M: midi-event name<< 3 set-slot ; inline


USING: accessors alien.fortran.private slots.private ;

M: misc-type name<< 5 set-slot ; inline


USING: accessors irc.messages slots.private ;

M: mode name<< 9 set-slot ; inline


USING: accessors kernel mongodb.cmd.private slots slots.private
strings ;

M: mongodb-cmd name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors mime.multipart slots.private ;

M: multipart name<< 10 set-slot ; inline


USING: accessors interpolate.private slots.private ;

M: named-var name<< 2 set-slot ; inline


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

M: namespace name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private strings xml.data ;

M: notation-decl name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors dns slots.private ;

M: ns name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private xml.data ;

M: opener name<<
    [ dup name? [ \ name bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors checksums.openssl slots.private ;

M: openssl-checksum name<< 2 set-slot ; inline


USING: accessors irc.messages slots.private ;

M: oper name<< 9 set-slot ; inline


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

M: parameter name<< 2 set-slot ; inline


USING: accessors slots.private tools.deploy.test.17 ;

M: person name<< 2 set-slot ; inline


USING: accessors cocoa.statusbar slots.private ;

M: platform-menu name<< 2 set-slot ; inline


USING: accessors jamshred.player kernel slots slots.private
strings ;

M: player name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    6 set-slot ; inline


USING: accessors classes.struct classes.struct.private macho ;

M: prebound_dylib_command name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 8 }
        { class lc_str }
        { initial S{ lc_str { offset 0 } { ptr f } } }
        { type lc_str }
    } write-struct-slot ; inline


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

M: property name<< 2 set-slot ; inline


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

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


USING: accessors dns slots.private ;

M: ptr name<< 2 set-slot ; inline


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

M: ptx-entry name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

M: ptx-struct-definition name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


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

M: ptx-variable name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    7 set-slot ; inline


USING: accessors dns slots.private ;

M: query name<< 2 set-slot ; inline


USING: accessors slots.private zoneinfo ;

M: raw-rule name<< 2 set-slot ; inline


USING: accessors slots.private zoneinfo ;

M: raw-zone name<< 2 set-slot ; inline


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

M: read-register name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors furnace.auth slots.private ;

M: realm name<< 4 set-slot ; inline


USING: accessors ftp.client.listing-parser slots.private ;

M: remote-file name<< 12 set-slot ; inline


USING: accessors continuations slots.private ;

M: restart name<< 2 set-slot ; inline


USING: accessors slots.private xml-rpc ;

M: rpc-method name<< 2 set-slot ; inline


USING: accessors irc.messages slots.private ;

M: rpl-nickname-in-use name<< 9 set-slot ; inline


USING: accessors dns slots.private ;

M: rr name<< 2 set-slot ; inline


USING: accessors slots.private xmode.rules ;

M: rule-set name<< 2 set-slot ; inline


USING: accessors elf slots.private ;

M: section name<< 2 set-slot ; inline


USING: accessors cocoa.messages slots.private ;

M: selector-tuple name<< 2 set-slot ; inline


USING: accessors alien.c-types classes.struct
classes.struct.private kernel windows.winsock.32 ;

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


USING: accessors alien.c-types classes.struct
classes.struct.private kernel windows.winsock.64 ;

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


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

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


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

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


USING: accessors kernel papier.map slots slots.private ;

M: slab name<<
    [ dup ?string? [ \ ?string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors inspector.private slots.private ;

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


USING: accessors slots slots.private ;

M: slot-spec name<< 2 set-slot ; inline


USING: accessors db.errors slots.private ;

M: sql-index-exists name<< 3 set-slot ; inline


USING: accessors metar slots.private ;

M: station name<< 3 set-slot ; inline


USING: accessors elf slots.private ;

M: symbol name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private smalltalk.ast
strings ;

M: symbol name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors slots.private tar ;

M: symbolic-link name<< 3 set-slot ; inline


USING: accessors slots.private toml.private ;

M: table name<< 2 set-slot ; inline


USING: accessors html.parser slots.private ;

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


USING: accessors modern.html slots.private ;

M: tag name<< 3 set-slot ; inline


USING: accessors kernel slots slots.private xml.data ;

M: tag name<<
    [ dup name? [ \ name bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors html5 slots.private ;

M: tag name<< 3 set-slot ; inline


USING: accessors slots.private tar ;

M: tar-header name<< 2 set-slot ; inline


USING: accessors kernel slots slots.private strings threads ;

M: thread name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors io.servers slots.private ;

M: threaded-server name<< 2 set-slot ; inline


USING: accessors slots.private twitter ;

M: twitter-user name<< 3 set-slot ; inline


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

M: type name<< 2 set-slot ; inline


USING: accessors help.vocabs slots.private ;

M: vocab-author name<< 2 set-slot ; inline


USING: accessors slots.private vocabs ;

M: vocab-link name<< 2 set-slot ; inline


USING: accessors slots.private vocabs.hierarchy ;

M: vocab-prefix name<< 2 set-slot ; inline


USING: accessors help.vocabs slots.private ;

M: vocab-tag name<< 2 set-slot ; inline


USING: accessors slots.private vocabs ;

M: vocab name<< 2 set-slot ; inline


USING: accessors slots.private words ;

M: word name<< 2 set-slot ; inline


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

M: word name<<
    T{ struct-slot-spec
        { name "name" }
        { offset 16 }
        { class integer }
        { initial 0 }
        { type cell_t }
    } write-struct-slot ; inline


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

M: write-register name<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors kernel xml.data ;

M: xml name<< [ body>> ] call \ name<< execute ;