Paradoc Documentation and Built-Ins

Version 0.6

Introduction
Syntax
Semantics
Mnemonics
Stability
Overview
Block Trailers
String Trailers
Int Trailers
Float Trailers
Hoard Trailers
Built-Ins

Introduction

Because there aren't enough golfing languages already™

Paradoc is a golfing language in the stack-based lineage of GolfScript, heavily inspired by it and CJam. Other inspirations include 05AB1E, Jelly, Pyth, and rhoScript.

Like many of these other things, Paradoc is a work in progress. Still, I like to think we have some pretty reasonable documentation.

Some example programs:

Hello, world! (unterminated strings are on the TODO list)

"Hello, world!"

Print squares from 0 to 100, separated by spaces

s¹²m                 .. 4 bytes (if encoded as CP1252)
sA)2pm               .. 6 ASCII characters
_space 11 Square_map .. Expanded version

Print Fibonacci numbers from 0 to 89, separated by spaces:

sZ1A+kx .. 7 bytes / ASCII characters

_space 0 1 10 +_keep_xloop .. Expanded version

Usage

Paradoc is written in Python 3 (and uses mypy (optional static typing) annotations extensively). REPL:

python3 -m paradoc

Run a file:

python3 -m paradoc source_file.prdc

Evaluate a command:

python3 -m paradoc -e "sA)2pm"

Design Philosophy

In decreasing order of importance:

The most important design goal for Paradoc is that programs should be writable in a natural literate style without much effort, even for complicated problems, although the naturally resulting programs may not lend themselves to immediate golfing. This includes both naming, formatting, and structure of logic.

Of course, with its unusual order of operations, stack-based language can only be so natural to write in. The biggest non-negotiable concrete consequence, though, is that Paradoc must have support for long alphabetic identifiers. This is something GolfScript did that, based on what I've seen, most of its descendants and more recent golfing languages have abandoned in favor of optimizing for brevity. While the reduction in short identifier namespace/usability certainly puts Paradoc at a disadvantage for achieving that low golf score, I am OK with that tradeoff in order to make coding directly in Paradoc easier. Even then, I don't think Paradoc has sacrificed very much golfability in its design.

Specifically, Paradoc supports (admittedly somewhat bizarre) Capitalized_snake_case identifiers of arbitrary length. It treats the underscore as a lowercase letter and parses identifiers as one capital letter followed by zero or more lowercase letters. Happily, this frees up the lowercase letter to perform a host of other useful effects on other things.

Another corollary is that Paradoc must have support for legible comments: towards that end, you can start a simple end-of-line comment with .., which is pretty visually clean as end-of-line comment markers go, in my opinion.
The definitions, names, and behavior of built-ins and variables should be simple, predictable, and consistent. When the most obvious mnemonic names are not possible, they should at least be consistent; for example, x and * perform similar operations because they look similar, the letter D ("downward") consistently reverses lists, and variants of A and O refer to maximum and minimum respectively.

A more specific rule is that everything must have a mnemonic. Paradoc will not, for example, use ¾ to do something unrelated to 3, 4, or fractions. Fortunately, mnemonics are not that hard to make.

Another specific concrete consequence: Built-ins should never read an integer constant from the stack in order to select one of several completely dissimilar operations. Compared to the other golfing languages, this is pretty much not an issue at all, since we allow alphabetic identifiers of arbitrary length and are thus in no danger of running out of identifiers.

Consistency internal to Paradoc is slightly more important than simplicity/predictability from an external viewpoint. For example, if there are two namespaces in which we want to define a similar operation, and there's a name with an easy mnemonic available in only one namespace and a name with an awkward mnemonic available in both namespaces, we will prefer to use the awkward name in both namespaces.
When none of the above concerns apply, Paradoc should be similar to pre-existing languages, mostly GolfScript/CJam but also Python (so Ruby/Java-isms may need to be replaced with their Python counterparts). A notable example is that * no longer folds/joins; instead we have R (for "reduce", which is what the corresponding function in Python is called), and allows * on a block and an integer n to behave consistently with * on a block and the half-open range [0..n), a coercion made by many built-ins.
Literate programs should not be totally different modes of the parser/interpreter (contrast rhoScript or "big Pyth"). Literate Paradoc and golfed Paradoc should just be styles of programming used by the programmer that can coexist in one program, and it should be possible to manually translate between them.
Debugging, at least printf-style debugging if not more, should be natural and easy.
Paradoc should be golfable. Obviously this is important (and is the reason for the choice of identifiers), but it should not override the above concerns.
Although Paradoc uses characters from the common Windows-1252 encoding, its golfability (in terms of number of bytes) should degrade gracefully when restricted to being written in UTF-8 or even ASCII.

There also exist a few control codes that we have been replaced with custom characters, although this is still quite unstable.

Differences from GolfScript/CJam

Paradoc parses tokens differently; identifiers begin with either a symbol (excluding the underscore and various other characters taken in the syntax) or an uppercase letter, and are followed by zero or more lowercase letters or underscores.
Like CJam, Paradoc uses single quotes to escape and push the following character, no matter what it is.
Paradoc swaps . and : from GolfScript/CJam, using . for assignment and : for duplicating top of stack. Rationale: I think : is more mnemonic for "duplicate" since there are two dots (Befunge also uses it), and it feels more like an inverse to ;. At the same time, this clears up some corners of the syntax more elegantly. First, it allows us to parse numbers starting with a decimal point like .618, and it allows us to begin end-of-line comments with .., which are a high priority for Paradoc, easy to type, and not visually noisy.
In Paradoc, + on a list and block filters the list by the block, instead of ,. This is to allow symmetry with -, which filters out elements from the list that satisfy the block. , instead filters the lists and returns the indexes of elements that satisfy the block. Further, , on a list zips it with its indices; instead, L computes the length of a list.
In Paradoc, R joins sequences with other sequences and reduces/folds lists by a block, instead of *, which instead repeats a block over a list or the half-open range [0..n), without pushing anything onto the stack, but instead putting each element into the special variable X. This allows * to behave consistently on integers n and half-open ranges [0..n), and for it to perform the more intuitive Cartesian products on sequences.
In Paradoc, @ and # are changed to what I consider more mnemonic operations. @ finds the index of an element or substring in a sequence (so it figures out where the element is at) and # counts the number of occurrences of that element of substring. Exponentiation is relegated to the (non-ASCII character) ˆ or *p, which seems a more reasonable mnemonic anyway (although I thought the audial mnemonic of Pound for # and Power was pretty reasonable) and allows it to also perform list exponentiation in the sense of Cartesian products. There is currently no one-character built-in for the stack-manipulation analogue of @ in GolfScript/CJam.
Most of the alphabetic built-ins are different, of course.

Syntax

End-of-line comments start with two periods .. or two em dashes ——.

A shebang line at the start of a file is also considered an end-of-line comment.
Strings are delimited by double quotes. Inside a string literal, the only special characters are double quotes and backslashes, the latter of which escape double quotes and themselves, and nothing else. (So multiline string literals are totally fine.) Normally, they simply push themselves onto the stack.
Characters consist of a single quote followed by a single character. No characters after the single quote are special.
Numbers consist mostly of ASCII digits. There can be a decimal point, and it can start the numeric literal, but if there is one, there must be at least one digit after it. Scientific notation is supported.

Numeric literals can be preceded by an em dash (—, U+2014) to make them negative. (Alternatively, you can also append an m; more on that later.)
Curly braces delimit code blocks. Code is parsed inside of them, and they nest.
Assignment is performed with the period . or the em dash —, and assigns the value on top of the stack to the following identifier.
Identifiers consist of an "uppercase letter" followed by zero or more "lowercase letters" or underscores.

Paradoc considers most symbols to be uppercase letters, including whitespace. Lowercase letters include the typical ASCII lowercase letters and other lowercase letters in CP1252. Digits and underscores are neither.

The set of special characters that can't appear in identifiers are the period ., the em dash —, the single quote ', the double quote ", all ASCII digits 0123456789, and curly braces {}. All other characters (letters, symbols, whitespace including newlines, control characters) are valid.
A very important syntactic concept is a trailer, which basically refers to sequences of lowercase letters directly following some other token. Trailers modify the behavior of the token they follow. A trailer consists of either a single lowercase letter or an underscore followed by zero or more lowercase letters.

For example, there is a block trailer called _bind or b. You can modify the built-in block + by appending it, to get +b or +_bind, which does something related to +. Trailers can be chained; +bm is + with the trailers b and m.

Note that this means identifiers are actually ambiguous. If you write Dup, how does Paradoc if you mean the identifier Dup, or a built-in called Du with a trailer p, or a built-in called D with two trailers, u and p? The answer is that Paradoc doesn't know this, and simply tries each of these possibilities in turn until it finds an identifier that it has something associated with. Then it applies (or tries to apply) all of the trailers following it.

