Examples (and some documentation) for the Words in the Library¶

Stack Chatter¶

This is what I like to call the functions that just rearrange things on the stack. (One thing I want to mention is that during a hypothetical compilation phase these "stack chatter" words effectively disappear, because we can map the logical stack locations to registers that remain static for the duration of the computation. This remains to be done but it's "off the shelf" technology.)

`clear`¶

1 2 3

1 1 3 1 2 3

clear

`dup` `dupd`¶

1 2 3 dup

1 2 3 3

clear

1 2 3 dupd

1 2 2 3

clear

`enstacken` `disenstacken` `stack` `unstack`¶

Replace the stack with a quote of itself.

1 2 3 enstacken

[3 2 1]

clear

Unpack a list onto the stack.

4 5 6 [3 2 1] unstack

Get the stack on the stack.

1 2 3 stack

1 2 3 [3 2 1]

clear

Replace the stack with the list on top. The items appear reversed but they are not, is on the top of both the list and the stack.

1 2 3 [4 5 6] disenstacken

6 5 4

`pop` `popd` `popop`¶

clear
1 2 3 pop

1 2

clear
1 2 3 popd

1 3

clear
1 2 3 popop

1

`roll<` `rolldown` `roll>` `rollup`¶

The "down" and "up" refer to the movement of two of the top three items (displacing the third.)

clear
1 2 3 roll<

2 3 1

clear
1 2 3 roll>

3 1 2

`swap`¶

clear
1 2 3 swap

1 3 2

`tuck` `over`¶

clear
1 2 3 tuck

1 3 2 3

clear
1 2 3 over

1 2 3 2

`unit` `quoted` `unquoted`¶

clear
1 2 3 unit

1 2 [3]

clear
1 2 3 quoted

1 [2] 3

clear
1 [2] 3 unquoted

1 2 3

Unquoting evaluates. Be aware.

clear
1 [dup] 3 unquoted

1 1 3

List words¶

`concat` `swoncat` `shunt`¶

clear
[1 2 3] [4 5 6] concat

[1 2 3 4 5 6]

clear
[1 2 3] [4 5 6] swoncat

[4 5 6 1 2 3]

clear
[1 2 3] [4 5 6] shunt

[6 5 4 1 2 3]

`cons` `swons` `uncons`¶

clear
1 [2 3] cons

[1 2 3]

clear
[2 3] 1 swons

[1 2 3]

clear
[1 2 3] uncons

1 [2 3]

`first` `second` `third` `rest`¶

clear
[1 2 3 4] first

1

clear
[1 2 3 4] second

2

clear
[1 2 3 4] third

3

clear
[1 2 3 4] rest

[2 3 4]

`flatten`¶

clear
[[1] [2 [3] 4] [5 6]] flatten

[1 2 [3] 4 5 6]

`getitem` `at` `of` `drop` `take`¶

at and getitem are the same function. of == swap at

clear
[10 11 12 13 14] 2 getitem

12

clear
[1 2 3 4] 0 at

1

clear
2 [1 2 3 4] of

3

clear
[1 2 3 4] 2 drop

[3 4]

clear
[1 2 3 4] 2 take

[2 1]

take reverses the order.

reverse could be defines as reverse == dup size take

`remove`¶

clear
[1 2 3 1 4] 1 remove

[2 3 1 4]

`reverse`¶

clear
[1 2 3 4] reverse

[4 3 2 1]

`size`¶

clear
[1 1 1 1] size

4

`swaack`¶

"Swap stack" swap the list on the top of the stack for the stack, and put the old stack on top of the new one. Think of it as a context switch. Niether of the lists/stacks change their order.

clear
1 2 3 [4 5 6] swaack

6 5 4 [3 2 1]

`choice` `select`¶

clear
23 9 true choice

9

clear
23 9 false choice

23

clear
[23 9 7] 1 select

9

(select is basically getitem, should retire it?)

clear
[23 9 7] 0 select

23

`zip`¶

clear
[1 2 3] [6 5 4] zip

[[6 1] [5 2] [4 3]]

clear
[1 2 3] [6 5 4] zip [sum] map

[7 7 7]

Math words¶

`+` `add`¶

clear
23 9 +

32

`-` `sub`¶

clear
23 9 -

14

`*` `mul`¶

clear
23 9 *

207

`/` `div`¶

clear
23 9 /

2

clear
23 9 div

2

clear
23 -9 div

-3

`%` `mod` `modulus` `rem` `remainder`¶

clear
23 9 %

5

`neg`¶

clear
23 neg -5 neg

-23 5

pow¶

clear
2 10 pow

1024

`sqr`¶

clear
23 sqr

529

`++` `succ` `--` `pred`¶

clear
1 ++

2

clear
1 --

0

`<<` `lshift` `>>` `rshift`¶

clear
8 1 <<

16

clear
8 1 >>

4

`range` `range_to_zero` `down_to_zero`¶

clear
5 range

[4 3 2 1 0]

clear
5 range_to_zero

[0 1 2 3 4 5]

clear
5 down_to_zero

5 4 3 2 1 0

clear
[5 down_to_zero] run

[0 1 2 3 4 5]

`product`¶

clear
[1 2 3 5] product

30

`sum`¶

clear
[1 2 3 5] sum

11

`min`¶

clear
[1 2 3 5] min

1

`gcd`¶

clear
45 30 gcd

15

Logic and Comparison¶

`?` `truthy`¶

Get the Boolean value of the item on the top of the stack.

clear
23 bool

true

clear
[] bool

false

clear
0 bool

false

? == dup truthy

clear
23 ?

23 true

clear
[] ?

[] false

clear
0 ?

0 false

`&` `and`¶

clear
true false &

false

`!=` `<>` `ne`¶

clear
23 9 !=

true

The usual suspects:

< lt
<= le
= eq
> gt
>= ge
not
or

Miscellaneous¶

`help`¶

clear
[help] help

==== Help on help ====

Accepts a quoted symbol on the top of the stack and prints its docs.

---- end ( help )

`run`¶

Evaluate a quoted Joy sequence.

clear
[1 2 dup + +] run

[5]

Combinators¶

`app1` `app2` `app3`¶

clear
[app1] help

==== Help on app1 ====

app1 ≡ grba infrst

---- end ( app1 )

clear
10 4 [sqr *] app1

10 160

clear
10 3 4 [sqr *] app2

10 90 160

clear
[app2] help

==== Help on app2 ====

app2 ≡ [grba swap grba swap] dip [infrst] cons ii

---- end ( app2 )

clear
10 2 3 4 [sqr *] app3

160 90 40

(Wait... is that... backwards?)

It should be 40 90 160 shouldn't it?

clear
10 2 3 4 [sqr *] 3 [grabN] codi map reverse disenstacken

40 90 160

Ah! See? It needs reverse in there!

clear
10 2 3 4 5 [sqr *] 4 [grabN] codi map reverse disenstacken

40 90 160 250

`anamorphism`¶

Given an initial value, a predicate function [P], and a generator function [G], the anamorphism combinator creates a sequence.

   n [P] [G] anamorphism
---------------------------
          [...]

Example, range:

range == [0 <=] [1 - dup] anamorphism

J('3 [0 <=] [1 - dup] anamorphism')

`branch`¶

J('3 4 1 [+] [*] branch')

J('3 4 0 [+] [*] branch')

`cleave`¶

... x [P] [Q] cleave

From the original Joy docs: "The cleave combinator expects two quotations, and below that an item x It first executes [P], with x on top, and saves the top result element. Then it executes [Q], again with x, and saves the top result. Finally it restores the stack to what it was below x and pushes the two results P(X) and Q(X)."

Note that P and Q can use items from the stack freely, since the stack (below x) is restored. cleave is a kind of parallel primitive, and it would make sense to create a version that uses, e.g. Python threads or something, to actually run P and Q concurrently. The current implementation of cleave is a definition in terms of app2:

cleave == [i] app2 [popd] dip

J('10 2 [+] [-] cleave')

`dip` `dipd` `dipdd`¶

J('1 2 3 4 5 [+] dip')

J('1 2 3 4 5 [+] dipd')

J('1 2 3 4 5 [+] dipdd')

`dupdip`¶

Expects a quoted program [Q] on the stack and some item under it, dup the item and dip the quoted program under it.

n [Q] dupdip == n Q n

V('23 [++] dupdip *')  # N(N + 1)

`genrec` `primrec`¶

J('[genrec] help')

J('3 [1 <=] [] [dup --] [i *] genrec')

`i`¶

V('1 2 3 [+ +] i')

`ifte`¶

[predicate] [then] [else] ifte

J('1 2 [1] [+] [*] ifte')

J('1 2 [0] [+] [*] ifte')

`infra`¶

V('1 2 3 [4 5 6] [* +] infra')

`loop`¶

J('[loop] help')

V('3 dup [1 - dup] loop')

`map` `pam`¶

J('10 [1 2 3] [*] map')

J('10 5 [[*][/][+][-]] pam')

`nullary` `unary` `binary` `ternary`¶

Run a quoted program enforcing arity.

J('1 2 3 4 5 [+] nullary')

J('1 2 3 4 5 [+] unary')

J('1 2 3 4 5 [+] binary')  # + has arity 2 so this is technically pointless...

J('1 2 3 4 5 [+] ternary')

`step`¶

J('[step] help')

V('0 [1 2 3] [+] step')

`times`¶

V('3 2 1 2 [+] times')

`b`¶

J('[b] help')

V('1 2 [3] [4] b')

`while`¶

[predicate] [body] while

J('3 [0 >] [dup --] while')

`x`¶

J('[x] help')

V('1 [2] [i 3] x')  # Kind of a pointless example.

`void`¶

Implements Laws of Form arithmetic over quote-only datastructures (that is, datastructures that consist soley of containers, without strings or numbers or anything else.)

J('[] void')

J('[[]] void')

J('[[][[]]] void')

J('[[[]][[][]]] void')

Examples (and some documentation) for the Words in the Library¶

Stack Chatter¶

clear¶

dup dupd¶

enstacken disenstacken stack unstack¶

pop popd popop¶

roll< rolldown roll> rollup¶

swap¶

tuck over¶

unit quoted unquoted¶

List words¶

concat swoncat shunt¶

cons swons uncons¶

first second third rest¶

flatten¶

getitem at of drop take¶

remove¶

reverse¶

size¶

swaack¶

choice select¶

zip¶

Math words¶

+ add¶

- sub¶

* mul¶

/ div¶

% mod modulus rem remainder¶

neg¶

pow¶

sqr¶

++ succ -- pred¶

<< lshift >> rshift¶

range range_to_zero down_to_zero¶

product¶

sum¶

min¶

gcd¶