     float = [ remove-integer-words ] [ remove-float-words ] if
     remove-boolean-words ;
 
-: check-vector-ops ( class elt-class compare-quot -- )
+: check-vector-ops ( class elt-class compare-quot -- failures )
     [
         [ nip ops-to-check ] 2keep
         '[ first2 vector-word-inputs _ _ check-vector-op ]

: boa-ctors ( -- seq )
    simd-classes [ [ name>> "-boa" append ] [ vocabulary>> ] bi lookup-word ] map ;

: check-optimizer ( seq test-quot eq-quot -- failures )
    #! Use test-quot to generate a bunch of test cases from the
    #! given inputs. Run each test case optimized and
    #! unoptimized. Compare results with eq-quot.
    #!
    #! seq: sequence of inputs
    #! test-quot: ( input -- input-quot: ( -- values ) code-quot: ( values -- result ) )
    #! eq-quot: ( result1 result2 -- ? )
    dup '[
        @
        [ dup [ class-of ] { } map-as ] dip '[ _ declare @ ]
        {
            [ "print-mr" get [ nip regs. ] [ 2drop ] if ]
            [ "print-checks" get [ [ . ] bi@ ] [ 2drop ] if ]
            [ [ [ call ] dip call ] call( quot quot -- result ) ]
            [ [ [ call ] dip compile-call ] call( quot quot -- result ) ]
            [ [ t "always-inline-simd-intrinsics" [ [ call ] dip compile-call ] with-variable ] call( quot quot -- result ) ]
        } 2cleave
        [ drop @ ] [ nip @ ] 3bi and not
    ] filter ; inline

"== Checking -new constructors" print


    {
        { [ 2dup [ float? ] both? ] [ fp-bitwise= ] }
        { [ 2dup [ sequence? ] both? ] [ [ fp-bitwise= ] 2all? ] }
        [ = ]
    } cond ;

: simd-classes&reps ( -- alist )
