x>> ( object -- value )

Vocabulary

accessors

Inputs

object

an object

Outputs

value

an object

Definition

IN: accessors

GENERIC: x>> ( object -- value )

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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors math.affine-transforms slots.private ;

M: affine-transform x>> 2 slot ; inline


USING: accessors math.bitwise slots.private ;

M: bit-range-error x>> 2 slot ; inline


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

M: blum-blum-shub x>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors pdf.canvas slots.private ;

M: canvas x>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors game.input slots.private ;

M: controller-state x>> 2 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 }
    } read-struct-slot ; inline


USING: accessors curses kernel.private math slots.private ;

M: curses-window x>> 9 slot { integer } declare ; inline


USING: accessors math.ratios slots.private ;

M: division-by-zero x>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors slots.private tinyvg ;

M: horizontal-line x>> 3 slot ; inline


USING: accessors slots.private svg ;

M: horizontal-lineto x>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors progress-bars slots.private ;

M: invalid-length x>> 2 slot ; inline


USING: accessors progress-bars slots.private ;

M: invalid-percent x>> 2 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors curses kernel.private math slots.private ;

M: mouse-event x>> 4 slot { fixnum } declare ; inline


USING: accessors money slots.private ;

M: not-an-integer x>> 2 slot ; inline


USING: accessors benchmark.ant slots.private ;

M: point x>> 2 slot ; inline


USING: accessors slots.private tinyvg ;

M: point x>> 2 slot ; inline


USING: accessors shapefiles slots.private ;

M: point x>> 2 slot ; inline


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

M: point x>> 2 slot { float } declare ; 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 }
    } read-struct-slot ; inline


USING: accessors slots.private tinyvg ;

M: rectangle x>> 2 slot ; inline


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

M: scroller x>> 24 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors db.tester slots.private ;

M: test-2 x>> 3 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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-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 }
    } read-struct-slot ; inline


USING: accessors colors.xyy slots.private ;

M: xyYa x>> 2 slot ; inline


USING: accessors colors.xyz slots.private ;

M: xyza x>> 2 slot ; inline


USING: accessors boolean-expr slots.private ;

M: ¬ x>> 2 slot ; inline


USING: accessors boolean-expr slots.private ;

M: ⋀ x>> 2 slot ; inline


USING: accessors boolean-expr slots.private ;

M: ⋁ x>> 2 slot ; inline