type<< ( value object -- )


Vocabulary
accessors

Inputs
valuean object
objectan object


Outputs
None

Definition

GENERIC: type<< ( value object -- )


Methods

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



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






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






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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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






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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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



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









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



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


















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
















































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














































































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