object
Factor handbook » The language » Objects » Classes

Prev:	Class predicate words
Next:	null

Vocabulary
kernel

Class description
The class of all objects. If a generic word defines a method specializing on this class, the method is used as a fallback, if no other applicable method is found. For instance:

GENERIC: enclose ( number -- array ) M: number enclose 1array ; M: object enclose ;

Definition

IN: kernel

INTERSECTION: object ;

Methods

USING: cpu.architecture kernel ;

M: object %abs-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %add-sub-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %add-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %alien-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %and-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %andn-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %binary-vector-function-reps drop { } ;


USING: cpu.architecture kernel ;

M: object %blend-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %compare-vector-ccs 2drop { } f ;


USING: cpu.architecture kernel ;

M: object %compare-vector-reps drop { } ;


USING: cpu.architecture kernel ;

M: object %div-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %dot-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %fill-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %float-pack-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %float>integer-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %fma-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %gather-int-vector-2-reps { } ;


USING: cpu.architecture kernel ;

M: object %gather-int-vector-4-reps { } ;


USING: cpu.architecture kernel ;

M: object %gather-vector-2-reps { } ;


USING: cpu.architecture kernel ;

M: object %gather-vector-4-reps { } ;


USING: cpu.architecture kernel ;

M: object %horizontal-add-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %horizontal-shl-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %horizontal-shr-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %horizontal-sub-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %integer>float-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %max-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %merge-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %min-vector-reps { } ;


USING: cpu.architecture kernel ;

M:: object %mneg ( dst src1 src2 -- )
    dst src2 eq?
    [ dst src2 src1 %mul ] [ dst src1 src2 %mul ] if
    dst dst %neg ;


USING: cpu.architecture kernel ;

M: object %mul-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %mul-wide-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %not-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %or-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %saturated-add-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %saturated-mul-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %saturated-sub-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %select-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %shl-vector-count-reps { } ;


USING: cpu.architecture kernel ;

M: object %shl-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %shl-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %shr-vector-count-reps { } ;


USING: cpu.architecture kernel ;

M: object %shr-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %shr-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %shuffle-vector-halves-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %shuffle-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %shuffle-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %shuffle2-vector-imm-reps { } ;


USING: cpu.architecture kernel ;

M: object %signed-pack-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %sqrt-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %sub-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %test-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %unary-vector-function-reps drop { } ;


USING: cpu.architecture kernel ;

M: object %unpack-vector-head-reps { } ;


USING: cpu.architecture kernel ;

M: object %unpack-vector-tail-reps { } ;


USING: cpu.architecture kernel ;

M: object %unsigned-pack-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %xor-vector-reps { } ;


USING: cpu.architecture kernel ;

M: object %zero-vector-reps { } ;


USING: combinators io.backend.unix io.files io.ports
io.sockets.private io.sockets.unix kernel libc math ;

M: object (accept)
    2dup do-accept over 0 >=
    [ [ 2nip <fd> init-fd ] dip ] [
        errno {
            { EINTR [ 2drop (accept) ] }
            {
                EAGAIN
                [
                    2drop
                    [ drop +input+ wait-for-port ] [ (accept) ]
                    2bi
                ]
            }
            [ (throw-errno) ]
        } case
    ] if ;


USING: destructors io.sockets.private kernel ;

M: object (client)
    [
        [ remote>handle ] keep [
            [ <ports> [ |dispose ] bi@ dup ] dip
            establish-connection
        ] [ get-local-address ] 2bi
    ] with-destructors ;


USING: kernel opengl.textures ;

M: object (component-type>type) unsupported-component-order ;


USING: kernel yaml.private ;

M: object (deref-aliases) nip ;


USING: bootstrap.image.private kernel ;

M: object (eql?) = ;


USING: gml.runtime kernel ;

M: object (exec) is-gml over push-operand ;


USING: functors.private kernel make ;

M: object (fake-quotations>) , ;


USING: alien.data io.backend.unix io.sockets.private kernel libc
unix.ffi unix.types ;

M: object (get-local-address)
    [ handle-fd ] dip empty-sockaddr/size socklen_t <ref>
    [ getsockname io-error ] keepd ;


USING: alien.data io.backend.unix io.sockets.private kernel libc
unix.ffi unix.types ;

M: object (get-remote-address)
    [ handle-fd ] dip empty-sockaddr/size socklen_t <ref>
    [ getpeername io-error ] keepd ;


USING: kernel sequences variants ;

M: object (match-branch) over \ unboa [ ] 2sequence prepend ;


USING: io.launcher kernel ;

M: object (monitor-process) drop f ;


USING: io.launcher kernel ;

M: object (process-notifications?) f ;


USING: kernel math.quaternions.private math.vectors ;

M: object (q*sign) { -1 1 1 1 } v* ; inline


USING: kernel yaml.private ;

M: object (replace-aliases) nip ;


USING: kernel yaml.private ;

M: object (replace-anchors) nip ;


USING: destructors io.backend.unix io.sockets.private
io.sockets.unix kernel unix unix.ffi ;

M: object (server)
    [
        SOCK_STREAM server-socket-fd dup handle-fd 128
        [ listen ] unix-system-call drop
    ] with-destructors ;


USING: assocs http.client.post-data.private kernel ;

M: object (set-post-data-headers)
    drop "chunked" "transfer-encoding" pick set-at ;


USING: kernel regexp.classes ;

M: object (substitute) answer ;


USING: kernel stack-checker.inlining ;

M: object (undeclared-known) ;


USING: kernel math math.floats.small.bfloat math.vectors.simd
math.vectors.simd.extensions sequences ;

M:: object (vbdot2+) ( a b accumulator -- result )
    4 <iota> [| lane |
        lane accumulator nth lane 2 * a nth lane 2 * 1 + a nth
        lane 2 * b nth lane 2 * 1 + b nth bfloat-dot-add
    ] float-4 new map-as ;


USING: kernel math math.floats.small.bfloat math.vectors.simd
math.vectors.simd.extensions sequences ;

M:: object (vbmatmul2x4+) ( a b accumulator -- result )
    4 <iota> [| lane |
        lane 2 /i 4 * :> row lane 2 mod 4 *
        :> column lane accumulator nth row a nth row 1 + a nth
        column b nth column 1 + b nth bfloat-dot-add row 2 +
        a nth row 3 + a nth column 2 + b nth column 3 + b nth
        bfloat-dot-add
    ] float-4 new map-as ;


USING: kernel math math.vectors.simd.extensions sequences ;

M:: object (vdot4+) ( a b accumulator -- result )
    4 <iota> [| lane |
        lane accumulator nth 4 <iota> swap [| value j |
            lane 4 * j + :> index index a nth index b nth *
            value +
        ] reduce
    ] accumulator map-as ;


USING: kernel math math.vectors.simd.extensions sequences ;

M:: object (vmatmul2x8+) ( a b accumulator -- result )
    4 <iota> [| lane |
        lane accumulator nth 8 <iota> swap [| value j |
            lane 2 /i 8 * j + a nth lane 2 mod 8 * j + b nth *
            value +
        ] reduce
    ] accumulator map-as ;


USING: assocs kernel math math.vectors sequences ;

M: object (vmerge-head)
    over length 2 /i '[ _ head-slice ] bi@ [ zip ] keep
    concat-as ; inline


USING: assocs kernel math math.vectors sequences ;

M: object (vmerge-tail)
    over length 2 /i '[ _ tail-slice ] bi@ [ zip ] keep
    concat-as ; inline


USING: kernel ui.tools.listener ;

M: object (word-at-caret) 2drop f ;


USING: http.client.post-data.private io io.encodings.ascii
io.encodings.string kernel ;

