Nibbles Quick Ref

Lit

Bin

Desc

Arg Types

Autos

Example

integer

{int}

3 → 3

string

{str}

"hi\n" → "hi\n"

char

{chr}

'b' → 'b'

1st arg

;1;2;3 $ → 1,2,3,3

2nd arg

;1;2;3 @ → 1,2,3,2

3rd arg

;1;2;3 _ → 1,2,3,1

;

save

any

+ ;3 $ → 6

append

any*

[]

:"abc" "def" → "abcdef"

]

max

num

>num

]4 5 → 5

add

num

vec

+2 1 → 3

[

min

int

>num

[4 5 → 4

multiply

int

vec

-1

*7 6 → 42

subtract

num

- 5 3 → 2

divide

num

/7 2 → 3

modulus

num

%7 2 → 1

pow (minus is nth root)

int

^2 8 → 256

sum

[int]

+,3 → 6

concat

[[*]]

+.,3,$ → [1,1,2,1,2,3]

map

[*]

."abc"+1$ → "bcd"

filter

[*]

reqfn

not∘

|,5%$2 → [1,3,5]

zip with

[*]

const

zipop

! ,3"abc" + → "bdf"

foldr1

[*]

reqfn

/,3+@$ → 6

foldr

[*]

const

tuple

/,3 1 +@$ → 7

reverse

[*]

\,3 → [3,2,1]

length

[*]

,"asdf" → 4

take ( `< also drop)

num

[*]

while

<3"asdfg" → "asd"

drop ( `> also take)

int

[*]

while

>3,5 → [4,5]

range 1.. ( `, is 0...)

num

∞

,3 → [1,2,3]

replicate

int

[*]|chr

∞

^3"ab" → "ababab"

subscript (wrapped)

num

[*]

nowrap

=2 "asdf" → 's'

index (or 0 if not found)

[a]

? "abc" 'b' → 2

diff

[a]

-"abcd" "bd" → "ac"

split (remove empties)

str

str|chr

words

%"a b c" " " → ["a","b","c"]

join

str

[*]

*" ",3 → "1 2 3"

justify

str

int

vec

center

& " " 4 "hi" → " hi"

char class?

chr

chclass

|"a.c d" \$a → "acd"

ord

chr

o'd' → 100

if/else

num

default

? 0 "T" "F" → "F"

9 d

divmod

num

`/7 2 $ → 3,1

b d

moddiv

num

`%7 2 $ → 1,3

f 1

read int

str

`r"12" → 12

if/else (lazy list)

[*]

default

?, "cond" 1 0 → 1

tail

[*]

>>,5 → [2,3,4,5]

init

[*]

<<"asdf" → "asd"

e 1

uncons

[*]

`( ,3 $ → 1,[2,3]

e 2

swapped uncons

[*]

`) ,3 $ → [2,3],1

chunks of

num

[*]

`/2,5 → [[1,2],[3,4],[5]]

n chunks

int

[*]

`\ 2 ,6 → [[1,2,3],[4,5,6]]

step

num

[*]

`%2,5 → [1,3,5]

e a

find indices [by]

[*]

fn|const

not∘

`? "a b" \$a → [1,3]

chunk by

[*]

reqfn

`= ,5 /$2 → [[1],[2,3],[4,5]]

group by (also sorts)

[*]

reqfn

nosort

=~ "cabcb" $ → ["a","bb","cc"]

[*]

const

tbd

or"" "b" or "a" "c" → "b","a"

e d

sort

[*]

`<"asdf" → "adfs"

e 3

transpose

[*]

`' "hi""yo" → ["hy","io"]

scanl1

[*]

reqfn

=\,3+*2$@ → [1,5,11]

scanl

[*]

const

tuple

=\,3 0 +@$ → [0,1,3,6]

e c

special scans

[*]

foldop

`\ ,4 + → [1,3,6,10]

e b

special folds

[*]

foldop

`/ "asdf" ] → 's'

product

[int]

`*,4 → 24

subsequences

int

[*]

`_ 2 "abc" → ["ab","ac","bc"]

nary cartesian product

[[*]]

*" "`*"ab""cd" → "ac ad bc bd"

``p

b80

permutations

[*]

``p "ab" → ["ab","ba"]

e 8

list of 2 lists

[a]

`: ,2 ,1 → [[1,2],[1]]

e 8

list difference [by]

[*]

fn?

any

uniq

`- "aabd" 'a' → "abd"

e 5

list intersection [by]

[*]

fn?

any

uniq

`& "abaccd" "aabce" → "abac"

e 6

list union [by]

[*]

fn?

any

uniq

`| "abccd" "aabce" → "abccdae"

e 7

list xor [by]

[*]

fn?

any

uniq

`^ "aabce" "abbde" → "acbd"

e 4

uniq

[*]

`$ "bcba" → "bca"

abs diff

num

>num

!= 3 5 → 2

bit intersection

num

-2

`& 6 3 → 2

bit union

num

>num

`| 3 6 → 7

bit xor

num

`^ 6 3 → 5

partition

[*]

not∘

|,5~~%$2 $ → [1,3,5],[2,4]

e 0

split by

[*]

not∘

%~"a b"$ → [("a",""),("b"," ")]

split list (keep empties)

[*]

any

default

`% ,5 :3 4 → [[1,2],[5]]

strip

str

-~ " bcd\n\n" → "bcd"

signum

num

`$ -2 `$ 0 `$ 2 → -1,0,1

c 2

to uppercase

chr

`) 'a' → 'A'

c 7

to lowercase

chr

`( 'A' → 'a'

chr

int

256

ch 100 → 'd'

int to str

num

`p 5 → "5"

``@

d70

to bits

num

``@ 10 → [1,0,1,0]

hex

b02

to/from hex

any

hex 31 → "1f"

800

to base from data

{int}

`D 2 10 → [1,0,1,0]

to base

int

num

tbd

`@ 2 10 → [1,0,1,0]

from base

num

[*]

`@ 2 :1 :0 :1 0 → 10

iterate while uniq

any*

inf

`. 10 %+1$3 → [10,2,0,1]

.~~

900

append until null

any*

.~~,3,-/$$1 → [1,2,3,1,2,1]

save fn

any*

reqfn

;~2+1$ $4 → 3,5

equal?

any*

const

== 1 2 == 1 1 → 0,1

recursion (alt name ``; )

any*

`; 5 $ 1 *@-$~$ → 120

hashmod

any

{int}

nosalt

."Fizz""Buzz" `# $ 6 1a → [3,5]

fsb

find salt by

[*]

int

∞

not∘

fsb"Fizz""Buzz"6~==$ :3 5 → "1a"

find salt

[*]

int

[*]

∞

fs "Fizz""Buzz"6~ :3 5 → "1a"

debug arg type

any

pt 5 → error"Integer"

show

any

p"a" → "\"a\""

debug context types

;5 ct → error"$ :: Integer ..."

let

let statement

let x +5 4 *x x → 81

lambda (only in fns)

/,3 \e a +a e → 6

sets

name extras (; ok)

`/ 10 3 sets a a → 3,1

error

fd02

error

any

error +2 1 → error "3"

Legend:

symbol	meaning
{type}	parse a value of that type (not an expression, saves a nibble though)
any*	any type or ~ for a tuple
>type	this argument must be longer in length than the preceding (for commutative extensions)
vec	same as "any" but used to denote that it will vectorize if a list is given
num	int\|chr
[*]	list of any type
[a]	list of type variable "a"
reqfn	fn but its argument must be used
const	fn but its argument must not be used (for extensions)
fn?	auto ~ means to take an extra fn argument here
itatlic	auto ~ specifies "option present" but does not replace the arg

Special args:

chclass		zipop		foldop
a	isAlpha	]	max
A	not.isAlpha	[	min
n	isAlphaNum	+	add
N	not.isAlphaNum	*	mult
s	isSpace	-	sub
S	not.isSpace	/	div
l	isLower	%	mod
L	not.isLower	^	pow
u	isUpper	:	cons
U	not.isUpper	~	by	\|	or
p	isPrint	,	make tuple	&	and
P	not.isPrint	!	abs diff	;	rev cons
d	isDigit	=	subscript	>	max by fn
D	not.isDigit	?	index	<	min by fn
$	isSym
!	not.isSym

Inputs:

sym*	type	name	default
$	int	fstInt	100
@	str	fstLine	printable chars
_	[int]	ints	[]
;$	int	sndInt	1000
;@	[str]	allLines	[]
;_	str	allInput	""
;;$	[[int]]	intMatrix	[]
;;@	str	sndLine	""
* command args can be of any type and precede these (use Haskell syntax)

Implicit Ops (top level multiple expressions):

1st type	arg used	meaning
int	$ or @	range
list	@	foldl
list	$	map
~		encode data