# Thun Function Reference

Home

Version -10.0.0

Each function, combinator, or definition should be documented here.

- !-
- !=
- %
- *
- +
- ++
- -
- --
- /
- /\
- <
- <<
- <<{}
- <=
- <>
- <{}
- =
- >
- >=
- >>
- ?
- \/
- abs
- add
- anamorphism
- and
- app1
- app2
- app3
- appN
- at
- average
- b
- binary
- bool
- branch
- ccccons
- ccons
- choice
- clear
- cleave
- clop
- cmp
- codi
- codireco
- concat
- cond
- cons
- dinfrirst
- dip
- dipd
- dipdd
- dipddd
- disenstacken
- div
- divmod
- down_to_zero
- drop
- dup
- dupd
- dupdd
- dupdip
- dupdipd
- empty?
- enstacken
- eq
- first
- first_two
- flatten
- fork
- fourth
- gcd
- ge
- genrec
- getitem
- grabN
- grba
- gt
- i
- ifte
- ii
- infra
- infrst
- inscribe
- le
- loop
- lshift
- lt
- make_generator
- map
- max
- max-of-two
- min
- min-of-two
- mod
- modulus
- mul
- neg
- neq
- not
- nulco
- null
- nullary
- of
- or
- over
- pam
- pick
- pm
- pop
- popd
- popdd
- popop
- popopd
- popopdd
- popopop
- pow
- pred
- primrec
- product
- quote-two
- quoted
- range
- range_to_zero
- reco
- rem
- remainder
- rest
- reverse
- roll<
- roll>
- rolldown
- rollup
- rrest
- rshift
- run
- second
- select
- sharing
- shift
- shunt
- size
- small
- spiral_next
- split_at
- split_list
- sqr
- stack
- stackd
- step
- step_zero
- stuncons
- sub
- succ
- sum
- swaack
- swap
- swapd
- swoncat
- swons
- tailrec
- take
- ternary
- third
- times
- tuck
- unary
- uncons
- uncons-pair
- uncons-two
- unit
- unquoted
- unstack
- unswons
- warranty
- while
- x
- zip

## !- ¶

Not negative.

        n !-
    ----------- n < 0
       false

       n !-
    ---------- n >= 0
       true

### Definition

0 >=

### Discussion

Return a Boolean value indicating if a number is greater than or equal to zero.

### Used By

spiral_next

## != ¶

built-in

See neq.

## % ¶

built-in

See mod.

### Used By

divmod mod modulus

## * ¶

built-in

See mul.

### Used By

lshift pow product

## + ¶

built-in

See add.

### Used By

++ pm sum

## ++ ¶

See succ.

### Definition

1 +

### Used By

size spiral_next

## - ¶

built-in

See sub.

### Used By

-- neg pm

## -- ¶

See pred.

### Definition

1 -

### Used By

down_to_zero pred range spiral_next succ

## / ¶

built-in

See div.

### Used By

average divmod rshift

## /\ ¶

Binary Boolean and.

### Definition

_isnt_two_bools [pop false] [] branch

### See Also

bool not \/

## < ¶

built-in

See lt.

### Used By

abs min-of-two

## << ¶

built-in

See lshift.

### Definition

lshift

## <<{} ¶

       ... b a <{}
    -----------------
       ... [] b a

### Definition

[] rollup

### Discussion

Tuck an empty list just under the first two items on the stack.

### See Also

<{}

### Used By

take

## <= ¶

built-in

See le.

### Used By

range spiral_next

## <> ¶

built-in

See neq.

### Used By

spiral_next

## <{} ¶

       ... a <{}
    ----------------
       ... [] a

### Definition

[] swap

### Discussion

Tuck an empty list just under the first item on the stack.

### See Also

<<{}

### Used By

flatten grabN reverse run

## = ¶

built-in

See eq.

### Used By

cmp

## > ¶

built-in

See gt.

### Used By

cmp down_to_zero gcd max-of-two

## >= ¶

built-in

See ge.

### Used By

!-

## >> ¶

built-in

See rshift.

### Definition

rshift

## ? ¶

Is the item on the top of the stack "truthy"?

### Definition

dup bool

### Discussion

You often want to test the truth value of an item on the stack without consuming the item.

### See Also

bool

## \/ ¶

Binary Boolean or.

### Definition

_isnt_two_bools [] [pop true] branch

### See Also

bool not /\

## abs ¶

Take an integer from the stack and replace it with its absolute value.

### Definition

dup 0 < [] [neg] branch

### Used By

spiral_next

## add ¶

built-in

Take two integers from the stack and replace them with their sum.

## anamorphism ¶

combinator

Build a list of values from a generator program `G` and a stopping predicate `P`.

               [P] [G] anamorphism
    -----------------------------------------
       [P] [pop []] [G] [dip swons] genrec

### Example

The `range` function generates a list of the integers from 0 to n - 1:

    [0 <=] [-- dup] anamorphism

> joy? 5

> 5

> joy? [0 <=] [-- dup]

> 5 [0 <=] [-- dup]

> joy? anamorphism

> [4 3 2 1 0]

Note that the last value generated (0) is at the bottom of the list. See the Recursion Combinators notebook.

### Definition

[pop []] swap [dip swons] genrec

### Used By

range

## and ¶

combinator

Short-circuiting Boolean AND

Accept two quoted programs, run the first and expect a Boolean value, if it's `true` pop it and run the second program (which should also return a Boolean value) otherwise pop the second program (leaving `false` on the stack.) The quoted programs are run with [nullary].

       [A] [B] and
    ----------------- A -> true
            B

       [A] [B] and
    ----------------- A -> false
         false

TODO: this is derived in one of the notebooks I think, look it up and link to it, or copy the content here.

### Definition

nulco [nullary [false]] dip branch

### See Also

or

### Used By

spiral_next

## app1 ¶

combinator

"apply one"

Given a quoted program on TOS and anything as the second stack item run the program without disturbing the rest of the stack and replace the two args with the first result of the program.

             ... x [Q] app1
    ---------------------------------
       ... [x ...] [Q] infra first

This is the same effect as the unary combinator.

### Definition

grba infrst

### Discussion

Just a specialization of `nullary` really. Its parallelizable cousins are more useful.

### See Also

app2 app3 appN unary

## app2 ¶

combinator

Like app1 with two items.

       ... y x [Q] . app2
    -----------------------------------
       ... [y ...] [Q] . infra first
           [x ...] [Q]   infra first

### Definition

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

### Discussion