M: object (write-post-data)
    [ [ write-chunk ] each-block ] with-input-stream
    "0;\r\n" ascii encode write ;


USING: io.encodings kernel ;

M: object <decoder> f decoder boa ; inline


USING: io.encodings kernel ;

M: object <encoder> encoder boa ; inline


USING: kernel ui.commands ui.gadgets.buttons ui.gadgets.glass
ui.gadgets.menus ui.gadgets.menus.private ;

M:: object <menu-item> ( target hook command -- menu-item )
    command command-name [
        hook call target command command-button-quot call
        hide-glass
    ] <menu-button> ;


USING: kernel regexp.classes ;

M: object <not-class> not-class boa ;


USING: io.sockets kernel ping ;

M: object <ping-port> <raw> ;


USING: accessors io.sockets.secure io.sockets.secure.debug
kernel ;

M: object <test-secure-config>*
    drop
    <secure-config> "vocab:openssl/test-1.2/server.pem"
    >>key-file "vocab:openssl/test-1.2/dh2048.pem" >>dh-file
    "password" >>password ;


USING: colors.lab colors.lch kernel ;

M: object >LCHab >laba >LCHab ;


USING: colors.lch colors.luv kernel ;

M: object >LCHuv >luva >LCHuv ;


USING: accessors alien kernel ;

M: object >c-ptr underlying>> ; inline


USING: colors colors.cmyk kernel ;

M: object >cmyka >rgba >cmyka ;


USING: accessors combinators furnace.syndication kernel
syndication ;

M: object >entry
    <entry> swap {
        [ feed-entry-title >>title ]
        [ feed-entry-date >>date ]
        [ feed-entry-url >>url ]
        [ feed-entry-description >>description ]
    } cleave ;


USING: functors.private kernel ;

M: object >fake-quotations ;


USING: colors colors.gray kernel ;

M: object >gray >rgba >gray ;


USING: colors colors.hsl kernel ;

M: object >hsla >rgba >hsla ;


USING: colors colors.hsv kernel ;

M: object >hsva >rgba >hsva ;


USING: colors colors.hwb kernel ;

M: object >hwba >rgba >hwba ;


USING: kernel math punycode punycode.private sequences splitting
;

M: object >idna
    "." split
    [ dup [ N < ] all? [ >punycode "xn--" prepend ] unless ] map
    "." join ;


USING: colors colors.lab kernel ;

M: object >laba >rgba >laba ;


USING: kernel ui.gadgets.labels ;

M: object >label ;


USING: help.topics kernel ;

M: object >link link boa ;


USING: colors colors.luv kernel ;

M: object >luva >rgba >luva ;


USING: alien.c-types kernel pack ;

M: object >n-byte-array heap-size >n-byte-array ;


USING: colors colors.oklab kernel ;

M: object >oklaba >rgba >oklaba ;


USING: colors.oklab colors.oklch kernel ;

M: object >oklcha >oklaba >oklcha ;


USING: accessors http http.client.post-data kernel ;

M: object >post-data
    "application/octet-stream" <post-data> swap >>data ;


USING: kernel prettyprint.custom ;

M: object >pprint-sequence ;


USING: accessors io.launcher kernel ;

M: object >process <process> swap >>command ;


USING: kernel quiz ;

M: object >question clone ;


USING: colors colors.ryb kernel ;

M: object >ryba >rgba >ryba ;


USING: alien.c-types gpu.render.private kernel sequences
specialized-arrays.instances.alien.c-types.int ;

M: object >uniform-bool-array
    [ >c-bool ] int-array{ } map-as ; inline


USING: alien.c-types gpu.render.private kernel sequences
specialized-arrays.instances.alien.c-types.int ;

M: object >uniform-bvec-array
    '[ _ head-slice [ >c-bool ] int-array{ } map-as ] map concat
    ; inline


USING: alien.c-types alien.data gpu.render.private kernel ;

M: object >uniform-float-array float >c-array ; inline


USING: alien.c-types alien.data gpu.render.private kernel ;

M: object >uniform-int-array int >c-array ; inline


USING: gpu.render.private kernel sequences
specialized-arrays.instances.alien.c-types.int ;

M: object >uniform-ivec-array
    '[ _ head ] map int-array{ } concat-as ; inline


USING: alien.c-types alien.data gpu.render.private kernel
sequences ;

M:: object >uniform-matrix ( sequence cols rows -- c-array )
    sequence flip cols head-slice
    [ rows head-slice float >c-array ] { } map-as concat ;
    inline


USING: gpu.render.private kernel sequences ;

M: object >uniform-matrix-array
    '[ _ _ >uniform-matrix ] map concat ; inline


USING: alien.c-types alien.data gpu.render.private kernel ;

M: object >uniform-uint-array uint >c-array ; inline


USING: gpu.render.private kernel sequences
specialized-arrays.instances.alien.c-types.uint ;

M: object >uniform-uvec-array
    '[ _ head ] map uint-array{ } concat-as ; inline


USING: gpu.render.private kernel sequences
specialized-arrays.instances.alien.c-types.float ;

M: object >uniform-vec-array
    '[ _ head ] map float-array{ } concat-as ; inline


USING: kernel vocabs ;

M: object >vocab-link
    [ lookup-vocab ] [ <vocab-link> ] ?unless ;


USING: inverse kernel xml.syntax.inverse ;

M: object >xml fail ;


USING: kernel xml.syntax.inverse ;

M: object >xml-chunk 1chunk ;


USING: colors.xyy colors.xyz kernel ;

M: object >xyYa >xyza >xyYa ;


USING: colors colors.xyz kernel ;

M: object >xyza >rgba >xyza ;


USING: colors colors.yiq kernel ;

M: object >yiqa >rgba >yiqa ;


USING: colors colors.yuv kernel ;

M: object >yuva >rgba >yuva ;


USING: cpu.x86.assembler kernel ;

M: object MOVABS bad-movabs-operands ;


USING: kernel math.order math.vectors sequences ;

M: object [v-] [ [-] ] 2map ; inline


USING: kernel ui.tools.listener.completion ;

M: object accept-completion-hook 2drop ;


USING: kernel ui.gestures ;

M: object action-modifier C+ ;


USING: kernel tools.continuations ;

M: object add-breakpoint ;


USING: kernel ui.gadgets.layout ;

M: object add-gadget-at insertion-point -rot (add-gadget-at) ;


USING: help.home kernel ;

M: object add-recent-where f ;


USING: io.backend.unix.multiplexers kernel ;

M: object add-signal-callback 3drop f ;


USING: accessors kernel namespaces sets tools.scaffold
tools.scaffold.private ;

M: object add-using
    vocabulary>> using get [ adjoin ] [ drop ] if* ;


USING: cpu.arm.32.assembler.private kernel math.bitwise ;

M: object addressing-mode-2 shifter-op { { 1 25 } 0 } bitfield ;


USING: cpu.arm.32.assembler.private kernel math.bitwise ;

M: object addressing-mode-3
    shifter-op { { 1 7 } { 1 4 } 0 } bitfield ;


USING: kernel math.order ;

M: object after=? <=> +lt+ eq? not ; inline


USING: kernel math.order ;

M: object after? <=> +gt+ eq? ; inline


USING: accessors alien.strings kernel ;

M: object alien>string [ underlying>> ] dip alien>string ;


USING: compiler.cfg.builder.alien.params cpu.architecture kernel
layouts math namespaces ;

M:: object alloc-stack-param ( rep size -- n )
    compact-stack-params? get
    [ stack-params get size align dup size + stack-params set ] 
    [
        stack-params get dup rep rep-size cell align +
        stack-params set
    ] if ;


