type<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: type<< ( value object -- )

Methods

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

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


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

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


USING: accessors alien alien.syntax classes.struct
classes.struct.private glib.ffi gobject.ffi ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
math ;

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

M: alias type<< 4 set-slot ; inline


USING: accessors binhex slots.private ;

M: binhex type<< 3 set-slot ; inline


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

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


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

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


USING: accessors kernel libclang slots slots.private strings ;

M: c-arg type<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors kernel libclang slots slots.private strings ;

M: c-field type<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    3 set-slot ; inline


USING: accessors kernel libclang slots slots.private strings ;

M: c-typedef type<<
    [ dup string? [ \ string bad-slot-value ] unless ] dip
    2 set-slot ; inline


USING: accessors cairo.ffi classes.struct classes.struct.private
kernel ;

M: cairo_path_data_t-header type<<
    T{ struct-slot-spec
        { name "type" }
        { offset 0 }
        { class object }
        { type cairo_path_data_type_t }
    } write-struct-slot ; inline


USING: accessors google.charts slots.private ;

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


USING: accessors opencl slots.private ;

M: cl-device type<< 3 set-slot ; inline


USING: accessors odbc slots.private ;

M: column type<< 5 set-slot ; inline


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

M: const type<< 4 set-slot ; inline


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

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


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

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


USING: accessors io.directories slots.private ;

M: directory-entry type<< 3 set-slot ; inline


USING: accessors ping.private slots.private ;

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


USING: accessors slots.private source-files.errors ;

M: error-type-holder type<< 2 set-slot ; inline


USING: accessors slots.private yaml.private ;

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


USING: accessors fastcgi slots.private ;

M: fcgi-header type<< 3 set-slot ; inline


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

M: field type<< 5 set-slot ; inline


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

M: file-info-tuple type<< 2 set-slot ; inline


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

M: file-system-info-tuple type<< 4 set-slot ; inline


USING: accessors cuesheet slots.private ;

M: file type<< 3 set-slot ; inline


USING: accessors db.types slots.private ;

M: generator-bind type<< 5 set-slot ; inline


USING: accessors gopher.private slots.private ;

M: gopher-link type<< 2 set-slot ; inline


USING: accessors images.tiff slots.private ;

M: ifd-entry type<< 3 set-slot ; inline


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

M: insn-slot-spec type<< 2 set-slot ; inline


USING: accessors io.encodings.iso2022.private slots.private ;

M: iso2022-state type<< 2 set-slot ; inline


USING: accessors images.jpeg.private slots.private ;

M: jpeg-chunk type<< 3 set-slot ; inline


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

M: libusb_transfer type<<
    T{ struct-slot-spec
        { name "type" }
        { offset 10 }
        { class fixnum }
        { initial 0 }
        { type uchar }
    } write-struct-slot ; inline


USING: accessors prettyprint.sections slots.private ;

M: line-break type<< 8 set-slot ; inline


USING: accessors bare slots.private ;

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


USING: accessors db.types slots.private ;

M: literal-bind type<< 3 set-slot ; inline


USING: accessors metar.private slots.private ;

M: metar-report type<< 2 set-slot ; inline


USING: accessors midi slots.private ;

M: midi-chunk type<< 2 set-slot ; inline


USING: accessors curses slots.private ;

M: mouse-event type<< 6 set-slot ; inline


USING: accessors bare slots.private ;

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


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

M: parameter type<< 3 set-slot ; inline


USING: accessors images.png slots.private ;

M: png-chunk type<< 2 set-slot ; inline


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

M: property type<< 7 set-slot ; inline


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

M: ptx-typed-instruction type<<
    [ dup ptx-type? [ \ ptx-type bad-slot-value ] unless ] dip
    4 set-slot ; inline


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

M: ptx-variable type<<
    [ dup ptx-type? [ \ ptx-type bad-slot-value ] unless ] dip
    6 set-slot ; inline


USING: accessors dns slots.private ;

M: query type<< 3 set-slot ; inline


USING: accessors slots.private zoneinfo ;

M: raw-rule type<< 5 set-slot ; inline


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

M: remote-file type<< 2 set-slot ; inline


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

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


USING: accessors dns slots.private ;

M: rr type<< 3 set-slot ; inline


USING: accessors slots.private yahoo ;

M: search type<< 8 set-slot ; inline


USING: accessors irc.messages slots.private ;

M: service type<< 11 set-slot ; inline


USING: accessors irc.messages slots.private ;

M: servlist type<< 10 set-slot ; inline


USING: accessors slots.private snake-game.game ;

M: snake-part type<< 3 set-slot ; inline


USING: accessors db.types slots.private ;

M: sql-spec type<< 5 set-slot ; inline


USING: accessors db.sqlite slots.private ;

M: sqlite-low-level-binding type<< 4 set-slot ; inline


USING: accessors db slots.private ;

M: statement type<< 8 set-slot ; inline


USING: accessors classes.struct slots.private ;

M: struct-slot-spec type<< 7 set-slot ; inline


USING: accessors midi slots.private ;

M: sysex-event type<< 3 set-slot ; inline


USING: accessors slots.private unix.utmpx ;

M: utmpx-record type<< 6 set-slot ; inline


USING: accessors alien.endian classes.struct
classes.struct.private dbf math ;

M: vfp-memo-header type<<
    T{ struct-slot-spec
        { name "type" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type ube32 }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private kernel
yaml.ffi ;

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


USING: accessors classes.struct classes.struct.private kernel
yaml.ffi ;

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


USING: accessors classes.struct classes.struct.private kernel
yaml.ffi ;

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