Unlike app1, which is essentially an alias for unary, this function is not the same as binary. Instead of running one program using exactly two items from the stack and pushing one result (as binary does) this function takes two items from the stack and runs the program twice, separately for each of the items, then puts both results onto the stack. This is not currently implemented as parallel processes but it can (and should) be done.

### See Also

app1 app3 appN unary

### Used By

fork

## app3 ¶

combinator

Like [app1] with three items.

         ... z y x [Q] . app3
    -----------------------------------
       ... [z ...] [Q] . infra first
           [y ...] [Q]   infra first
           [x ...] [Q]   infra first

### Definition

3 appN

### Discussion

See [app2].

### See Also

app1 app2 appN unary

## appN ¶

combinator

Like [app1] with any number of items.

       ... xN ... x2 x1 x0 [Q] n . appN
    --------------------------------------
       ... [xN ...] [Q] . infra first
                       ...
           [x2 ...] [Q]   infra first
           [x1 ...] [Q]   infra first
           [x0 ...] [Q]   infra first

### Definition

[grabN] codi map reverse disenstacken

### Discussion

This function takes a quoted function `Q` and an integer and runs the function that many times on that many stack items. See also [app2].

### See Also

app1 app2 app3 unary

### Used By

app3

## at ¶

See getitem.

### Definition

drop first

### Used By

of

## average ¶

Compute the average of a list of numbers. (Currently broken until I can figure out what to do about "numeric tower" in Thun.)

### Definition

[sum] [size] cleave /

### Discussion

Theoretically this function would compute the sum and the size in two separate threads, then divide. This works but a compiled version would probably do better to sum and count the list once, in one thread, eh? As an exercise in Functional Programming in Joy it would be fun to convert this into a catamorphism. See the Recursion Combinators notebook.

## b ¶

combinator

Run two quoted programs

       [P] [Q] b
    ---------------
          P Q

### Definition

[i] dip i

### Discussion

This combinator may seem trivial but it comes in handy.

### See Also

dupdip ii

## binary ¶

combinator

Run a quoted program using exactly two stack values and leave the first item of the result on the stack.

       ... y x [P] binary
    -----------------------
            ... a

### Definition

unary popd

### Discussion

Runs any other quoted function and returns its first result while consuming exactly two items from the stack.

### See Also

nullary ternary unary

### Used By

ternary

## bool ¶

built-in

Convert the item on the top of the stack to a Boolean value.

### Discussion

For integers 0 is `false` and any other number is `true`; for lists the empty list is `false` and all other lists are `true`.

### See Also

not

### Used By

? null

## branch ¶

combinator built-in

Use a Boolean value to select and run one of two quoted programs.

       false [F] [T] branch
    --------------------------
              F

       true [F] [T] branch
    -------------------------
                 T

### Discussion

This is one of the fundamental operations (although it can be defined in terms of [choice] as above). The more common "if..then..else" construct [ifte] adds a predicate function that is evaluated [nullary].

### See Also

choice ifte select

### Used By

/\ \/ abs and choice ifte not on-non-empty-list or select small

## ccccons ¶

       a b c d [...] ccccons
    ---------------------------
           [a b c d ...]

Do [cons] four times.

### Definition

ccons ccons

### See Also

ccons cons times

### Used By

genrec

## ccons ¶

       a b [...] ccons
    ---------------------
          [a b ...]

Do [cons] two times.

### Definition

cons cons

### See Also

cons ccons

### Used By

ccccons cmp make_generator

## choice ¶

Use a Boolean value to select one of two items.

       a b false choice
    ----------------------
              a

       a b true choice
    ---------------------
              b

### Definition

[pop] [popd] branch

### Discussion

It's a matter of taste whether you implement this in terms of [branch] or the other way around.

### See Also

branch select

## clear ¶

built-in

Clear everything from the stack.

### Definition

[] swaack pop

### See Also

stack swaack

### Used By

enstacken

## cleave ¶

combinator

Run two programs in parallel, consuming one additional item, and put their results on the stack.

       ... x [A] [B] cleave
    ------------------------
            ... a b

### Derivation

> [fork] [popdd]

### Example

       1 2 3 [+] [-] cleave
    --------------------------
             1 2 5 -1

### Definition

fork popdd

### Discussion

One of a handful of useful parallel combinators.

### See Also

clop fork map

### Used By

average clop

## clop ¶

combinator

Run two programs in parallel, consuming two additional items, and put their results on the stack.

       ... x y [A] [B] clop
    --------------------------
            ... a b

### Definition

cleave popdd

### Discussion

Like [cleave] but consumes an additional item from the stack. 1 2 3 4 [+] [-] clop -------------------------- 1 2 7 -1

### See Also

cleave fork map

### Used By

divmod pm split_at split_list

## cmp ¶

combinator

Take two values and three quoted programs on the stack and run one of the three depending on the results of comparing the two values.

       a b [G] [E] [L] cmp
    ------------------------- a > b
            G

       a b [G] [E] [L] cmp
    ------------------------- a = b
                E

       a b [G] [E] [L] cmp
    ------------------------- a < b
                    L

### Definition

[[>] swap] dipd [ifte] ccons [=] swons ifte

### Discussion

This is useful sometimes, and you can [dup] or [dupd] with two quoted programs to handle the cases when you just want to deal with [<=] or [>=] and not all three possibilities, e.g.: [G] [EL] dup cmp [GE] [L] dupd cmp Or even: [GL] [E] over cmp

### Used By

eq ge gt le lt neq

## codi ¶

combinator

Take a quoted program from the stack, [cons] the next item onto it, then [dip] the whole thing under what was the third item on the stack.

       a b [F] . codi
    --------------------
             b . F a

### Definition

cons dip

### Discussion

This is one of those weirdly specific functions that turns out to be useful in a few places.

### See Also

appN codireco

### Used By

appN codireco dipd

## codireco ¶

combinator

This is part of the [make_generator] function. You would not use this combinator directly.

### Definition

codi reco

### Discussion

See [make_generator] and the "Using `x` to Generate Values" notebook as well as Recursion Theory and Joy by Manfred von Thun.

### See Also

make_generator

### Used By

make_generator

## concat ¶

built-in

Concatinate two lists.

       [a b c] [d e f] concat
    ----------------------------
           [a b c d e f]

### See Also

first first_two flatten fourth getitem rest reverse rrest second shift shunt size split_at split_list swaack third zip

### Used By

flatten genrec swoncat while

## cond ¶

combinator