USING: compiler.cfg.register-allocation kernel ;

M: object allocator-statistics drop H{ } clone ;


USING: compiler.units kernel ;

M: object always-bump-effect-counter? drop f ;


USING: irc.client.internals kernel ;

M: object annotate-message nip ;


USING: kernel regexp.classes ;

M:: object answer ( class from to -- new-class )
    class from = to class ? ;


USING: kernel yaml.private ;

M: object apply-merge-keys nip ;


USING: kernel stack-checker.backend ;

M: object apply-object push-literal ;


USING: kernel smalltalk.printer ;

M: object array-element>string smalltalk>string ;


USING: arrays.shaped kernel ;

M: object array-replace drop f ;


USING: help.topics kernel ;

M: object article-content lookup-article article-content ;


USING: help.topics kernel ;

M: object article-name article-title ;


USING: assocs help.topics kernel namespaces ;

M: object article-parent article-xref get at ;


USING: help.topics kernel ;

M: object article-title lookup-article article-title ;


USING: io.encodings io.encodings.ascii.private kernel math
sequences ;

M: object ascii>
    [ dup 127 <= [ encode-error ] unless ] B{ } map-as ; inline


USING: kernel smalltalk.compiler.assignment ;

M: object assigned-locals drop f ;


USING: audio.engine kernel ;

M: object audio-distance drop 1.0 ; inline


USING: audio.engine kernel ;

M: object audio-gain drop 1.0 ; inline


USING: audio.engine kernel ;

M: object audio-orientation
    drop T{ audio-orientation-state } ; inline


USING: audio.engine kernel ;

M: object audio-position drop { 0.0 0.0 0.0 } ; inline


USING: audio.engine kernel ;

M: object audio-relative? drop f ; inline


USING: audio.engine kernel ;

M: object audio-rolloff drop 1.0 ; inline


USING: audio.engine kernel ;

M: object audio-velocity drop { 0.0 0.0 0.0 } ; inline


USING: kernel x11.io ;

M: object awaken-event-loop ;


USING: kernel math.order ;

M: object before=? <=> +gt+ eq? not ; inline


USING: kernel math.order ;

M: object before? <=> +lt+ eq? ; inline


USING: game.worlds kernel ;

M: object begin-game-world drop ;


USING: alien.data kernel ;

M: object binary-zero? drop f ; inline


USING: alien.c-types gpu.render.private kernel opengl.gl
sequences specialized-arrays.instances.alien.c-types.int ;

M: object bind-uniform-bvec2
    1 swap 2 head-slice [ >c-bool ] int-array{ } map-as
    glUniform2iv ; inline


USING: alien.c-types gpu.render.private kernel opengl.gl
sequences specialized-arrays.instances.alien.c-types.int ;

M: object bind-uniform-bvec3
    1 swap 3 head-slice [ >c-bool ] int-array{ } map-as
    glUniform3iv ; inline


USING: alien.c-types gpu.render.private kernel opengl.gl
sequences specialized-arrays.instances.alien.c-types.int ;

M: object bind-uniform-bvec4
    1 swap 4 head-slice [ >c-bool ] int-array{ } map-as
    glUniform4iv ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-ivec2 first2 glUniform2i ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-ivec3 first3 glUniform3i ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-ivec4 first4 glUniform4i ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-uvec2 first2 glUniform2ui ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-uvec3 first3 glUniform3ui ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-uvec4 first4 glUniform4ui ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-vec2 first2 glUniform2f ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-vec3 first3 glUniform3f ; inline


USING: gpu.render.private kernel opengl.gl sequences ;

M: object bind-uniform-vec4 first4 glUniform4f ; inline


USING: alien alien.c-types alien.data kernel math.bitwise
math.bitwise.private ;

M: object bit-count
    binary-object uchar <c-direct-array> byte-array-bit-count ;


USING: kernel sequences.deep ;

M: object branch? drop f ;


USING: kernel peg.ebnf.private ;

M: object build-locals drop ;


USING: alien kernel math sequences ;

M: object byte-length [ length ] [ element-size ] bi * ; inline


USING: compiler.tree.propagation.call-effect kernel ;

M: object cached-effect drop +unknown+ ;


USING: kernel quotations.private ;

M: object call-sequence ; inline


USING: html.templates io kernel namespaces ;

M: object call-template* output-stream get stream-copy ;


USING: io.pathnames kernel ;

M: object canonicalize-drive ;


USING: io.pathnames kernel ;

M: object canonicalize-path canonicalize-path* ;


USING: io.pathnames kernel ;

M: object canonicalize-path-full
    canonicalize-path canonicalize-drive ;


USING: containers kernel ;

M: object capacity count ;


USING: kernel regexp.captures.private regexp.compiler ;

M: object capture-question>quot question>quot ;


USING: kernel mason.release.sign ;

M: object cert-path f ;


USING: combinators.private kernel ;

M: object check-call-effect 2drop ;


USING: generic kernel ;

M: object check-combination-effect 2drop ;


USING: classes classes.builtin kernel kernel.private ;

M: object class-of tag type>class ; inline


USING: arrays kernel regexp.classes ;

M: object class>questions 1array ;


USING: kernel ;

M: object clone ; inline


USING: kernel ui ui.gadgets.private ui.gadgets.worlds ;

M: object close-window find-world [ ungraft ] when* ;


USING: kernel ui.gadgets.tables ;

M: object column-alignment drop f ;


USING: kernel ui.gadgets.tables ;

M: object column-titles drop f ;


USING: kernel quotations smalltalk.compiler ;

M: object compile-ast nip 1quotation ;


USING: documents.elements kernel ui.tools.listener.completion ;

M: object completion-element drop word-start-elt ;


USING: classes.tuple fixups kernel slots.private ;

M: object compute-fixups
    "error" over ?offset-of-slot
    [ slot compute-fixups ] [ 2drop { } ] if* ;


USING: continuations kernel ;

M: object compute-restarts drop { } ;


USING: kernel macros.expander ;

M: object condomize ;


USING: kernel macros.expander ;

M: object condomize? drop f ;


USING: classes kernel words ;

M: object contained-classes "members" word-prop ;


USING: kernel smalltalk.compiler ;

M: object contains-blocks? drop f ;


USING: kernel ui.gadgets.panes ;

M: object content-gadget drop f ;


USING: kernel ui.clipboards ;

M: object copy-clipboard nip set-clipboard-contents ;


USING: destructors io io.directories io.encodings.binary
io.files kernel ;

M: object copy-file
    make-parent-directories binary <file-writer> [
        swap binary <file-reader>
        [ swap stream-copy ] with-disposal
    ] with-disposal ;


USING: cpu.x86 kernel ;

M: object copy-memory* copy-register* ;


USING: kernel sequences.cords ;

M: object cord-append generic-cord boa ; inline


USING: fry.private kernel ;

M: object count-inputs drop 0 ;


USING: kernel tools.coverage.generic-testvocab ;

M: object coverage-generic ;


USING: kernel ui.backend ;

M: object current-gl-context f ;


USING: io.files.private kernel ;

M: object cwd "." ;


USING: kernel see.private ;

M: object declarations. drop ;


USING: io.encodings kernel ;

M: object decode-until (decode-until) ;


USING: accessors classes kernel libclang sequences ;

M: object def>out-form
    class-of name>> "unknown object: " prepend ;


USING: graphviz.render graphviz.render.private io.standard-paths
kernel sequences ;

M: object default-graphviz-program
    standard-layouts
    [ find-in-standard-login-path ] map-find drop ;


USING: kernel locals.rewrite ;

