Uiua Documentation

In Uiua, operations appear to the left of their arguments. Code is typically read from right to left to determine the order of operations. Code is also executed from top to bottom.

• Multiple outputs: If code generates multiple outputs, they are displayed on multiple lines.
• Single line outputs: Outputs generated on the same line will appear on the same line in the output.
• Grouping: Use parentheses () to make the grouping of functions and arguments visually apparent.

Uiua programs transform lists of arguments. A number literal makes the first argument to the next function called, pushing current arguments to the right.

Common Modifiers

Modifiers change how functions behave. They are applied to one or more functions.

• self (˙): Makes a function take a single value as all of its arguments.
• backward (˜): Reverses the order of a function's arguments.
• on (⟜): Keeps the first argument to a function in front of the function's outputs.
• by (⊸): Keeps the last argument to a function after the function's outputs.
• dip (⊙): Skips the first arguments and calls the function on later arguments. Can be chained (e.g., ⊙⊙).
• reduce (/): Applies a function "between" the items of an array (e.g., /+ for sum).

You can declare modules within a single file using --- delimiters and a name.

• Exporting: Append a ~ to the module name to export its names into the outer scope.
• Calling as a function: If a module contains a function named Call or New, you can invoke the module itself as a function.
• Macros: Append a ! to the module name to make the module's names available as a macro within that scope.

---MyMod ~ Go
  Foo ← 5
  Go ← +1
---
Go MyMod~Foo

---Foo
  Call ← /++1⇡
---
Foo 5

---Foo
  A ← 10
  F ← +1
  G ← ×2
---
Foo!(G F ×A) [1 2 3]

Index macros allow you to define functions that use placeholders to refer to arguments passed during the macro call. These macros act similarly to modifiers, taking function arguments and modifying how they are used.

Key Rules:

• Placeholders: Use ^ followed by a number (the index of the function argument) to represent a placeholder. ^0 can be shortened to ^.
• Naming: A named macro must end with a number of ! characters equal to the number of functions it takes.
• Hygiene: Index macros are hygienic, meaning they won't accidentally capture or be interfered with by bindings in the surrounding scope.

Use index macros when you want to define a custom modifier.

ReduceRange! ← /^0+1⇡
ReduceRange!+5
ReduceRange!×4

The scan() modifier is similar to reduce(), but instead of returning only the final result, it returns an array of all intermediate results produced during the reduction process.

This is particularly useful when applied to a mask to progressively change the mask's state (e.g., zeroing out a mask after a certain condition is met).

To include digits in identifiers (which are otherwise disallowed), use subscript digits. These are formatted using a comma , followed by digits.

Sha,256 ← "todo" # This
Sha₂₅₆ ← "todo"   # Formats to this

The repeat() modifier (glyph: ⍥) takes a number and calls its function that many times.

Key behaviors:

• Scalar input: Calls the function $N$ times where $N$ is the input.
• Boolean input: Since booleans are numbers in Uiua, repeat()ing with a boolean will call the function 0 or 1 times, making it useful for conditional execution.
• Extra outputs: If the function produces more outputs than arguments, the extra outputs are collected into arrays.
• Random generation: A common pattern for generating lists of random numbers is [repeat]()random().

Labels allow you to attach a debug-only name to an array using the $ prefix followed by an identifier.

Key behaviors:

• Visibility: Labels are only visible in debugging outputs (like normal interpreter output or args()). They are not shown when using &p or format strings.
• Multiple Labels: You can label multiple values within an array using [].
• Storage: Labeled arrays cannot be placed in a standard array together unless they are boxed (using {}).
• Removal: Use $_ to remove a label from a value.
• Limitation: Labels are for debugging only; they cannot be retrieved or manipulated via code.

Correct vs Incorrect usage:

• [$a 1 $b 2 $c 3] is incorrect (will fail because they are different types).
• {$a 1 $b 2 $c 3} is correct (uses boxing).

$Numbers [1 2 3]
⊓$Foo$Bar °⊂ [2 3 5 7]
⊸$_ $Label [1 2]

Uiua is a dynamically-typed array language. While array shapes and scalar types can often be determined at compile-time, they are not guaranteed to be static. Types and shapes that depend on user input, environmental factors, or randomness can only be resolved at runtime.

Because of this dynamism, Uiua functions do not require explicit type signatures for inputs or outputs, allowing them to operate polymorphically across different types and shapes. This simplifies writing code but requires care in large-scale maintainability.

# Example of a function working on different shapes and types
F ← ⊂↯
F 4 0 [1 2 3]
F 3 [1 2] [3_5 5_6]
F 8 @U "iua"