Summary
Contains sequence operations that are not commonly needed. Most of these words are elaborations on functions already available in the main sequences vocabulary.

Metadata

Parents:	sequences
Tags:	sequences

Words

Error classes

Class	Superclass	Slots
slice-error-of	tuple	from to seq
slices-don't-touch	tuple	slice1 slice2
underlying-mismatch	tuple	slice1 slice2

Tuple classes

Class	Superclass	Slots
evens	wrapped-sequence
odds	wrapped-sequence
step-slice	tuple	from to seq step
virtual-zip-index	tuple	seq

Ordinary words

Word	Stack effect
(2selector-as)	( quot length exemplar -- selector accum )
(collect-with-previous)	( quot into -- quot' )
(each-integer-with-previous)	( ... prev i n quot: ( ... i -- ... ) -- ... )
(start-all)	( seq subseq increment -- indices )
0accumulate	( ... seq quot: ( ... prev elt -- ... next ) -- ... final newseq )
0accumulate-as	( ... seq quot: ( ... prev elt -- ... next ) exemplar -- ... newseq )
0reduce	( seq quot: ( ..a prev elt -- ..a next ) -- result )
1reduce	( seq quot: ( ..a prev elt -- ..a next ) -- result )
2count	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... ? ) -- ... n )
2each-index	( ... seq1 seq2 quot: ( ... elt1 elt2 index -- ... ) -- ... )
2filter	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... newelt ) -- ... newseq )
2filter-as	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... newelt ) exemplar -- ... newseq )
2filter-map	( ... seq1 seq2 filter-quot: ( ... elt1 elt2 -- ... ? ) map-quot: ( elt1 elt2 -- obj ) -- ... newseq )
2filter-map*	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... ? ) -- ... newseq )
2filter-map-as	( ... seq1 seq2 filter-quot: ( ... elt1 elt2 -- ... ? ) map-quot: ( elt1 elt2 -- obj ) exemplar -- ... newseq )
2filter-map-as*	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... obj ? ) exemplar -- ... newseq )
2map!	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... newelt ) -- ... seq1 )
2map-index	( ... seq1 seq2 quot: ( ... elt1 elt2 index -- ... newelt ) -- ... newseq )
2map-into	( seq1 seq2 quot into -- )
2map-sum	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... n ) -- ... n )
2nested-each	( seq1 seq2 quot -- )
2nested-each*	( seq1 seq-quot: ( n -- seq ) quot: ( a b -- ) -- )
2nested-filter	( seq1 seq2 quot -- seq )
2nested-filter*	( seq1 seq-quot quot -- seq )
2nested-filter-as	( seq1 seq2 quot exemplar -- seq )
2nested-filter-as*	( seq1 seq-quot quot exemplar -- seq )
2nested-map	( seq1 seq2 quot -- seq )
2nested-map*	( seq1 seq-quot quot -- seq )
2nested-map-as	( seq1 seq2 quot exemplar -- seq )
2nested-map-as*	( seq1 seq-quot quot exemplar -- seq )
2none?	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... ? ) -- ... ? )
2push-when	( ..a elt1 elt2 quot: ( ..a elt1 elt2 -- ..b ? ) accum -- ..b )
2reduce-from	( ... seq1 seq2 identity quot: ( ... prev elt1 elt2 -- ... next ) i -- ... result )
2reject	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... newelt ) -- ... newseq )
2reject-as	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... newelt ) exemplar -- ... newseq )
2reject-map	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... ? ) map-quot: ( elt1 elt2 -- obj ) -- ... newseq )
2reject-map*	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... obj ? ) -- ... newseq )
2reject-map-as	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... ? ) map-quot: ( elt1 elt2 -- obj ) exemplar -- ... newseq )
2reject-map-as*	( ... seq1 seq2 quot: ( ... elt1 elt2 -- ... obj ? ) exemplar -- ... newseq )
3each-from	( ... seq1 seq2 seq3 quot: ( ... elt1 elt2 elt3 -- ... ) i -- ... )
3map-reduce	( ..a seq1 seq2 seq3 map-quot: ( ..a elt1 elt2 elt3 -- ..b intermediate ) reduce-quot: ( ..b prev intermediate -- ..a next ) -- ..a result )
3nested-each	( seq1 seq2 seq3 quot -- )
3nested-filter	( seq1 seq2 seq3 quot -- seq )
3nested-filter-as	( seq1 seq2 seq3 quot exemplar -- seq )
3nested-map	( seq1 seq2 seq3 quot -- seq )
3nested-map-as	( seq1 seq2 seq3 quot exemplar -- seq )
<evens>	( seq -- evens )
<odds>	( seq -- odds )
<step-slice>	( from/f to/f step seq -- step-slice )
<zip-index>	( seq -- virtual-zip-index )
>resizable	( seq -- accum )
>string-list	( seq -- seq' )
?<slice>	( from/f to/f sequence -- slice )
??nth	( n seq -- elt/f ? )
??nth-of	( seq n -- elt/f ? )
??prev	( n seq -- obj/f ? )
??prev-of	( seq n -- obj/f ? )
?cut	( seq n -- before after )
?first2	( seq -- first/f second/f )
?first3	( seq -- first/f second/f third/f )
?first4	( seq -- first/f second/f third/f fourth/f )
?heap-pop-value>array	( heap -- array )
?infimum	( seq/f -- elt/f )
?maximum	( seq/f -- elt/f )
?minimum	( seq/f -- elt/f )
?nth-of	( seq n -- elt/f )
?prev	( n seq -- obj/f )
?prev-of	( seq n -- obj/f )
?span-slices	( slice1/f slice2/f -- slice )
?supremum	( seq/f -- elt/f )
?trim	( seq quot: ( elt -- ? ) -- seq/newseq )
?trim-head	( seq quot: ( elt -- ? ) -- seq/newseq )
?trim-tail	( seq quot: ( elt -- ? ) -- seq/newseq )
?unclip	( seq -- rest/f first/f )
accumulate-of	( seq quot: ( prev elt -- next ) identity -- result )
adjacent-differences	( seq -- seq' )
all-longest	( seqs -- seqs' )
all-rotations	( seq -- seq' )
all-same-eq?	( seq quot: ( elt -- obj/f ) -- ? )
all-same?	( seq quot: ( elt -- obj/f ) -- ? )
all-shortest	( seqs -- seqs' )
all-subseqs	( seq -- seqs )
appender	( quot -- appender accum )
appender-for	( quot exemplar -- appender accum )
arg-max	( seq -- n )
arg-min	( seq -- n )
arg-sort	( seq -- indices )
arg-where	( ... seq quot: ( ... elt -- ... ? ) -- ... indices )
assoc-zip-with	( quot: ( key value -- calc ) -- alist )
at+*	( n key assoc -- old new )
bqn-index	( seq1 seq2 -- seq )
bqn-index-as	( seq1 seq2 exemplar -- seq )
bqn-index-by	( seq1 seq2 quot -- seq )
bqn-index-by-as	( seq1 seq2 quot exemplar -- seq )
call-push-when	( ..a elt quot: ( ..a elt -- ..b elt' ? ) accum -- ..b )
change-last	( seq quot -- )
change-last-unsafe	( seq quot -- )
change-nths	( ... indices seq quot: ( ... elt -- ... elt' ) -- ... )
check-slice-of	( seq from to -- seq from to )
classify	( seq -- seq' )
classify*	( seq -- next hash seq' )
classify-from	( next hash seq -- next' hash seq' )
collapse	( ... seq quot: ( ... elt -- ... ? ) elt -- ... seq' )
collect-with-previous	( n quot into -- )
compact	( ... seq quot: ( ... elt -- ... ? ) elt -- ... seq' )
count-head	( seq quot -- n )
count-subseq	( seq subseq -- n )
count-subseq*	( seq subseq -- n )
count-tail	( seq quot -- n )
count=	( ... seq quot: ( ... elt -- ... ? ) n -- ... ? )
cut-when	( ... seq quot: ( ... elt -- ... ? ) -- ... before after )
deduplicate	( seq -- seq' )
deduplicate-last	( seq -- seq' )
deep-nth	( index-seq nested-seq -- elt )
deep-nth-of	( nested-seq index-seq -- elt )
delete-slice-of	( seq from to -- seq )
drop-while	( ... seq quot: ( ... elt -- ... ? ) -- tail-slice )
each-index-from	( ... seq quot: ( ... elt index -- ... ) i -- ... )
each-integer-with-previous	( ... n quot: ( ... i -- ... ) -- ... )
each-prior	( ... seq quot: ( ... prior elt -- ... ) -- ... )
each-prior-from	( ... i seq quot: ( ... prior elt -- ... ) -- ... )
each-prior-identity-from	( ... identity i seq quot: ( ... prior elt -- ... ) -- ... )
each-subseq	( ... seq quot: ( ... subseq -- ... ) -- ... )
ensure-same-underlying	( slice1 slice2 -- slice1 slice2 )
even-indices	( seq -- seq' )
exchange-subseq	( len pos1 pos2 seq -- )
extract!	( ... seq quot: ( ... elt -- ... ? ) -- ... seq )
filter-all-subseqs	( ... seq quot: ( ... subseq -- ... ? ) -- seq )
filter-all-subseqs-range	( ... seq range quot: ( ... subseq -- ... ? ) -- seq )
filter-errors	( ... seq quot: ( ... elt -- ... ? ) -- ... subseq )
filter-errors-as	( ... seq quot: ( ... elt -- ... ? ) -- ... subseq )
filter-index	( ... seq quot: ( ... elt i -- ... ? ) -- ... seq' )
filter-index-as	( ... seq quot: ( ... elt i -- ... ? ) exemplar -- ... seq' )
filter-length	( seq n -- seq' )
filter-map	( ... seq filter-quot: ( ... elt -- ... ? ) map-quot: ( obj -- obj' ) -- ... newseq )
filter-map*	( ... seq quot: ( ... elt -- ... newelt ? ) -- ... newseq )
filter-map-as	( ... seq filter-quot: ( ..a elt -- ..b ? ) map-quot: ( obj -- obj' ) exemplar -- ... newseq )
filter-map-as*	( ... seq quot: ( ..a elt -- ..b obj ? ) exemplar -- ... newseq )
find*	( ... seq quot: ( ... elt -- ... ? ) -- ... elt i/f )
find-all	( ... seq quot: ( ... elt -- ... ? ) -- ... elts )
find-deep	( ... seq quot: ( ... elt -- ... calc ) -- ... calc/f )
find-from*	( ... n seq quot: ( ... elt -- ... ? ) -- ... elt i/f )
find-index*	( ... seq quot: ( ... elt i -- ... ? ) -- ... elt i/f )
find-index-from*	( ... n seq quot: ( ... elt i -- ... ? ) -- ... elt i/f )
find-last*	( ... seq quot: ( ... elt -- ... ? ) -- ... elt i/f )
find-last-from*	( ... n seq quot: ( ... elt -- ... ? ) -- ... elt i/f )
find-last-index	( ... seq quot: ( ... elt i -- ... ? ) -- ... i elt )
find-last-index-from	( ... n seq quot: ( ... elt i -- ... ? ) -- ... i elt )
find-nth	( nth seq quot: ( obj -- ? ) -- i/f obj/f )
find-nth-from	( nth from seq quot: ( obj -- ? ) -- i/f obj/f )
find-nth-last	( nth seq quot: ( obj -- ? ) -- i/f obj/f )
find-nth-last-from	( nth from seq quot: ( obj -- ? ) -- i/f obj/f )
find-pred	( ... seq quot: ( ... elt -- ... calc ) pred: ( ... calc -- ... ? ) -- ... calc/f i/f elt/f )
find-pred-loop	( ... i n seq quot: ( ... elt -- ... calc ? ) -- ... calc/f i/f elt/f )
first=	( seq elt -- ? )
first?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
fourth=	( seq elt -- ? )
fourth?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
fry-map-as	( seq quot exemplar -- newseq )
harvest!	( seq -- newseq )
harvest-as	( seq exemplar -- newseq )
head*-as	( seq n exemplar -- seq' )
head-as	( seq n exemplar -- seq' )
heap>pairs	( heap -- pairs )
inc-at*	( key assoc -- old new )
index*	( seq obj -- n )
index-from*	( i seq obj -- n )
index-selector	( quot -- selector accum )
index-selector-as	( quot exemplar -- selector accum )
indices*	( seq obj -- indices )
infimum-by*	( ... seq quot: ( ... elt -- ... x ) -- ... i elt )
insert-nth!	( elt n seq -- )
interleaved	( seq glue -- newseq )
interleaved-as	( seq glue exemplar -- newseq )
iterate-heap-while	( heap quot1: ( value key -- slurp? ) quot2: ( value key -- obj/f ) -- obj/f loop? )
last-index*	( seq obj -- n )
last-index-from*	( i seq obj -- n )
last=	( seq elt -- ? )
last?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
longest-subseq	( seq1 seq2 -- subseq )
loop>array	( ... quot: ( ... -- ... obj/f ) -- ... array )
loop>array*	( ... quot: ( ... -- ... obj ? ) -- ... array )
loop>array**	( ... quot: ( ... -- ... obj ? ) -- ... array )
loop>sequence	( ... quot: ( ... -- ... obj/f ) exemplar -- ... seq )
loop>sequence*	( ... quot: ( ... -- ... obj ? ) exemplar -- ... seq )
loop>sequence**	( ... quot: ( ... -- ... obj ? ) exemplar -- ... seq )
map-concat	( ... seq quot: ( ... elt -- ... newelt ) -- ... newseq )
map-concat-as	( ... seq quot: ( ... elt -- ... newelt ) exemplar -- ... newseq )
map-filter	( ... seq map-quot: ( ... elt -- ... newelt ) filter-quot: ( ... newelt -- ... ? ) -- ... subseq )
map-filter-as	( ... seq map-quot: ( ... elt -- ... newelt ) filter-quot: ( ... newelt -- ... ? ) exemplar -- ... subseq )
map-find-index	( ... seq quot: ( ... elt index -- ... result/f ) -- ... result i elt )
map-find-last-index	( ... seq quot: ( ... elt index -- ... result/f ) -- ... result i elt )
map-from	( ... seq quot: ( ... elt -- ... newelt ) from -- ... newseq )
map-from-as	( ... seq quot: ( ... elt -- ... newelt ) from exemplar -- ... newseq )
map-harvest	( ... seq quot: ( ... elt -- ... newelt ) -- ... newseq )
map-if	( ... seq if-quot: ( ... elt -- ... ? ) map-quot: ( ... elt -- ... newelt ) -- ... newseq )
map-index!	( ... seq quot: ( ... elt index -- ... newelt ) -- ... seq )
map-infimum	( seq quot: ( ... elt -- ... elt' ) -- elt' )
map-integers-with	( ... len quot: ( ... prev i -- ... elt ) exemplar -- ... newseq )
map-like	( seq exemplar -- seq' )
map-maximum	( seq quot: ( ... elt -- ... elt' ) -- elt' )
map-minimum	( seq quot: ( ... elt -- ... elt' ) -- elt' )
map-prior	( ... seq quot: ( ... prior elt -- elt' ) -- seq' )
map-prior-as	( ... seq quot: ( ... prior elt -- elt' ) exemplar -- seq' )
map-prior-from	( ... i seq quot: ( ... prior elt -- elt' ) -- seq' )
map-prior-from-as	( ... i seq quot: ( ... prior elt -- elt' ) exemplar -- seq' )
map-prior-identity-as	( ... identity seq quot: ( ... prior elt -- elt' ) exemplar -- seq' )
map-prior-identity-from-as	( ... identity i seq quot: ( ... prior elt -- elt' ) exemplar -- seq' )
map-product	( ... seq quot: ( ... elt -- ... n ) -- ... n )
map-sift	( ... seq quot: ( ... elt -- ... newelt ) -- ... newseq )
map-supremum	( seq quot: ( ... elt -- ... elt' ) -- elt' )
map-with-previous	( ... seq quot: ( ... elt prev/f -- ... newelt ) -- ... newseq )
map-with-previous-as	( ... seq quot: ( ... elt prev/f -- ... newelt ) exemplar -- ... newseq )
map-zip-swap	( quot: ( x -- y ) -- alist )
mark-firsts	( seq -- seq' )
max-subarray-sum	( seq -- sum )
maximum-by*	( ... seq quot: ( ... elt -- ... x ) -- ... i elt )
maybe-push	( elt/f accum -- )
member-eq-of?	( seq elt -- ? )
member-of?	( seq elt -- ? )
merge-slices	( slice1 slice2 -- slice/* )
minimum-by*	( ... seq quot: ( ... elt -- ... x ) -- ... i elt )
mismatch-last	( seq1 seq2 -- i-back )
nth*	( n seq -- elt )
nth-index	( n obj seq -- i )
nth-of	( seq n -- elt )
nth=	( n seq elt -- ? )
nth?	( ... n seq quot: ( ... elt -- ... ? ) -- ... ? )
occurrence-count-by	( seq quot: ( elt -- elt' ) -- hash seq' )
odd-indices	( seq -- seq' )
one?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
ordered-slices-overlap?	( slice-lt slice-gt -- ? )
ordered-slices-range	( slice-lt slice-gt -- to from )
ordered-slices-touch?	( slice-lt slice-gt -- ? )
pad-center	( seq n elt -- padded )
pad-longest	( seq1 seq2 elt -- seq1 seq2 )
partial-sums	( seq -- seq' )
percent-of	( ... seq quot: ( ... elt -- ... ? ) -- ... % )
prepend-lines-with-spaces	( str -- str' )
prev	( n seq -- obj )
prev-identity	( i seq -- identity i seq )
prev-of	( seq n -- obj )
progressive-index	( seq1 seq2 -- hash seq )
progressive-index-as	( seq1 seq2 exemplar -- hash seq )
progressive-index-by	( seq1 seq2 quot -- hash seq )
progressive-index-by-as	( seq1 seq2 quot exemplar -- hash seq )
push-if*	( ..a elt quot: ( ..a elt -- ..b obj/f ) accum -- ..b )
push-if-index	( ..a elt i quot: ( ..a elt i -- ..b ? ) accum -- ..b )
reduce-from	( ... seq identity quot: ( ... prev elt -- ... next ) from -- ... result )
reduce-of	( seq quot: ( prev elt -- next ) identity -- result )
reject-errors	( ... seq quot: ( ... elt -- ... ? ) -- ... subseq )
reject-errors-as	( ... seq quot: ( ... elt -- ... ? ) -- ... subseq )
reject-map	( ... seq filter-quot: ( ... elt -- ... ? ) map-quot: ( obj -- obj' ) -- ... newseq )
reject-map*	( ... seq quot: ( ... elt -- ... newelt ? ) -- ... newseq )
reject-map-as	( ... seq filter-quot: ( ... elt -- ... ? ) map-quot: ( obj -- obj' ) exemplar -- ... newseq )
reject-map-as*	( ... seq quot: ( ... elt -- ... newelt ? ) exemplar -- ... newseq )
remove-eq-of	( seq elt -- newseq )
remove-first	( obj seq -- seq' )
remove-first!	( obj seq -- seq )
remove-first-of	( seq obj -- seq' )
remove-last	( obj seq -- seq' )
remove-last!	( obj seq -- seq )
remove-nth-of	( seq n -- seq' )
remove-nth-of!	( seq n -- seq )
remove-nth-of*	( seq n -- nth seq' )
remove-nth-of*!	( seq n -- nth seq )
remove-of	( seq elt -- newseq )
replicate-into	( ... seq quot: ( ... -- ... newelt ) -- ... )
reverse-as	( seq exemplar -- newseq )
rotate	( seq n -- seq' )
rotate!	( seq n -- )
round-robin	( seq -- newseq )
safe-subseq	( from to seq -- subseq )
second=	( seq elt -- ? )
second?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
selector*	( quot -- selector accum )
selector-as*	( quot exemplar -- selector accum )
sequence-cartesian-product	( seqs -- seqs' )
sequence-index-operator-last	( n seq quot -- n quot' )
sequence>slice	( sequence -- slice )
set-nth-of	( seq n elt -- seq )
set-nths	( value indices seq -- )
set-nths-unsafe	( value indices seq -- )
setup-each-from	( seq quot -- n quot )
shorten*	( vector n -- seq )
sift!	( seq -- seq' )
sift-as	( seq exemplar -- newseq )
slice-error-of	( from to seq -- * )
slice-order-by-from	( slice1 slice2 -- slice-lt slice-gt )
slice-when	( seq quot: ( elt -- ? ) -- seq' )
slices-don't-touch	( slice1 slice2 -- * )
slices-overlap?	( slice1 slice2 -- ? )
slices-touch?	( slice1 slice2 -- ? )
slurp-heap-while-map	( heap quot1: ( value key -- slurp? ) quot2: ( value key -- obj/f ) -- seq )
snip-of	( seq from to -- head tail )
snip-slice-of	( seq from to -- head tail )
span-slices	( slice1 slice2 -- slice )
start-all	( seq subseq -- indices )
start-all*	( seq subseq -- indices )
subseq*	( from to seq -- subseq )
subseq-indices	( seq subseq -- indices )
supremum-by*	( ... seq quot: ( ... elt -- ... x ) -- ... i elt )
tail*-as	( seq n exemplar -- seq' )
tail-as	( seq n exemplar -- seq' )
take-while	( ... seq quot: ( ... elt -- ... ? ) -- head-slice )
third=	( seq elt -- ? )
third?	( ... seq quot: ( ... elt -- ... ? ) -- ... ? )
throws?	( quot -- ? )
trim-as	( ... seq quot: ( ... elt -- ... ? ) exemplar -- ... newseq )
underlying-mismatch	( slice1 slice2 -- * )
unordered-slices-overlap?	( slice1 slice2 -- ? )
unordered-slices-range	( slice1 slice2 -- to from )
unordered-slices-touch?	( slice1 slice2 -- ? )
unsurround	( newseq seq2 seq3 -- seq1 )
until-empty	( seq quot -- )
with-string-lines	( str quot -- str' )
zero-loop>array	( quot: ( ..a n -- ..a obj ) -- seq )
zero-loop>sequence	( ... quot: ( ... n -- ... obj/f ) exemplar -- ... seq )
zip-longest	( seq1 seq2 -- assoc )
zip-longest-with	( seq1 seq2 fill -- assoc )

Class predicate words

Word	Stack effect
evens?	( object -- ? )
odds?	( object -- ? )
slice-error-of?	( object -- ? )
slices-don't-touch?	( object -- ? )
step-slice?	( object -- ? )
underlying-mismatch?	( object -- ? )
virtual-zip-index?	( object -- ? )

Files


Metadata files