M: object defs-vars* drop ;


USING: discord.chatgpt-bot kernel ;

M: object discord-chatgpt-bot 2drop ;


USING: discord kernel ;

M: object discord-help-bot 2drop ;


USING: accessors discord kernel ;

M: object dispatch-message
    "unhandled: " gwrite name>> gwrite g... ;


USING: accessors destructors kernel ;

M: object dispose [ t >>disposed dispose* ] unless-disposed ;


USING: io.monitors kernel ;

M: object dispose-monitors ;


USING: kernel math math.functions math.vectors sequences ;

M: object distance [ - absq ] [ + ] 2map-reduce sqrt ; inline


USING: kernel mason.release.dlls ;

M: object dll-list { } ;


USING: kernel ui.text.private ;

M: object draw-selected-string draw-selected-string-default ;


USING: kernel ui.text.private ;

M: object draw-string* draw-string-default ;


USING: kernel ui.text.private ;

M: object draws-selection-background? f ;


USING: definitions editors kernel sequences ;

M: object edit
    [ where ] [ first2 edit-location ] [ cannot-find-source ]
    ?if ;


USING: editors kernel vocabs.loader ;

M: object edit-docs vocab-docs-path 1 edit-location ;


USING: editors kernel vocabs.files ;

M: object edit-tests vocab-tests-path 1 edit-location ;


USING: editors kernel ;

M: object editor-detached? t ;


USING: editors kernel ;

M: object editor-is-child? f ;


USING: effects kernel ;

M: object effect>string drop "object" ;


USING: effects kernel ;

M: object effect>type drop object ;


USING: help.markup kernel ;

M: object elements* 2drop ;


USING: compiler.cfg.instructions
compiler.cfg.linear-scan.assignment kernel ;

M: object emit-restore ##reload, ;


USING: compiler.cfg.instructions
compiler.cfg.linear-scan.assignment kernel ;

M: object emit-save ##spill, ;


USING: kernel yaml.private ;

M: object emit-value emit-scalar ;


USING: containers kernel math ;

M: object empty? count zero? ; inline


USING: io.encodings kernel sequences ;

M: object encode-string [ encode-char ] 2curry each ; inline


USING: io.encodings.utf16.private kernel sequences ;

M: object encode-string-utf16be [ char>utf16be ] curry each
    ; inline


USING: io.encodings.utf16.private kernel sequences ;

M: object encode-string-utf16le [ char>utf16le ] curry each
    ; inline


USING: io.encodings.utf8.private kernel sequences ;

M: object encode-string-utf8 [ char>utf8 ] curry each ; inline


USING: game.worlds kernel ;

M: object end-game-world drop ;


USING: assocs io.launcher.private kernel ;

M: object environment-union assoc-union ;


USING: compiler.tree.propagation.info kernel ;

M: object eql? eq? ;


USING: kernel ;

M: object equal? 2drop f ; inline


USING: kernel source-files.errors ;

M: object error-file drop f ;


USING: debugger kernel ;

M: object error-help drop f ;


USING: kernel ui.tools.debugger ;

M: object error-in-debugger? drop f ;


USING: combinators continuations kernel namespaces ;

M: object error-in-thread
    thread-error-hook get-global ( error thread -- * )
    call-effect ;


USING: kernel source-files.errors ;

M: object error-line drop f ;


USING: debugger kernel prettyprint ;

M: object error. short. ;


USING: accessors combinators io.backend.unix io.sockets.private
io.sockets.unix kernel libc unix.ffi ;

M: object establish-connection
    2dup [ handle>> handle-fd ] [ make-sockaddr/size ] bi*
    connect 0 =
    [ 2drop ] [
        errno {
            { EINTR [ establish-connection ] }
            { EINPROGRESS [ drop wait-to-connect ] }
            [ (throw-errno) ]
        } case
    ] if ;


USING: gml.runtime kernel ;

M: object exec-proc (exec) ;


USING: continuations db destructors kernel ;

M: object execute-statement*
    '[ _ _ drop query-results dispose ]
    [ parse-db-error rethrow ] recover ;


USING: kernel shell ;

M: object expand ;


USING: kernel macros.expander ;

M: object expand-macros* literal ;


USING: cpu.x86.assembler.operands.private kernel ;

M: object extended? drop f ;


USING: furnace.syndication kernel ;

M: object feed-entry-description drop f ;


USING: accessors calendar.format combinators kernel math.parser
tools.files tools.files.private ;

M: object file-spec>string
    {
        { +file-name+ [ directory-entry>> name>> ] }
        { +directory-or-size+ [ file-info>> dir-or-size ] }
        { +file-size+ [ file-info>> size>> number>string ] }
        { +file-date+ [ file-info>> modified>> listing-date ] }
        { +file-time+ [ file-info>> modified>> listing-time ] }
        {
            +file-datetime+
            [ file-info>> modified>> timestamp>ymdhms ]
        }
        [ unknown-file-spec ]
    } case ;


USING: kernel ui.gadgets.tables ;

M: object filled-column drop f ;


USING: classes.tuple kernel ;

M: object final-class? drop f ;


USING: editors.aquamacs kernel ;

M: object find-aquamacs-path f ;


USING: editors.atom io.standard-paths kernel ;

M: object find-atom "atom" ?find-in-path ;


USING: editors.cudatext kernel ;

M: object find-cudatext-path f ;


USING: editors.emacs io.standard-paths kernel ;

M: object find-emacsclient "emacsclient" ?find-in-path ;


USING: editors.gvim kernel ;

M: object find-gvim-path f ;


USING: io.standard-paths kernel ;

M: object find-in-standard-login-path* find-in-path* ;


USING: editors.jedit kernel ;

M: object find-jedit-path f ;


USING: editors.kate kernel ;

M: object find-kate-path f ;


USING: editors.lapce kernel ;

M: object find-lapce-path f ;


USING: editors.pulsar io.standard-paths kernel ;

M: object find-pulsar "pulsar" ?find-in-path ;


USING: editors.rider kernel ;

M: object find-rider-path f ;


USING: editors.sublime kernel ;

M: object find-sublime-path f ;


USING: editors.textadept kernel ;

M: object find-textadept-path f ;


USING: kernel opengl.textures ;

M: object fix-internal-component-order ;


USING: alien.c-types arrays compiler.cfg.builder.alien.boxing
cpu.architecture kernel layouts math ;

M: object flatten-struct-type
    heap-size cell align cell /i { int-rep f f } <array>
    record-reg-reps ;


USING: compiler.cfg.builder.alien.boxing kernel ;

M: object flatten-struct-type-return flatten-struct-type ;


USING: arrays editors.focus kernel ;

M: object focus-command focus-path nip swap 2array ;


USING: kernel ui.gadgets ;

M: object focusable-child* drop f ;


USING: kernel math ;

M: object fp-infinity? drop f ; inline


USING: kernel math ;

M: object fp-nan? drop f ; inline


USING: kernel math ;

M: object fp-qnan? drop f ; inline


USING: kernel math ;

M: object fp-snan? drop f ; inline


USING: kernel math ;

M: object fp-special? drop f ; inline


USING: fuel.pprint kernel prettyprint ;

M: object fuel-pprint pprint ; inline


USING: fuel.listener kernel ;

M: object fuel-pty-setup ;


USING: benchmark.dispatch3 kernel ;

M: object g drop "object" ;


USING: accessors classes kernel sequences ui.gadgets.panes ;

M: object gadget-alt-text class-of name>> "( " " )" surround ;


USING: kernel quiz ;

M: object generate-question generator-needs-reponse-type ;


USING: kernel ui.gestures ;

M: object gesture>string drop f ;