This combinator works like a case statement. It expects a single quote on the stack that must contain zero or more condition quotes and a default quote. Each condition quote should contain a quoted predicate followed by the function expression to run if that predicate returns `true`. If no predicates return `true` the default function runs.

    [
        [ [Predicate0] Function0 ]
        [ [Predicate1] Function1 ]
        ...
        [ [PredicateN] FunctionN ]
        [Default]
    ]
    cond

### Discussion

It works by rewriting into a chain of nested [ifte]{.title-ref} expressions, e.g.: [[[B0] T0] [[B1] T1] [D]] cond ----------------------------------------- [B0] [T0] [[B1] [T1] [D] ifte] ifte

### See Also

ifte

## cons ¶

built-in

Given an item and a list, append the item to the list to make a new list.

       a [...] cons
    ------------------
         [a ...]

### Discussion

Cons is a venerable old function from Lisp. Its inverse operation is [uncons].

### See Also

uncons

### Used By

app2 ccons codi dipdd dipddd grabN map nulco pow quote-two reco swons unit zip

## dinfrirst ¶

combinator

Specialist function (that means I forgot what it does and why.)

### Definition

dip infrst

### Used By

nullary

## dip ¶

combinator built-in

The `dip` combinator expects a quoted program on the stack and below it some item, it hoists the item into the expression and runs the program on the rest of the stack.

       ... x [Q] . dip
    ---------------------
             ... . Q x

### Discussion

This along with [infra] are enough to update any datastructure. See the "Traversing Datastructures with Zippers" notebook. Note that the item that was on the top of the stack (`x` in the example above) will not be treated specially by the interpreter when it is reached again. This is something of a footgun. My advice is to avoid putting bare unquoted symbols onto the stack, but then you can't use symbols as "atoms" and also use `dip` and `infra` to operate on compound datastructures with atoms in them. This is a kind of side-effect of the Continuation-Passing Style. The `dip` combinator could "set aside" the item and replace it after running `Q` but that means that there is an "extra space" where the item resides while `Q` runs. One of the nice things about CPS is that the whole state is recorded in the stack and pending expression (not counting modifications to the dictionary.)

### See Also

dipd dipdd dupdip dupdipd infra

### Used By

anamorphism and app2 b codi dinfrirst dipd dipdd dupd dupdip enstacken grba ii infra map on-non-empty-list or over popd popopd quoted shift spiral_next stackd swapd unquoted unstack

## dipd ¶

combinator

Like [dip] but expects two items.

       ... y x [Q] . dipd
    -------------------------
               ... . Q y x

### Definition

[dip] codi

### Discussion

See [dip].

### See Also

dip dipdd dipddd dupdip dupdipd infra

### Used By

cmp dipdd dipddd dupdd dupdipd ifte popdd popopdd uncons-pair

## dipdd ¶

combinator

Like [dip] but expects three items. :

       ... z y x [Q] . dipdd
    -----------------------------
                 ... . Q z y x

### Definition

[dip] cons dipd

### Discussion

See [dip].

### See Also

dip dipd dipddd dupdip dupdipd infra

## dipddd ¶

combinator

Like [dip] but expects four items. :

       ... z y x w [Q] . dipddd
    -------------------------------
                 ... . Q z y x w

### Definition

[dipd] cons dipd

### Discussion

See [dip].

### See Also

dip dipd dipdd dupdip dupdipd infra

## disenstacken ¶

The `disenstacken` function expects a list on top of the stack and makes that the stack discarding the rest of the stack.

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

### Definition

swaack pop

### Discussion

Note that the order of the list is not changed, it just looks that way because the stack is printed with the top on the right while lists are printed with the top or head on the left.

### See Also

enstacken stack unstack

### Used By

appN

## div ¶

built-in

Divide.

## divmod ¶

        x y divmod
    ------------------
         q      r
       (x/y)  (x%y)

Invariant: `qy + r = x`.

### Definition

[/] [%] clop

## down_to_zero ¶

Given a number greater than zero put all the Natural numbers (including zero) less than that onto the stack.

### Example

       3 down_to_zero
    --------------------
          3 2 1 0

### Definition

[0 >] [dup --] while

### See Also

range

### Used By

range_to_zero

## drop ¶

Expects an integer and a quote on the stack and returns the quote with n items removed off the top.

### Example

       [a b c d] 2 drop
    ----------------------
           [c d]

### Definition

[rest] times

### See Also

take

### Used By

at split_at split_list

## dup ¶

built-in

"Dup"licate the top item on the stack.

       a dup
    -----------
        a a

### See Also

dupd dupdd dupdip dupdipd

### Used By

? abs down_to_zero dupd dupdd dupdipd empty? gcd over range sqr tuck x

## dupd ¶

[dup] the second item down on the stack.

       a b dupd
    --------------
        a a b

### Definition

[dup] dip

### See Also

dup dupdd dupdip dupdipd

### Used By

dupdip

## dupdd ¶

[dup] the third item down on the stack.

       a b c dupdd
    -----------------
         a a b c

### Definition

[dup] dipd

### See Also

dup dupd dupdip dupdipd

## dupdip ¶

combinator

Apply a function `F` and [dup] the item under it on the stack.

       a [F] dupdip
    ------------------
          a F a

### Derivation

    a [F] dupdip
    a [F] dupd dip
    a [F] [dup] dip dip
    a dup [F] dip
    a a [F] dip
    a F a

### Definition

dupd dip

### Discussion

A very common and useful combinator.

### See Also

dupdipd

### Used By

ii uncons

## dupdipd ¶

combinator

Run a copy of program `F` under the next item down on the stack.

       a [F] dupdipd
    -------------------
          F a [F]

### Definition

dup dipd

### See Also

dupdip

### Used By

while

## empty? ¶

Expects a list on the stack and pushes `true` if it's empty and `false` otherwise. It doesn't consume the list.

### Definition

dup null

### See Also

null

### Used By

on-non-empty-list small

## enstacken ¶

Put the stack onto the stack replacing the contents of the stack.

       ... a b c enstacken
    -------------------------
           [c b a ...]

### Definition

stack [clear] dip

### Discussion

This is a destructive version of [stack]. See the note under [disenstacken] about the apparent but illusory reversal of the stack.

### See Also

stack disenstacken unstack

## eq ¶

built-in

Compare the two items on the top of the stack for equality and replace them with a Boolean value.

       a b eq
    -------------
       Boolean
       (a = b)

### Definition

[false] [true] [false] cmp

### See Also

cmp ge gt le lt neq

## first ¶

built-in