More precisely, when Paradoc encounters an identifier, it first tries to look up the entire identifier. While this fails, if the identifier has an underscore, it cuts off the part including and after the last underscore, and if not it cuts off the last (lowercase) letter. It treats the part it cut off as a trailer. It repeats this process, cutting off trailers, until it finds an identifier that it can look up. Then it applies all the trailers it cut off in the order they appear in the source (the reverse of the order in which they were cut off).

Not all trailers for all letters exist for all types. If Paradoc finds an identifier but fails to apply the trailers following it, it does not keep examining shorter identifiers.

There are also global trailers, which come right at the start of the program. These haven't been documented yet, sorry.

Semantics

Paradoc is stack-based. It starts with an empty stack and just runs each thing in the code in sequence. Things run on the stack.

The data types are ints, floats, Chars, complex numbers, strings, (heterogeneous) lists, and blocks (executable things). When Paradoc sees an identifier, it modifies it with trailers, if any, and then executes it if it's a block and the final trailer is not reluctant.

Floats are often coerced to ints by truncation. Complex numbers are often coerced to floats by taking the real part (and then possibly to ints by truncation). Support for complex numbers across all built-ins is still in alpha though.

Marks

Paradoc keeps track of marks in the stack, which you can create with [. These are usually placed for ] to be called later and collect elements above the last mark into a list. If a mark is at the top of the stack and an element is popped, it moves down; if elements are pushed after it, it stays below them.

Note that many higher-order functions and the like will execute a block in a protected "shadow" stack that start with a mark in it. Although the shadow stack "bottoms out" into the underlying stack, so trying to pop from the shadow stack when it's empty will pop from the underlying stack instead, the mark will not leave the shadow stack, and its presence or absence won't affect the underlying stack when it's destroyed. This way, something like ]z does the right thing.

There are a few variations of shadow stacks, but these are kind of implementation details.

The X-Stack

A handful of identifiers are specially aliased to the X-stack, a place where the current element/index being operated on is pushed in most loops.

Usually, an element and an index are pushed together, the element on top. As you'd expect, elements higher on the stack are easier to access. X is the top element, Y is the second-to-top (so usually the index), Z is the third; these names are pretty stable. The following elements currently go Xx, Xy, Xz, Yx, Yy, Yz, etc, but they should be considered unstable.

See * for examples.

In addition, the X-stack starts with a few elements on program start to provide single-letter aliases for them, but these should also be considered unstable.

Input

Note that there's no implicit input; however, global trailers can configure an input trigger, the result of which is that when you try to pop from an empty stack, Paradoc will read input and offer it to you as the result of the pop. (Note that you will pop things in the order they're read, which is the opposite order of how lists are usually ordered on the stack!)

You can also explicitly read input with V.

Hoards

Paradoc has flexible mutable data structures, which are called hoards mostly because H was the single unallocated letter when we got to the concept. Hoards start out as empty lists, but depending on how you use them, they will automagically become deques or dictionaries. The primary interface for mutation is through hoard trailers.

Mnemonics

Mostly we pretend Python lists are called Arrays and use the letter A.
D is for Down, which is all sorts of Reversing.
A is for max and O is for min. There are several ways to remember this: obviously "max" has an A in it; you could think lArge and smOl, or Alpha (first, highest ranking, etc.) and Omega (the opposite).
R is for Reduce, which covers the higher-order function called reduce or fold as well as joining strings/lists together with something in between.
S sometimes refers to substrings and slicing.
As in Lisp, many built-ins use the last letter p for predicate, as in a test for some quality that returns true or false, generally represented by 1 and 0, respectively.

Stability

As noted, Paradoc is a work in progress, so although there is autogenerated documentation here for all the built-ins, they are all subject to change. Some of then are more likely to change than others, though, so each one is labeled with a stability. Here are my crude definitions of the stabilities:

Stable means you can almost certainly expect this feature to be in Paradoc pretty much as-is, but we reserve the possibility of adding/changing behavior in cases it previously did not cover, in ways that might technically not be backwards-compatible, or of changing the long expository identifier alias.
Beta means you can probably expect this to be in Paradoc as-is, but should also be prepared for it to be renamed or have its behavior changed. Or, there may be known bugs/design issues/TODOs in its implementation, or it may not have been tested as thoroughly as a stable feature.
Alpha means this is likely to be in Paradoc, but its name or some aspects of its behavior are decidedly not final. It may be replaced with something only spiritually similar.
For unstable features, all bets are off...
Of course, until we hit version 1.0, nothing should be considered absolutely fixed; if I have a good reason I will still change stable built-ins.

The ids of elements on this page should be considered unstable, so permalinks to this page should be considered unstable as well.

Built-in/Trailer Overview

A brief, incomplete categorized list of built-ins and trailers, useful for golf, and related golf tips.

Stack manipulation: There are lots of built-ins. Note that there is no single-character built-in for GolfScript's @, but all permutations of the top three elements of the stack are accessible in one or two characters. In addition, the trailers _a, _d, _k, _q, _u can often reduce or eliminate the need for stack manipulation.
- Popping: ;, ¸
- Duplicating: :, :p or ¦, :a
- Conditional popping (not stable): ;i, ;f, ;n, ;t
- Swapping: \ (and \_u), \a, \o, \i
(Finite-arity) Math: The usual.
- Expressing literals: _h, _k, _m
- Two-operand arithmetic: +, -, ¯, ±, *, /, ÷, %, ‰
  - Also note the deep/vectorizing variants: Á, À, Ó, Ò.
- One-operand arithmetic: (, ), ‹ or <i, =i, › or >i, «, », L, M, U, ×, ½, ¼, ¾, ², ³, Si
  - Also note deep/vectorizing variants: É, È, Í, Ì, Ú.
- Bit operations: &, |, ^, <s, >s, ~
- Comparisons and min/max: <, =, >, <a, =a, >a, <e, >e, <m or Õ, >m or Ã =c or ˜
- Powers, exponentials, and logarithms: ˆ or *p, _p, _r, Ln, Lg, Lt
- Number theory: #, G, Lcm, ¡ or !p, ¿ or Ss, (p, )p, Bc, Et, Fb, Fc, Ff, Js, ¶ or Pp
- Predicates: Â or +p, Ê or Ev, Î, Ô or Od, Û or -p, +o, -o
List operations:
- General construction: [, ], ¬, integer_a, †, ‡, °
- Range construction: ,, D, J, Ð, Tl or ¨, To or …. Note that many built-ins and trailers implicitly convert numbers to the half-open ranges ending at them, which can be taken advantage of with e.g. +_v and +_y. 3 5 +v just gives [3 4 5 6 7].
- Length: L
- Indexing: =, ‹, ›
- Slicing: <, >, « or (s, » or )s, ½, ¼, ¾
- Indexing and slicing: (, )
- Reductions/folds: Of course you can reduce with _r. Common folds include Š, Þ, Œ or <r, Æ or >r
- Recombining lists: +, -, &, |, ^, *
- Fragmenting or rearranging: $, U, /, %, G, W, ™ or Tt
- Predicates: <h, =h, >h, $p, <p, =p, >p
- "Destructuring" onto the stack: ~
Logic:
- !, ?, &, |, &p, |p.
- Any whitespace character is the identity function. A nonobvious application of this is that you can apply trailers to it: so, for example, to filter truthy elements in a list, SPACE_f works.
- If you need to convert a nonnegative integer to a "boolean" (0 or 1) for some other purpose (e.g. to sum, or to execute something 0 or 1 times), you can use U or Â.
- If you need to convert a list to a "boolean", you may be able to use Ê.
Strings:
- Operations: Uc, Lc, Xc, Tc, Up, Lp, Ap
- Constants: Ua, La, Aa, Da
- Formatting/string interpolation: S, _i, _f
Higher-order functions:
- Argument, stack, reluctance fiddling: _, _a, _b, _d, _k, _q, _u
- Operations on sequences:
  - Each: *, /, _e, _x. Note that this is often also "reduce with initial value".
  - Map: %, _m, _o, _w. Note that all elements on the shadow stack are collected into the list, so you can use this to flatmap. Most simply, ~_m flattens a sequence of sequences once.
  - Filter: +, -, ,, J, _f
  - Reduce: R, _r
  - Zip: ‰, _z, _ž
  - Vectorize (bind + map): _v, _y
  - Find: =, ^, _g (?)
  - Take/drop: <, >
  While looping, the X-stack (X, Y, Z etc.) is very useful.
