needs tests/harness lib/func lib/bit
testbegin
\test embedded lambdas in :
: foo [: 7 * :] ;
2 foo execute 14 #eq

\test embedded lambdas in :~
:~ [: 5 * :] ;
6 ~ execute 30 #eq

\test embedded lambdas in :>
:> [: $f and :] ; execute
$f3 swap execute $3 #eq

\test temporary lambdas
5 [: 7 - :] execute -2 #eq

\test nested lambdas
:~ [: 1 [: 1+ [: 1 + :] execute :] execute :] ;
~ execute 3 #eq

\test n>[:]
[: * + :]
4 5 rot 2 swap n>[:]
8 over execute 28 #eq
3 swap execute 23 #eq

\test binding by hand
:~ [: * + :] ; ~
[: 3 rot> 2 swap execute :] >[:]
4 swap execute 11 #eq

\test if ... then in lambdas
[: if 2 else 3 then :]
1 over execute 2 #eq
0 swap execute 3 #eq

\test do ... loop in lambdas
[: 0 swap 0 do 2+ loop :]
0 over execute 0 #eq
4 swap execute 8 #eq

\test timesi
create data 5 4* allot
create expected map< , 3 5 7 9 11
[: dup 2* 3 + swap 4* data + ! :] 5 timesi
data expected 5 []= #true

\test map[]
create foo map< , 1 2 3 4 5
create expected map< , 2 3 4 5 6
foo 5 ' 1+ map[]
foo expected 5 []= #true

\test cmap[]
create foo ,"hello"
create expected ,"HELLO"
foo 5 ' upcase cmap[]
foo expected 5 c[]= #true

\test fold[]
create data map< , 4 2 1 3
5 data 4 ' + fold[] 15 #eq
42 data 0 ' / fold[] 42 #eq

\test reduce[]
data 4 ' * reduce[] some# 24 #eq
data 0 ' * reduce[] 0 #eq
\ xt is not called on u=1
data 1 ' abort reduce[] some# 4 #eq

\test cfold[]
create data 3 c, 4 c, 5 c, 6 c, -1 ,
-100 data 4 ' + cfold[] -82 #eq

\test creduce[]
data 4 ' + creduce[] some# 18 #eq
0 0 ' + creduce[] 0 #eq

\test filter[]
create data map< , 1 2 3 4 5 6 7 8 9 10 11 12
create expected map< , 3 6 9 12
data 12 [: 3 mod not :] filter[]
4 #eq expected 4 []= #true

\test cfilter[]
create data map< c, -4 -3 -2 -1 0 1 2 3 4 
create expected map< c, 0 1 2 3 4
data 9 [: sex8 0>= :] cfilter[]
5 #eq expected 5 c[]= #true

\test find[]
create data map< , 5 1 -1 3 -6 8
data 6 ' 0< find[] some# 2 #eq
data 6 ' not find[] 0 #eq

\test rfind[]
data 6 ' 0< rfind[] some# 4 #eq
data 6 [: dup 0< if neg then 9 >= :] rfind[] 0 #eq
testend