Replace a list with its first item.

       [a ...]
    --------------
          a

### Definition

uncons pop

### See Also

second third fourth rest

### Used By

at first_two getitem infrst on-non-empty-list second select uncons

## first_two ¶

Replace a list with its first two items.

       [a b ...] first_two
    -------------------------
               a b

### Definition

uncons first

### See Also

first second third fourth rest

## flatten ¶

Given a list of lists, concatinate them.

### Example

       [[1 2] [3 [4] 5] [6 7]] flatten
    -------------------------------------
              [1 2 3 [4] 5 6 7]

### Definition

<{} [concat] step

### Discussion

Note that only one "level" of lists is flattened. In the example above `[4]` is not unquoted.

### See Also

concat first first_two fourth getitem rest reverse rrest second shift shunt size split_at split_list swaack third zip

## fork ¶

combinator

Run two quoted programs in parallel and replace them with their results.

       ... [F] [G] fork
    ----------------------
           ... f g

### Definition

[i] app2

### Discussion

The basic parallelism combinator, the two programs are run independently.

### See Also

cleave clop map

### Used By

cleave

## fourth ¶

Replace a list with its fourth item.

       [a b c d ...] fourth
    --------------------------
              d

### Definition

rest third

### See Also

first second third rest

## gcd ¶

Take two integers from the stack and replace them with their Greatest Common Denominator.

### Definition

true [tuck mod dup 0 >] loop pop

### Discussion

Euclid's Algorithm

## ge ¶

built-in

Greater-than-or-equal-to comparison of two numbers.

       a b ge
    --------------
       Boolean
       (a >= b)

### Definition

[true] [true] [false] cmp

### See Also

cmp eq gt le lt neq

## genrec ¶

combinator

General Recursion Combinator.

                          [if] [then] [rec1] [rec2] genrec
    ---------------------------------------------------------------------
       [if] [then] [rec1 [[if] [then] [rec1] [rec2] genrec] rec2] ifte

### Definition

[[genrec] ccccons] nullary swons concat ifte

### Discussion

Note that this definition includes the `genrec` symbol itself, it is self-referential. This is possible because the definition machinery does not check that symbols in defs are in the dictionary. `genrec` is the only self-referential definition. See the Recursion Combinators notebook. From "Recursion Theory and Joy" by Manfred von Thun:

> "The genrec combinator takes four program parameters in addition to whatever data parameters it needs. Fourth from the top is an if-part, followed by a then-part. If the if-part yields true, then the then-part is executed and the combinator terminates. The other two parameters are the rec1-part and the rec2-part. If the if-part yields false, the rec1-part is executed. Following that the four program parameters and the combinator are again pushed onto the stack bundled up in a quoted form. Then the rec2-part is executed, where it will find the bundled form. Typically it will then execute the bundled form, either with i or with app2, or some other combinator." The way to design one of these is to fix your base case `[then]` and the test `[if]`, and then treat `rec1` and `rec2` as an else-part "sandwiching" a quotation of the whole function. For example, given a (general recursive) function `F`: F == [I] [T] [R1] [R2] genrec If the `[I]` if-part fails you must derive `R1` and `R2` from: : ... R1 [F] R2 Just set the stack arguments in front, and figure out what `R1` and `R2` have to do to apply the quoted `[F]` in the proper way. In effect, the `genrec` combinator turns into an [ifte] combinator with a quoted copy of the original definition in the else-part: F == [I] [T] [R1] [R2] genrec == [I] [T] [R1 [F] R2] ifte Tail recursive functions are those where `R2` is the `i` combinator: P == [I] [T] [R] tailrec == [I] [T] [R [P] i] ifte == [I] [T] [R P] ifte

### See Also

anamorphism tailrec x

### Used By

anamorphism genrec tailrec zip

## getitem ¶

Expects an integer and a quote on the stack and returns the item at the nth position in the quote counting from 0.

### Example

       [a b c d] 2 getitem
    -------------------------
            c

### Definition

[rest] times first

### Discussion

If the number isn't a valid index into the quote `getitem` will cause some sort of problem (the exact nature of which is implementation-dependant.)

### See Also

concat first first_two flatten fourth rest reverse rrest second shift shunt size split_at split_list swaack third zip

### Used By

pick

## grabN ¶

Expect a number on the top of the stack and [cons] that many items from under it onto a new list.

### Example

       a b c d e 3 grabN
    -----------------------
          a b [c d e]

### Definition

<{} [cons] times

### Used By

appN

## grba ¶

A weird function used in [app2] that does this:

          ... 1 2 3 4 5 grba
    -------------------------------
       ... 1 2 3 [4 3 2 1 ...] 5

It grabs the stack under the top item, and substitutes it for the second item down on the stack.

### Definition

[stack popd] dip

### Discussion

This function "grabs" an item from the stack along with a copy of the stack. It's part of the [app2] definition.

### See Also

app2

### Used By

app1 app2

## gt ¶

built-in

Greater-than comparison of two numbers.

       a b gt
    --------------
       Boolean
       (a > b)

### Definition

[true] [false] [false] cmp

### See Also

cmp eq ge le lt neq

## i ¶

combinator built-in

Append a quoted expression onto the pending expression.

       [Q] . i
    -------------
           . Q

### Discussion

This is a fundamental combinator. It is used in all kinds of places. For example, the [x] combinator can be defined as `dup i`.

### Used By

b fork ii infra pam tailrec unquoted x zip

## ifte ¶

combinator

If-Then-Else combinator, a common and convenient specialization of [branch].

            [if] [then] [else] ifte
    ---------------------------------------
       [if] nullary [else] [then] branch

### Definition

[nullary] dipd swap branch

### See Also

branch loop while

### Used By

cmp genrec max-of-two min-of-two spiral_next

## ii ¶

combinator

Take a quoted program from the stack and run it twice, first under the top item, then again with the top item.

    ... a [Q] ii
    ------------------
     ... Q a Q

### Example

It's a little tricky to understand how this works so here's an example trace:

          1 2 3 4 [++] • [dip] dupdip i
    1 2 3 4 [++] [dip] • dupdip i
          1 2 3 4 [++] • dip [++] i
                 1 2 3 • ++ 4 [++] i
                 1 2 4 • 4 [++] i
               1 2 4 4 • [++] i
          1 2 4 4 [++] • i
               1 2 4 4 • ++
               1 2 4 5 •

### Definition

[dip] dupdip i

### Discussion

