true
; returns 1

false
; returns 0

not true
; returns 0

not false
; returns 1

true .and true
; returns 1

false .and true
; returns 0

true .or true
; returns 1

false .or true
; returns 1

true .or false
; returns 1

false .or false
; returns 0

true .xor true
; returns 0

false .xor true
; returns 1

true .xor false
; returns 1

false .xor false
; returns 0

all { 1 2 3 }
; returns 3

all { 1 0 3 }
; returns 0

any { 1 2 3 }
; returns 1

any { 1 0 3 }
; returns 1

any { 0 0 3 }
; returns 3

any\with 10 { + 10 , * 10 }
; returns 20

inc 123
; returns 124

inc "123"
; correctly causes error:
; builtin `inc` requires argument 1 to be: Integer. 

is-positive 123
; returns 1

is-positive -123
; returns 0

is-positive "123"
; correctly causes error:
; builtin `is-positive` requires argument 1 to be: Integer, Decimal. 

is-zero 0
; returns 1

is-zero 123
; returns 0

is-zero "123"
; correctly causes error:
; builtin `is-zero` requires argument 1 to be: Integer, Decimal. 

10 .multiple-of 2
; returns 1

10 .multiple-of 3
; returns 0

3 .odd
; returns 1

2 .odd
; returns 0

3 .even
; returns 0

2 .even
; returns 1

4 .mod 2
; returns 0

5 .mod 2
; returns 1

5 .mod 3
; returns 2

random\integer 2 |type?
; returns integer

random\integer 1 |< 2
; returns 1

a:: 123 inc! 'a a
; returns 124

inc! 123
; correctly causes error:
; builtin `inc!` requires argument 1 to be: Word. 

a:: 123 dec! 'a a
; returns 122

dec! 123
; correctly causes error:
; builtin `dec!` requires argument 1 to be: Word. 

4 . .type?
; returns void

1 + 1
; returns 2

3 + 4
; returns 7

5.6 + 7.8
; returns 13.399999999999999

"A" + "b"
; returns "Ab"

"A" + 1
; returns "A1"

{ 1 2 } + { 3 4 }
; returns { 1 2 3 4 }

dict { "a" 1 } |+ { "b" 2 }
; returns dict { a 1 b 2 }

dict { "a" 1 } |+ dict { "b" 2 }
; returns dict { a 1 b 2 }

2 - 1
; returns 1

5 - 6
; returns -1

4 * 2
; returns 8

2.5 * -2
; returns -5

4 / 2
; returns 2

102 / 2
; returns 51

5 // 2
; returns 2

102 // 5
; returns 20

7.99 // 2
; returns 3

5 = 5
; returns 1

5 = 4
; returns 0

6 > 5
; returns 1

5 > 5
; returns 0

5 >= 6
; returns 0

5 >= 5
; returns 1

6 >= 5
; returns 1

5 < 6
; returns 1

5 < 5
; returns 0

5 <= 6
; returns 1

5 <= 5
; returns 1

newline
; returns "
; "

"123" .ln
; returns "123
; "

trim " ASDF "
; returns "ASDF"

trim\ "__ASDF__" "_"
; returns "ASDF"

trim\right "__ASDF__" "_"
; returns "__ASDF"

trim\left "___ASDF__" "_"
; returns "ASDF__"

replace "...xoxo..." "xo" "LoL"
; returns "...LoLLoL..."

substring "...xoxo..." 3 7
; returns "xoxo"

contains "...xoxo..." "xo"
; returns 1

contains "...xoxo..." "lol"
; returns 0

has-suffix "xoxo..." "xoxo"
; returns 0

has-suffix "...xoxo" "xoxo"
; returns 1

has-prefix "xoxo..." "xoxo"
; returns 1

has-prefix "...xoxo" "xoxo"
; returns 0

index? "...xo..." "xo"
; returns 3

position? "...xo..." "xo"
; returns 4

encode\base64 "abcd"
; returns "YWJjZA=="

decode\base64 encode\base64 "abcd"
; returns "abcd"

"abcd" .space
; returns "abcd "

capitalize "abcde"
; returns "Abcde"

to-lower "ABCDE"
; returns "abcde"

to-upper "abcde"
; returns "ABCDE"

concat3 "aa" "BB" "cc"
; returns "aaBBcc"

