Nibbles Full 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"

;

hidden save before EOF

unknown

→

hidden foldr1 EOF

[*]

unknown

→

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"

hidden auto value

→

hidden singleton

any*

→

hidden subscript no wrap

num

[*]

→

hidden filter not (done here rather than using AutoNot to allow for a const expression. There isn't a useful behavior for ~ in zipWith

[*]

not∘

→

hidden foldr init tuple

[*]

→

a 3

hidden foldr1 $, needed because normally foldr1 needs to know if size 1 or 1+ to determine if f will be called on anything, but in this case, it doesn't matter, so this is lazier... The best way to actually fix this would be to call foldr with an initial value of "identity" which is a special value that when used in a binary op always returns the other value.

[1]

→

hidden range from 0 ...

num

∞

→

hidden index by

[*]

not∘

→

hidden join str str error

str

→

`<~

e 9

hidden take drop while

[*]

not∘

→

e f

hidden take while

[*]

not∘

→

`>~

c00

hidden drop take while

[*]

not∘

→

e e

hidden drop while

[*]

not∘

→

hidden take drop

num

[*]

→

hidden drop take

num

[*]

→

e a

hidden find indices

[*]

const

not

→

hidden scanl init tuple

[*]

→

.>>

hidden warning for map on tail

[*]

→

\>>

hidden warning for reverse tail

[*]

→

tbd

hidden tbd

chr

tbd

→

``;

a00

hidden recursion alt (because ;; might be invalid if arg is $ @ _)

any*

→

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