In some cases (like the example above) this is the same effect as using [app2] but most of the time it's not: 1 2 3 4 [+] ii -------------------- 1 9 1 2 3 4 [+] app2 ---------------------- 1 2 5 6

### See Also

app2 b

### Used By

app2 spiral_next uncons-two

## infra ¶

combinator

Accept a quoted program and a list on the stack and run the program with the list as its stack. Does not affect the stack (below the list.)

       ... x y z [a b c] [Q] infra
    ---------------------------------
        c b a Q [z y x ...] swaack

    ... [a b c] [F] swons swaack [i] dip swaack
    ... [[F] a b c]       swaack [i] dip swaack

    c b a [F]   [...] [i] dip swaack
    c b a [F] i [...]         swaack
    c b a  F    [...]         swaack
    d e         [...]         swaack
    ... [e d]

### Definition

swons swaack [i] dip swaack

### Discussion

This is one of the more useful combinators. It allows a quoted expression to serve as a stack for a program, effectively running it in a kind of "pocket universe". If the list represents a datastructure then `infra` lets you work on its internal structure.

### See Also

swaack

### Used By

infrst range_to_zero run

## infrst ¶

combinator

Does [infra] and then extracts the [first] item from the resulting list.

### Definition

infra first

### Used By

app1 app2 dinfrirst

## inscribe ¶

built-in

Create a new Joy function definition in the Joy dictionary. A definition is given as a quote with a name followed by a Joy expression.

### Example

    [sqr dup mul] inscribe

### Discussion

This is the only function that modifies the dictionary. It's provided as a convenience, for tinkering with new definitions before entering them into the `defs.txt` file. It can be abused, which you should avoid unless you know what you're doing.

## le ¶

built-in

Less-Than-or-Equal-to comparison of the two items on the top of the stack, replacing them with a Boolean value.

       a b le
    -------------
       Boolean
       (a <= b)

### Definition

[false] [true] [true] cmp

### See Also

cmp eq ge gt lt neq

## loop ¶

combinator built-in

Expect a quoted program `Q` and a Boolean value on the stack. If the value is false discard the quoted program, otherwise run a copy of `Q` and `loop` again.

       false [Q] loop
    --------------------

       true [Q] . loop
    --------------------------
                . Q [Q] loop

### Discussion

This, along with [branch] and [fork], is one of the four main combinators of all programming. The fourth, sequence, is implied by juxtaposition. That is to say, in Joy `F G` is like `G(F(...))` in a language bassed on function application. Or again, to quote the Joy Wikipedia entry,

> In Joy, the meaning function is a homomorphism from the syntactic monoid onto the semantic monoid. That is, the syntactic relation of concatenation of symbols maps directly onto the semantic relation of composition of functions. Anyway, [branch], [fork], amd [loop] are the fundamental combinators in Joy. Just as [branch] has it's more common and convenient form [ifte], [loop] has [while].

### See Also

branch fork while

### Used By

gcd while

## lshift ¶

built-in

Logical Left-Shift

       a n lshift
    ----------------
         (a×2ⁿ)

### Definition

[2 *] times

### See Also

rshift

### Used By

<<

## lt ¶

built-in

Less-Than comparison of the two items on the top of the stack, replacing them with a Boolean value.

       a b lt
    -------------
       Boolean
       (a < b)

### Definition

[false] [false] [true] cmp

### See Also

cmp eq ge gt le neq

## make_generator ¶

Given an initial state value and a quoted generator function build a generator quote.

       state [generator function] make_generator
    -----------------------------------------------
         [state [generator function] codireco]

### Example

       230 [dup ++] make_generator
    ---------------------------------
         [230 [dup ++] codireco]

And then:

       [230 [dup ++] codireco] 5 [x] times pop
    ---------------------------------------------
                 230 231 232 233 234

### Definition

[codireco] ccons

### Discussion

See the "Using `x` to Generate Values" notebook.

### See Also

codireco

## map ¶

combinator

Given a list of items and a quoted program run the program for each item in the list (with the rest of the stack) and replace the old list and the program with a list of the results.

### Example

       5 [1 2 3] [++ *] map
    --------------------------
           5 [10 15 20]

### Definition

[_map0] cons [[] [_map?] [_mape]] dip tailrec

### Discussion

This is a common operation in many languages. In Joy it can be a parallelism combinator due to the "pure" nature of the language.

### See Also

app1 app2 app3 appN fork

### Used By

appN pam

## max ¶

Given a list find the maximum.

### Example

       [1 2 3 4] max
    -------------------
             4

### Definition

[uncons [max-of-two] step] on-non-empty-list

### See Also

min size sum

## max-of-two ¶

Expects two integers on the stack and removes the lesser of them, if they are equal just remove one.

### Definition

[>] [pop] [popd] ifte

### Used By

max

## min ¶

Given a list find the minimum.

### Example

       [1 2 3 4] min
    -------------------
             1

### Definition

[uncons [min-of-two] step] on-non-empty-list

### See Also

max size sum

## min-of-two ¶

Expects two integers on the stack and removes the greater of them, if they are equal just remove one.

### Definition

[<] [pop] [popd] ifte

### Used By

min

## mod ¶

Return the remainder of `a` divided by `b`.

       a b mod
    -------------
        (a%b)

### Definition

%

### See Also

divmod mul

### Used By

gcd

## modulus ¶

See mod.

### Definition

%

## mul ¶

built-in

Multiply two numbers.

       a b mul
    -------------
        (a×b)

### See Also

div product

### Used By

sqr

## neg ¶

Invert the sign of a number.

       a neg
    -----------
        -a

### Definition

0 swap -

### Used By

abs

## neq ¶

built-in

Not-Equal comparison of the two items on the top of the stack, replacing them with a Boolean value.

       a b neq
    -------------
       Boolean
       (a = b)

### Definition

[true] [false] [true] cmp

### See Also

cmp eq ge gt le lt

## not ¶

Invert the Boolean value on the top of the stack.

       true not
    --------------
        false

       false not
    ---------------
         true

### Definition

[true] [false] branch

### See Also

bool

### Used By

null

## nulco ¶

Take the item on the top of the stack and [cons] it onto `[nullary]`.

         [F] nulco
    -------------------
       [[F] nullary]

### Definition

[nullary] cons

### Discussion

Helper function for [or] and [and].

### See Also

and or

### Used By

and or while

## null ¶

True if the item on the top of the stack is an empty list, false if it's a list but not empty, and an error if it's not a list.

### Definition

_isnt_list bool not

### Used By

empty? small zip

## nullary ¶

combinator

