equal? ( obj1 obj2 -- ? )
Factor handbook » The language » Objects » Equality

Prev:	= ( obj1 obj2 -- ? )
Next:	identity-tuple

Vocabulary
kernel

Inputs

obj1	an object
obj2	an object

Outputs

?

a boolean

Generic word contract
Tests if two objects are equal.

User code should call = instead; that word first tests the case where the objects are eq?, and so by extension, methods defined on equal? assume they are never called on eq? objects.

Method definitions should ensure that this is an equality relation, modulo the assumption that the two objects are not eq?. That is, for any three non-eq? objects a, b and c, we must have:

•	a = b implies b = a
•	a = b and b = c implies a = c

If a class defines a custom equality comparison test, it should also define a compatible method for the hashcode* generic word.

Examples
An example demonstrating why this word should only be used to define methods on, and never called directly:

USING: kernel prettyprint ; 5 5 equal? .
f

Using = gives the expected behavior:

USING: kernel prettyprint ; 5 5 = .
t

Definition

IN: kernel

GENERIC: equal? ( obj1 obj2 -- ? )

Methods

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

M: BoneInfo-array equal?
    over BoneInfo-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: Elf32_Phdr-array equal?
    over Elf32_Phdr-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Elf32_Shdr-array equal?
    over Elf32_Shdr-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Elf32_Sym-array equal?
    over Elf32_Sym-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Elf64_Phdr-array equal?
    over Elf64_Phdr-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Elf64_Shdr-array equal?
    over Elf64_Shdr-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Elf64_Sym-array equal?
    over Elf64_Sym-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: Material-array equal?
    over Material-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: MaterialMap-array equal?
    over MaterialMap-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: Matrix-array equal?
    over Matrix-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: Mesh-array equal?
    over Mesh-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: Vector2-array equal?
    over Vector2-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: Vector3-array equal?
    over Vector3-array instance? [ sequence= ] [ 2drop f ] if ;


USING: alien kernel ;

M: alien equal?
    over alien? [
        2dup [ expired? ] either?
        [ [ expired? ] both? ] [ [ alien-address ] same? ] if
    ] [ 2drop f ] if ;


USING: arrays kernel sequences ;

M: array equal? over array? [ sequence= ] [ 2drop f ] if ;


USING: kernel math math.private ;

M: bignum equal?
    over bignum?
    [ bignum= ]
    [ swap dup fixnum? [ >bignum bignum= ] [ 2drop f ] if ] if ;
    inline


USING: accessors bit-arrays kernel math math.bitwise sequences ;

M: bit-array equal?
    over bit-array? [
        2dup 2length dupd = [
            [ [ underlying>> ] bi@ ] dip 8 mod
            [ sequence= ] [
                [ [ unclip-slice ] bi@ swapd ] dip
                [ bits ] curry bi@ =
                [ sequence= ] [ 2drop f ] if
            ] if-zero
        ] [ 3drop f ] if
    ] [ 2drop f ] if ;


USING: bit-vectors classes kernel sequences ;

M: bit-vector equal?
    over bit-vector instance? [ sequence= ] [ 2drop f ] if ;


USING: combinators.short-circuit kernel math.blas.matrices
sequences ;

M: blas-matrix-base equal?
    {
        [ and ]
        [ [ Mwidth ] bi@ = ]
        [ [ Mcols ] bi@ [ = ] 2all? ]
    } 2&& ;


USING: combinators.short-circuit kernel math.blas.vectors
sequences ;

M: blas-vector-base equal?
    { [ [ length ] same? ] [ [ = ] 2all? ] } 2&& ;


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

M: body-array equal?
    over body-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: bunny-vertex-struct-array equal?
    over bunny-vertex-struct-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: bunny-vertex-struct-vector equal?
    over bunny-vertex-struct-vector instance?
    [ sequence= ] [ 2drop f ] if ;


USING: byte-arrays kernel sequences ;

M: byte-array equal?
    over byte-array? [ sequence= ] [ 2drop f ] if ;


USING: byte-vectors kernel sequences ;

