like ( seq exemplar -- newseq )
Factor handbook » The language » Collections » Sequence operations » Sequence protocol

Prev:	lengthen ( n seq -- )
Next:	new-sequence ( len seq -- newseq )

Vocabulary
sequences

Inputs

seq	a sequence
exemplar	a sequence

Outputs

newseq

a new sequence

Generic word contract
Outputs a sequence with the same elements as seq, but like the template sequence, in the sense that it either has the same class as the template sequence, or if the template sequence is a virtual sequence, the same class as the template sequence's underlying sequence.

The default implementation does nothing.

Notes
Unlike clone-like, the output sequence might share storage with the input sequence.

Examples

USING: prettyprint sequences ; { 1 2 3 } V{ } like .
V{ 1 2 3 }

Demonstrating the shared storage:

USING: kernel prettyprint sequences ; { 1 2 3 } dup V{ } like reverse! [ . ] bi@
{ 3 2 1 } V{ 3 2 1 }

Definition

IN: sequences

GENERIC: like ( seq exemplar -- newseq ) flushable

Methods

USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.BoneInfo ;

M: BoneInfo-array like
    drop dup BoneInfo-array instance?
    [ \ BoneInfo >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf32_Phdr ;

M: Elf32_Phdr-array like
    drop dup Elf32_Phdr-array instance?
    [ \ Elf32_Phdr >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf32_Shdr ;

M: Elf32_Shdr-array like
    drop dup Elf32_Shdr-array instance?
    [ \ Elf32_Shdr >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf32_Sym ;

M: Elf32_Sym-array like
    drop dup Elf32_Sym-array instance?
    [ \ Elf32_Sym >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf64_Phdr ;

M: Elf64_Phdr-array like
    drop dup Elf64_Phdr-array instance?
    [ \ Elf64_Phdr >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf64_Shdr ;

M: Elf64_Shdr-array like
    drop dup Elf64_Shdr-array instance?
    [ \ Elf64_Shdr >c-array ] unless ; inline


USING: alien.data classes elf kernel sequences
specialized-arrays.instances.elf.Elf64_Sym ;

M: Elf64_Sym-array like
    drop dup Elf64_Sym-array instance?
    [ \ Elf64_Sym >c-array ] unless ; inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.Material ;

M: Material-array like
    drop dup Material-array instance?
    [ \ Material >c-array ] unless ; inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.MaterialMap ;

M: MaterialMap-array like
    drop dup MaterialMap-array instance?
    [ \ MaterialMap >c-array ] unless ; inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.Matrix ;

M: Matrix-array like
    drop dup Matrix-array instance? [ \ Matrix >c-array ] unless
    ; inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.Mesh ;

M: Mesh-array like
    drop dup Mesh-array instance? [ \ Mesh >c-array ] unless ;
    inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.Vector2 ;

M: Vector2-array like
    drop dup Vector2-array instance?
    [ \ Vector2 >c-array ] unless ; inline


USING: kernel raylib sequences ;

M: Vector2 like
    over length 2 =
    [ drop dup Vector2? [ first2 <Vector2> ] unless ]
    [ invalid-vector-length ] if ; inline


USING: alien.data classes kernel raylib sequences
specialized-arrays.instances.raylib.Vector3 ;

M: Vector3-array like
    drop dup Vector3-array instance?
    [ \ Vector3 >c-array ] unless ; inline


USING: kernel raylib sequences ;

M: Vector3 like
    over length 3 =
    [ drop dup Vector3? [ first3 <Vector3> ] unless ]
    [ invalid-vector-length ] if ; inline


USING: kernel raylib sequences ;

M: Vector4 like
    over length 4 =
    [ drop dup Vector4? [ first4 <Vector4> ] unless ]
    [ invalid-vector-length ] if ; inline


USING: accessors arrays kernel sequences vectors ;

M: array like
    drop dup array? [
        dup vector? [
            [ length ] [ underlying>> ] bi 2dup length eq?
            [ nip ] [ resize-array ] if
        ] [ >array ] if
    ] unless ; inline


USING: bit-arrays kernel sequences ;

M: bit-array like drop dup bit-array? [ >bit-array ] unless
    ; inline


USING: bit-arrays bit-vectors classes kernel sequences ;

M: bit-vector like
    drop dup bit-vector instance? [
        dup bit-array instance?
        [ dup length bit-vector boa ] [ >bit-vector ] if
    ] unless ; inline


USING: alien.data benchmark.nbody-simd classes kernel sequences
specialized-arrays.instances.benchmark.nbody-simd.body ;

M: body-array like
    drop dup body-array instance? [ \ body >c-array ] unless ;
    inline


USING: accessors alien alien.data classes gpu.demos.bunny kernel
sequences
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
specialized-vectors.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-array like
    drop dup bunny-vertex-struct-array instance? [
        dup bunny-vertex-struct-vector instance? [
            [ >c-ptr ] [ length>> ] bi
            <direct-bunny-vertex-struct-array>
        ] [ \ bunny-vertex-struct >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.gpu.demos.bunny.bunny-vertex-struct
specialized-vectors.instances.gpu.demos.bunny.bunny-vertex-struct
;

M: bunny-vertex-struct-vector like
    drop dup bunny-vertex-struct-vector instance? [
        dup bunny-vertex-struct-array instance?
        [ dup length bunny-vertex-struct-vector boa ]
        [ >bunny-vertex-struct-vector ] if
    ] unless ; inline


USING: accessors byte-arrays byte-vectors kernel sequences ;

M: byte-array like
    drop dup byte-array? [
        dup byte-vector? [
            [ length ] [ underlying>> ] bi 2dup length eq?
            [ nip ] [ resize-byte-array ] if
        ] [ >byte-array ] if
    ] unless ; inline


USING: byte-arrays byte-vectors kernel sequences ;

M: byte-vector like
    drop dup byte-vector? [
        dup byte-array?
        [ dup length byte-vector boa ] [ >byte-vector ] if
    ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.c-string ;

M: c-string-array like
    drop dup c-string-array instance?
    [ \ c-string >c-array ] unless ; inline


USING: kernel quotations sequences ;

M: callable like drop dup quotation? [ >quotation ] unless ;


USING: classes kernel math.vectors.simd sequences ;

M: char-16 like
    drop dup \ char-16 instance? [ >char-16 ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: char-32 like
    over \ char-32 instance?
    [ drop ] [ M\ char-32 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.char ;

M: char-array like
    drop dup char-array instance? [ \ char >c-array ] unless ;
    inline


USING: grouping.private kernel sequences ;

M: chunking like drop { } like ; inline


USING: alien.complex alien.data classes kernel sequences
specialized-arrays.instances.alien.complex.complex-double ;

M: complex-double-array like
    drop dup complex-double-array instance?
    [ \ complex-double >c-array ] unless ; inline


USING: alien.complex alien.data classes kernel sequences
specialized-arrays.instances.alien.complex.complex-float ;

M: complex-float-array like
    drop dup complex-float-array instance?
    [ \ complex-float >c-array ] unless ; inline


USING: alien.data chipmunk.ffi classes kernel sequences
specialized-arrays.instances.chipmunk.ffi.cpContact ;

M: cpContact-array like
    drop dup cpContact-array instance?
    [ \ cpContact >c-array ] unless ; inline


USING: alien.data chipmunk.ffi classes kernel sequences
specialized-arrays.instances.chipmunk.ffi.cpPolyShapeAxis ;

M: cpPolyShapeAxis-array like
    drop dup cpPolyShapeAxis-array instance?
    [ \ cpPolyShapeAxis >c-array ] unless ; inline


USING: alien.data chipmunk.ffi classes kernel sequences
specialized-arrays.instances.chipmunk.ffi.cpVect ;

M: cpVect-array like
    drop dup cpVect-array instance? [ \ cpVect >c-array ] unless
    ; inline


USING: classes kernel math.vectors.simd sequences ;

M: double-2 like
    drop dup \ double-2 instance? [ >double-2 ] unless ; inline


USING: alien.data classes kernel math.vectors.simd.cords
sequences
specialized-arrays.instances.math.vectors.simd.cords.double-4 ;

M: double-4-array like
    drop dup double-4-array instance?
    [ \ double-4 >c-array ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: double-4 like
    over \ double-4 instance?
    [ drop ] [ M\ double-4 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.double ;

M: double-array like
    drop dup double-array instance? [ \ double >c-array ] unless
    ; inline


USING: kernel sequences ;

M: f like drop [ f ] when-empty ; inline


USING: alien.data classes kernel macho sequences
specialized-arrays.instances.macho.fat_arch ;

M: fat_arch-array like
    drop dup fat_arch-array instance?
    [ \ fat_arch >c-array ] unless ; inline


USING: alien.data classes fftw.ffi kernel sequences
specialized-arrays.instances.fftw.ffi.fftw_complex ;

M: fftw_complex-array like
    drop dup fftw_complex-array instance?
    [ \ fftw_complex >c-array ] unless ; inline


USING: accessors alien alien.data classes kernel
math.vectors.simd sequences
specialized-arrays.instances.math.vectors.simd.float-4
specialized-vectors.instances.math.vectors.simd.float-4 ;

M: float-4-array like
    drop dup float-4-array instance? [
        dup float-4-vector instance?
        [ [ >c-ptr ] [ length>> ] bi <direct-float-4-array> ]
        [ \ float-4 >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.math.vectors.simd.float-4
specialized-vectors.instances.math.vectors.simd.float-4 ;

M: float-4-vector like
    drop dup float-4-vector instance? [
        dup float-4-array instance?
        [ dup length float-4-vector boa ] [ >float-4-vector ] if
    ] unless ; inline


USING: classes kernel math.vectors.simd sequences ;

M: float-4 like
    drop dup \ float-4 instance? [ >float-4 ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: float-8 like
    over \ float-8 instance?
    [ drop ] [ M\ float-8 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.float ;

M: float-array like
    drop dup float-array instance? [ \ float >c-array ] unless ;
    inline


USING: accessors alien alien.data classes game.loop.benchmark
kernel sequences
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
specialized-vectors.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-array like
    drop dup game-loop-benchmark-array instance? [
        dup game-loop-benchmark-vector instance? [
            [ >c-ptr ] [ length>> ] bi
            <direct-game-loop-benchmark-array>
        ] [ \ game-loop-benchmark >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.game.loop.benchmark.game-loop-benchmark
specialized-vectors.instances.game.loop.benchmark.game-loop-benchmark
;

M: game-loop-benchmark-vector like
    drop dup game-loop-benchmark-vector instance? [
        dup game-loop-benchmark-array instance?
        [ dup length game-loop-benchmark-vector boa ]
        [ >game-loop-benchmark-vector ] if
    ] unless ; inline


USING: gap-buffer kernel sequences ;

M: gb like drop <gb> ;


USING: alien.data classes kernel math.floats.half sequences
specialized-arrays.instances.math.floats.half.half ;

M: half-array like
    drop dup half-array instance? [ \ half >c-array ] unless ;
    inline


USING: accessors kernel sequences sequences.inserters ;

M: inserter like nip underlying>> ; inline


USING: classes kernel math.vectors.simd sequences ;

M: int-4 like drop dup \ int-4 instance? [ >int-4 ] unless ;
    inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: int-8 like
    over \ int-8 instance?
    [ drop ] [ M\ int-8 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.int ;

M: int-array like
    drop dup int-array instance? [ \ int >c-array ] unless ;
    inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.int32_t ;

M: int32_t-array like
    drop dup int32_t-array instance?
    [ \ int32_t >c-array ] unless ; inline


USING: accessors sequences sequences.interleaved ;

M: interleaved like seq>> like ;


USING: alien.data classes io.files.acls.macos.ffi kernel
sequences
specialized-arrays.instances.io.files.acls.macos.ffi.kauth_ace ;

M: kauth_ace-array like
    drop dup kauth_ace-array instance?
    [ \ kauth_ace >c-array ] unless ; inline


USING: alien.data classes kernel sequences
specialized-arrays.instances.unix.kqueue.kevent unix.kqueue ;

M: kevent-array like
    drop dup kevent-array instance? [ \ kevent >c-array ] unless
    ; inline


USING: alien.data classes kernel libusb sequences
specialized-arrays.instances.libusb.libusb_iso_packet_descriptor
;

M: libusb_iso_packet_descriptor-array like
    drop dup libusb_iso_packet_descriptor-array instance?
    [ \ libusb_iso_packet_descriptor >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.long ;

M: long-array like
    drop dup long-array instance? [ \ long >c-array ] unless ;
    inline


USING: classes kernel math.vectors.simd sequences ;

M: longlong-2 like
    drop dup \ longlong-2 instance? [ >longlong-2 ] unless ;
    inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: longlong-4 like
    over \ longlong-4 instance?
    [ drop ] [ M\ longlong-4 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.longlong ;

M: longlong-array like
    drop dup longlong-array instance?
    [ \ longlong >c-array ] unless ; inline


USING: classes classes.tuple named-tuples sequences ;

M: named-tuple like class-of slots>tuple ;


USING: kernel nibble-arrays sequences ;

M: nibble-array like
    drop dup nibble-array? [ >nibble-array ] unless ;


USING: alien.data classes kernel macho sequences
specialized-arrays.instances.macho.nlist ;

M: nlist-array like
    drop dup nlist-array instance? [ \ nlist >c-array ] unless ;
    inline


USING: alien.data classes kernel macho sequences
specialized-arrays.instances.macho.nlist_64 ;

M: nlist_64-array like
    drop dup nlist_64-array instance?
    [ \ nlist_64 >c-array ] unless ; inline


USING: accessors sequences sequences.padded ;

M: padded-head like underlying>> like ;


USING: accessors sequences sequences.padded ;

M: padded-tail like underlying>> like ;


USING: alien.data classes kernel papier.map sequences
specialized-arrays.instances.papier.map.papier-vertex-struct ;

M: papier-vertex-struct-array like
    drop dup papier-vertex-struct-array instance?
    [ \ papier-vertex-struct >c-array ] unless ; inline


USING: alien.data classes fluids kernel sequences
specialized-arrays.instances.fluids.particle_t ;

M: particle_t-array like
    drop dup particle_t-array instance?
    [ \ particle_t >c-array ] unless ; inline


USING: kernel persistent.sequences persistent.vectors sequences
;

M: persistent-vector like drop PV{ } [ swap ppush ] reduce ;


USING: benchmark.tuple-arrays kernel sequences ;

M: point-array like
    drop dup point-array? [ >point-array ] unless ; inline


USING: alien.data benchmark.struct-arrays classes kernel
sequences
specialized-arrays.instances.benchmark.struct-arrays.point ;

M: point-array like
    drop dup point-array instance? [ \ point >c-array ] unless ;
    inline


USING: gml.types kernel sequences ;

M: proc like drop dup proc? [ { } like { } <proc> ] unless ;


USING: alien.data classes kernel rlgl sequences
specialized-arrays.instances.rlgl.rlDrawCall ;

M: rlDrawCall-array like
    drop dup rlDrawCall-array instance?
    [ \ rlDrawCall >c-array ] unless ; inline


USING: alien.data classes kernel rlgl sequences
specialized-arrays.instances.rlgl.rlVertexBuffer ;

M: rlVertexBuffer-array like
    drop dup rlVertexBuffer-array instance?
    [ \ rlVertexBuffer >c-array ] unless ; inline


USING: kernel sbufs sequences strings ;

M: sbuf like
    drop dup sbuf?
    [ dup string? [ dup length sbuf boa ] [ >sbuf ] if ] unless
    ; inline


USING: alien.data classes kernel macho sequences
specialized-arrays.instances.macho.section ;

M: section-array like
    drop dup section-array instance?
    [ \ section >c-array ] unless ; inline


USING: alien.data classes kernel macho sequences
specialized-arrays.instances.macho.section_64 ;

M: section_64-array like
    drop dup section_64-array instance?
    [ \ section_64 >c-array ] unless ; inline


USING: kernel sequences ;

M: sequence like drop ; inline


USING: accessors arrays.shaped sequences ;

M: shaped-array like shape>> <shaped-array> ;


USING: accessors sequences sequences.shifted ;

M: shifted like underlying>> like ;


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: short-16 like
    over \ short-16 instance?
    [ drop ] [ M\ short-16 like (call-next-method) ] if ;


USING: classes kernel math.vectors.simd sequences ;

M: short-8 like
    drop dup \ short-8 instance? [ >short-8 ] unless ; inline


USING: accessors alien alien.c-types alien.data classes kernel
sequences specialized-arrays.instances.alien.c-types.short
specialized-vectors.instances.alien.c-types.short ;

M: short-array like
    drop dup short-array instance? [
        dup short-vector instance?
        [ [ >c-ptr ] [ length>> ] bi <direct-short-array> ]
        [ \ short >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.alien.c-types.short
specialized-vectors.instances.alien.c-types.short ;

M: short-vector like
    drop dup short-vector instance? [
        dup short-array instance?
        [ dup length short-vector boa ] [ >short-vector ] if
    ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.size_t ;

M: size_t-array like
    drop dup size_t-array instance? [ \ size_t >c-array ] unless
    ; inline


USING: alien.data classes kernel sequences
specialized-arrays.instances.unix.statfs.macos.statfs64
unix.statfs.macos ;

M: statfs64-array like
    drop dup statfs64-array instance?
    [ \ statfs64 >c-array ] unless ; inline


USING: accessors kernel sbufs sequences strings strings.private
;

M: string like
    drop dup string? [
        dup sbuf? [
            [ length ] [ underlying>> ] bi 2dup length eq?
            [ nip dup reset-string-hashcode ] [ resize-string ]
            if
        ] [ >string ] if
    ] unless ; inline


USING: accessors kernel sequences xml.data ;

M: tag like
    over tag?
    [ drop ]
    [ [ name>> ] keep attrs>> rot dup [ V{ } like ] when <tag> ]
    if ;


USING: accessors arrays kernel sequences
specialized-arrays.instances.alien.c-types.float tensors
tensors.private ;

M: tensor like
    over tensor?
    [ drop ] [
        over float-array?
        [ [ dup [ length 1array ] dip <tensor> ] dip ]
        [ [ >tensor ] dip ] if 2dup 2length =
        [ shape>> reshape ] [ drop ] if
    ] if ;


USING: alien.data classes kernel ogg.theora sequences
specialized-arrays.instances.ogg.theora.th-quant-ranges ;

M: th-quant-ranges-array like
    drop dup th-quant-ranges-array instance?
    [ \ th-quant-ranges >c-array ] unless ; inline


USING: alien.data classes kernel sequences
specialized-arrays.instances.unix.time.timeval unix.time ;

M: timeval-array like
    drop dup timeval-array instance?
    [ \ timeval >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.u16 ;

M: u16-array like
    drop dup u16-array instance? [ \ u16 >c-array ] unless ;
    inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.u32 ;

M: u32-array like
    drop dup u32-array instance? [ \ u32 >c-array ] unless ;
    inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.u64 ;

M: u64-array like
    drop dup u64-array instance? [ \ u64 >c-array ] unless ;
    inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.u8 ;

M: u8-array like
    drop dup u8-array instance? [ \ u8 >c-array ] unless ;
    inline


USING: alien.data classes kernel math.vectors.simd sequences
specialized-arrays.instances.math.vectors.simd.uchar-16 ;

M: uchar-16-array like
    drop dup uchar-16-array instance?
    [ \ uchar-16 >c-array ] unless ; inline


USING: classes kernel math.vectors.simd sequences ;

M: uchar-16 like
    drop dup \ uchar-16 instance? [ >uchar-16 ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: uchar-32 like
    over \ uchar-32 instance?
    [ drop ] [ M\ uchar-32 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uchar ;

M: uchar-array like
    drop dup uchar-array instance? [ \ uchar >c-array ] unless ;
    inline


USING: alien.data classes kernel math.vectors.simd sequences
specialized-arrays.instances.math.vectors.simd.uint-4 ;

M: uint-4-array like
    drop dup uint-4-array instance? [ \ uint-4 >c-array ] unless
    ; inline


USING: classes kernel math.vectors.simd sequences ;

M: uint-4 like
    drop dup \ uint-4 instance? [ >uint-4 ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: uint-8 like
    over \ uint-8 instance?
    [ drop ] [ M\ uint-8 like (call-next-method) ] if ;


USING: accessors alien alien.c-types alien.data classes kernel
sequences specialized-arrays.instances.alien.c-types.uint
specialized-vectors.instances.alien.c-types.uint ;

M: uint-array like
    drop dup uint-array instance? [
        dup uint-vector instance?
        [ [ >c-ptr ] [ length>> ] bi <direct-uint-array> ]
        [ \ uint >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.alien.c-types.uint
specialized-vectors.instances.alien.c-types.uint ;

M: uint-vector like
    drop dup uint-vector instance? [
        dup uint-array instance?
        [ dup length uint-vector boa ] [ >uint-vector ] if
    ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uint16_t ;

M: uint16_t-array like
    drop dup uint16_t-array instance?
    [ \ uint16_t >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uint32_t ;

M: uint32_t-array like
    drop dup uint32_t-array instance?
    [ \ uint32_t >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uint64_t ;

M: uint64_t-array like
    drop dup uint64_t-array instance?
    [ \ uint64_t >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uint8_t ;

M: uint8_t-array like
    drop dup uint8_t-array instance?
    [ \ uint8_t >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.uintptr_t ;

M: uintptr_t-array like
    drop dup uintptr_t-array instance?
    [ \ uintptr_t >c-array ] unless ; inline


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.ulong ;

M: ulong-array like
    drop dup ulong-array instance? [ \ ulong >c-array ] unless ;
    inline


USING: classes kernel math.vectors.simd sequences ;

M: ulonglong-2 like
    drop dup \ ulonglong-2 instance? [ >ulonglong-2 ] unless ;
    inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: ulonglong-4 like
    over \ ulonglong-4 instance?
    [ drop ] [ M\ ulonglong-4 like (call-next-method) ] if ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.ulonglong ;

M: ulonglong-array like
    drop dup ulonglong-array instance?
    [ \ ulonglong >c-array ] unless ; inline


USING: classes generic kernel math.vectors.simd.cords sequences
;

M: ushort-16 like
    over \ ushort-16 instance?
    [ drop ] [ M\ ushort-16 like (call-next-method) ] if ;


USING: classes kernel math.vectors.simd sequences ;

M: ushort-8 like
    drop dup \ ushort-8 instance? [ >ushort-8 ] unless ; inline


USING: accessors alien alien.c-types alien.data classes kernel
sequences specialized-arrays.instances.alien.c-types.ushort
specialized-vectors.instances.alien.c-types.ushort ;

M: ushort-array like
    drop dup ushort-array instance? [
        dup ushort-vector instance?
        [ [ >c-ptr ] [ length>> ] bi <direct-ushort-array> ]
        [ \ ushort >c-array ] if
    ] unless ; inline


USING: classes kernel sequences
specialized-arrays.instances.alien.c-types.ushort
specialized-vectors.instances.alien.c-types.ushort ;

M: ushort-vector like
    drop dup ushort-vector instance? [
        dup ushort-array instance?
        [ dup length ushort-vector boa ] [ >ushort-vector ] if
    ] unless ; inline


USING: arrays kernel sequences vectors ;

M: vector like
    drop dup vector?
    [ dup array? [ dup length vector boa ] [ >vector ] if ]
    unless ; inline


USING: sequences ;

M: virtual-sequence like virtual-exemplar like ; inline


USING: kernel sequences vlists ;

M: vlist like drop dup vlist? [ >vlist ] unless ;


USING: alien.c-types alien.data classes kernel sequences
specialized-arrays.instances.alien.c-types.void* ;

M: void*-array like
    drop dup void*-array instance? [ \ void* >c-array ] unless ;
    inline


USING: accessors kernel sequences xml.data ;

M: xml-chunk like [ seq>> ] call \ like execute ;


USING: kernel sequences xml.data xml.data.private ;

M: xml like
    swap dup xml?
    [ nip ] [ dup tag? [ tag>xml ] [ sequence>xml ] if ] if ;