USING: kernel ui.gadgets ;

M: object graft* drop ;


USING: io.encodings kernel ;

M: object guess-decoded-length drop ; inline


USING: io.encodings kernel ;

M: object guess-encoded-length drop ; inline


USING: combinators kernel math math.vectors.simd
math.vectors.simd.extensions
math.vectors.simd.intrinsics.private sequences ;

M:: object half-binary ( a b op -- result )
    a b op {
        { "+" [ [ + ] 2map ] }
        { "-" [ [ - ] 2map ] }
        { "*" [ [ * ] 2map ] }
        { "/" [ [ /f ] 2map ] }
        { "min" [ [ min-vector-lane ] 2map ] }
        { "max" [ [ max-vector-lane ] 2map ] }
        {
            "="
            [ [ = -1 0 ? ] ushort-8 new 2map-as half-8-cast ]
        }
        {
            "<"
            [ [ < -1 0 ? ] ushort-8 new 2map-as half-8-cast ]
        }
        {
            "<="
            [ [ <= -1 0 ? ] ushort-8 new 2map-as half-8-cast ]
        }
        {
            ">"
            [ [ > -1 0 ? ] ushort-8 new 2map-as half-8-cast ]
        }
        {
            ">="
            [ [ >= -1 0 ? ] ushort-8 new 2map-as half-8-cast ]
        }
        {
            "unordered"
            [
                [ unordered? -1 0 ? ] ushort-8 new 2map-as
                half-8-cast
            ]
        }
    } case ;


USING: kernel math.floats.small math.vectors.simd.extensions
sequences ;

M: object half-fma [ half-fma-value ] 3map ;


USING: kernel math.libm math.vectors.simd.extensions sequences ;

M: object half-sqrt [ fsqrt ] map ;


USING: combinators kernel ui.gestures ;

M: object handle-gesture
    [ nip ] [ get-gesture-handler ] 2bi dup
    [ ( gadget -- ) call-effect f ] [ 2drop t ] if ;


USING: bittorrent kernel ;

M: object handle-message drop ;


USING: irc.gitbot kernel ;

M: object handle-message drop ;


USING: irc.logbot kernel ;

M: object handle-message drop ;


USING: kernel ui.gestures ;

M: object handles-gesture? get-gesture-handler >boolean ;


USING: kernel ;

M: object hashcode* 2drop 0 ; inline


USING: kernel math math.functions math.vectors sequences ;

M: object hdot [ conjugate * ] [ + ] 2map-reduce ; inline


USING: calendar.holidays calendar.holidays.private combinators
kernel sequences ;

M: object holidays
    (holidays)
    [ [ clone ] dip ( timestamp -- timestamp ) execute-effect ]
    with map ;


USING: io.pathnames kernel ;

M: object home "" resource-path ;


USING: alien.c-types arrays cpu.architecture cpu.arm.64.abi
kernel ;

M: object homogeneous-aggregate-members
    c-type-rep dup homogeneous-rep? [
        homogeneous-rep [ drop 0 ] [ rep-size ] [ ] tri 3array
        1array
    ] [ drop f ] if ;


USING: kernel punycode sequences splitting ;

M: object idna>
    "." split [ "xn--" ?head [ punycode> ] when ] map "." join ;


USING: combinators cpu.architecture kernel layouts math ;

M: object immediate-comparand?
    {
        { [ dup fixnum? ] [ tag-fixnum immediate-arithmetic? ] }
        { [ dup not ] [ drop t ] }
        [ drop f ]
    } cond ;


USING: kernel stack-checker.branches ;

M: object indirect-branch? drop f ;


USING: kernel stack-checker.errors stack-checker.known-words ;

M: object infer-call* \ call bad-macro-input ;


USING: combinators.smart kernel ;

M: object infer-known* drop f ;


USING: io.monitors kernel ;

M: object init-monitors ;


USING: furnace.sessions kernel ;

M: object init-session* drop ;


USING: furnace.auth kernel ;

M: object init-user-profile drop ;


USING: kernel x11.io ;

M: object init-x-io ;


USING: compiler.cfg.intrinsics.simd.backend kernel ;

M: object insn-available? drop t ;


USING: classes kernel slots ;

M: object instance-check-quot
    [ predicate-def [ dup ] prepose ] keep
    [ bad-slot-value ] curry [ unless ] curry compose ;


USING: kernel xml.syntax.private ;

M: object interpolate-item [ swap ] curry ;


USING: kernel math.order sorting.quick ;

M: object inv-sort! [ <=> ] inv-sort-with! ;


USING: assocs kernel sorting ;

M: object inv-sort-keys >alist inv-sort-keys ;


USING: assocs kernel sorting ;

M: object inv-sort-values >alist inv-sort-values ;


USING: inverse kernel ;

M: object inverse undo-literal ;


USING: kernel tools.crossref.private ;

M: object irrelevant? drop f ;


USING: ascii kernel sequences ui.gestures ;

M: object keysym>string dup length 1 = [ >lower ] when ;


USING: kernel stack-checker.values ;

M: object known>callable drop \ _ ;


USING: kernel ui.gadgets ;

M: object layout* drop ;


USING: io.streams.limited kernel ;

M: object limit-stream <limited-stream> ;


USING: furnace.utilities kernel ;

M: object link-attr 2drop ;


USING: kernel lint.private ;

M: object lint drop f ;


USING: classes.tuple.parser kernel ;

M: object literal>object drop boa>object ;


USING: kernel quotations ;

M: object literalize ;


USING: images.loader kernel ;

M: object load-image* stream>image ;


USING: alien.c-types alien.data combinators kernel
openal.alut.backend openal.alut.other ;

M: object load-wav-file
    0 int <ref> f void* <ref> 0 int <ref> 0 int <ref>
    [ 0 char <ref> alutLoadWAVFile ] 4keep {
        [ int deref ]
        [ void* deref ]
        [ int deref ]
        [ int deref ]
    } spread ;


USING: kernel locals.rewrite quotations ;

M: object localize 1quotation ;


USING: kernel math math.functions ;

M: object log1+ 1 + log ; inline


USING: assocs kernel namespaces vocabs ;

M: object lookup-vocab vocab-name dictionary get at ;


USING: kernel mirrors ;

M: object make-mirror <mirror> ;


USING: assocs kernel mirrors ui.tools.inspector ;

M: object make-slot-descriptions
    make-mirror [ <slot-description> ] { } assoc>map ;


USING: io.sockets.private kernel ;

M: object make-sockaddr-outgoing make-sockaddr ;


USING: kernel math.order ;

M: object max [ after? ] most ; inline


USING: kernel sequences ;

M: object member? [ = ] with any? ;


USING: kernel math.order ;

M: object min [ before? ] most ; inline


USING: kernel models ;

M: object model-changed 2drop ;


USING: accessors kernel sequences ui.gestures ;

M: object modifiers>string [ name>> ] map "" concat-as ;


USING: kernel regexp.nfa ;

M: object modify-class ;


USING: furnace.utilities kernel ;

M: object modify-form drop f ;


USING: furnace.utilities kernel ;

M: object modify-query drop ;


USING: furnace.utilities kernel ;

M: object modify-redirect-query drop ;


USING: accessors assocs io.files.info kernel ;

M: object mount-points
    file-systems [ [ mount-point>> ] keep ] H{ } map>assoc ;


USING: kernel math math.vectors sequences ;

M: object n*v [ * ] with map ; inline


USING: kernel math math.vectors sequences ;

M: object n+v [ + ] with map ; inline


USING: kernel math math.vectors sequences ;

M: object n-v [ - ] with map ; inline


USING: kernel math math.vectors sequences ;