M: byte-vector equal?
    over byte-vector? [ sequence= ] [ 2drop f ] if ;


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

M: c-string-array equal?
    over c-string-array instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel quotations sequences ;

M: callable equal? over callable? [ sequence= ] [ 2drop f ] if ;


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

M: char-array equal?
    over char-array instance? [ sequence= ] [ 2drop f ] if ;


USING: grouping kernel sequences ;

M: circular-slice equal?
    over circular-slice? [ sequence= ] [ 2drop f ] if ;


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

M: complex-double-array equal?
    over complex-double-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: complex-float-array equal?
    over complex-float-array instance?
    [ sequence= ] [ 2drop f ] if ;


USING: kernel math math.complex.private ;

M: complex equal?
    over complex? [ [ = ] complex= ] [ 2drop f ] if ; inline


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

M: cpContact-array equal?
    over cpContact-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: cpPolyShapeAxis-array equal?
    over cpPolyShapeAxis-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: cpVect-array equal?
    over cpVect-array instance? [ sequence= ] [ 2drop f ] if ;


USING: accessors combinators.short-circuit decimals kernel ;

M: decimal equal?
    {
        [ [ decimal? ] both? ]
        [
            scale-decimals {
                [ [ mantissa>> ] same? ]
                [ [ exponent>> ] same? ]
            } 2&&
        ]
    } 2&& ;


USING: accessors combinators.short-circuit dlists kernel ;

M: dlist equal?
    over dlist? [
        [ front>> ] bi@
        [ 2dup { [ and ] [ [ obj>> ] same? ] } 2&& ]
        [ [ next>> ] bi@ ] while or not
    ] [ 2drop f ] if ;


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

M: double-4-array equal?
    over double-4-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: double-array equal?
    over double-array instance? [ sequence= ] [ 2drop f ] if ;


USING: accessors bootstrap.image.private kernel ;

M: eq-wrapper equal?
    over eq-wrapper? [ [ obj>> ] bi@ eq? ] [ 2drop f ] if ;


USING: accessors bootstrap.image.private kernel ;

M: eql-wrapper equal?
    over eql-wrapper? [ [ obj>> ] bi@ eql? ] [ 2drop f ] if ;


USING: accessors kernel vocabs.parser ;

M: extra-words equal?
    over extra-words? [ [ words>> ] bi@ eq? ] [ 2drop f ] if ;


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

M: fat_arch-array equal?
    over fat_arch-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: fftw_complex-array equal?
    over fftw_complex-array instance?
    [ sequence= ] [ 2drop f ] if ;


USING: kernel math math.private ;

M: fixnum equal?
    over bignum? [ >bignum bignum= ] [ 2drop f ] if ; inline


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

M: float-4-array equal?
    over float-4-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: float-4-vector equal?
    over float-4-vector instance? [ sequence= ] [ 2drop f ] if ;


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

M: float-array equal?
    over float-array instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel math math.private ;

M: float equal? over float? [ float= ] [ 2drop f ] if ; inline


USING: kernel ui.gadgets ;

M: gadget equal? 2drop f ;


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

M: game-loop-benchmark-array equal?
    over game-loop-benchmark-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: game-loop-benchmark-vector equal?
    over game-loop-benchmark-vector instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: half-array equal?
    over half-array instance? [ sequence= ] [ 2drop f ] if ;


USING: hash-sets kernel sets ;

M: hash-set equal? over hash-set? [ set= ] [ 2drop f ] if ;


USING: assocs hashtables kernel ;

M: hashtable equal? over hashtable? [ assoc= ] [ 2drop f ] if ;


USING: kernel ;

M: identity-tuple equal? 2drop f ; inline


USING: accessors hash-sets.identity.private kernel ;

M: identity-wrapper equal?
    over identity-wrapper?
    [ [ underlying>> ] bi@ eq? ] [ 2drop f ] if ; inline


USING: accessors hashtables.identity.private kernel ;

M: identity-wrapper equal?
    over identity-wrapper?
    [ [ underlying>> ] bi@ eq? ] [ 2drop f ] if ; inline


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