join { "Mary" "Anne" }
; returns "MaryAnne"

join { "Spot" "Fido" "Rex" }
; returns "SpotFidoRex"

join\with { "Mary" "Anne" } " "
; returns "Mary Anne"

join\with { "Spot" "Fido" "Rex" } "/"
; returns "Spot/Fido/Rex"

split "a,b,c" ","
; returns { "a" "b" "c" }

split\quoted "`a,b`,c,d" "," "`"
; returns { "`a,b`" "c" "d" }

split\many "192.0.0.1" "."
; returns { "192" "0" "0" "1" }

split\many "abcd..e.q|bar" ".|"
; returns { "abcd" "e" "q" "bar" }

split\every "abcdefg" 3
; returns { "abc" "def" "g" }

split\every "abcdefg" 2
; returns { "ab" "cd" "ef" "g" }

split\every "abcdef" 2
; returns { "ab" "cd" "ef" }

random { 1 2 3 } |type?
; returns integer

unpack { { 123 } { 234 } }
; returns { 123 234 }

unpack { { { 123 } } { 234 } }
; returns { { 123 } 234 }

sample { 1 2 3 4 } 2 |length?
; returns 2

sample { 123 123 123 123 } 3 |-> 0
; returns 123

max { 8 2 10 6 }
; returns 10

max list { 8 2 10 6 }
; returns 10

try { max { } } |type?
; returns error

try { max list { } } |type?
; returns error

min { 8 2 10 6 }
; returns 2

min list { 8 2 10 6 }
; returns 2

try { min { } } |type?
; returns error

try { min list { } } |type?
; returns error

avg { 8 2 10 6 }
; returns 6.5

avg list { 8 2 10 6 }
; returns 6.5

try { avg { } } |type?
; returns error

try { avg list { } } |type?
; returns error

sum { 8 2 10 6 }
; returns 26

sum { 8 2 10 6.5 }
; returns 26.5

sum { }
; returns 0

sum list { 8 2 10 6 }
; returns 26

sum list { 8 2 10 6.5 }
; returns 26.5

sum list { }
; returns 0

mul { 1 2 3 4 5 }
; returns 120

mul { 1 2 3.3 4 5 }
; returns 132

first { 1 2 3 4 }
; returns 1

first "abcde"
; returns "a"

first list { 1 2 3 }
; returns 1

rest { 1 2 3 4 }
; returns { 2 3 4 }

rest "abcde"
; returns "bcde"

rest list { 1 2 3 }
; returns list { 2 3 }

rest\from { 1 2 3 4 5 6 } 3
; returns { 4 5 6 }

rest\from "abcdefg" 1
; returns "bcdefg"

rest\from list { 1 2 3 4 } 2
; returns list { 3 4 }

tail { 1 2 3 4 5 6 7 } 3
; returns { 5 6 7 }

tail "abcdefg" 4
; returns "defg"

tail list { 1 2 3 4 } 1
; returns list { 4 }

second { 123 234 345 }
; returns 234

third { 123 234 345 }
; returns 345

last { 1 2 }
; returns 2

last "abcd"
; returns "d"

last list { 4 5 6 }
; returns 6

head { 4 5 6 7 } 3
; returns { 4 5 6 }

head "abcdefg" 2
; returns "ab"

head "abcdefg" 4
; returns "abcd"

head list { 10 20 30 40 } 2
; returns list { 10 20 }

nth { 1 2 3 4 5 } 4
; returns 4

nth { "a" "b" "c" "d" "e" } 2
; returns "b"

dict { "a" 1 "b" 2 "c" 3 } |values
; returns list { 1 2 3 }

sort { 6 12 1 }
; returns { 1 6 12 }

sort x: { 6 12 1 } x
; returns { 6 12 1 }

sort { "b" "c" "a" }
; returns { "a" "b" "c" }

x: { 6 12 1 } , sort! x
; correctly causes error:
; builtin `sort!` requires argument 1 to be: Block, List. 

x: ref { 1 6 12 } , sort! x , x
; returns { 1 6 12 }

sort\by { 6 12 1 } fn { a b } { a < b }
; returns { 1 6 12 }

sort\by { 6 12 1 } fn { a b } { a > b }
; returns { 12 6 1 }

sort\by { { x 6 } { x 12 } { x 1 } } fn { a b } { second a |< second b }
; returns { { x 1 } { x 6 } { x 12 } }