M: object n/v [ / ] with map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object n^v [ ^ ] with map ; inline


USING: binary-search kernel math.order ;

M: object natural-search [ <=> ] with search ;


USING: kernel smalltalk.compiler.return ;

M: object need-return-continuation? drop f ;


USING: arrays kernel sequences ;

M: object new-sequence drop 0 <array> ; inline


USING: compiler.cfg.builder.alien.params cpu.architecture kernel
namespaces sequences ;

M: object next-reg-param
    nip [ ?dummy-stack-params ] [ ?dummy-int-params ] bi
    float-regs get pop ;


USING: kernel regexp.nfa ;

M: object nfa-node modify-class add-simple-entry ;


USING: kernel lists ;

M: object nil? drop f ;


USING: kernel reports.noise ;

M: object noise drop { 0 0 } ;


USING: kernel math math.functions math.vectors sequences ;

M: object norm-sq [ absq ] [ + ] map-reduce ; inline


USING: classes.algebra.private kernel ;

M: object normalize-class ;


USING: io.backend io.pathnames kernel ;

M: object normalize-path absolute-path ;


USING: kernel math.combinatorics.private ;

M: object nths-unsafe (nths-unsafe) ;


USING: kernel regexp.captures.private ;

M: object number-captures ;


USING: kernel math ;

M: object number= 2drop f ;


USING: cuda.nvcc kernel ;

M: object nvcc-path "nvcc" ;


USING: cpu.x86.assembler.operands.private kernel ;

M: object operand-64? drop f ;


USING: arrays kernel math.vectors.simd
math.vectors.simd.extensions sequences ;

M: object pack-bfloat [ >array ] bi@ append >bfloat-8 ;


USING: arrays kernel math.vectors.simd
math.vectors.simd.extensions sequences ;

M: object pack-half [ >array ] bi@ append >half-8 ;


USING: accessors images.bitmap io kernel math ;

M: object parse-color-data*
    dup image-size>> [ 0 ] unless* dup 0 >
    [ nip ] [ drop color-index-length ] if read >>color-index ;


USING: ascii crontab kernel sequences ;

M: object parse-crontab
    [ [ blank? not ] find nip { f 35 } member? ] reject
    [ parse-cronentry ] map ;


USING: gitignore globs kernel sequences splitting unicode ;

M: object parse-gitignore
    [ [ blank? ] trim ] map harvest [ "#" head? ] reject [
        "!" ?head [
            "\\#" ?head [ "#" prepend ] when "\\!" ?head
            [ "!" prepend ] when 47 over but-last-slice index
            [ "**/" prepend ] unless <glob>
        ] dip <gitignore>
    ] map ;


USING: dns io kernel ;

M: object parse-rdata drop read ;


USING: kernel ui.clipboards ui.gestures ;

M: object paste-clipboard
    clipboard-contents [ swap user-input ] [ drop ] if* ;


USING: kernel ui.pens ;

M: object pen-background 2drop f ;


USING: kernel ui.pens ;

M: object pen-foreground 2drop f ;


USING: kernel ui.pens ;

M: object pen-pref-dim 2drop { 0 0 } ;


USING: alien.c-types kernel ;

M: object pointer-string drop f ;


USING: kernel tools.image.analyzer.references ;

M: object pointers 3drop { } ;


USING: kernel prettyprint.custom ;

M: object pprint* pprint-object ;


USING: json json.prettyprint.private kernel ;

M: object pprint-json* write-json ;


USING: kernel prettyprint.custom ;

M: object pprint-narrow? drop f ;


USING: kernel prettyprint.backend prettyprint.custom
prettyprint.sections ;

M: object pprint-object
    [
        <flow dup pprint-delims [
            pprint-word dup pprint-narrow? <inset
            >pprint-sequence pprint-elements block>
        ] dip pprint-word block>
    ] check-recursion ;


USING: classes kernel ;

M: object predicate-def [ instance? ] curry ;


USING: compiler.cfg.register-allocation.ssa.bases kernel ;

M: object prepare-allocation-bases drop f ;


USING: kernel regexp.captures.private ;

M: object prepare-capture-label ;


USING: accessors kernel libclang ;

M: object print-deferred
    type>> ?lookup-type [ def>out-forms ] when* ;


USING: io kernel present rdap.private sequences ;

M: object print-rdap-nested
    present
    [ 2drop ] [ [ ": " [ write ] tri@ ] dip print ] if-empty ;


USING: cpu.arm.64.features kernel ;

M: object probe-arm64-features { } ;


USING: kernel xml.private ;

M: object process add-child ;


USING: irc.client.internals kernel ;

M: object process-message drop ;


USING: io io.styles kernel listener namespaces sequences ;

M: object prompt.
    nip [ prompt-style get-global format bl ] unless-empty ;


USING: kernel ui.gadgets.tables ;

M: object prototype-row drop { "" } ;


USING: cuda.ptx kernel ;

M: object ptx-element-label drop f ;


USING: cuda.ptx kernel ;

M: object ptx-semicolon? drop t ;


USING: kernel make present xml.syntax.private ;

M: object push-item present , ;


USING: accessors kernel math math.order math.statistics.running
;

M:: object push-value ( stats x -- stats )
    stats dup n>> zero?
    [ x >>min x >>max ]
    [ [ x min ] change-min [ x max ] change-max ] if
    [ 1 + dup ] change-n swap :> n [ x + ] change-sum
    x over mom1>> - :> delta delta n /f
    :> delta_n delta_n sq :> delta_n2 delta delta_n * n 1 - *
    :> term1 [
        term1 delta_n2 * n sq 3 n * - 3 + * 6 delta_n2 *
        stats mom2>> * + 4 delta_n * stats mom3>> * - +
    ] change-mom4
    [ term1 delta_n * n 2 - * 3 delta_n * stats mom2>> * - + ]
    change-mom3 [ term1 + ] change-mom2
    [ delta_n + ] change-mom1 ;


USING: kernel math.quaternions math.vectors ;

M: object qconjugate { 1 -1 -1 -1 } v* ; inline


USING: kernel tools.crossref.private ;

M: object quot-uses 2drop ;


USING: kernel random ;

M: object random-32* not-a-random-generator ;


USING: kernel random ;

M: object random-bytes* not-a-random-generator ;


USING: io.encodings kernel ;

M: object re-decode <decoder> ;


USING: io.encodings kernel ;

M: object re-encode <encoder> ;


USING: accessors arrays kernel kernel.private slots
slots.private words ;

M: object reader-quot
    nip [ offset>> [ slot ] curry ] [ class>> ] bi
    dup object bootstrap-word eq?
    [ drop ] [ 1array [ declare ] curry compose ] if ;


USING: combinators game.loop.private kernel ;

M: object record-benchmarking ( loop -- ) call-effect ;


USING: alien.prettyprint.private kernel ;

M: object record-pointer drop ;


USING: io.pathnames kernel ;

M: object relative-path relative-path* ;


USING: io.sockets.private io.sockets.unix kernel unix.ffi ;

M: object remote>handle
    [ protocol-family SOCK_STREAM ] [ protocol ] bi socket-fd
    [ init-client-socket ] [ ?bind-client ] [ ] tri ;


USING: kernel wipe ;

M: object remove-read-only drop ;


USING: kernel match ;

M: object replace-patterns ;


USING: kernel ui ;

M: object resize-window 2drop ;


USING: io.sockets kernel ;

M: object resolve-localhost
    ipv6-supported?
    { T{ ipv4 { host "0.0.0.0" } } T{ ipv6 { host "::" } } }
    { T{ ipv4 { host "0.0.0.0" } } } ? ;