M: int-array equal?
    over int-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: int32_t-array equal?
    over int32_t-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: kauth_ace-array equal?
    over kauth_ace-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: kevent-array equal?
    over kevent-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: libusb_iso_packet_descriptor-array equal?
    over libusb_iso_packet_descriptor-array instance?
    [ sequence= ] [ 2drop f ] if ;


USING: accessors kernel linked-assocs ;

M: linked-assoc equal?
    over linked-assoc? [ [ dlist>> ] bi@ = ] [ 2drop f ] if ;


USING: accessors kernel linked-sets ;

M: linked-set equal?
    over linked-set? [ [ dlist>> ] bi@ = ] [ 2drop f ] if ;


USING: accessors combinators.short-circuit
compiler.cfg.linear-scan.resolve kernel ;

M: location equal?
    over location?
    [ { [ [ reg>> ] same? ] [ [ reg-class>> ] same? ] } 2&& ]
    [ 2drop f ] if ;


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

M: long-array equal?
    over long-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: longlong-array equal?
    over longlong-array instance? [ sequence= ] [ 2drop f ] if ;


USING: accessors kernel libc.private ;

M: malloc-ptr equal?
    over malloc-ptr? [ [ value>> ] same? ] [ 2drop f ] if ;


USING: kernel nibble-arrays sequences ;

M: nibble-array equal?
    over nibble-array? [ sequence= ] [ 2drop f ] if ;


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

M: nlist-array equal?
    over nlist-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: nlist_64-array equal?
    over nlist_64-array instance? [ sequence= ] [ 2drop f ] if ;


USING: accessors hash-sets.numbers.private kernel math ;

M: number-wrapper equal?
    over number-wrapper?
    [ [ underlying>> ] bi@ number= ] [ 2drop f ] if ; inline


USING: accessors hashtables.numbers.private kernel math ;

M: number-wrapper equal?
    over number-wrapper?
    [ [ underlying>> ] bi@ number= ] [ 2drop f ] if ; inline


USING: kernel ;

M: object equal? 2drop f ; inline


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

M: papier-vertex-struct-array equal?
    over papier-vertex-struct-array instance?
    [ sequence= ] [ 2drop f ] if ;


USING: accessors classes combinators.short-circuit kernel peg ;

M: parser equal?
    { [ [ class-of ] same? ] [ [ id>> ] same? ] } 2&& ;


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

M: particle_t-array equal?
    over particle_t-array instance? [ sequence= ] [ 2drop f ] if
    ;


USING: assocs kernel persistent.hashtables ;

M: persistent-hash equal?
    over persistent-hash? [ assoc= ] [ 2drop f ] if ;


USING: kernel persistent.vectors sequences ;

M: persistent-vector equal?
    over persistent-vector? [ sequence= ] [ 2drop f ] if ;


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

M: point-array equal?
    over point-array instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel quadtrees quadtrees.private ;

M: quadtree equal? over quadtree? [ tree= ] [ 2drop f ] if ;


USING: kernel math math.ratios ;

M: ratio equal?
    over ratio?
    [ 2>fraction = [ = ] [ 2drop f ] if ] [ 2drop f ] if ;


USING: assocs kernel redis ;

M: redis equal? assoc= ;


USING: accessors compiler.cfg.value-numbering.expressions kernel
math ;

M: reference-expr equal?
    over reference-expr? [
        [ value>> ] bi@ 2dup [ float? ] both?
        [ fp-bitwise= ] [ eq? ] if
    ] [ 2drop f ] if ;


USING: accessors compiler.cfg.gvn.expressions kernel math ;

M: reference-expr equal?
    over reference-expr? [
        [ value>> ] bi@ 2dup [ float? ] both?
        [ fp-bitwise= ] [ eq? ] if
    ] [ 2drop f ] if ;


USING: kernel sequences ;

M: reversed equal? over reversed? [ sequence= ] [ 2drop f ] if ;


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

M: rlDrawCall-array equal?
    over rlDrawCall-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: rlVertexBuffer-array equal?
    over rlVertexBuffer-array instance?
    [ sequence= ] [ 2drop f ] if ;