Input and output: If a global trailer is set, input from the stack is implicit like GolfScript, but you can also explicitly read input with V. For output you can use O and P or string trailers _o and _p.
Hoards:
- To read data, = indexes or accesses hoards. Many built-ins will convert hoards to lists (e.g. you can _map or _each a hoard, take its Array_min or Array_max...).
- H and • are two built-in empty hoards. If you need more somehow in convenient variables, Ah, Bh, Ch, and Dh can produce them cheaply.
- To create a dictionary hoard: Dc.
- To mutate as a deque: _a, _b, _p, _q.
- You can update lists and deques at an index with _u. Note that the hoard automatically becomes a dictionary if the index is out of bounds, so that we can make empty lists automatically become dictionaries if used as such.
- To mutate as a dictionary: _u, _d. In special cases _m can be quite useful.
- To access safely as a dictionary: _g, _h, _z.
- To use as a set: probably _o to add things, _d to delete things, and _z to check things.

Right now, pop the top element of this stack; before each time this block is to be executed, push it. Makes the result reluctant.

`_bindmap`

Stability: beta

Aliases: _vectorize, _v

Pop the top element of the stack. Then, apply this block to each element of the next element of the stack (coerces numbers to ranges), pushing that top element before each application; collect the results into a new list.

Basically a _bind followed by a _map; you can imagine it as vectorizing an operator if the top element of the stack is a scalar and the one beneath it is a sequence, hence the single-letter name. But, for the purposes of attaching further trailers, note that it isn't as eager as bind in popping the top element immediately.

[1 2 3] 100+v => [101 102 103]

Below is an example where +bm would not work, as the bind would already have bound the [100 200] rather than only bind anything inside the zip.

[[1 2][3 4]] [100 200] +vz => [[101 102][203 204]]

`_boundary`

Stability: unstable

Aliases: _ß

Run this block, but catch any exception and push its Python traceback, or an empty list if nothing happens. Does not catch breaks, continues, or KeyboardInterrupts (?) (but does catch exits).

`_count`

Stability: alpha

Aliases: _ç

Apply this block to each element of a list (coerces numbers to ranges); push the number of truthy results.

`_countdistinct`

Stability: unstable

Aliases: _ð

Apply this block to each element of a list (coerces numbers to ranges); push the number of distinct elements that gave truthy results.

`_countnot`

Stability: unstable

Aliases: _ñ, _ƒ

Apply this block to each element of a list (coerces numbers to ranges); push the number of falsy results.

`_d`

Stability: beta

Aliases: _double

Apply this block in a bracketed shadow, then apply it again on what's underneath. In essence, applies this block to two disjoint sets of arguments on the stack.

1 8 )d => 2 9
1 2 8 9 +d => 3 17

`_deepmap`

Stability: alpha

Aliases: _walk, _w

Apply this block to each element of a possibly multi-level list (coerces numbers to ranges), as deeply as possible; collect the results into a new list with the same shape. Mnemonic: walk, as in traversing the entire structure; or upside-down "deeper" m.

`_double`

Stability: beta

Aliases: _d

Apply this block in a bracketed shadow, then apply it again on what's underneath. In essence, applies this block to two disjoint sets of arguments on the stack.

1 8 )d => 2 9
1 2 8 9 +d => 3 17

`_fold`

Stability: beta

Aliases: _reduce, _r

Combine all elements in a list into one by repeatedly applying a binary block (coerces numbers to 1-indexed ranges), and push the final element.

[10 20 30] +r => 60

Compare _keepunder.

10 Uk => 10 1
5 6 +k => 5 6 11

`_keep`

Stability: stable

Aliases: _k

Execute this block in a preservation-shadow, so that any elements it pops aren't actually popped from the stack (so, "keep" those elements around).

Compare _keepunder.

10 Uk => 10 1
5 6 +k => 5 6 11

`_keepunder`

Stability: stable

Aliases: _q

Execute this block in a preservation-shadow, so that any elements it pops aren't actually popped from the stack. Then push its results underneath elements it thinks were popped.

Compare _keep.

Mnemonic: "q" and "k" are phonetically similar and "q" is usually followed by a "u".

10 Uq => 1 10
5 6 +q => 11 5 6

`_l`

Stability: unstable

Aliases: _last

Find the last index of the list where this block gives a truthy result (coerces numbers to ranges).

`_last`

Stability: unstable

Aliases: _l

Find the last index of the list where this block gives a truthy result (coerces numbers to ranges).

`_loop`

Stability: alpha

Loop this block forever (until an error is thrown).

`_loopzip`

Stability: alpha

Aliases: _ö

Execute this block once for each corresponding pair of elements from two lists (coerces numbers to ranges). Both elements are pushed onto the stack. Collect the results into a list, which has the same length as the longer of the arguments; if one list is shorter, that list's elements are cycled until it is the same length as the longer list.

`_m`

Stability: stable

Aliases: _map

Apply this block to each element of a list (coerces numbers to ranges); collect the results into a new list.

`_map`

Stability: stable

Aliases: _m

Apply this block to each element of a list (coerces numbers to ranges); collect the results into a new list.

`_mapbind`

Stability: beta

Stability: stable

Aliases: _keepunder

Execute this block in a preservation-shadow, so that any elements it pops aren't actually popped from the stack. Then push its results underneath elements it thinks were popped.

Compare _keep.

Mnemonic: "q" and "k" are phonetically similar and "q" is usually followed by a "u".

10 Uq => 1 10
5 6 +q => 11 5 6

`_r`

Stability: beta

Aliases: _reduce, _fold

Combine all elements in a list into one by repeatedly applying a binary block (coerces numbers to 1-indexed ranges), and push the final element.

[10 20 30] +r => 60

`_reduce`

Stability: beta

Aliases: _fold, _r

Combine all elements in a list into one by repeatedly applying a binary block (coerces numbers to 1-indexed ranges), and push the final element.

[10 20 30] +r => 60

`_reject`

Stability: unstable

Aliases: _j

Apply this block to each element of a list (coerces numbers to ranges) and filter elements for which the block gives a falsy result.

`_reluctant`

Stability: stable

Aliases: _

Make this block reluctant: push it instead of executing it.

`_s`

Stability: alpha

Aliases: _scan

Combine all elements in a list into one by repeatedly applying a binary block (coerces numbers to 1-indexed ranges), and push the list of all intermediate results.

[10 20 30] +s => [10 30 60]
[10 20 30] -s => [10 -10 -40]
[10 20 30] -as => [10 10 20]

`_scan`

Stability: alpha

Aliases: _s

Combine all elements in a list into one by repeatedly applying a binary block (coerces numbers to 1-indexed ranges), and push the list of all intermediate results.

[10 20 30] +s => [10 30 60]
[10 20 30] -s => [10 -10 -40]
[10 20 30] -as => [10 10 20]

`_select`

Stability: stable

Aliases: _filter, _f

Apply this block to each element of a list (coerces numbers to ranges) and filter elements for which the block gives a truthy result.

`_sum`

Stability: alpha

Aliases: _mapsum, _š

Apply this block to each element of a list (coerces numbers to ranges); deeply sum the results.

`_u`

Stability: stable

Aliases: _under

Execute this block underneath the top element. That is, before executing this block, pop the top element, and after executing it, push it back.

5 10 Uu => 1 10
1 5 9 +u => 6 9

`_under`

Stability: stable

Aliases: _u

Execute this block underneath the top element. That is, before executing this block, pop the top element, and after executing it, push it back.

5 10 Uu => 1 10
1 5 9 +u => 6 9

`_unemap`

Stability: unstable

Aliases: _ü

Apply this block to each element and index of a list (coerces numbers to ranges); collect the results into a new list.

`_v`

Stability: beta

Aliases: _vectorize, _bindmap

[1 2 3] 100+v => [101 102 103]

Below is an example where +bm would not work, as the bind would already have bound the [100 200] rather than only bind anything inside the zip.

[[1 2][3 4]] [100 200] +vz => [[101 102][203 204]]

`_vectorize`

Stability: beta

Aliases: _bindmap, _v

[1 2 3] 100+v => [101 102 103]

Below is an example where +bm would not work, as the bind would already have bound the [100 200] rather than only bind anything inside the zip.

[[1 2][3 4]] [100 200] +vz => [[101 102][203 204]]

`_w`

Stability: alpha

Aliases: _deepmap, _walk

Stability: unstable

Aliases: _countnot, _ƒ

Apply this block to each element of a list (coerces numbers to ranges); push the number of falsy results.

`_ô`

Stability: alpha

Aliases: _none

Apply this block to each element of a list (coerces numbers to ranges); push whether all results are falsy.

`_`

Stability: alpha

Aliases: _reluctant

Convert to a reluctant block that pushes this string.

Stability: unstable

Stability: unstable

Get list of keys

`_l`

Stability: alpha

Aliases: _list

To list

`_list`

Stability: alpha

Aliases: _l

To list

`_m`

Stability: unstable

Aliases: _modify

Modify at an index or key: change the value at that index or key to the result of running that value through incrementing an integer or running a block. If no value existed there previously, 0 is assumed. (In the future we may handle other types of values differently.)

`^@`

Stability: unstable