Run a quoted program without using any stack values and leave the first item of the result on the stack.

       ... [P] nullary
    ---------------------
            ... a

### Example

    ... [P] nullary
    ... [P] [stack] dip infra first
    ... stack [P] infra first
    ... [...] [P] infra first
    ... [a ...] first
    ...  a

### Definition

[stack] dinfrirst

### Discussion

A very useful function that runs any other quoted function and returns it's first result without disturbing the stack (under the quoted program.)

### See Also

unary binary ternary

### Used By

and genrec ifte nulco or unary

## of ¶

Like [getitem] but [swap]s the order of arguments.

### Example

       2 [a b c d] of
    --------------------
             c

### Definition

swap at

### See Also

getitem

## or ¶

combinator

Short-circuiting Boolean OR

Accept two quoted programs, run the first and expect a Boolean value, if it’s `false` pop it and run the second program (which should also return a Boolean value) otherwise pop the second program (leaving `true` on the stack.) The quoted programs are run with [nullary].

       [A] [B] or
    ---------------- A -> false
            B

       [A] [B] or
    ---------------- A -> true
          true

### Definition

nulco [nullary] dip [true] branch

### See Also

and

### Used By

spiral_next

## over ¶

[dup] the second item on the stack `over` the first.

       a b over
    --------------
        a b a

### Definition

There are many many ways to define this function.

> [swap] [tuck]

> [[pop]] [nullary]

> [[dup]] [dip] [swap]

> [unit] [dupdip]

> [unit] [dupdipd] [first]

And so on...

### Definition

[dup] dip swap

### Discussion

A fine old word from Forth.

### See Also

tuck

## pam ¶

combinator

Take a list of quoted functions from the stack and replace it with a list of the [first] results from running those functions (on copies of the rest of the stack.)

### Example

       5 7 [[+][-][*][/][%]] pam
    -------------------------------
          5 7 [12 -2 35 0 5]

### Definition

[i] map

### Discussion

A specialization of [map] that runs a list of functions in parallel (if the underlying [map] function is so implemented, of course.)

### See Also

map

## pick ¶

See getitem.

### Definition

getitem

## pm ¶

Plus or minus. Replace two numbers with their sum and difference.

          a b pm
    -----------------
       (a+b) (a-b)

### Definition

[+] [-] clop

## pop ¶

built-in

Pop the top item from the stack and discard it.

       a pop
    -----------

### See Also

popd popdd popop popopd popopdd popopop

### Used By

/\ \/ anamorphism choice clear disenstacken first gcd max-of-two min-of-two popd popdd popop popopop size small spiral_next take unstack zip

## popd ¶

[pop] the second item down on the stack.

       a b popd
    --------------
          b

### Definition

[pop] dip

### See Also

pop popdd popop popopd popopdd popopop

### Used By

binary choice grba max-of-two min-of-two rest ternary unary

## popdd ¶

[pop] the third item on the stack.

       a b c popdd
    -----------------
           b c

### Definition

[pop] dipd

### See Also

pop popd popop popopd popopdd popopop

### Used By

cleave clop

## popop ¶

[pop] two items from the stack.

       a b popop
    ---------------

### Definition

pop pop

### See Also

pop popd popdd popopd popopdd popopop

### Used By

popopd popopdd popopop

## popopd ¶

[pop] the second and third items from the stack.

       a b c popopd
    ------------------
            c

### Definition

[popop] dip

### See Also

pop popd popdd popop popopdd popopop

## popopdd ¶

       a b c d popopdd
    ---------------------
            c d

### Definition

[popop] dipd

### See Also

pop popd popdd popop popopd popopop

## popopop ¶

[pop] three items from the stack.

       a b c popopop
    -------------------

### Definition

pop popop

### See Also

pop popd popdd popop popopd popopdd

## pow ¶

Take two numbers `a` and `n` from the stack and raise `a` to the `n`th power. (`n` is on the top of the stack.)

       a n pow
    -------------
        (aⁿ)

### Example

       2 [2 3 4 5 6 7 8 9] [pow] map
    -----------------------------------
        2 [4 8 16 32 64 128 256 512]

### Definition

1 roll> swap [*] cons times

## pred ¶

Predecessor. Decrement TOS.

### Definition

--

### See Also

succ

## primrec ¶

combinator

From the "Overview of the language JOY"

> The primrec combinator expects two quoted programs in addition to a data parameter. For an integer data parameter it works like this: If the data parameter is zero, then the first quotation has to produce the value to be returned. If the data parameter is positive then the second has to combine the data parameter with the result of applying the function to its predecessor.

> 5 [1] [*] primrec

> Then primrec tests whether the top element on the stack (initially the 5) is equal to zero. If it is, it pops it off and executes one of the quotations, the [1] which leaves 1 on the stack as the result. Otherwise it pushes a decremented copy of the top element and recurses. On the way back from the recursion it uses the other quotation, [*], to multiply what is now a factorial on top of the stack by the second element on the stack.

       0 [Base] [Recur] primrec
    ------------------------------
          Base

             n [Base] [Recur] primrec
    ------------------------------------------ n > 0
       n (n-1) [Base] [Recur] primrec Recur

### Discussion

Simple and useful specialization of the [genrec] combinator from the original Joy system.

### See Also

genrec tailrec

## product ¶

Just as [sum] sums a list of numbers, this function multiplies them together.

### Definition

> 1 [swap] [[mul]] [step]

Or,

> [1] [[mul]] [primrec]

### Definition

1 swap [*] step

## quote-two ¶

Take two items from the stack and put them into a new list.

    joy? 1 2 3 4

    1 2 3 4

    joy? quote-two

    1 2 [3 4]

### Definition

unit cons

### See Also

quoted

### Used By

uncons-pair

## quoted ¶

"Quote D" Wrap the second item on the stack in a list.

       a b quoted
    ----------------
         [a] b

### Definition

[unit] dip

### Discussion

This comes from the original Joy stuff.

### See Also

quote-two unit

## range ¶

Expect a number `n` on the stack and replace it with a list: `[(n-1)...0]`.

### Example

         5 range
    -----------------
       [4 3 2 1 0]

       -5 range
    --------------
          []

### Definition

[0 <=] [-- dup] anamorphism

### Discussion

If `n` is less than 1 the resulting list is empty.

### See Also

range_to_zero

## range_to_zero ¶

Take a number `n` from the stack and replace it with a list `[0...n]`.

### Example

       5 range_to_zero
    ---------------------
        [0 1 2 3 4 5]

### Definition