USING: kernel sbufs sequences ;

M: sbuf equal? over sbuf? [ sequence= ] [ 2drop f ] if ;


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

M: section-array equal?
    over section-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: section_64-array equal?
    over section_64-array instance? [ sequence= ] [ 2drop f ] if
    ;


USING: accessors hashtables.sequences.private kernel sequences ;

M: sequence-wrapper equal?
    over sequence-wrapper?
    [ [ underlying>> ] bi@ sequence= ] [ 2drop f ] if ; inline


USING: accessors hash-sets.sequences.private kernel sequences ;

M: sequence-wrapper equal?
    over sequence-wrapper?
    [ [ underlying>> ] bi@ sequence= ] [ 2drop f ] if ; inline


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

M: short-array equal?
    over short-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: short-vector equal?
    over short-vector instance? [ sequence= ] [ 2drop f ] if ;


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

M: simd-128 equal?
    dup simd-rep
    [ drop v= vall? ] [ 3drop f ] if-both-vectors-match ; inline


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

M: size_t-array equal?
    over size_t-array instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel sequences ;

M: slice equal? over slice? [ sequence= ] [ 2drop f ] if ;


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

M: statfs64-array equal?
    over statfs64-array instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel sequences strings ;

M: string equal?
    over string? [
        over hashcode over hashcode eq?
        [ sequence= ] [ 2drop f ] if
    ] [ 2drop f ] if ;


USING: classes classes.struct kernel ;

M: struct equal?
    [ [ class-of ] same? ] 2check
    [ [ struct-slot-values ] same? ] [ 2drop f ] if ; inline


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

M: th-quant-ranges-array equal?
    over th-quant-ranges-array instance?
    [ sequence= ] [ 2drop f ] if ;


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

M: timeval-array equal?
    over timeval-array instance? [ sequence= ] [ 2drop f ] if ;


USING: assocs kernel tokyo.abstractdb ;

M: tokyo-abstractdb equal? assoc= ;


USING: assocs kernel tokyo.remotedb ;

M: tokyo-remotedb equal? assoc= ;


USING: classes.tuple kernel ;

M: tuple equal? over tuple? [ tuple= ] [ 2drop f ] if ;


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

M: u16-array equal?
    over u16-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: u32-array equal?
    over u32-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: u64-array equal?
    over u64-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: u8-array equal?
    over u8-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uchar-16-array equal?
    over uchar-16-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uchar-array equal?
    over uchar-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint-4-array equal?
    over uint-4-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint-array equal?
    over uint-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint-vector equal?
    over uint-vector instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint16_t-array equal?
    over uint16_t-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint32_t-array equal?
    over uint32_t-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint64_t-array equal?
    over uint64_t-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uint8_t-array equal?
    over uint8_t-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: uintptr_t-array equal?
    over uintptr_t-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: ulong-array equal?
    over ulong-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: ulonglong-array equal?
    over ulonglong-array instance? [ sequence= ] [ 2drop f ] if
    ;


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

M: ushort-array equal?
    over ushort-array instance? [ sequence= ] [ 2drop f ] if ;


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

M: ushort-vector equal?
    over ushort-vector instance? [ sequence= ] [ 2drop f ] if ;


USING: kernel sequences vectors ;

M: vector equal? over vector? [ sequence= ] [ 2drop f ] if ;


USING: kernel sequences vlists ;

M: vlist equal? over vlist? [ sequence= ] [ 2drop f ] if ;


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

M: void*-array equal?
    over void*-array instance? [ sequence= ] [ 2drop f ] if ;


USING: accessors hash-sets.wrapped kernel ;

M: wrapped-hash-set equal?
    over wrapped-hash-set?
    [ [ underlying>> ] same? ] [ 2drop f ] if ;


USING: accessors hashtables.wrapped kernel ;

M: wrapped-hashtable equal?
    over wrapped-hashtable?
    [ [ underlying>> ] same? ] [ 2drop f ] if ;


USING: accessors kernel ;

M: wrapper equal?
    over wrapper? [ [ wrapped>> ] same? ] [ 2drop f ] if ;