list { 3 2 3 5 3 2 } .unique |sort
; returns list { 2 3 5 }

unique list { 1 1 2 2 3 } |sort
; returns list { 1 2 3 }

unique list { 1 1 2 2 } |sort
; returns list { 1 2 }

unique { 1 1 2 2 3 } |sort
; returns { 1 2 3 }

unique { 1 1 2 2 } |sort
; returns { 1 2 }

unique "aabbc" |length?
; returns 3

unique "ab" |length?
; returns 2

reverse { 3 1 2 3 }
; returns { 3 2 1 3 }

reverse { 3 1 2 3 }
; returns { 3 2 1 3 }

reverse! { 3 1 2 3 }
; correctly causes error:
; builtin `reverse!` requires argument 1 to be: Block, String, List. 

reverse! ref { 3 2 1 3 }
; returns { 3 2 1 3 }

"abcd" .concat "cde"
; returns "abcdcde"

concat { 1 2 3 4 } { 2 4 5 }
; returns { 1 2 3 4 2 4 5 }

union { 1 2 3 4 } { 2 4 5 } |length?
; returns 5

union list { 1 2 3 4 } list { 2 4 5 } |length?
; returns 5

union { 8 2 } { 1 9 } |sort
; returns { 1 2 8 9 }

union { 1 2 } { } |sort
; returns { 1 2 }

union { } { 1 9 } |sort
; returns { 1 9 }

union { } { }
; returns { }

union list { 1 2 } list { 1 2 3 4 } |sort
; returns list { 1 2 3 4 }

union list { 1 2 } list { 1 } |sort
; returns list { 1 2 }

union list { 1 2 } list { } |sort
; returns list { 1 2 }

union list { } list { 1 2 } |sort
; returns list { 1 2 }

union list { } list { }
; returns list { }

range 1 5
; returns { 1 2 3 4 5 }

{ } .is-empty
; returns 1

dict { } |is-empty
; returns 1

table { 'a 'b } { } |is-empty
; returns 1

{ 1 2 3 } .length?
; returns 3

length? "abcd"
; returns 4