USING: io.backend io.pathnames kernel ;

M: object resolve-symlinks normalize-path ;


USING: cpu.architecture kernel ;

M: object return-struct-pointer? f ;


USING: kernel locals.rewrite make ;

M: object rewrite-closures* , ;


USING: kernel locals.rewrite make ;

M: object rewrite-element , ;


USING: kernel locals.rewrite ;

M: object rewrite-literal? drop f ;


USING: kernel locals.rewrite make ;

M: object rewrite-sugar* , ;


USING: io.pathnames kernel sequences ;

M: object root-directory?
    [ f ] [ [ path-separator? ] all? ] if-empty ;


USING: io.pathnames kernel ;

M: object root-path root-path* ;


USING: kernel ui.gadgets.tables ;

M: object row-color 2drop f ;


USING: kernel ui.gadgets.tables ;

M: object row-summary row-value ;


USING: kernel ui.gadgets.tables ;

M: object row-value drop ;


USING: kernel ui.gadgets.tables ;

M: object row-value? drop eq? ;


USING: arrays kernel quiz ;

M: object run-multiple-choice-quiz
    [ 1array ] dip run-multiple-choice-quiz ;


USING: accessors destructors io.launcher io.pipes.private kernel
;

M: object run-pipeline-element
    [
        [ [ dup [ &dispose drop ] when* ] bi@ ] dip
        >process swap >>stdout swap >>stdin run-detached
    ] with-destructors wait-for-process ;


USING: arrays kernel quiz ;

M: object run-quiz 1array run-quiz ;


USING: compiler.tree.propagation.constraints kernel ;

M: object satisfied? drop f ;


USING: io.sockets.secure kernel ;

M: object secure-hostname drop f ;


USING: definitions kernel namespaces prettyprint
prettyprint.backend prettyprint.config prettyprint.sections see
see.private ;

M: object see*
    [
        has-limits? get
        [ 12 nesting-limit set 100 length-limit set ] unless
        <colon dup synopsis*
        <block dup definition pprint-elements
        block> dup definer nip [ pprint-word ] when*
        declarations. block>
    ] with-use ;


USING: gml.viewer kernel ;

M: object selected-vectors drop { } ;


USING: arrays kernel math.order ui.text ;

M:: object selection-spans
    ( start end font string -- spans )
    start end [ font string offset>x ] bi@ [ min ] [ max ] 2bi
    2array 1array ;


USING: kernel math smalltalk.selectors ;

M: object selector-* swap * ;


USING: kernel math smalltalk.selectors ;

M: object selector-+ swap + ;


USING: kernel math smalltalk.selectors ;

M: object selector-- swap - ;


USING: kernel math smalltalk.selectors ;

M: object selector-/ swap / ;


USING: kernel math smalltalk.selectors ;

M: object selector-< swap < ;


USING: kernel math smalltalk.selectors ;

M: object selector-<= swap <= ;


USING: kernel smalltalk.selectors ;

M: object selector-= swap = ;


USING: kernel math smalltalk.selectors ;

M: object selector-> swap > ;


USING: kernel math smalltalk.selectors ;

M: object selector->= swap >= ;


USING: kernel present smalltalk.selectors ;

M: object selector-asString present ;


USING: combinators kernel sequences smalltalk.ast
smalltalk.selectors ;

M:: object selector-do: ( quot receiver -- result )
    receiver [ quot ( elt -- result ) call-effect drop ] each
    nil ;


USING: combinators kernel smalltalk.ast smalltalk.selectors ;

M: object selector-ifFalse:
    [ drop nil ] [ ( -- result ) call-effect ] if ;


USING: combinators kernel smalltalk.ast smalltalk.selectors ;

M: object selector-ifTrue:
    [ ( -- result ) call-effect ] [ drop nil ] if ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-ifTrue:ifFalse:
    [ drop ( -- result ) call-effect ]
    [ nip ( -- result ) call-effect ] if ;


USING: kernel smalltalk.ast smalltalk.selectors ;

M: object selector-isNil nil eq? ;


USING: kernel math.order smalltalk.selectors ;

M: object selector-max: max ;


USING: kernel math.order smalltalk.selectors ;

M: object selector-min: min ;


USING: kernel smalltalk.selectors ;

M: object selector-new new ;


USING: kernel smalltalk.selectors ;

M: object selector-nextPutAll: selector-print: ;


USING: io kernel smalltalk.ast smalltalk.selectors ;

M: object selector-nl stream-nl nil ;


USING: io kernel present smalltalk.selectors ;

M: object selector-print dup present print ;


USING: io kernel present smalltalk.ast smalltalk.selectors ;

M: object selector-print: [ present ] dip stream-print nil ;


USING: kernel smalltalk.selectors ;

M: object selector-tab "    " swap selector-print: ;


USING: combinators kernel smalltalk.selectors tools.time ;

M: object selector-time '[ _ ( -- result ) call-effect ] time ;


USING: kernel ranges smalltalk.selectors ;

M: object selector-to: swap [a..b] ;


USING: combinators kernel ranges sequences smalltalk.ast
smalltalk.selectors ;

M:: object selector-to:do: ( to quot from -- result )
    from to [a..b]
    [ quot ( i -- result ) call-effect drop ] each nil ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-value ( -- result ) call-effect ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-value: ( input -- result ) call-effect ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-value:value:
    ( input input -- result ) call-effect ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-value:value:value:
    ( input input input -- result ) call-effect ;


USING: combinators kernel smalltalk.selectors ;

M: object selector-value:value:value:value:
    ( input input input input -- result ) call-effect ;


USING: assocs help.topics kernel namespaces ;

M: object set-article-parent article-xref get set-at ;


USING: kernel prettyprint.sections ;

M: object short-section? section-fits? ;


USING: io.ports kernel ;

M: object shutdown drop ;


USING: kernel mason.release.sign ;

M: object sign-archive drop ;


USING: kernel mason.release.sign ;

M: object sign-factor-app ;


USING: kernel math.vectors.simd ;

M: object simd-element-type drop f ;


USING: kernel math.vectors.simd ;

M: object simd-rep drop f ;


USING: kernel prettyprint smalltalk.printer ;

M: object smalltalk>string unparse-short ;


USING: kernel sequences tools.crossref tools.crossref.private ;

M: object smart-usage usage [ irrelevant? ] reject ;


USING: kernel math.order sorting.quick ;

M: object sort! [ <=> ] sort-with! ;


USING: assocs kernel sorting ;

M: object sort-keys >alist sort-keys ;


USING: assocs kernel sorting ;

M: object sort-values >alist sort-values ;


USING: kernel present text-to-speech ;

M: object speak present speak-text ;


USING: classes hints kernel ;

M: object specializer-declaration class-of ;


USING: hints kernel ;

M: object specializer-predicate '[ _ eq? ] ;


USING: io.sockets.secure kernel ;

M: object ssl-certificate-verification-supported? f ;


USING: io.sockets.secure kernel ;

M: object ssl-supported? f ;


USING: cpu.architecture kernel ;

M: object stack-cleanup 3drop 0 ;


USING: kernel ui.backend ;

M: object stop-event-loop ;


USING: kernel listener ;

M: object stream-read-quot V{ } clone read-quot-loop ;


USING: kernel libc ;

M: object strerror strerror_unsafe ;


USING: cpu.architecture kernel ;

M: object struct-return-register f ;


USING: arrays cpu.x86.64.unix kernel ;

M: object struct-types&offset 0 2array 1array ;


USING: kernel math sequences ;

M: object sum 0 [ + ] binary-reduce ; inline


USING: kernel math sequences ;

