: c-type-interval ( c-type -- from to )
{
- { [ dup { float double } memq? ] [ drop -1/0. 1/0. ] }
- { [ dup { char short int long longlong } memq? ] [ signed-interval ] }
- { [ dup { uchar ushort uint ulong ulonglong } memq? ] [ unsigned-interval ] }
+ { [ dup { float double } member-eq? ] [ drop -1/0. 1/0. ] }
+ { [ dup { char short int long longlong } member-eq? ] [ signed-interval ] }
+ { [ dup { uchar ushort uint ulong ulonglong } member-eq? ] [ unsigned-interval ] }
} cond ; foldable
: c-type-clamp ( value c-type -- value' ) c-type-interval clamp ; inline
{ member? sorted-member? } related-words
-HELP: sorted-memq?
+HELP: sorted-member-eq?
{ $values { "obj" object } { "seq" "a sorted sequence" } { "?" "a boolean" } }
{ $description "Tests if the sorted sequence contains " { $snippet "elt" } ". Equality is tested with " { $link eq? } "." } ;
-{ memq? sorted-memq? } related-words
+{ member-eq? sorted-member-eq? } related-words
ARTICLE: "binary-search" "Binary search"
"The " { $emphasis "binary search" } " algorithm allows elements to be located in sorted sequence in " { $snippet "O(log n)" } " time."
{ $subsections
sorted-index
sorted-member?
- sorted-memq?
+ sorted-member-eq?
}
{ $see-also "order-specifiers" "sequences-sorting" } ;
: sorted-member? ( obj seq -- ? )
dupd natural-search nip = ;
-: sorted-memq? ( obj seq -- ? )
+: sorted-member-eq? ( obj seq -- ? )
dupd natural-search nip eq? ;
"." write flush
{
- memq? split harvest sift cut cut-slice start index clone
+ member-eq? split harvest sift cut cut-slice start index clone
set-at reverse push-all class number>string string>number
like clone-like
} compile-unoptimized
" done" print flush
-] unless
\ No newline at end of file
+] unless
ERROR: bad-successors ;
: check-successors ( bb -- )
- dup successors>> [ predecessors>> memq? ] with all?
+ dup successors>> [ predecessors>> member-eq? ] with all?
[ bad-successors ] unless ;
: check-basic-block ( bb -- )
{ cc/> { +lt+ +eq+ +unordered+ } }
{ cc/<> { +eq+ +unordered+ } }
{ cc/<>= { +unordered+ } }
- } at memq? ;
+ } at member-eq? ;
: hat-effect ( insn -- effect )
"insn-slots" word-prop
- [ type>> { def temp } memq? not ] filter [ name>> ] map
+ [ type>> { def temp } member-eq? not ] filter [ name>> ] map
{ "vreg" } <effect> ;
: define-hat ( insn -- )
[
vreg-insn
insn-classes get [
- "insn-slots" word-prop [ type>> { def use temp } memq? ] any?
+ "insn-slots" word-prop [ type>> { def use temp } member-eq? ] any?
] filter
define-union-class
] with-compilation-unit
: update-phi ( bb ##phi -- )
[
swap predecessors>>
- '[ drop _ memq? ] assoc-filter
+ '[ drop _ member-eq? ] assoc-filter
] change-inputs drop ;
: update-phis ( bb -- )
: needs-predecessors ( cfg -- cfg' )
dup predecessors-valid?>>
- [ compute-predecessors t >>predecessors-valid? ] unless ;
\ No newline at end of file
+ [ compute-predecessors t >>predecessors-valid? ] unless ;
bi define ;
: reps-getter-quot ( reps -- quot )
- dup [ rep>> { f scalar-rep } memq? not ] all? [
+ dup [ rep>> { f scalar-rep } member-eq? not ] all? [
[ rep>> ] map [ drop ] swap suffix
] [
[ rep>> rep-getter-quot ] map dup length {
##compare-imm-branch
##compare-float-ordered-branch
##compare-float-unordered-branch
- } memq?
+ } member-eq?
]
[ successors>> first2 [ skip-empty-blocks ] bi@ eq? ]
} 1&& ;
:: insert-basic-block ( froms to bb -- )
bb froms V{ } like >>predecessors drop
bb to 1vector >>successors drop
- to predecessors>> [ dup froms memq? [ drop bb ] when ] map! drop
+ to predecessors>> [ dup froms member-eq? [ drop bb ] when ] map! drop
froms [ successors>> [ dup to eq? [ drop bb ] when ] map! drop ] each ;
: add-instructions ( bb quot -- )
<<
: input-values ( slot-specs -- slot-specs' )
- [ type>> { use literal constant } memq? ] filter ;
+ [ type>> { use literal constant } member-eq? ] filter ;
: expr-class ( insn -- expr )
name>> "##" ?head drop "-expr" append create-class-in ;
{
[ src1>> vreg>expr general-compare-expr? ]
[ src2>> \ f tag-number = ]
- [ cc>> { cc= cc/= } memq? ]
+ [ cc>> { cc= cc/= } member-eq? ]
} 1&& ; inline
: rewrite-redundant-comparison ( insn -- insn' )
[ src1>> ] [ src2>> ] bi [ vreg>vn ] bi@ = ; inline
: (rewrite-self-compare) ( insn -- ? )
- cc>> { cc= cc<= cc>= } memq? ;
+ cc>> { cc= cc<= cc>= } member-eq? ;
: rewrite-self-compare-branch ( insn -- insn' )
(rewrite-self-compare) fold-branch ;
##sub-imm
##mul
##mul-imm
- } memq? ;
+ } member-eq? ;
: immediate? ( value op -- ? )
arithmetic-op? [ immediate-arithmetic? ] [ immediate-bitwise? ] if ;
: bleh ( seq -- seq' ) [ 3 + ] map [ 0 > ] filter ;
-: stack-trace-any? ( word -- ? ) symbolic-stack-trace memq? ;
+: stack-trace-any? ( word -- ? ) symbolic-stack-trace member-eq? ;
[ t ] [
[ { 1 "hi" } bleh ] ignore-errors \ + stack-trace-any?
0 cell-bits tag-bits get - 1 - [a,b] interval-subset? ;
: modular-word? ( #call -- ? )
- dup word>> { shift fixnum-shift bignum-shift } memq?
+ dup word>> { shift fixnum-shift bignum-shift } member-eq?
[ node-input-infos second interval>> small-shift? ]
[ word>> "modular-arithmetic" word-prop ]
if ;
] when ;
: like->fixnum? ( #call -- ? )
- word>> { >fixnum bignum>fixnum float>fixnum } memq? ;
+ word>> { >fixnum bignum>fixnum float>fixnum } member-eq? ;
: like->integer? ( #call -- ? )
- word>> { >integer >bignum fixnum>bignum } memq? ;
+ word>> { >integer >bignum fixnum>bignum } member-eq? ;
M: #call optimize-modular-arithmetic*
{
! Method body inlining
SYMBOL: history
-: already-inlined? ( obj -- ? ) history get memq? ;
+: already-inlined? ( obj -- ? ) history get member-eq? ;
: add-to-history ( obj -- ) history [ swap suffix ] change ;
] if ;
: always-inline-word? ( word -- ? )
- { curry compose } memq? ;
+ { curry compose } member-eq? ;
: never-inline-word? ( word -- ? )
{ [ deferred? ] [ "default" word-prop ] [ \ call eq? ] } 1|| ;
[ t ] [ [ { 1 2 3 } member? ] { member? } inlined? ] unit-test
[ f ] [ [ { 1 2 3 } swap member? ] { member? } inlined? ] unit-test
-[ t ] [ [ { 1 2 3 } memq? ] { memq? } inlined? ] unit-test
-[ f ] [ [ { 1 2 3 } swap memq? ] { memq? } inlined? ] unit-test
+[ t ] [ [ { 1 2 3 } member-eq? ] { member-eq? } inlined? ] unit-test
+[ f ] [ [ { 1 2 3 } swap member-eq? ] { member-eq? } inlined? ] unit-test
[ t ] [ [ V{ } clone ] { clone (clone) } inlined? ] unit-test
[ f ] [ [ { } clone ] { clone (clone) } inlined? ] unit-test
UNION: fixed-length-sequence array byte-array string ;
: sequence-constructor? ( word -- ? )
- { <array> <byte-array> (byte-array) <string> } memq? ;
+ { <array> <byte-array> (byte-array) <string> } member-eq? ;
: constructor-output-class ( word -- class )
{
] [ drop f ] if
] 1 define-partial-eval
-: memq-quot ( seq -- newquot )
+: member-eq-quot ( seq -- newquot )
[ [ dupd eq? ] curry [ drop t ] ] { } map>assoc
[ drop f ] suffix [ cond ] curry ;
-\ memq? [
- dup sequence? [ memq-quot ] [ drop f ] if
+\ member-eq? [
+ dup sequence? [ member-eq-quot ] [ drop f ] if
] 1 define-partial-eval
! Membership testing
ERROR: bad-index indirect ;
: check-ESP ( indirect -- indirect )
- dup index>> { ESP RSP } memq? [ bad-index ] when ;
+ dup index>> { ESP RSP } member-eq? [ bad-index ] when ;
: canonicalize ( indirect -- indirect )
#! Modify the indirect to work around certain addressing mode
C: <byte> byte
: extended-8-bit-register? ( register -- ? )
- { SPL BPL SIL DIL } memq? ;
+ { SPL BPL SIL DIL } member-eq? ;
: n-bit-version-of ( register n -- register' )
! Certain 8-bit registers don't exist in 32-bit mode...
: 16-bit-version-of ( register -- register' ) 16 n-bit-version-of ;
: 32-bit-version-of ( register -- register' ) 32 n-bit-version-of ;
: 64-bit-version-of ( register -- register' ) 64 n-bit-version-of ;
-: native-version-of ( register -- register' ) cell-bits n-bit-version-of ;
\ No newline at end of file
+: native-version-of ( register -- register' ) cell-bits n-bit-version-of ;
M: x86.32 has-small-reg?
{
- { 8 [ have-byte-regs memq? ] }
+ { 8 [ have-byte-regs member-eq? ] }
{ 16 [ drop t ] }
{ 32 [ drop t ] }
} case ;
: small-reg-that-isn't ( exclude -- reg' )
[ have-byte-regs ] dip
[ native-version-of ] map
- '[ _ memq? not ] find nip ;
+ '[ _ member-eq? not ] find nip ;
: with-save/restore ( reg quot -- )
[ drop PUSH ] [ call ] [ drop POP ] 2tri ; inline
M: x86 %set-alien-double [ [+] ] dip MOVSD ;
M: x86 %set-alien-vector [ [+] ] 2dip %copy ;
-: shift-count? ( reg -- ? ) { ECX RCX } memq? ;
+: shift-count? ( reg -- ? ) { ECX RCX } member-eq? ;
:: emit-shift ( dst src quot -- )
src shift-count? [
M: x86 %compare-vector-reps
{
- { [ dup { cc= cc/= cc/<>= cc<>= } memq? ] [ drop %compare-vector-eq-reps ] }
+ { [ dup { cc= cc/= cc/<>= cc<>= } member-eq? ] [ drop %compare-vector-eq-reps ] }
[ drop %compare-vector-ord-reps ]
} cond ;
dup { load-local load-locals get-local drop-locals } intersect
[ >r/r>-in-fry-error ] unless-empty ;
-PREDICATE: fry-specifier < word { _ @ } memq? ;
+PREDICATE: fry-specifier < word { _ @ } member-eq? ;
GENERIC: count-inputs ( quot -- n )
\ split, { string string } "specializer" set-word-prop
-\ memq? { array } "specializer" set-word-prop
+\ member-eq? { array } "specializer" set-word-prop
\ member? { array } "specializer" set-word-prop
[
dup flattenable? [
def>>
- [ visited get memq? [ no-recursive-inverse ] when ]
+ [ visited get member-eq? [ no-recursive-inverse ] when ]
[ flatten ]
bi
] [ 1quotation ] if
\ tri* 3 [ [ [undo] ] tri@ '[ _ _ _ tri* ] ] define-pop-inverse
\ not define-involution
-\ >boolean [ dup { t f } memq? assure ] define-inverse
+\ >boolean [ dup { t f } member-eq? assure ] define-inverse
\ tuple>array \ >tuple define-dual
\ reverse define-involution
bi ; inline
: search-buffer-until ( pos fill ptr separators -- n )
- [ [ swap alien-unsigned-1 ] dip memq? ] 2curry find-from drop ; inline
+ [ [ swap alien-unsigned-1 ] dip member-eq? ] 2curry find-from drop ; inline
: finish-buffer-until ( buffer n -- byte-array separator )
[
<PRIVATE
: (read-until) ( stream seps buf -- stream seps buf sep/f )
- 3dup [ [ stream-read1 dup ] dip memq? ] dip
+ 3dup [ [ stream-read1 dup ] dip member-eq? ] dip
swap [ drop ] [ push (read-until) ] if ;
:: limited-stream-seek ( n seek-type stream -- )
rewrite-wrapper ;
M: word rewrite-sugar*
- dup { load-locals get-local drop-locals } memq?
+ dup { load-locals get-local drop-locals } member-eq?
[ >r/r>-in-lambda-error ] [ call-next-method ] if ;
M: object rewrite-sugar* , ;
SYMBOL: message-histogram\r
\r
: analyze-entry ( entry -- )\r
- dup level>> { ERROR CRITICAL } memq? [ dup errors get push ] when\r
+ dup level>> { ERROR CRITICAL } member-eq? [ dup errors get push ] when\r
dup word-name>> word-histogram get inc-at\r
dup word-name>> word-names get member? [\r
dup [ level>> ] [ word-name>> ] [ message>> ] tri 3array\r
: interval-sq ( i1 -- i2 ) dup interval* ;
: special-interval? ( interval -- ? )
- { empty-interval full-interval } memq? ;
+ { empty-interval full-interval } member-eq? ;
: interval-singleton? ( int -- ? )
dup special-interval? [
[ f ] [ \ + object number math-both-known? ] unit-test
[ f ] [ \ number= fixnum object math-both-known? ] unit-test
[ t ] [ \ number= integer fixnum math-both-known? ] unit-test
-[ f ] [ \ >fixnum \ shift derived-ops memq? ] unit-test
-[ f ] [ \ >integer \ /i derived-ops memq? ] unit-test
-[ t ] [ \ fixnum-shift \ shift derived-ops memq? ] unit-test
+[ f ] [ \ >fixnum \ shift derived-ops member-eq? ] unit-test
+[ f ] [ \ >integer \ /i derived-ops member-eq? ] unit-test
+[ t ] [ \ fixnum-shift \ shift derived-ops member-eq? ] unit-test
[ { integer fixnum } ] [ \ +-integer-fixnum integer-op-input-classes ] unit-test
[ { fixnum fixnum } ] [ \ fixnum+ integer-op-input-classes ] unit-test
[ 3 ] [ 1 2 +-integer-integer ] unit-test
[ 3 ] [ 1 >bignum 2 +-integer-integer ] unit-test
[ 3 ] [ 1 2 >bignum +-integer-integer ] unit-test
-[ 3 ] [ 1 >bignum 2 >bignum +-integer-integer ] unit-test
\ No newline at end of file
+[ 3 ] [ 1 >bignum 2 >bignum +-integer-integer ] unit-test
<PRIVATE
: float-type? ( c-type -- ? )
- { float double } memq? ;
+ { float double } member-eq? ;
: unsigned-type? ( c-type -- ? )
- { uchar ushort uint ulonglong } memq? ;
+ { uchar ushort uint ulonglong } member-eq? ;
: check-vconvert-type ( value expected-type -- value )
2dup instance? [ drop ] [ bad-vconvert-input ] if ; inline
name>> "math.vectors.simd.instances." prepend ;
: parse-base-type ( c-type -- c-type )
- dup { c:char c:uchar c:short c:ushort c:int c:uint c:longlong c:ulonglong c:float c:double } memq?
+ dup { c:char c:uchar c:short c:ushort c:int c:uint c:longlong c:ulonglong c:float c:double } member-eq?
[ bad-base-type ] unless ;
: forget-instances ( -- )
"x" get [ 2 * ] <arrow> dup "z" set\r
[ 1 + ] <arrow> "y" set\r
[ ] [ "y" get activate-model ] unit-test\r
-[ t ] [ "z" get "x" get connections>> memq? ] unit-test\r
+[ t ] [ "z" get "x" get connections>> member-eq? ] unit-test\r
[ 7 ] [ "y" get value>> ] unit-test\r
[ ] [ 4 "x" get set-model ] unit-test\r
[ 9 ] [ "y" get value>> ] unit-test\r
[ ] [ "y" get deactivate-model ] unit-test\r
-[ f ] [ "z" get "x" get connections>> memq? ] unit-test\r
+[ f ] [ "z" get "x" get connections>> member-eq? ] unit-test\r
\r
3 <model> "x" set\r
"x" get [ sq ] <arrow> "y" set\r
"~" over class name>> "~" 3append
swap present-text
] [
- over recursion-check get memq? [
+ over recursion-check get member-eq? [
drop "~circularity~" swap present-text
] [
over recursion-check get push
[ quot-uses ] curry each ;
: seq-uses ( seq assoc -- )
- over visited get memq? [ 2drop ] [
+ over visited get member-eq? [ 2drop ] [
over visited get push
(seq-uses)
] if ;
: assoc-uses ( assoc' assoc -- )
- over visited get memq? [ 2drop ] [
+ over visited get member-eq? [ 2drop ] [
over visited get push
[ >alist ] dip (seq-uses)
] if ;
[ invalidate-crossref add-definition-observer ] "tools.crossref" add-init-hook
-PRIVATE>
\ No newline at end of file
+PRIVATE>
next-method ;
: calls-next-method? ( method -- ? )
- def>> flatten \ (call-next-method) swap memq? ;
+ def>> flatten \ (call-next-method) swap member-eq? ;
: compute-next-methods ( -- )
[ standard-generic? ] instances [
M:: cocoa-ui-backend (open-window) ( world -- )
world [ [ dim>> ] dip <FactorView> ]
with-world-pixel-format :> view
- world window-controls>> textured-background swap memq?
+ world window-controls>> textured-background swap member-eq?
[ view make-context-transparent ] when
view world [ world>NSRect ] [ world>styleMask ] bi <ViewWindow> :> window
view -> release
COLOR_BTNFACE GetSysColor RGB>color ;
: ?make-glass ( world hwnd -- )
- over window-controls>> textured-background swap memq? [
+ over window-controls>> textured-background swap member-eq? [
composition-enabled? [
full-window-margins DwmExtendFrameIntoClientArea drop
T{ rgba f 0.0 0.0 0.0 0.0 }
PRIVATE>
: ?string-lines ( string -- string/array )
- CHAR: \n over memq? [ string-lines ] when ;
+ CHAR: \n over member-eq? [ string-lines ] when ;
ERROR: not-a-string object ;
V{ } clone >>window-resources ;
: initial-background-color ( attributes -- color )
- window-controls>> textured-background swap memq?
+ window-controls>> textured-background swap member-eq?
[ T{ rgba f 0.0 0.0 0.0 0.0 } ]
[ T{ rgba f 1.0 1.0 1.0 1.0 } ] if ;
M: world children-on nip children>> ;
M: world remove-gadget
- 2dup layers>> memq?
+ 2dup layers>> member-eq?
[ layers>> remove-eq! drop ] [ call-next-method ] if ;
SYMBOL: flush-layout-cache-hook
M: word-completion row-color
[ vocabulary>> ] [ manifest>> ] bi* {
{ [ dup not ] [ COLOR: black ] }
- { [ 2dup search-vocabs>> memq? ] [ COLOR: black ] }
+ { [ 2dup search-vocabs>> member-eq? ] [ COLOR: black ] }
{ [ over ".private" tail? ] [ COLOR: dark-red ] }
[ COLOR: dark-gray ]
} cond 2nip ;
M: completion-popup handle-gesture ( gesture completion -- ? )
2dup completion-gesture dup [
[ nip hide-glass ] [ invoke-command ] 2bi* f
- ] [ 2drop call-next-method ] if ;
\ No newline at end of file
+ ] [ 2drop call-next-method ] if ;
: method-matches? ( method generic class -- ? )
[ first ] 2dip
{
- [ drop dup [ subwords memq? ] [ 2drop t ] if ]
+ [ drop dup [ subwords member-eq? ] [ 2drop t ] if ]
[ nip dup [ swap "method-class" word-prop = ] [ 2drop t ] if ]
} 3&& ;
ERROR: invalid-c-string string ;
: check-string ( string -- )
- 0 over memq? [ invalid-c-string ] [ drop ] if ;
+ 0 over member-eq? [ invalid-c-string ] [ drop ] if ;
GENERIC# string>alien 1 ( string encoding -- byte-array )
] unless ;
: if-mixin-member? ( class mixin true false -- )
- [ check-mixin-class 2dup members memq? ] 2dip if ; inline
+ [ check-mixin-class 2dup members member-eq? ] 2dip if ; inline
: change-mixin-class ( class mixin quot -- )
[ [ members swap bootstrap-word ] dip call ] [ drop ] 2bi
[ t ] [ \ yo-momma class? ] unit-test
[ ] [ \ yo-momma forget ] unit-test
[ ] [ \ <yo-momma> forget ] unit-test
- [ f ] [ \ yo-momma update-map get values memq? ] unit-test
+ [ f ] [ \ yo-momma update-map get values member-eq? ] unit-test
] with-compilation-unit
TUPLE: loc-recording ;
: read-until-loop ( stream delim -- ch )
over stream-read1 dup [
- dup pick memq? [ 2nip ] [ , read-until-loop ] if
+ dup pick member-eq? [ 2nip ] [ , read-until-loop ] if
] [
2nip
] if ;
: find-sep ( seps stream -- sep/f n )
swap [ >sequence-stream< swap tail-slice ] dip
- [ memq? ] curry find swap ; inline
+ [ member-eq? ] curry find swap ; inline
: sequence-read-until ( separators stream -- seq sep/f )
[ find-sep ] keep
] unit-test
[ t ] [
- array "smudge-me" "parser.tests" lookup order memq?
+ array "smudge-me" "parser.tests" lookup order member-eq?
] unit-test
[ t ] [
- integer "smudge-me" "parser.tests" lookup order memq?
+ integer "smudge-me" "parser.tests" lookup order member-eq?
] unit-test
[ f ] [
- string "smudge-me" "parser.tests" lookup order memq?
+ string "smudge-me" "parser.tests" lookup order member-eq?
] unit-test
[ ] [
{ $description "Tests if the sequence contains an element equal to the object." }
{ $notes "This word uses equality comparison (" { $link = } ")." } ;
-HELP: memq?
+HELP: member-eq?
{ $values { "elt" object } { "seq" sequence } { "?" "a boolean" } }
{ $description "Tests if the sequence contains the object." }
{ $notes "This word uses identity comparison (" { $link eq? } ")." } ;
"Testing indices:"
{ $subsections bounds-check? }
"Testing if a sequence contains an object:"
-{ $subsections member? memq? }
+{ $subsections member? member-eq? }
"Testing if a sequence contains a subsequence:"
{ $subsections head? tail? subseq? } ;
[ t ] [ 2 [ 1 2 ] member? ] unit-test
[ t ]
-[ [ "hello" "world" ] [ second ] keep memq? ] unit-test
+[ [ "hello" "world" ] [ second ] keep member-eq? ] unit-test
[ 4 ] [ CHAR: x "tuvwxyz" >vector index ] unit-test
: member? ( elt seq -- ? )
[ = ] with any? ;
-: memq? ( elt seq -- ? )
+: member-eq? ( elt seq -- ? )
[ eq? ] with any? ;
: remove ( elt seq -- newseq )
conjoin
conjoin-at
}
-{ $see-also member? memq? any? all? "assocs-sets" } ;
+{ $see-also member? member-eq? any? all? "assocs-sets" } ;
ABOUT: "sets"
translate-seq 60 <groups> [ print ] each ;
: do-line ( seq line -- seq )
- dup first ">;" memq?
+ dup first ">;" member-eq?
[ over show-seq print dup delete-all ] [ over push ] if ;
HINTS: do-line vector string ;
: slot-option? ( tuple slot option -- ? )
[ swap mdb-slot-map at ] dip
- '[ _ swap memq? ] [ f ] if* ;
+ '[ _ swap member-eq? ] [ f ] if* ;
PRIVATE>
syn keyword factorKeyword ?at assoc? assoc-clone-like assoc= delete-at* assoc-partition extract-keys new-assoc value? assoc-size map>assoc push-at assoc-like key? assoc-intersect assoc-refine update assoc-union assoc-combine at* assoc-empty? at+ set-at assoc-all? assoc-subset? assoc-hashcode change-at assoc-each assoc-diff zip values value-at rename-at inc-at enum? at cache assoc>map <enum> assoc assoc-map enum value-at* assoc-map-as >alist assoc-filter-as clear-assoc assoc-stack maybe-set-at substitute assoc-filter 2cache delete-at assoc-find keys assoc-any? unzip
syn keyword factorKeyword case execute-effect no-cond no-case? 3cleave>quot 2cleave cond>quot wrong-values? no-cond? cleave>quot no-case case>quot 3cleave wrong-values to-fixed-point alist>quot case-find cond cleave call-effect 2cleave>quot recursive-hashcode linear-case-quot spread spread>quot
syn keyword factorKeyword byte-array>bignum sgn >bignum next-float number= each-integer next-power-of-2 ?1+ fp-special? imaginary-part mod recip float>bits rational >float number? 2^ bignum? integer fixnum? neg fixnum sq bignum fp-snan? fp-infinity? denominator (all-integers?) times find-last-integer (each-integer) bit? * + fp-bitwise= - fp-qnan? / power-of-2? >= bitand find-integer complex <fp-nan> < log2 > integer? real number bits>double double>bits bitor 2/ zero? rem fp-nan-payload all-integers? (find-integer) real-part prev-float align bits>float float? shift float fp-nan? abs bitxor ratio? even? <= /mod odd? >integer ratio rational? bitnot real? >fixnum complex? /i numerator /f
-syn keyword factorKeyword append assert-sequence= find-last-from trim-head-slice clone-like 3sequence assert-sequence? map-as filter! last-index-from reversed index-from cut* pad-tail (indices) concat-as remove-eq but-last snip trim-tail nths nth 2pusher sequence slice? <slice> partition remove-nth tail-slice empty? tail* if-empty find-from virtual-sequence? member? set-length remove-eq! drop-prefix unclip iota unclip-last-slice bounds-error? sequence-hashcode-step map start midpoint@ rest-slice prepend fourth sift delete sigma new-sequence follow like remove-nth! first4 1sequence reverse slice unless-empty padding virtual@ repetition? set-last index 4sequence max-length set-second immutable-sequence first2 first3 replicate-as reduce-index unclip-slice supremum insert-nth trim-tail-slice tail 3append short count suffix concat flip filter sum immutable? 2sequence map-integers delete-all start* indices snip-slice check-slice sequence? head map-find reduce append-as reverse! sequence= halves collapse-slice interleave 2map binary-reduce virtual-seq slice-error? product bounds-check? bounds-check harvest immutable find produce remove pad-head last replicate set-fourth shorten reversed? map-find-last 3map-as 2unclip-slice shorter? 3map find-last head-slice pop* 2map-as tail-slice* but-last-slice 2map-reduce iota? accumulate each pusher cut-slice new-resizable each-index head-slice* 2reverse-each sequence-hashcode memq? pop set-nth ?nth <flat-slice> second map! join when-empty accumulator immutable-sequence? <reversed> all? 3append-as virtual-sequence subseq? push-either new-like length last-index push-if 2all? lengthen assert-sequence copy map-reduce move third first 3each tail? set-first prefix bounds-error any? <repetition> trim-slice exchange surround 2reduce cut change-nth min-length set-third produce-as push-all head? delete-slice rest sum-lengths 2each head* infimum glue slice-error subseq replace-slice push repetition map-index trim-head unclip-last mismatch trim
+syn keyword factorKeyword append assert-sequence= find-last-from trim-head-slice clone-like 3sequence assert-sequence? map-as filter! last-index-from reversed index-from cut* pad-tail (indices) concat-as remove-eq but-last snip trim-tail nths nth 2pusher sequence slice? <slice> partition remove-nth tail-slice empty? tail* if-empty find-from virtual-sequence? member? set-length remove-eq! drop-prefix unclip iota unclip-last-slice bounds-error? sequence-hashcode-step map start midpoint@ rest-slice prepend fourth sift delete sigma new-sequence follow like remove-nth! first4 1sequence reverse slice unless-empty padding virtual@ repetition? set-last index 4sequence max-length set-second immutable-sequence first2 first3 replicate-as reduce-index unclip-slice supremum insert-nth trim-tail-slice tail 3append short count suffix concat flip filter sum immutable? 2sequence map-integers delete-all start* indices snip-slice check-slice sequence? head map-find reduce append-as reverse! sequence= halves collapse-slice interleave 2map binary-reduce virtual-seq slice-error? product bounds-check? bounds-check harvest immutable find produce remove pad-head last replicate set-fourth shorten reversed? map-find-last 3map-as 2unclip-slice shorter? 3map find-last head-slice pop* 2map-as tail-slice* but-last-slice 2map-reduce iota? accumulate each pusher cut-slice new-resizable each-index head-slice* 2reverse-each sequence-hashcode member-eq? pop set-nth ?nth <flat-slice> second map! join when-empty accumulator immutable-sequence? <reversed> all? 3append-as virtual-sequence subseq? push-either new-like length last-index push-if 2all? lengthen assert-sequence copy map-reduce move third first 3each tail? set-first prefix bounds-error any? <repetition> trim-slice exchange surround 2reduce cut change-nth min-length set-third produce-as push-all head? delete-slice rest sum-lengths 2each head* infimum glue slice-error subseq replace-slice push repetition map-index trim-head unclip-last mismatch trim
syn keyword factorKeyword global +@ change set-namestack change-global init-namespaces on off set-global namespace set with-scope bind with-variable inc dec counter initialize namestack get get-global make-assoc
syn keyword factorKeyword <array> 2array 3array pair >array 1array 4array pair? array resize-array array?
syn keyword factorKeyword +character+ bad-seek-type? readln stream-seek read print with-output-stream contents write1 stream-write1 stream-copy stream-element-type with-input-stream stream-print stream-read stream-contents bl seek-output bad-seek-type nl stream-nl write flush stream-lines +byte+ stream-flush read1 seek-absolute? stream-read1 lines stream-readln stream-read-until each-line seek-end with-output-stream* seek-absolute with-streams seek-input seek-relative? input-stream stream-write read-partial seek-end? seek-relative error-stream read-until with-input-stream* with-streams* each-block output-stream stream-read-partial
projects / factor.git / commitdiff