`^A`

Stability: unstable

Integer constant with value 1

`TAB`

Stability: stable

Aliases: Nop, SPACE, NEWLINE, RETURN

Do nothing.

`NEWLINE`

Stability: stable

Aliases: Nop, SPACE, TAB, RETURN

Do nothing.

`NEWLINEb`

Stability: alpha

Aliases: Line_split, Lines, Line_break, \nb

Split by a single newline.

`NEWLINEm`

Stability: alpha

Aliases: Map_on_lines, \nm

Map on lines: takes a block and a string, split the string into lines, map the block over the tokens, then join the tokens with a linebreak.

`NEWLINEo`

Stability: beta

Aliases: Newline_output, \no

Output a newline.

`NEWLINEp`

Stability: beta

Aliases: Newline_print, \np

Output a newline, followed by an output record separator.

`NEWLINEr`

Stability: beta

Aliases: Line_join, \nr

Join with newlines

`NEWLINEx`

Aliases: Rectangularize_with_space

Rectangularize a matrix with spaces: append the space character as necessary to rows until the matrix is rectangular. Mnemonic: Q for Quadrangle.

`SPACEr`

Stability: beta

Aliases: Space_join

`SPACEt`

Stability: alpha

Aliases: Transpose_fill_with_space

Transpose a matrix, or list of lists (or of strings), adding the space character as necessary until the matrix is rectangular.

`SPACEx`

Stability: alpha

Aliases: Space_repeat

`!`

Stability: stable

Logical Not: 0 and empty lists/strings yield 1, everything else yields 0. Or postcompose a logical NOT onto a block (not recursively though).

`!j`

Stability: unstable

Aliases: Not_imaginary

Test if the imaginary part is zero. Deeply vectorizes.

Stability: beta

Aliases: Is_sorted

Test if sorted

`%`

Stability: stable

Aliases: Mod_or_slice_mod_or_split_nonempty_or_map

Modulus on numbers. On a sequence and number, slice elements at indices equal to 0 mod the number, just like Python s[::n] (negative numbers reverse the sequence). On two sequences, split the first sequence around occurrences of the second sequence, discarding empty tokens. Map on blocks and sequences (numbers coerce to ranges).

"tweedledee""e"% => ["tw" "dl" "d"]

Stability: unstable

Aliases: King_neighbors

Return a list of almost-copies of the object, every variant obtainable by modifying each deep element by -1, 0, or 1, except for the original object itself.

`*p`

Stability: beta

Aliases: Power, ˆ

On numbers, power/exponentiate. On a list and a number, exponentiate the list by making a list of all lists of that length composed of elements from the original list (possibly repeating).

`*w`

Stability: alpha

Aliases: Product, Þ

(Deep) product (coerces numbers to range!?).

`+`

Stability: stable

Aliases: Plus_or_filter_or_compose, Plus_or_filter

Addition on numbers. Concatenation on lists and strings (numbers coerce to single-element lists or to strings). Filter on block and list (numbers coerce to ranges). Compose on blocks.

`+i`

Stability: alpha

Aliases: Plus_ints

Add two things after coercing both to integers.

`+j`

Stability: alpha

First number plus second number times the imaginary unit.

`+l`

Stability: unstable

Aliases: Plus_lengths

Add two things after coercing both to ints or floats, sequences by taking their length.

`+n`

Stability: unstable

Aliases: Orthogonal_neighbors

Return a list of almost-copies of the object, two per deep element, one with that deep element decreased by 1 and one with it increased by 1.

`+o`

Stability: alpha

Aliases: Positive_or_zero

`+p`

Stability: beta

Aliases: Positive

`+w`

Stability: beta

Aliases: Sum, Š

(Deep) sum (coerces numbers to range).

`,`

Stability: beta

Aliases: Range_enumerate_or_filter_indices

Range on numbers. Enumerate (zip with indices from 0) on sequences. On block and sequence, list indices at which block is true.

Compare Range_enumerate_one_or_reject_indices.

`-`

Stability: stable

Aliases: Minus_or_reject

Golf as: -

Subtraction on numbers. Filter-not-in on lists and strings (numbers coerce to single-element lists). Filter-not on block and list (numbers coerce to ranges). See also Antiminus.

`-c`

Stability: unstable

Aliases: Clamped_subtract

Subtraction clamped to zero, or saturating subtraction: the maximum of the subtraction or 0.

`-i`

Stability: unstable

Aliases: Minus_ints

Subtract two things after coercing both to integers.

`-j`

Stability: alpha

First number minus second number times the imaginary unit.

`-l`

Stability: unstable

Aliases: Minus_lengths

Subtract two things after coercing both to ints or floats, sequences by taking their length.

`-o`

Stability: alpha

Aliases: Negative_or_zero

`-p`

Stability: beta

Aliases: Negative

`/`

Stability: stable

Aliases: Div_or_split_or_each

Float division on numbers. On a sequence and number, split the sequence into chunks of size equal to the number, including leftovers if any. On two sequences, split the first sequence around occurrences of the second sequence. For-each on blocks and sequences (numbers coerce to ranges).

`/j`

Stability: alpha

Divide by the imaginary unit; equivalently, multiply by -1j. Deeply vectorizes.

`:`

Stability: stable

Aliases: Dup

Duplicate the top element of the stack.

1 2 3 : => 1 2 3 3

`:o`

Stability: alpha

Aliases: Dup_out

Duplicate the second element of the stack onto the top: a b -> a b a

1 2 3 :o => 1 2 3 2

`:p`

Stability: beta

Aliases: Dup_pair, ¦

Duplicate the top two elements of the stack: a b -> a b a b

1 2 3 :p => 1 2 3 2 3

`:s`

Stability: alpha

Aliases: Is_string

Test if string

`;`

Stability: stable

Aliases: Pop

Pop the top element of the stack.

1 2 3; => 1 2

`;a`

Stability: unstable

Aliases: Pop_around

Pop the first and third from the top elements of the stack, named to be somewhat analogous to \a.

1 2 3;a => 2

`;f`

Stability: alpha

Aliases: Pop_if_false

Look at the top element of the stack. Pop it if it's falsy.

`;i`

Stability: alpha

Aliases: Pop_if

Pop the top element of the stack. Pop the second element if the first element was truthy.

`;j`

Stability: unstable

Aliases: Imaginary_part

Imaginary part. Deeply vectorizes because why not. Mnemonic: deletes part of the complex number like ;. Keeps the imaginary part rather than deleting it because direct conversion to float, F, already computes the real part.

`;n`

Stability: alpha

Aliases: Pop_if_not

Pop the top element of the stack. Pop the second element if the first element was falsy.

`;o`

Stability: unstable

Aliases: Pop_out

Pop the third from the top element of the stack, named to be somewhat analogous to \o.

1 2 3;o => 2 3

`;p`

Stability: unstable

Aliases: Pop_second_pair

Pop the second and third from the top elements of the stack. Not the first and second because that's ;_d.

1 2 3;p => 3

`>h`

Stability: unstable

Aliases: Has_suffix

Test if the first argument has a suffix equal to the second argument (numbers coerce to single-element lists; if at least one argument is a string, both coerce to strings).

`>i`

`?`

Stability: beta

Aliases: If_else

If-else.

1 "True!" "False" ? => "True!"

Golf as: Â

`All`

Stability: beta

Aliases: Al

Golf as: Â

Stability: alpha

Aliases: <rs, Œs

Minima of array, optionally by a block (numbers will coerce to ranges if you supply a block).

`As`

Stability: beta

Aliases: Asin

`Asin`

Stability: beta

Aliases: As

`Assign_bullet`

Stability: alpha

Aliases: ·

Assign to the variable •

`Assign_bullet_destructive`

Stability: alpha

Aliases: –

Pop and assign to the variable •

`At`

Stability: beta

Aliases: Atan

Stability: beta

Aliases: Binomial_coefficient

Golf as: Ç

Stability: unstable

Aliases: Cat_between

two copies of a with b between: a, b -> a + b + a. Numbers coerce to single-element lists.

`Cc`

Stability: alpha

Aliases: Csc

`Ceiling`

Stability: beta

Aliases: >i

Golf as: ›

Round up to the nearest integer.

`Ceiling_or_last`

Stability: beta

Aliases: ›

Ceiling or Last of sequence or Modify_last

`Center_fill_with_spaces`

Stability: unstable

Aliases: =f

Given a value and a length, convert the value to a string if necessary and pad it with equally many spaces on either side until at least the length.

`Cf`

Stability: unstable

Aliases: Cat_flank

a with two copies of b flanking: a, b -> b + a + b. Numbers coerce to single-element lists.

`Ch`

Stability: alpha

Hoardify the C variable: delete all variables starting with C and set C to a new empty hoard.

`Clamped_subtract`

Stability: unstable

Aliases: -c