M: object sum-lengths 0 [ length + ] reduce ;


USING: kernel math.functions math.statistics sequences ;

M: object sum-of-cubes [ 3 ^ ] map-sum ;


USING: kernel math.functions math.statistics sequences ;

M: object sum-of-quads [ 4 ^ ] map-sum ;


USING: kernel math math.statistics sequences ;

M: object sum-of-squares [ sq ] map-sum ;


USING: kernel summary ;

M: object summary object-summary ;


USING: formatting kernel sequences terminfo ;

M: object terminfo-relative-path
    [ first ] keep "%c/%s" sprintf ;


USING: cpu.architecture kernel ;

M: object test-instruction? f ;


USING: combinators.private kernel kernel.private ;

M: object throw
    ERROR-HANDLER-QUOT special-object [ die ] or
    ( error -- * ) call-effect-unsafe ;


USING: game.worlds kernel ;

M: object tick-game-world drop ;


USING: kernel summary ;

M: object tuple-summary object-summary ;


USING: kernel ui.backend ;

M: object ui-backend-available? f ;


USING: accessors io.ports kernel ;

M: object underlying-handle underlying-port handle>> ;


USING: kernel ui.gadgets ;

M: object ungraft* drop ;


USING: kernel math ;

M: object unordered? 2drop f ;


USING: kernel shapefiles.private ;

M: object update-bounds drop ;


USING: io.streams.html kernel ;

M: object url-of drop f ;


USING: furnace.auth furnace.redirection kernel urls ;

M: object user-registered 2drop URL" %24realm" <redirect> ;


USING: kernel tools.crossref ;

M: object uses drop f ;


USING: kernel locals.rewrite ;

M: object uses-vars* drop ;


USING: kernel math math.vectors sequences ;

M: object v* [ * ] 2map ; inline


USING: kernel math math.vectors math.vectors.private sequences ;

M: object v*hs+ [ * ] 2map (h+) ; inline


USING: kernel math math.vectors sequences ;

M: object v*n [ * ] curry map ; inline


USING: kernel math math.vectors sequences ;

M: object v+ [ + ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v+-
    [ t ] 2dip [ [ not ] 2dip pick [ + ] [ - ] if ] 2map nip ;
    inline


USING: kernel math math.vectors sequences ;

M: object v+n [ + ] curry map ; inline


USING: kernel math math.vectors sequences ;

M: object v- [ - ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v-n [ - ] curry map ; inline


USING: kernel math math.vectors sequences ;

M: object v/ [ / ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v/n [ / ] curry map ; inline


USING: kernel math math.vectors sequences ;

M: object v< [ < ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v<= [ <= ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object v= [ = ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v> [ > ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object v>= [ >= ] 2map ; inline


USING: kernel math.vectors ;

M: object v? [ vand ] [ vandn ] bi-curry* bi vor ; inline


USING: kernel math.functions math.vectors sequences ;

M: object v^ [ ^ ] 2map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object v^n [ ^ ] curry map ; inline


USING: kernel math math.vectors sequences ;

M: object vabs [ abs ] map ; inline


USING: assocs help.topics kernel namespaces ;

M: object valid-article? articles get key? ;


USING: kernel math.vectors sequences ;

M: object vall? [ ] all? ; inline


USING: kernel math.vectors sequences ;

M: object vand [ and ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object vandn [ [ not ] dip and ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object vany? [ ] any? ; inline


USING: kernel math math.vectors sequences ;

M: object vavg [ + 2 / ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vbitand [ bitand ] 2map ; inline


USING: kernel math.vectors math.vectors.private sequences ;

M: object vbitandn [ bitandn ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vbitnot [ bitnot ] map ; inline


USING: kernel math math.vectors sequences ;

M: object vbitor [ bitor ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vbitxor [ bitxor ] 2map ; inline


USING: kernel math.vectors sequences ;

M:: object vbroadcast ( u n -- v )
    u length n u nth <repetition> u like ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vceiling [ ceiling ] map ; inline


USING: kernel math.vectors sequences ;

M: object vcount [ ] count ; inline


USING: kernel math math.vectors sequences ;

M: object vdot [ * ] [ + ] 2map-reduce ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vfloor [ floor ] map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vfma [ fma ] 3map ; inline


USING: kernel math math.vectors sequences ;

M: object vlshift '[ _ shift ] map ; inline


USING: cpu.architecture kernel ;

M: object vm-stack-space 0 ;


USING: kernel math.order math.vectors sequences ;

M: object vmax [ max ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object vmax-element maximum ; inline


USING: assocs kernel math.vectors sequences ;

M: object vmerge [ zip ] keep concat-as ; inline


USING: kernel math.order math.vectors sequences ;

M: object vmin [ min ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object vmin-element minimum ; inline


USING: kernel math math.vectors sequences ;

M: object vneg [ neg ] map ; inline


USING: kernel math.vectors sequences ;

M: object vnone? [ not ] all? ; inline


USING: kernel math.vectors sequences ;

M: object vnot [ not ] map ; inline


USING: kernel vocabs ;

M: object vocab-help lookup-vocab vocab-help ;


USING: kernel vocabs ;

M: object vocab-main lookup-vocab vocab-main ;


USING: kernel vocabs ;

M: object vocab-name check-vocab-name ;


USING: kernel vocabs ;

M: object vocab-words-assoc lookup-vocab vocab-words-assoc ;


USING: kernel math.vectors sequences ;

M: object vor [ or ] 2map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vround [ round ] map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vround-to-even [ round-to-even ] map ; inline


USING: kernel math math.vectors sequences ;

M: object vrshift neg '[ _ shift ] map ; inline


USING: kernel math math.vectors sequences ;

M: object vs* [ * ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vs+ [ + ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vs- [ - ] 2map ; inline


USING: kernel math math.vectors sequences ;

M: object vsad [ - abs ] [ + ] 2map-reduce ; inline


USING: kernel math.vectors sequences ;

M: object vshuffle-elements
    over length 0 pad-tail swap [ '[ _ nth ] ] keep map-as ;
    inline


USING: kernel math.vectors sequences ;

M: object vshuffle2-elements
    [ append ] dip vshuffle-elements ; inline


USING: kernel math math.libm math.vectors sequences ;

M: object vsqrt [ >float fsqrt ] map ; inline


USING: kernel math.functions math.vectors sequences ;

M: object vtruncate [ truncate ] map ; inline


USING: kernel math math.vectors sequences ;

M: object vunordered? [ unordered? ] 2map ; inline


USING: kernel math.vectors sequences ;

M: object vxor [ xor ] 2map ; inline


USING: calendar kernel threads x11.io ;

M: object wait-for-display 10 milliseconds sleep ;


USING: definitions kernel ;

M: object where drop f ;


USING: db.queries kernel ;

M: object where object-where ;


USING: kernel ui.backend ;

M: object window-drawable? drop t ;


USING: kernel ui.backend ;

M: object window-framebuffer drop 0 ;


USING: cpu.arm.64.features.windows kernel ;

M: object windows-processor-feature drop 0 ;


USING: combinators kernel shell ;

M: object with-foreground-interrupts ( -- ) call-effect ;


USING: edn kernel ;

M: object write-edn edn-error ;


USING: io kernel ui.gadgets.panes ;

M: object write-gadget [ gadget-alt-text ] dip stream-write ;


USING: accessors gml.printer io kernel ;

M: object write-gml "«Object: " write name>> write "»" write ;


USING: accessors kernel sequences slots slots.private ;

M: object writer-quot
    nip [
        class>> instance-check-quot dup empty?
        [ [ dip ] curry ] unless
    ] [ offset>> [ set-slot ] curry ] bi append ;