table { 'val } { 1 2 3 4 } |length?
; returns 4

vector { 10 20 30 } |length?
; returns 3

dict { "a" 1 "b" 2 "c" 3 } |keys |length?
; returns 3

table { "a" "b" "c" } { 1 2 3 } |keys |length?
; returns 3

{ 23 34 45 } |-> 1
; returns 34

0 <- { 23 34 45 }
; returns 23

2 <~ { 23 34 45 }
; returns 34

{ 23 34 45 } |~> 1
; returns 23

"abcd" .intersection "cde"
; returns "cd"

intersection { 1 2 3 4 } { 2 4 5 }
; returns { 2 4 }

intersection { 1 3 5 6 } { 2 3 4 5 }
; returns { 3 5 }

intersection { 1 2 3 } { }
; returns { }

intersection { } { 2 3 4 }
; returns { }

intersection { 1 2 3 } { 4 5 6 }
; returns { }

intersection { } { }
; returns { }

intersection list { 1 3 5 6 } list { 2 3 4 5 }
; returns list { 3 5 }

intersection list { 1 2 3 } list { }
; returns list { }

intersection list { } list { 2 3 4 }
; returns list { }

intersection list { 1 2 3 } list { 4 5 6 }
; returns list { }

intersection list { } list { }
; returns list { }

intersection\by "foobar" "fbx" fn { a b } { a .contains b }
; returns "fb"

intersection\by "fooBar" "Fbx" fn { a b } { a .to-lower .contains to-lower b }
; returns "fB"

intersection\by { "foo" 33 } { 33 33 } fn { a b } { a .contains b }
; returns { 33 }

intersection\by { "foo" "bar" 33 } { 42 } fn { a b } { map a { .type? } |contains b .type? }
; returns { 33 }

intersection\by { { "foo" x } { "bar" y } } { { "bar" z } } fn { a b } { map a { .first } |contains first b }
; returns { { "bar" y } }

"abcde" .difference "cde"
; returns "ab"

difference { 1 2 3 4 } { 2 4 }
; returns { 1 3 }

difference list { "Bob" "Sal" "Joe" } list { "Joe" }
; returns list { "Bob" "Sal" }

difference "abc" "bc"
; returns "a"

difference "abc" "abc"
; returns ""

difference "abc" ""
; returns "abc"

difference "" ""
; returns ""

difference { 1 3 5 6 } { 2 3 4 5 }
; returns { 1 6 }

difference { 1 2 3 } { }
; returns { 1 2 3 }

difference { } { 2 3 4 }
; returns { }

difference { } { }
; returns { }

difference list { 1 3 5 6 } list { 2 3 4 5 }
; returns list { 1 6 }

difference list { 1 2 3 } list { }
; returns list { 1 2 3 }

difference list { } list { 2 3 4 }
; returns list { }

difference list { } list { }
; returns list { }

{ { 1 2 3 } { 4 5 6 } } .transpose
; returns { { 1 4 } { 2 5 } { 3 6 } }

{ { 1 4 } { 2 5 } { 3 6 } } .transpose
; returns { { 1 2 3 } { 4 5 6 } }

x: ref { 1 2 3 4 } remove-last! 'x x
; returns { 1 2 3 }

x: ref { 1 2 3 4 } remove-last! 'x
; returns { 1 2 3 }

x: ref { 1 2 3 } append! 4 'x , x
; returns { 1 2 3 4 }

x: ref { 1 222 3 } change\nth! x 2 222 , x
; returns { 1 222 3 }

c: raw-context { x: 123 } c/x
; returns 123

y: 123 try { c: raw-context { x: y } } |type?
; returns error

try { c: raw-context { x: inc 10 } } |type?
; returns error

c: isolate { x: 123 } c/x
; returns 123

y: 123 c: isolate { x: y } c/x
; returns 123

c: isolate { x: inc 10 } c/x
; returns 11

y: 99 c: isolate { x: does { y } } try { c/x } |type?
; returns error

y: 99 c: isolate { t: ?try x: does { t { y } } } c/x |type?
; returns error

c: context { x: 123 } c/x
; returns 123

y: 123 c: context { x: y } c/x
; returns 123

c: context { x: inc 10 } c/x
; returns 11

y: 123 c: context { x: does { y } } c/x
; returns 123

private { x: 123 }
; returns 123

y: 123 private { x: y }
; returns 123

private { x: inc 10 }
; returns 11

y: 123 private { does { y } } :f f
; returns 123

private\ "what are we doing here" { x: 234 1000 + x }
; returns 1234

ct: context { p: 123 } cn: extends ct { r: p + 234 } cn/r
; returns 357

c: context { y: 123 } cc: bind! context { z: does { y + 234 } } c , cc/z
; returns 357

c: context { y: 123 } cc: bind! context { z: does { y + 234 } } c , unbind cc cc/z
; returns 357

c: context { y: 123 } cc: bind! context { z: does { y + 234 } } c , dd: unbind cc dd/z
; correctly causes error:
; word not found: y 

101 .pass { 202 }
; returns 101

101 .pass { 202 + 303 }
; returns 101

wrap { prn "*" } { prn "x" }
; prints "*x*"

20 .keep { + 202 } { + 101 }
; returns 222

x: 123 , change! 234 'x , x
; returns 234

a:: 123 change! 333 'a a
; returns 333

a:: 123 change! 124 'a
; returns 1

a:: 123 change! 123 'a
; returns 0

set! { 123 234 } { a b } b
; returns 234

x: 1 unset! 'x x: 2
; returns 2

does { 123 } |type?
; returns function

x: does { 123 } x
; returns 123

fn1 { .pass { } } |type?
; returns function

x: fn1 { } , x 123
; returns 123

x: fn1 { .pass { } } , x 123
; returns 123

x: fn1 { + 1 } , x 123
; returns 124

fn { } { } |type?
; returns function

x: fn { } { 234 } , x
; returns 234

x: fn { x } { x } , x 123
; returns 123

x: fn { x } { + 123 } , x 123
; returns 246

pfn { } { } |type?
; returns function

x: pfn { x } { + 123 } , x 123
; returns 246

x: pfn { x } { .print } , x 123
; correctly causes error:
; word not found: print 

to-word "test"
; returns test

to-word 123
; correctly causes error:
; builtin `to-word` requires argument 1 to be: String, Word. 

to-integer "123"
; returns 123

to-integer "abc"
; correctly causes error:
; strconv.Atoi: parsing "abc": invalid syntax in builtin to-integer. 

to-decimal "123.4"
; returns 123.4

to-decimal "abc"
; correctly causes error:
; strconv.ParseFloat: parsing "abc": invalid syntax in builtin to-decimal. 

to-string 'test
; returns "test"

to-string 123
; returns "123"

to-string 123.4
; returns "123.400000"

to-string "test"
; returns "test"

to-char 42
; returns "*"

to-char "*"
; correctly causes error:
; builtin `to-char` requires argument 1 to be: Integer. 

list [ 1 2 3 ] |to-block |type?
; returns block

list [ 1 2 3 ] |to-block |first
; returns 1

dict [ "a" 1 "b" 2 "c" 3 ] |to-context |type?
; returns ctx

is-string "test"
; returns 1

is-string 'test
; returns 0

is-string 123
; returns 0

is-integer 123
; returns 1

is-integer 123.4
; returns 0

is-integer "123"
; returns 0

is-decimal 123
; returns 1

is-decimal 123
; returns 0

is-decimal "123.4"
; returns 0

is-number 123
; returns 1

is-number 123.4
; returns 1

is-number "123"
; returns 0

to-uri "https://example.com"
; returns https://example.com

to-file "example.txt"
; returns file://example.txt

to-file 123
; returns file://123

type? "test"
; returns string

type? 123.4
; returns decimal

types? { "test" 123 }
; returns { string integer }

does { 1 } |dump
; returns "fn { } { 1 }"

mold 123
; returns "123"

mold { 123 }
; returns "{ 123 }"

mold\nowrap 123
; returns "123"

mold\nowrap { 123 }
; returns "123"

mold\nowrap { 123 234 }
; returns "123 234"

x: private { doc! "some doc" doc? }
; returns "some doc"

x: private { doc! "some doc" doc? }
; returns "some doc"

x: context { doc! "some doc" } doc\of? x
; returns "some doc"

is-ref ref { 1 2 3 }
; returns 1

is-ref deref ref { 1 2 3 }
; returns 0

ref { } |is-ref
; returns 1

{ } |is-ref
; returns 0

dict { "a" 123 } |-> "a"
; returns 123

list { "a" 123 } |-> 1
; returns "a"

prns "xy"
; prints "xy "

prn "xy"
; prints "xy"

print "xy"
; prints "xy
; "

format 123 "num: %d"
; returns "num: 123"

prnf 123 "num: %d"
; prints "num: 123"

embed 101 "val {}"
; returns "val 101"

prnv 101 "val {}"
; prints "val 101"

printv 101 "val {}"
; prints "val 101
; "

print\ssv { 101 "asd" }
; prints "101 asd
; "

print\csv { 101 "asd" }
; prints "101,asd
; "

probe 101
; prints "[Integer: 101]
; "

inspect 101
; returns "[Integer: 101]"

load " 1 2 3 " |third
; returns 3

load "{ 1 2 3 }" |first |third
; returns 3

if 1 { 222 }
; returns 222

if 0 { 333 }
; returns 0

x: does { ^if 1 { 222 } 555 } x
; returns 222

x: does { ^if 0 { 333 } 444 } x
; returns 444

either 1 { 222 } { 333 }
; returns 222

either 0 { 222 } { 333 }
; returns 333

switch 101 { 101 { 111 } 202 { 222 } }
; returns 111

switch 202 { 101 { 111 } 202 { 222 } }
; returns 222

cases 0 { { 1 > 0 } { + 100 } { 2 > 1 } { + 1000 } }
; returns 1100

cases 0 { { 1 > 0 } { + 100 } { 2 < 1 } { + 1000 } }
; returns 100

cases 0 { { 1 < 0 } { + 100 } { 2 > 1 } { + 1000 } }
; returns 1000

cases 0 { { 1 < 0 } { + 100 } { 2 < 1 } { + 1000 } }
; returns 0

cases 1 { { 1 > 0 } { + 100 } { 2 < 1 } { + 1000 } _ { * 3 } }
; returns 101

cases 1 { { 1 < 0 } { + 100 } { 2 > 1 } { + 1000 } _ { * 3 } }
; returns 1001

cases 1 { { 1 < 0 } { + 100 } { 2 < 1 } { + 1000 } _ { * 3 } }
; returns 3

do { 123 + 123 }
; returns 246

do { 123 + }
; correctly causes error:
; argument 2 of 2 missing of builtin: 'Adds or joins two values together (Integers, Strings, Uri-s and Blocks) (core) (_+)' 

try { 123 + 123 }
; returns 246

try { 123 + "asd" } |type?
; returns error

try { 123 + } |type?
; returns error

with 100 { + 11 }
; returns 111

with 100 { + 11 , * 3 }
; returns 300

c: context { x: 100 } do\in c { x * 9.99 }
; returns 999

c: context { x: 100 } do\in c { inc! 'x }
; returns 101

c: context { x: 100 } do\in c { x:: 200 } c/x
; returns 200

c: context { x: 100 } do\in c { x:: 200 , x }
; returns 200

c: context { x: 100 } try\in c { x * 9.99 }
; returns 999

c: context { x: 100 } try\in c { inc! 'x }
; returns 101

c: context { x: 100 } try\in c { x:: 200 , x }
; returns 200

c: context { x: 100 } try\in c { x:: 200 } c/x
; returns 200

c: context { x: 100 } try\in c { inc! 'y } |type?
; returns error

c: context { x: 100 } do\par c { x * 9.99 }
; returns 999

c: context { x: 100 } do\par c { inc! 'x }
; returns 101

c: context { x: 100 } do\par c { x:: 200 , x }
; returns 200

c: context { x: 100 } do\par c { x:: 200 } c/x
; returns 100

capture-stdout { print "hello" }
; returns "hello
; "

capture-stdout { loop 3 { prns "x" } }
; returns "x x x "

time-it { sleep 100 }
; returns 100

x: 1 y: 2 vals { x y }
; returns { 1 2 }

x: 1 y: 2 vals { 1 y }
; returns { 1 2 }

x: 1 y: 2 try { vals { z y } } |type?
; returns error

x: 1 y: 2 vals\with 10 { + x , * y }
; returns { 11 20 }

x: 1 y: 2 vals\with 100 { + 10 , * 8.9 }
; returns { 110 890 }

c: context { x: 9999 , incr: fn\in { } current { x:: inc x } } c/incr c/x
; returns 10000

y: 99 c: context { incr: fn\in { } parent { y:: inc y } } c/incr y
; returns 100

ct: context { p: 123 } parent\of ct |= current
; returns 1

3 .loop { prns "x" }
; prints "x x x "

3 .loop { + 1 }
; returns 4

produce 5 0 { + 3 }
; returns 15

produce 3 ">" { + "x>" }
; returns ">x>x>x>"

produce 3 { } { .concat "x" }
; returns { "x" "x" "x" }

produce 3 { } { :x .concat length? x }
; returns { 0 1 2 }

produce 5 { 2 } { :acc .last :x * x |concat* acc }
; returns { 2 4 16 256 65536 4294967296 }

x: 0 produce\while { x < 100 } 1 { * 2 :x }
; returns 64

x: 0 produce\while { x < 100 } 1 { * 2 :x .prns }
; prints "2 4 8 16 32 64 128 "

produce\ 5 1 'acc { * acc , + 1 }
; returns 1

forever { "once" .prn .return }
; prints "once"

forever { "once" .return }
; returns "once"

forever\with 1 { .prn .return }
; prints "1"

for { 1 2 3 } { prns "x" }
; prints "x x x "

{ "a" "b" "c" } .for { .prns }
; prints "a b c "

walk { 1 2 3 } { .prns .rest }
; prints "1 2 3  2 3  3  "

x: 0 walk { 1 2 3 } { :b .first + x :x , b .rest } x
; returns 6

purge { 1 3 3 } { .even }
; returns { 1 3 }

purge { } { .even }
; returns { }

purge list { 1 2 3 } { .even }
; returns list { 1 3 }

purge list { } { .even }
; returns list { }

purge "1234" { .to-integer .even }
; returns { "1" "3" }

purge "" { .to-integer .even }
; returns { }

{ 1 3 3 } :x purge! { .even } 'x , x
; returns { 1 3 }

map { 1 2 3 } { + 1 }
; returns { 2 3 4 }

map { } { + 1 }
; returns { }

map { "aaa" "bb" "c" } { .length? }
; returns { 3 2 1 }

map list { "aaa" "bb" "c" } { .length? }
; returns list { 3 2 1 }

map list { 3 4 5 6 } { .multiple-of 3 }
; returns list { 1 0 0 1 }

map list { } { + 1 }
; returns list { }

map "123" { .to-integer }
; returns { 1 2 3 }

map "123" ?to-integer
; returns { 1 2 3 }

map "" { + "-" }
; returns { }

map\pos { 1 2 3 } 'i { + i }
; returns { 2 4 6 }

map\pos { } 'i { + i }
; returns { }

map\pos list { 1 2 3 } 'i { + i }
; returns list { 2 4 6 }

map\pos list { } 'i { + i }
; returns list { }

map\pos "abc" 'i { + i }
; returns { "a1" "b2" "c3" }

map\pos "" 'i { + i }
; returns { }

map\idx { 1 2 3 } 'i { + i }
; returns { 1 3 5 }

map\idx { } 'i { + i }
; returns { }

map\idx list { 1 2 3 } 'i { + i }
; returns list { 1 3 5 }

map\idx list { } 'i { + i }
; returns list { }

map\idx "abc" 'i { + i }
; returns { "a0" "b1" "c2" }

map\idx "" 'i { + i }
; returns { }

reduce { 1 2 3 } 'acc { + acc }
; returns 6

reduce list { 1 2 3 } 'acc { + acc }
; returns 6

reduce "abc" 'acc { + acc }
; returns "cba"

try { reduce { } 'acc { + acc } } |type?
; returns error

try { reduce list { } 'acc { + acc } } |type?
; returns error

try { reduce "" 'acc { + acc } } |type?
; returns error

fold { 1 2 3 } 'acc 1 { + acc }
; returns 7

fold { } 'acc 1 { + acc }
; returns 1

fold list { 1 2 3 } 'acc 1 { + acc }
; returns 7

fold list { } 'acc 1 { + acc }
; returns 1

fold "abc" 'acc "123" { + acc }
; returns "cba123"

fold "" 'acc "123" { + acc }
; returns "123"

partition { 1 2 3 4 } { > 2 }
; returns { { 1 2 } { 3 4 } }

partition { "a" "b" 1 "c" "d" } { .is-integer }
; returns { { "a" "b" } { 1 } { "c" "d" } }

partition { "a" "b" 1 "c" "d" } ?is-integer
; returns { { "a" "b" } { 1 } { "c" "d" } }

partition { } { > 2 }
; returns { { } }

partition list { 1 2 3 4 } { > 2 }
; returns list { list { 1 2 } list { 3 4 } }

partition list { "a" "b" 1 "c" "d" } ?is-integer
; returns list { list { "a" "b" } list { 1 } list { "c" "d" } }

partition list { } { > 2 }
; returns list { list { } }

partition "aaabbccc" { , }
; returns list { "aaa" "bb" "ccc" }

partition "" { , }
; returns list { "" }

partition "aaabbccc" ?is-string
; returns list { "aaabbccc" }

{ } .list .group { .first }
; returns dict { }

try { { 1 2 3 4 } .group { .even } } |type?
; returns error

filter { 1 2 3 4 } { .even }
; returns { 2 4 }

filter { 1 2 3 4 } ?even
; returns { 2 4 }

filter { } { .even }
; returns { }

filter list { 1 2 3 4 } { .even }
; returns list { 2 4 }

filter list { 1 2 3 4 } ?even
; returns list { 2 4 }

filter list { } { .even }
; returns list { }

filter "1234" { .to-integer .even }
; returns { "2" "4" }

filter "01234" ?to-integer
; returns { "1" "2" "3" "4" }

filter "" { .to-integer .even }
; returns { }

seek { 1 2 3 4 } { .even }
; returns 2

seek list { 1 2 3 4 } { .even }
; returns 2

seek "1234" { .to-integer .even }
; returns "2"

try { seek { 1 2 3 4 } { > 5 } } |type?
; returns error

try { seek list { 1 2 3 4 } { > 5 } } |type?
; returns error

try { seek "1234" { .to-integer > 5 } } |type?
; returns error

x: fn { } { return 101 202 } x
; returns 101

cmd "echo "hello""
; returns 1

rye .type?
; returns native

time-it { sleep 10 }
; returns 10

5 .seconds
; returns 5000000000

5 .minutes
; returns 300000000000

5 .hours
; returns 18000000000000