Subtraction clamped to zero, or saturating subtraction: the maximum of the subtraction or 0.

`Co`

Stability: alpha

Aliases: Compare, ˜

Compare (-1, 0, or 1)

`Compare`

Stability: alpha

Aliases: Co, ˜

Compare (-1, 0, or 1)

`Compl_or_eval_or_expand`

Stability: beta

Aliases: ~

Bitwise complement of integers. Expand lists or strings onto the stack, pushing each element separately in order. Eval on a block.

Stability: beta

Aliases: Cs

`Cot`

Stability: alpha

Aliases: Ct

`Count_maybe_factors`

Stability: beta

Aliases: #

Count factor multiplicity, frequency, or number satisfying predicate. Mnemonic: number sign, as in you're counting the number of something

`Count_pairs`

Stability: alpha

Aliases: #p

Given a sequence, return a list of pairs, each pair with a distinct element and the number of times it appears in the sequence.

`Cs`

Stability: beta

Aliases: Cos

`Csc`

Stability: alpha

Aliases: Cc

Stability: unstable

Aliases: Dl

Deep length.

`Dh`

Stability: alpha

Hoardify the D variable: delete all variables starting with D and set D to a new empty hoard.

`Dictionary`

Stability: unstable

Aliases: Dc

Convert to new dictionary hoard.

`Digit_sum`

Stability: alpha

Aliases: Dr

Digit sum of integers. Deeply vectorizes. Mnemonic: r for reduce as always, since this is a reduction over the digits, and probably the most natural one.

Stability: beta

Aliases: ×

`Down`

Stability: beta

Aliases: Reverse

Golf as: D

Reverse a sequence (coerces numbers to range).

`Down_or_doloop`

Stability: beta

Aliases: Reverse_or_doloop, D

On a number of a sequence, Reverse; on a block, Doloop.

`Down_stack`

Stability: beta

Aliases: Reverse_stack, Ds

`Dp`

Stability: alpha

Aliases: Is_digit

Tests if characters are digits. Deeply vectorizes.

`Dr`

Stability: alpha

Aliases: Digit_sum

Digit sum of integers. Deeply vectorizes. Mnemonic: r for reduce as always, since this is a reduction over the digits, and probably the most natural one.

`Ds`

Stability: beta

Aliases: Reverse_stack, Down_stack

`Dump`

Stability: alpha

Aliases: Pdebug

Print debugging information about the environment and stack.

`Dup`

Stability: stable

Aliases: :

Duplicate the top element of the stack.

1 2 3 : => 1 2 3 3

`Dup_out`

Stability: alpha

Aliases: :o

Duplicate the second element of the stack onto the top: a b -> a b a

1 2 3 :o => 1 2 3 2

`Dup_pair`

Stability: beta

Aliases: :p, ¦

Duplicate the top two elements of the stack: a b -> a b a b

1 2 3 :p => 1 2 3 2 3

`E`

Stability: beta

Aliases: Exit

Exit the current program.

`Eb`

Stability: alpha

Aliases: Epoch_minute

Get the minute from a timestamp

`Ec`

Stability: beta

Aliases: Exit_with_code

Exit the current program with the specified exit code or message.

`Ed`

Stability: alpha

Aliases: Epoch_day

Get the day from a timestamp

Stability: beta

Aliases: =

`Equals_one_or_identical`

Stability: beta

Aliases: Î

Identity (equals 1) or Identical

`Er`

Stability: unstable

Aliases: Range_evens_exclusive

Range, evens, from 0, exclusive

`Es`

Stability: alpha

Aliases: Epoch_second

Get the second from a timestamp

`Et`

Stability: alpha

Stability: alpha

Aliases: Epoch_weekday

Get the weekday (Monday is 0, Sunday is 6) from a timestamp

`Exchange_case`

Stability: alpha

Aliases: Xc

Swaps the case of all characters. Deeply vectorizes.

`Exclusive_or_or_symmetric_difference_or_find_last`

Stability: beta

Aliases: ^

Binary XOR on numbers. Symmetric difference on sequences. Find last on block and sequence.

`Exclusive_range`

Stability: beta

Aliases: Tl

Stability: beta

Golf as: ¡

`Factorize`

Stability: alpha

Aliases: Fc

Factorize as a list of pairs of primes and exponents

`Factorize_flat`

Stability: alpha

Aliases: Ff

Factorize as a flat list of possibly repeating prime factors

`Fb`

Stability: beta

Aliases: Fibonacci

`Fc`

Stability: alpha

Aliases: Factorize

Factorize as a list of pairs of primes and exponents

`Ff`

Stability: alpha

Aliases: Factorize_flat

Factorize as a flat list of possibly repeating prime factors

`Fg`

Stability: alpha

Aliases: Float_groups

Finds float-looking parts of a string and converts them to floats.

`Fibonacci`

Stability: beta

Aliases: Fb

`Filter`

Stability: stable

Golf as: +

Filter a list by a block (numbers coerce to ranges).

`Filter_indexes`

Stability: beta

Golf as: ,

List indices at which block is true. Short: ,

`Filter_not`

Stability: stable

Aliases: Reject

Golf as: -

Filter-not a list by a block (numbers coerce to ranges).

`Filter_not_in`

Stability: stable

Aliases: Reject_in

Golf as: -

Filter-not-in on lists and strings (numbers coerce to single-element lists).

`Find_index`

Stability: beta

Aliases: @

Inside a sequence (numbers coerce to ranges), find the first index of an element, a substring, or something satisfying a block. Mnemonic: finds where the element is AT.

`First`

Stability: stable

Golf as: ‹

First of sequence

`First_and_last`

Stability: alpha

First and last of sequence

`First_duplicate`

Stability: unstable

Aliases: =g

Find the first element that appears a second time in a sequence.

`Fixed_point`

Stability: alpha

Golf as: F

