x<< ( value object -- )

Vocabulary

accessors

Inputs

value	an object
object	an object

Outputs

None

Definition

IN: accessors

GENERIC: x<< ( value object -- )

Methods

USING: accessors classes.struct classes.struct.private
core-graphics.types math ;

M: CGPoint x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type CGFloat }
    } write-struct-slot ; inline


USING: accessors classes.struct classes.struct.private gdk2.ffi
gobject-introspection.standard-types math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
gobject-introspection.standard-types math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
gobject-introspection.standard-types math ;

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


USING: accessors classes.struct classes.struct.private gdk2.ffi
gobject-introspection.standard-types math ;

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


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

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


USING: accessors classes.struct classes.struct.private
gobject-introspection.standard-types math pango.ffi ;

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


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

M: Rectangle x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: Vector2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: Vector3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: Vector4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: XButtonEvent x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 64 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 48 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 48 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 48 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 64 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 40 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 40 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 48 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 64 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 64 }
        { 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 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 56 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


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

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


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

M: XWindowAttributes x<<
    T{ struct-slot-spec
        { name "x" }
        { 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: XWindowChanges x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class fixnum }
        { initial 0 }
        { type int }
    } write-struct-slot ; inline


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

M: blum-blum-shub x<< 2 set-slot ; inline


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

M: cairo_glyph_t x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 8 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: cairo_path_data_t-point x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

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


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

M: cairo_rectangle_t x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


USING: accessors pdf.canvas slots.private ;

M: canvas x<< 2 set-slot ; inline


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

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


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

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


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

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


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

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


USING: accessors game.input slots.private ;

M: controller-state x<< 2 set-slot ; inline


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

M: cpVect x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type cpFloat }
    } write-struct-slot ; inline


USING: accessors curses kernel math slots slots.private ;

M: curses-window x<<
    [ dup integer? [ \ integer bad-slot-value ] unless ] dip
    9 set-slot ; inline


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

M: double1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: double2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: double3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: double4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type double }
    } write-struct-slot ; inline


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

M: float1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: float2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: float3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


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

M: float4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


USING: accessors slots.private tinyvg ;

M: horizontal-line x<< 3 set-slot ; inline


USING: accessors slots.private svg ;

M: horizontal-lineto x<< 2 set-slot ; inline


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

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


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

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


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

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


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

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


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

M: long1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type long }
    } write-struct-slot ; inline


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

M: long2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type long }
    } write-struct-slot ; inline


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

M: long3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type long }
    } write-struct-slot ; inline


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

M: long4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type long }
    } write-struct-slot ; inline


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

M: longlong1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type longlong }
    } write-struct-slot ; inline


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

M: longlong2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type longlong }
    } write-struct-slot ; inline


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

M: longlong3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type longlong }
    } write-struct-slot ; inline


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

M: longlong4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type longlong }
    } write-struct-slot ; inline


USING: accessors curses kernel math slots.private ;

M: mouse-event x<< [ integer>fixnum-strict ] dip 4 set-slot
    ; inline


USING: accessors benchmark.ant slots.private ;

M: point x<< 2 set-slot ; inline


USING: accessors slots.private tinyvg ;

M: point x<< 2 set-slot ; inline


USING: accessors shapefiles slots.private ;

M: point x<< 2 set-slot ; inline


USING: accessors benchmark.tuple-arrays kernel math
slots.private ;

M: point x<< [ >float ] dip 2 set-slot ; inline


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

M: point x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class float }
        { initial 0.0 }
        { type float }
    } write-struct-slot ; inline


USING: accessors slots.private tinyvg ;

M: rectangle x<< 2 set-slot ; inline


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

M: scroller x<< 24 set-slot ; inline


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

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


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

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


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

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


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

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


USING: accessors db.tester slots.private ;

M: test-2 x<< 3 set-slot ; inline


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

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


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

M: ulong1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulong }
    } write-struct-slot ; inline


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

M: ulong2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulong }
    } write-struct-slot ; inline


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

M: ulong3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulong }
    } write-struct-slot ; inline


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

M: ulong4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulong }
    } write-struct-slot ; inline


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

M: ulonglong1 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulonglong }
    } write-struct-slot ; inline


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

M: ulonglong2 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulonglong }
    } write-struct-slot ; inline


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

M: ulonglong3 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulonglong }
    } write-struct-slot ; inline


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

M: ulonglong4 x<<
    T{ struct-slot-spec
        { name "x" }
        { offset 0 }
        { class integer }
        { initial 0 }
        { type ulonglong }
    } write-struct-slot ; inline


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

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


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

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


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

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


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

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


USING: accessors colors.xyy slots.private ;

M: xyYa x<< 2 set-slot ; inline


USING: accessors colors.xyz slots.private ;

M: xyza x<< 2 set-slot ; inline


USING: accessors boolean-expr slots.private ;

M: ¬ x<< 2 set-slot ; inline


USING: accessors boolean-expr slots.private ;

M: ⋀ x<< 2 set-slot ; inline


USING: accessors boolean-expr slots.private ;

M: ⋁ x<< 2 set-slot ; inline