unit [down_to_zero] infra

### Discussion

Note that the order is reversed compared to [range].

### See Also

down_to_zero range

## reco ¶

Replace the first item in a list with the item under it.

       a [b ...] reco
    --------------------
         [a ...]

### Definition

rest cons

### See Also

codireco make_generator

### Used By

codireco

## rem ¶

built-in

See mod.

## remainder ¶

built-in

See mod.

## rest ¶

built-in

       [a ...] rest
    ------------------
          [...]

### Definition

uncons popd

### See Also

first uncons

### Used By

drop fourth getitem reco rrest second small third uncons

## reverse ¶

Reverse the list on the top of the stack.

### Example

       [1 2 3] reverse
    ---------------------
           [3 2 1]

### Definition

<{} shunt

### Used By

appN split_list

## roll< ¶

See rolldown.

### Definition

swapd swap

### Used By

rolldown

## roll> ¶

See rollup.

### Definition

swap swapd

### Used By

pow rollup step_zero

## rolldown ¶

       a b c rolldown
    --------------------
           b c a

### Definition

roll<

### See Also

rollup

## rollup ¶

       a b c rollup
    ------------------
          c a b

### Definition

roll>

### See Also

rolldown

### Used By

<<{}

## rrest ¶

       [a b ...] rrest
    ---------------------
            [...]

### Definition

rest rest

### See Also

rest

## rshift ¶

built-in

Logical Right-Shift

       a n rshift
    ----------------
         (a∕2ⁿ)

### Definition

[2 /] times

### See Also

lshift

### Used By

>>

## run ¶

Run a quoted program in a list.

### Example

       [1 2 +] run
    -----------------
           [3]

### Definition

<{} infra

## second ¶

       [a b ...] second
    ----------------------
              b

### Definition

rest first

### See Also

first third fourth

### Used By

select third

## select ¶

Use a Boolean value to select one of two items from a sequence. :

       [a b] false select
    ------------------------
               a

       [a b] true select
    -----------------------
               b

### Definition

[first] [second] branch

### Discussion

The sequence can contain more than two items but not fewer.

### See Also

choice

## sharing ¶

Print redistribution information.

### Discussion

Mathematically this is a form of [id], but it has the side-effect of printing out the GPL notice.

### See Also

warranty

## shift ¶

Move the top item from one list to another.

### Example

       [x y z] [a b c] shift
    ---------------------------
          [a x y z] [b c]

### Definition

uncons [swons] dip

### See Also

shunt

### Used By

take

## shunt ¶

Like [concat] but [reverse] the top list into the second.

### Example

       [a b c] [d e f] shunt
    ---------------------------
           [f e d a b c]

### Definition

[swons] step

### Discussion

This is more efficient than [concat] so prefer it if you don't need to preserve order.

### See Also

concat reverse shift

### Used By

reverse

## size ¶

Replace a list with its size.

### Example

       [23 [cats] 4] size
    ------------------------
               3

### Definition

[pop ++] step_zero

### Used By

average

## small ¶

Return `true` if the item on the top of the stack is a list with zero or one item in it, `false` if it is a list with more than one item in it, and an error if it is not a list.

### Definition

empty? [rest null] [pop true] branch

### See Also

null

## spiral_next ¶

Example code.

### Definition

[[[abs] ii <=] [[<>] [pop !-] or] and] [[!-] [[++]] [[--]] ifte dip] [[pop !-] [--] [++] ifte] ifte

### Discussion

See the "Square Spiral Example Joy Code" notebook.

## split_at ¶

Split a list (second on the stack) at the position given by the number on the top of the stack.

### Example

       [1 2 3 4 5 6 7] 4 split_at
    --------------------------------
           [5 6 7] [4 3 2 1]

### Definition

[drop] [take] clop

### Discussion

Take a list and a number `n` from the stack, take `n` items from the top of the list and [shunt] them onto a new list that replaces the number `n` on the top of the stack.

### See Also

split_list

## split_list ¶

Split a list (second on the stack) at the position given by the number on the top of the stack such that [concat] would reconstruct the original list.

       [1 2 3 4 5 6 7] 4 split_list
    ----------------------------------
            [1 2 3 4] [5 6 7]

### Definition

[take reverse] [drop] clop

### Discussion

Compare with [split_at]. This function does extra work to ensure that [concat] would reconstruct the original list.

### See Also

split_at

## sqr ¶

Square the number on the top of the stack.

       n  sqr
    ------------
         n²

### Definition

dup mul

## stack ¶

built-in

Put the stack onto the stack.

          ... c b a stack
    ---------------------------
       ... c b a [a b c ...]

### Discussion

This function forms a pair with [unstack], and together they form the complement to the "destructive" pair [enstacken] and [disenstacken].

### See Also

enstacken disenstacken stackd unstack

### Used By

enstacken grba nullary stackd stuncons

## stackd ¶

Grab the stack under the top item and put it onto the stack.

### Example

       ... 1 2 3 stackd
    ------------------------
      ... 1 2 [2 1 ...] 3

### Definition

[stack] dip

### See Also

stack

## step ¶

combinator

Run a quoted program on each item in a sequence.

       ... [] [Q] step
    ---------------------
             ...

       ... [a] [Q] step
    ----------------------
          ... a Q

       ... [a b c] [Q] . step
    ----------------------------------------
                 ... a . Q [b c] [Q] step

### Definition

[_step0] x

### Discussion

See the Recursion Combinators notebook.

### See Also

step_zero

### Used By

flatten max min product shunt step_zero

## step_zero ¶

combinator

Like [step] but with 0 as the initial value.

       [...] [F] step_zero
    -------------------------
         0 [...] [F] step

### Definition

0 roll> step

### Discussion

[size] and [sum] can both be defined in terms of this specialization of [step].

### See Also

step

### Used By

size sum

## stuncons ¶

Take the [stack] and [uncons] the top item.

### Example

       1 2 3 stuncons
    --------------------
       1 2 3 3 [2 1]

### Definition

stack uncons

## sub ¶

built-in

Subtract the number on the top of the stack from the number below it.

       a b sub
    -------------
        (a-b)

### See Also

add

## succ ¶

Successor. Increment TOS.

### Definition

--

### See Also

pred

## sum ¶

combinator

Given a quoted sequence of numbers return the sum.

### Example

       [1 2 3 4 5] sum
    ---------------------
             15

### Definition

[+] step_zero

### See Also

size

### Used By

average

## swaack ¶

built-in

Swap stack. Take a list from the top of the stack, replace the stack with the list, and put the old stack onto it.