Iterate a block, peeking at the stack between iterations, until a value repeats. Pushes that value. (This is more general than a "fixed point" as usually defined since it doesn't require a value to repeat after just one iteration.)

`Fl`

Stability: beta

Aliases: Flatten

`Flatten`

Stability: beta

Aliases: Fl

`Flatten_once`

Stability: beta

Aliases: Fo

`Float_groups`

Stability: alpha

Aliases: Fg

Finds float-looking parts of a string and converts them to floats.

`Floor`

Stability: beta

Aliases: <i

Golf as: ‹

Round down to the nearest integer.

`Floor_or_first`

Stability: beta

Aliases: ‹

Floor or First of sequence or Modify_first

`Fo`

Stability: beta

Aliases: Flatten_once

Stability: alpha

Aliases: Force_stack

`G`

Stability: beta

Aliases: Group_maybe_by

GCD; group like elements of a sequence, possibly under a mapping.

`Gcd`

Stability: beta

`Geq_length`

Stability: unstable

Aliases: >el

Greater than or equal to, after coercing two arguments to ints or floats, sequences by taking their length.

`Geq_or_slice`

Stability: beta

Aliases: >e

Greater than or equal to.

`Group`

Stability: beta

Golf as: G

Group into runs of equal elements.

[3 1 2 2 1 1 1]G => [[3][1][2 2][1 1 1]]

`Group_by`

Stability: beta

Golf as: G

Group into runs of equal elements according to the block

`Group_maybe_by`

Stability: beta

Aliases: G

GCD; group like elements of a sequence, possibly under a mapping.

`Gt_approx`

Stability: alpha

Aliases: >a

Approximately greater than; tolerance is given by Ep, epsilon

`Gt_length`

Stability: unstable

Aliases: >l

Greater than, after coercing two arguments to ints or floats, sequences by taking their length.

`Gt_or_slice`

Stability: beta

Aliases: >

`H`

Stability: alpha

An empty Hoard

`Halve`

Stability: alpha

Aliases: ½

`Halve_int`

Stability: unstable

Aliases: Hi

`Has_infix`

Stability: unstable

Aliases: =h

Test if the first argument has a substring equal to the second argument (numbers coerce to single-element lists; if at least one argument is a string, both coerce to strings).

`Has_prefix`

Stability: unstable

Aliases: <h

Test if the first argument has a prefix equal to the second argument (numbers coerce to single-element lists; if at least one argument is a string, both coerce to strings).

`Has_suffix`

Stability: unstable

Aliases: >h

Test if the first argument has a suffix equal to the second argument (numbers coerce to single-element lists; if at least one argument is a string, both coerce to strings).

`Hex_string`

Stability: beta

Aliases: Hs

Converts numbers to their hexadecimal representation as a string. Deeply vectorizes.

Single-branch if.

`If_else`

Stability: beta

Aliases: ?

If-else.

1 "True!" "False" ? => "True!"

`Ig`

Stability: alpha

Aliases: Int_groups

Finds integer-looking parts of a string and converts them to integers.

`Incr_two`

Stability: beta

Golf as: »

Increase by 2.

`Incr_two_or_but_first`

Stability: beta

Aliases: »

Increase by two, or all but first (tail)

`Index_cyclically`

Stability: unstable

Aliases: =c

Index into a list cyclically, by taking the index mod the length of the list.

`Index_translate`

Stability: unstable

Aliases: It

Translate the first argument by indexing into the second.

`Int_groups`

Stability: alpha

Aliases: Ig

Finds integer-looking parts of a string and converts them to integers.

`Int_of_alpha`

Stability: unstable

Aliases: Ia

Convert a letter to an integer starting with A = 1; non-letters (or letters outside the Latin alphabet) give 0. Deeply vectorizes.

`Int_sqrt`

Stability: alpha

Aliases: Si

Integer square root.

`Intdiv_or_split_discard`

Stability: beta

Aliases: ÷

Integer division on numbers. On a sequence and number, split the sequence into chunks of size equal to the number, discarding leftovers.

[1 2 3 4]2/ => [[1 2][3 4]]
[1 2 3 4 5]2/ => [[1 2][3 4]]

`Iterate`

Stability: unstable

Golf as: I

Iterate a block, peeking at the stack between iterations, until a value repeats. Pushes all values peeked until (excluding) the repeated value.

`J`

Stability: beta

Stability: beta

Aliases: Lowercase

Converts all characters to lowercase. Deeply vectorizes.

Stability: beta

Aliases: Ls

`Leq_length`

Stability: unstable

Aliases: <el

Less than or equal to, after coercing two arguments to ints or floats, sequences by taking their length.

`Leq_or_slice`

Stability: beta

Aliases: <e

Less than or equal to.

Stability: alpha

Aliases: Log_ten

`Lt_approx`

Stability: alpha

Aliases: <a

Approximately less than; tolerance is given by Ep, epsilon

`Lt_length`

Stability: unstable

Aliases: <l

Less than, after coercing two arguments to ints or floats, sequences by taking their length.

Stability: unstable

Aliases: Ó

Multiplication on numbers; deeply vectorizes.

`N`

Stability: stable

Output record separator

String constant with value '\n'

Stability: unstable

Aliases: |j

Negate the real part. Deeply vectorizes. Mnemonic: reflect this across the vertical y-axis on the complex plane. (Really really unstable.)

`Negative`

Stability: beta

Aliases: -p

`Negative_biased_balanced_mod`

Stability: unstable

Aliases: %û

Balanced mod: on a and b, returns the number that's equal to a mod b and as close to 0 as possible, preferring -|b|/2 over |b|/2.

`Negative_or_zero`

Stability: alpha

Aliases: -o

`Nest_of_character`

Stability: alpha

Aliases: Nc

Finds the amount by which a character affects "nestedness": ([{< give +1, >}]) give -1, everything else gives 0. Deeply vectorizes.

`Newline_output`

Stability: beta

Aliases: NEWLINEo, \no

Output a newline.

`Newline_print`

Stability: beta

Aliases: NEWLINEp, \np

Output a newline, followed by an output record separator.

Stability: stable

Aliases: SPACE, TAB, NEWLINE, RETURN

Do nothing.

`Not`

Stability: stable

Golf as: !

Logical NOT: 0 and empty lists/strings yield 1, everything else yields 0.

0! => 1
1! => 0
2! => 0
[]! => 1
[0]! => 0

Stability: alpha

Aliases: Ns

Get the current second

`Now_time`

Stability: alpha

Aliases: Nt

`Now_twelve_hour`

Stability: alpha

Aliases: Ni

Get the current hour, as a number from 1 to 12

`Now_weekday`

Stability: alpha

Aliases: Nw

Get the current weekday (Monday is 0, Sunday is 6)

`Now_year`

Stability: alpha

Aliases: Ny

Get the current year

`Ns`

Stability: alpha

Aliases: Now_second

Get the current second

`Nt`

Stability: alpha

Aliases: Now_time

`Nu`

Stability: alpha

Aliases: Now_iso_weekday

Get the current ISO weekday (Monday is 1, Sunday is 7)

`Nw`

Stability: alpha

Aliases: Now_weekday

Get the current weekday (Monday is 0, Sunday is 6)

`Ny`

Stability: alpha

Aliases: Now_year

Get the current year

`O`

Stability: beta

Aliases: Output

Output to standard output.

`Od`

Stability: alpha

Aliases: Odd

`Odd`

Stability: alpha

Aliases: Od

`Odd_or_not_any`

Stability: beta

Aliases: Ô

Odd or Not_any

`One_time_translate`

Stability: alpha

Aliases: Ot

Translate the first argument using a mapping obtained by zipping the second and third, repeating the last element of the third as necessary. Each entry in the mapping is used at most once, in the order they appear.

`Or`

Stability: unstable

Aliases: Range_odds_exclusive

Range, odds, from 1, exclusive

`Order_statistic`

Stability: alpha

Aliases: ¢

Order statistic (zero-indexed)

`Organize`

Stability: alpha

Golf as: Ø

Group into lists of equal elements; like Group, but the equal elements don't need to be consecutive. The lists come in the same order that their elements' first appearances did in the original list.

[3 1 2 2 1 1 1]Organize => [[3][1 1 1 1][2 2]]

`Organize_or_totient`

Stability: alpha

Aliases: Ø

On numbers, Euler's Totient function (does not vectorize). On sequences or blocks with sequences, Organize.

`Orthogonal_neighbors`

Stability: unstable

Aliases: +n

Return a list of almost-copies of the object, two per deep element, one with that deep element decreased by 1 and one with it increased by 1.

`Os`

Stability: beta

Aliases: Output_stack

`Pack_down`

Stability: stable

Aliases: ¬, Pack_reverse

Pack the elements above the last stack mark into a list in reverse order.

[1 2 3¬ => [3 2 1]

`Pack_reverse`

Stability: stable

Aliases: ¬, Pack_down

Pack the elements above the last stack mark into a list in reverse order.

[1 2 3¬ => [3 2 1]

`Palindromize`

Stability: alpha

Aliases: Pz

Concatenate a with the tail of its reverse.

`Pd`

Stability: alpha

Aliases: Eval

Evaluate a string as Paradoc code

`Pdebug`

Stability: alpha

Aliases: Dump

Print debugging information about the environment and stack.

`Peekdo`

Stability: beta

Golf as: D

Like Doloop except the condition is peeked instead of popped.

`Permutations`

Stability: beta

Golf as: ¡

`Permutations_or_factorial`

Stability: beta

Aliases: ¡, !p

`Ph`

Stability: alpha

Golden ratio

Float constant with value 1.618033988749895

`Phi`

Stability: alpha

Float constant with value 1.618033988749895

Stability: stable

Aliases: ;

Pop the top element of the stack.

1 2 3; => 1 2

`Pop_around`

Stability: unstable

Aliases: ;a

Pop the first and third from the top elements of the stack, named to be somewhat analogous to \a.

1 2 3;a => 2

`Pop_if`

Stability: alpha

Aliases: ;i

Pop the top element of the stack. Pop the second element if the first element was truthy.

`Pop_if_false`

Stability: alpha

Aliases: ;f

Look at the top element of the stack. Pop it if it's falsy.

`Pop_if_not`

Stability: alpha

Aliases: ;n

Pop the top element of the stack. Pop the second element if the first element was falsy.

`Pop_if_true`

Stability: alpha

Aliases: ;t

Look at the top element of the stack. Pop it if it's truthy.

`Pop_out`

Stability: unstable

Aliases: ;o

Pop the third from the top element of the stack, named to be somewhat analogous to \o.

1 2 3;o => 2 3

`Pop_second_pair`

Stability: unstable

Aliases: ;p

Pop the second and third from the top elements of the stack. Not the first and second because that's ;_d.

1 2 3;p => 3

`Pop_stack`

Stability: beta

Aliases: ;s

`Pop_under`

Stability: beta

Aliases: ¸

Pop the second from the top element of the stack.

1 2 3¸ => 1 3

`Prev_prime`

Stability: alpha

Aliases: (p

Find the largest prime smaller than this.

`Print`

Stability: beta

Aliases: P

Output to standard output, followed by an output record separator.

`Print_lines`

Stability: unstable

Aliases: Pl

Output each element of a sequence to standard output, each followed by an output record separator. At the end, output an extra output record separator.

`Print_stack`

Stability: beta

Aliases: Ps

`Printkeep`

Stability: unstable

Aliases: Ƥ, ^P

Pop something, output to standard output followed by an output record separator, then push it back. Pretty much just Print__keep.

`Product`

Stability: alpha

Aliases: Þ, *w

(Deep) product (coerces numbers to range!?).

`Product_map`

Stability: alpha

Golf as: B

Map over the Cartesian product of two sequences, resulting in a list.

`Product_stack`

Stability: beta

Aliases: Þs

`Ps`

Stability: beta

Aliases: Print_stack

`Pure_imaginary`

Stability: unstable

Aliases: &j, ?j

Test if the real part is zero. Deeply vectorizes.

`Py`

Stability: alpha

Aliases: Python

Evaluate arbitrary Python code. Push the result if non-None.

Disabled in sandbox mode.

`Python`

Stability: alpha

Aliases: Py

Evaluate arbitrary Python code. Push the result if non-None.

Disabled in sandbox mode.

`Pz`

Stability: alpha

Aliases: Palindromize

Concatenate a with the tail of its reverse.

`Q`

Stability: beta

Aliases: Break, Quit_loop

Break out of the current loop.

`Qo`

Stability: alpha

Aliases: Quine_output

Output the value of Qn, which will usually be the current program

`Qp`

Stability: alpha

Aliases: Quine_print

Print the value of Qn, which will usually be the current program

`Quarter`

Stability: alpha

Aliases: ¼

`Quine_output`

Stability: alpha

Aliases: Qo

Output the value of Qn, which will usually be the current program

`Quine_print`

Stability: alpha

Aliases: Qp

Print the value of Qn, which will usually be the current program

`Quit_loop`

Stability: beta

Aliases: Break, Q

Break out of the current loop.

`Qz`

Stability: alpha

Stability: alpha

`Range`

Stability: beta

Golf as: ,

Range (half-open from 0).

`Range_enumerate_one_or_reject_indices`

Stability: beta

Aliases: J

Compare Range_enumerate_or_filter_indices.

`Range_enumerate_or_filter_indices`

Stability: beta

Stability: beta

Aliases: R

`Reduce_complex`

Stability: unstable

Aliases: Rj

Create a complex number for a list with a real and imaginary part. Actually, for a full list, multiplies successive elements by powers of 1j and computes the sum of all the results. Mnemonic: This is shaped like a reduce because it takes a list and returns a single number.

`Regex_array`

Stability: unstable

Aliases: Xa

Take a string and a regex, and find all matches (this is Python's re.finditer, and its caveats apply.) Returns a list with one list for each match; each list consists of the string matched by the regex followed by all of the regex's groups.

`Regex_match`

Stability: unstable

Aliases: Xm

Take a string and a regex, and attempt to match the regex exactly against the entire string. Returns a list consisting of the string matched by the regex followed by all of the regex's groups, or an empty list if no match is found (so the truthiness of the result is whether a match is found).

`Regex_search`

Stability: unstable

Aliases: Xs

Take a string and a regex, and perform a regex search through the string. Returns a list consisting of the string matched by the regex followed by all of the regex's groups, or an empty list if no match is found (so the truthiness of the result is whether a match is found).

`Reject`

Stability: stable

Aliases: Filter_not

Golf as: -

Filter-not a list by a block (numbers coerce to ranges).

`Reject_in`

Stability: stable

Aliases: Filter_not_in

Golf as: -

Filter-not-in on lists and strings (numbers coerce to single-element lists).

`Replicate`

Stability: beta

Aliases: °, Rp

Make a list by repeating an element some number of times.

`Repr`

Stability: beta

Aliases: `

Push the string Paradoc representation of the top element.

`Reverse`

Stability: beta

Aliases: Down

Golf as: D

Reverse a sequence (coerces numbers to range).

`Reverse_one_or_map`

Stability: alpha

Aliases: Ð

On numbers, reverse inclusive range from that number to 1 (i.e. Range_one_down). On sequences, reverse each element (numbers coerce to length-1 lists, and characters coerce to length-1 strings, so you can also use this to wrap each element of a flat list into a list). (Heavily inspired by studying 05AB1E.)

`Reverse_or_doloop`

Stability: beta

`Rj`

Stability: unstable

Aliases: Reduce_complex

`Ro`

Stability: alpha

Aliases: Rotate

Rotate a matrix, or list of lists, 90 degrees counterclockwise (just by vague mathematical convention of angle).

`Rotate`

Stability: alpha

Aliases: Ro

Rotate a matrix, or list of lists, 90 degrees counterclockwise (just by vague mathematical convention of angle).

`Round`

Disabled in sandbox mode.

Stability: beta

Aliases: Sn

`Sl`

Stability: alpha

Aliases: Sleep

Sleep for some number of seconds.

`Sleep`

Stability: alpha

Aliases: Space_break, SPACEb

`Square`

Stability: beta

Aliases: ²

Square a number, or compute the Cartesian product of a sequence with itself, or map a block across that.

`Square_deep`

Stability: alpha

Aliases: È

Square of numbers. Deeply vectorizes.

`Sr`

Stability: unstable

Aliases: Signed_replicate

Make a list by repeating one of two elements some number of times, the first one if negative and the second one if positive.

`Ss`

Stability: beta

Aliases: Subsequences, ¿

`Standard_deviation`

Stability: alpha

`Swap_around`

Stability: alpha

Aliases: \a

Swap the first and third elements of the stack (swap "around" the second one).

1 2 3\a => 3 2 1

`Swap_in`

Stability: beta

Aliases: \i

Rotate the top three elements of the stack so that the top is now on bottom ("inward" by two): a b c -> c a b

1 2 3\i => 3 1 2

`Swap_out`

Stability: beta

Aliases: \o

Rotate the top three elements of the stack so that the 3rd from the top is now on top ("outward" by two): a b c -> b c a

1 2 3\o => 2 3 1

`T`

Stability: alpha

Aliases: Table

On two sequences (numbers coerce to ranges), "structured" Cartesian product: make a "table", or a list of lists, of pairs of elements. On a block and two sequences (number coerce to ranges), make a "table" of results of mapping pairs of elements. For the flat versions, see * or B.

`Table`

Stability: alpha

Aliases: T

`Tan`

Stability: beta

Aliases: Tn

`Tc`

Stability: alpha

Aliases: Title_case

Title-cases all strings?

`Tf`

Stability: alpha

Aliases: Transpose_fill

Given a filler element, transpose a matrix, or list of lists, with the filler element repeated as necessary until the matrix is rectangular.

`Three_quarters`

Stability: alpha

Aliases: ¾

`Title_case`

Stability: alpha

Aliases: Tc

Title-cases all strings?

`Tl`

Stability: beta

Aliases: Exclusive_range

`Tn`

Stability: beta

Aliases: Tan

Stability: beta

Golf as: (

Split into tail and first.

[1 2 3]Uncons => [2 3]1

`Under_zero_or_is_unique`

Stability: beta

Aliases: Û

Under zero or Unique (test)

`Unique`

Stability: beta

Golf as: Û

`Uniquify`

Stability: alpha

Golf as: U

Uniquify a sequence: drop all but first occurrence of each element

`Unless`

Stability: alpha

Aliases: Ul

Single-branch unless.

`Unrotate`

Stability: alpha

Aliases: Ur

Rotate a matrix, or list of lists, 90 degrees clockwise (just by vague mathematical convention of angle).

`Unsnoc`

Stability: beta

Golf as: )

Split into init and last.

[1 2 3]Uncons => [1 2]3

Stability: unstable

Aliases: Zf

Given a value and a length, convert the value to a string if necessary and left-pad it with zeroes until at least the length.

`Zf`

Stability: unstable

Aliases: Zero_fill

Given a value and a length, convert the value to a string if necessary and left-pad it with zeroes until at least the length.

`Zip`

Stability: alpha

Aliases: Zp

Zip two sequences (numbers coerce to ranges), returning a list of length-2 lists; or zip them with a block, which operates on corresponding pairs of the two lists. Truncates to the length of the shorter input sequence. Also see _zip, and ‰ for an alias.

`Ziplongest`

Stability: alpha

Aliases: Zl

Zip two sequences (numbers coerce to ranges), returning a list of length-2 or (at indices between their lengths, if the sequences are of unequal length) length-1 lists; or zip them with a block, which operates on corresponding pairs of the two lists, where elements of the longer list are collected unmodified. The result has length equal to that of the longest list.

`Zl`

Stability: alpha

Aliases: Ziplongest

`Zp`

Stability: alpha

Aliases: Zip

`Zt`

Stability: alpha

Aliases: Translate

Translate the first argument using a mapping obtained by zipping the second and third, mapping elements of the second to elements of the third, repeating the last element of the third as necessary.

`[`

Stability: stable

Aliases: Mark

Mark the stack.

`[f`

Stability: unstable

Aliases: Left_fill

Given a list (numbers coerce to ranges), a length, and a filler object, left-pad the list with the filler object until at least the length.

`\`

Stability: stable

Aliases: Swap

Swap the top two elements of the stack.

1 2 3\ => 1 3 2

`\a`

Stability: alpha

Aliases: Swap_around

Swap the first and third elements of the stack (swap "around" the second one).

1 2 3\a => 3 2 1

`\i`

Stability: beta

Aliases: Swap_in

Rotate the top three elements of the stack so that the top is now on bottom ("inward" by two): a b c -> c a b

1 2 3\i => 3 1 2

Stability: alpha

Aliases: Newline_repeat, NEWLINEx

`\o`

Stability: beta

Aliases: Swap_out

Rotate the top three elements of the stack so that the 3rd from the top is now on top ("outward" by two): a b c -> b c a

1 2 3\o => 2 3 1

`]`

Stability: stable

Aliases: Pack

Pack the elements above the last stack mark into a list.

`]_case`

Stability: beta

Aliases: ]c

Case statement: Takes a series of lists, the "cases", above the last stack mark, as well as one object, the "target", below the mark, which is popped. Then, find the first "case" such that the case "matches" the target, where "matches" means that if the case's first element is a block then the target must satisfy it, and otherwise they must be equal. Push or execute all remaining list elements in that first matching case.

`]_check`

Stability: alpha

Stack check: Takes a series of case predicates above the last stack mark. Peek at the same number of objects on the same stack below them. Assert that every object matches the corresponding predicate; otherwise, halt the program.

`]_stream`

Stability: alpha

Aliases: ]s

Stream case statement: Like the case statement, but just takes a series of alternative case predicates and case bodies instead of expecting them to be paired up.

Stability: unstable

Aliases: Complex_components

Real and imaginary part, as two elements on the stack. Mnemonic: Treating the complex number as a length-2 list, this expands it like ~.

`~p`

Stability: alpha

Aliases: Complement_parity

`NBSP`

Stability: alpha

Utility constant: space

`¡`

Stability: beta

Aliases: Permutations_or_factorial, !p

`¢`

Stability: alpha

Aliases: Order_statistic

Order statistic (zero-indexed)

`¤`

Stability: alpha

Aliases: Round_or_first_and_last

`¥`

Stability: unstable

Bimask. Mnemonics: like € but it "forks" the sequence into two instead of just having the truthy ones.

`¦`

Stability: beta

Aliases: Dup_pair, :p

Duplicate the top two elements of the stack: a b -> a b a b

1 2 3 :p => 1 2 3 2 3

`§`

Stability: unstable

Aliases: All_slices, =s

All slices of a sequence (numbers coerce to ranges).

`¨`

Stability: beta

Aliases: Exclusive_range_or_flatten_once

`«`

Stability: beta

Aliases: Decr_two_or_but_last

Decrease by two, or all but last

`«p`

Stability: unstable

Aliases: Left_add

Given a list (numbers coerce to ranges), a number, and a filler object, left-pad the list with number copies of the filler object.

`«s`

Stability: alpha

Aliases: From_empty_left_slices

Left slices (including the empty one, by increasing length)

`¬`

Stability: stable

Aliases: Pack_reverse, Pack_down

Pack the elements above the last stack mark into a list in reverse order.

[1 2 3¬ => [3 2 1]

`¸`

Stability: beta

Aliases: Pop_under

Pop the second from the top element of the stack.

1 2 3¸ => 1 3

`¹`

Stability: unstable

Utility constant: eleven

Integer constant with value 11

`»`

Stability: beta

Aliases: Incr_two_or_but_first

Increase by two, or all but first (tail)

`»p`

Stability: unstable

Aliases: Right_add

Given a list (numbers coerce to ranges), a number, and a filler object, right-pad the list with number copies of the filler object.

`»s`

Stability: alpha

`Á`

Stability: unstable

Aliases: Plus_deep_vectorizing

Addition on numbers; deeply vectorizes.

`Â`

Stability: beta

Aliases: Above_zero_or_all

Above zero or All

`Ã`

Stability: beta

Aliases: Max, >m

Maximum of two values, optionally by a block

`Ãw`

Stability: unstable

Aliases: Max_deep_vectorizing, >mw

Maximum of two values; deeply vectorizes.

`Å`

Stability: alpha

Stability: beta

Aliases: Array_max, >r

Maximum of array, optionally by a block (numbers will coerce to ranges if you supply a block). Mnemonic: it's like reducing by maximum of two values.

`Æs`

Stability: alpha

Aliases: Array_maxima, >rs

Maxima of array, optionally by a block (numbers will coerce to ranges if you supply a block).

Stability: beta

Aliases: Equals_one_or_identical

Identity (equals 1) or Identical

`Ð`

Stability: alpha

Aliases: Reverse_one_or_map

`Ñ`

Stability: stable

Output field separator

String constant with value ''

`Ò`

Stability: unstable

Aliases: Divide_deep_vectorizing

Division on numbers; deeply vectorizes.

`Ó`

Stability: unstable

Aliases: Multiply_deep_vectorizing

Multiplication on numbers; deeply vectorizes.

`Ô`

Stability: beta

Aliases: Odd_or_not_any

Odd or Not_any

`Õ`

Stability: beta

Aliases: Min, <m

Minimum of two values, optionally by a block

`Õw`

Stability: unstable

Aliases: Min_deep_vectorizing, <mw

Minimum of two values; deeply vectorizes.

`×`

Stability: beta

Aliases: Double

`Ø`

Stability: alpha

Aliases: Organize_or_totient

On numbers, Euler's Totient function (does not vectorize). On sequences or blocks with sequences, Organize.

`Ú`

Stability: unstable

Aliases: Modulus_deep_vectorizing

Modulus on numbers; deeply vectorizes.

`Û`

Stability: beta

Aliases: Under_zero_or_is_unique

Under zero or Unique (test)

`Þ`

Stability: alpha

Aliases: Product, *w

(Deep) product (coerces numbers to range!?).

`Þs`

Stability: beta

Aliases: Product_stack

`÷`

Stability: beta

Aliases: Intdiv_or_split_discard

Integer division on numbers. On a sequence and number, split the sequence into chunks of size equal to the number, discarding leftovers.

[1 2 3 4]2/ => [[1 2][3 4]]
[1 2 3 4 5]2/ => [[1 2][3 4]]

`Ŋ`

Stability: unstable

Aliases: ^N

Unstable aliases for Line_join.

`Œ`

Stability: beta

Aliases: Array_min, <r

Minimum of array, optionally by a block (numbers will coerce to ranges if you supply a block). Mnemonic: it's like reducing by minimum of two values.

`Œs`

Stability: alpha

Aliases: Array_minima, <rs

Minima of array, optionally by a block (numbers will coerce to ranges if you supply a block).

`Š`

Stability: beta

Aliases: Sum, +w

(Deep) sum (coerces numbers to range).

`Šs`

Stability: beta

Aliases: Sum_stack

`Ƥ`

Stability: unstable

Aliases: Printkeep, ^P

Pop something, output to standard output followed by an output record separator, then push it back. Pretty much just Print__keep.

`ˆ`

Stability: beta

Aliases: Power, *p

On numbers, power/exponentiate. On a list and a number, exponentiate the list by making a list of all lists of that length composed of elements from the original list (possibly repeating).

`ˆj`

Stability: unstable

Aliases: Imaginary_unit_power, ^j

Take the power of the imaginary unit to this number. Deeply vectorizes.

`˜`

Stability: alpha

Aliases: Compare, Co

Compare (-1, 0, or 1)

`α`

Stability: unstable

Integer constant with value 1

`–`

Stability: alpha

Aliases: Assign_bullet_destructive

Pop and assign to the variable •

`†`

Stability: stable

Pack the top element of the stack into a list by itself.

ASCII alternative: 1_array; see _array.

1 2 3† => 1 2 [3]

`‡`

Stability: stable

Pack the top two elements of the stack into a list.

ASCII alternative: 2_array; see _array.

1 2 3‡ => 1 [2 3]

`•`

Stability: alpha

A utility variable assigned to by Assign_bullet and Assign_bullet_destructive. Initialized to a new hoard.

`…`

Stability: beta

Aliases: Inclusive_range_or_flatten

`‰`

Stability: unstable

Aliases: Divmod_or_zip, %p

On integers, integer division and modulus. On two sequences or a block and two sequences, Zip.

`‹`

Stability: beta

Aliases: Floor_or_first

Floor or First of sequence or Modify_first

`‹p`

Stability: unstable

Aliases: Left_add_spaces

`›`

Stability: beta

Aliases: Ceiling_or_last

Ceiling or Last of sequence or Modify_last

Transpose a matrix, or list of lists. Mnemonic: matrices are transposed by a superscript T, so Tt is just that "doubled" and ™ is "Transpose Matrix" superscripted.

`∅`

Stability: unstable

`␣`

Stability: alpha

Utility constant: space

Paradoc Documentation and Built-Ins

Table of Contents

Introduction

Usage

Design Philosophy

Differences from GolfScript/CJam

Syntax

Semantics

Marks

The X-Stack

Input

Hoards

Mnemonics

Stability

Built-in/Trailer Overview

Block Trailers

String Trailers

Int Trailers