### Example

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

### Discussion

This function works as a kind of "context switch". It's used in the definition of [infra].

### See Also

infra

### Used By

clear disenstacken infra unstack

## swap ¶

built-in

Swap the top two items on the stack.

       a b swap
    --------------
         b a

### See Also

swapd

### Used By

<{} anamorphism app2 cmp ifte neg of over pow product roll< roll> swapd swoncat swons unswons while

## swapd ¶

Swap the second and third items on the stack.

       a b c swapd
    -----------------
          b a c

### Definition

[swap] dip

### See Also

over tuck

### Used By

roll< roll> tuck uncons-two

## swoncat ¶

[concat] two lists, but [swap] the lists first.

### Definition

swap concat

### See Also

concat

### Used By

unstack

## swons ¶

Like [cons] but [swap] the item and list.

       [...] a swons
    -------------------
          [a ...]

### Definition

swap cons

### Used By

anamorphism cmp genrec infra shift shunt

## tailrec ¶

combinator

A specialization of the [genrec] combinator.

### Definition

[i] genrec

### Discussion

Some recursive functions do not need to store additional data or pending actions per-call. These are called "tail recursive" functions. In Joy, they appear as [genrec] definitions that have [i] for the second half of their recursive branch. See the Recursion Combinators notebook.

### See Also

genrec

### Used By

map

## take ¶

Expects an integer `n` and a list on the stack and replace them with a list with just the top `n` items in reverse order.

       [a b c d] 2 take
    ----------------------
            [b a]

### Definition

<<{} [shift] times pop

### Used By

split_at split_list

## ternary ¶

combinator

Run a quoted program using exactly three stack values and leave the first item of the result on the stack.

       ... z y x [P] ternary
    -------------------------
             ... a

### Definition

binary popd

### Discussion

Runs any other quoted function and returns its first result while consuming exactly three items from the stack.

### See Also

binary nullary unary

## third ¶

       [a b c ...] third
    -----------------------
               c

### Definition

rest second

### See Also

first second fourth rest

### Used By

fourth

## times ¶

combinator

Expect a quoted program and an integer `n` on the stack and do the program `n` times.

       ... n [Q] . times
    -----------------------  w/ n <= 0
             ... .

       ... 1 [Q] . times
    -----------------------
             ... . Q

       ... n [Q] . times
    -------------------------------------  w/ n > 1
             ... . Q (n-1) [Q] times

### Definition

[_times0] x

### Discussion

This works by building a little [while] program and running it: 1 3 [++] • [-- dip] cons [swap] infra [0 >] swap while pop 1 3 [++] [-- dip] • cons [swap] infra [0 >] swap while pop 1 3 [[++] -- dip] • [swap] infra [0 >] swap while pop 1 3 [[++] -- dip] [swap] • infra [0 >] swap while pop dip -- [++] • swap [3 1] swaack [0 >] swap while pop dip [++] -- • [3 1] swaack [0 >] swap while pop dip [++] -- [3 1] • swaack [0 >] swap while pop 1 3 [-- [++] dip] • [0 >] swap while pop 1 3 [-- [++] dip] [0 >] • swap while pop 1 3 [0 >] [-- [++] dip] • while pop This is a common pattern in Joy. You accept some parameters from the stack which typically include qouted programs and use them to build another program which does the actual work. This is kind of like macros in Lisp, or preprocessor directives in C.

### Used By

drop getitem grabN lshift pow rshift take

## tuck ¶

[dup] the item on the top of the stack under the second item on the stack.

       a b tuck
    --------------
        b a b

### Definition

dup swapd

### See Also

over

### Used By

gcd

## unary ¶

(Combinator)

Run a quoted program using exactly one stack value and leave the first item of the result on the stack.

       ... x [P] unary
    ---------------------
           ... a

### Definition

nullary popd

### Discussion

Runs any other quoted function and returns its first result while consuming exactly one item from the stack.

### See Also

binary nullary ternary

### Used By

binary

## uncons ¶

Removes an item from a list and leaves it on the stack under the rest of the list. You cannot `uncons` an item from an empty list.

       [a ...] uncons
    --------------------
          a [...]

### Definition

[first] dupdip rest

### Discussion

This is the inverse of [cons].

### See Also

cons

### Used By

first first_two max min rest shift stuncons uncons-two unswons

## uncons-pair ¶

Expect two non-empty lists on the stack and `uncons` the first item from each and put them in a new list.

    joy? [1 2] [3 4] uncons-pair

    [1 3] [2] [4]

### Definition

uncons-two [quote-two] dipd

### Used By

zip

## uncons-two ¶

Expect two non-empty lists on the stack and `uncons` the first item from each.

    joy? [1 2] [3 4] uncons-two

    1 3 [2] [4]

### Definition

[uncons] ii swapd

### Used By

uncons-pair

## unit ¶

       a unit
    ------------
        [a]

### Definition

[] cons

### Used By

quote-two quoted range_to_zero

## unquoted ¶

combinator

Unquote (using [i]) the list that is second on the stack.

### Example

       1 2 [3 4] 5 unquoted
    --------------------------
             1 2 3 4 5

### Definition

[i] dip

### See Also

unit

## unstack ¶

Take a list from the top of the stack and `concat` it to the stack.

    joy? 1 2 3 [4 5 6]

    1 2 3 [4 5 6]

    joy? unstack

    1 2 3 6 5 4

### Definition

[[] swaack] dip swoncat swaack pop

### See Also

stack disenstacken enstacken

## unswons ¶

       [a ...] unswons
    ---------------------
           [...] a

### Definition

uncons swap

## warranty ¶

Print warranty information.

## while ¶

combinator

A specialization of [loop] that accepts a quoted predicate program `P` and runs it [nullary].

       [P] [F] while
    ------------------- P -> false

        [P] [F] while
    --------------------- P -> true
       F [P] [F] while

### Definition

swap nulco dupdipd concat loop

### See Also

loop

### Used By

down_to_zero

## x ¶

combinator

Take a quoted function `F` and run it with itself as the first item on the stack.

       [F] x
    -----------
       [F] F

### Definition

dup i

### Discussion

The simplest recursive pattern. See the Recursion Combinators notebook. as well as Recursion Theory and Joy by Manfred von

### Used By

step times

## zip ¶

Replace the two lists on the top of the stack with a list of the pairs from each list. The smallest list sets the length of the result list.

### Example

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

### Definition

[null] [pop] [uncons-pair] [i cons] genrec