Uiua: Difference between revisions

From APL Wiki
Jump to navigation Jump to search
No edit summary
m (Supports complex numbers as a distinct type from floats, also version bump)
 
(12 intermediate revisions by 4 users not shown)
Line 4: Line 4:
| index origin            = 0
| index origin            = 0
| function styles          = stack-based [[tacit]]
| function styles          = stack-based [[tacit]]
| numeric types            = 64-bit float
| numeric types            = 64-bit float, [[complex]] float
| unicode support          = full
| Unicode support          = full
| released                = 2023
| released                = 2023
| developer                = Kai Schmidt
| developer                = Kai Schmidt
| latest release version  = 0.8.0 / 2024
| latest release version  = 0.12.3 / 2024
| implementation languages = [[Wikipedia:Rust (programming language)|Rust]]
| implementation languages = [[Wikipedia:Rust (programming language)|Rust]]
| source                  = [https://github.com/uiua-lang/uiua GitHub]
| source                  = [https://github.com/uiua-lang/uiua GitHub]
Line 23: Line 23:


== Overview ==
== Overview ==
Uiua uses concatenative evaluation (a [[wikipedia:context-free grammar|context-free grammar]]) with a right-to-left ordering as in [[Wikipedia: Polish notation Polish notation]]. The language supports [[tacit programming]] using stack manipulation [[primitive]]s, and all complex functions must be defined this way as there is no explicit function form that allows local variables. [[Function]]s have a fixed number of input and output values, meaning the overloading of [[ambivalent function]]s is removed. Because of this, Uiua often splits APL primitives into two functions. Its primitives use [[Unicode]] glyphs including many not found in other languages. To avoid [[Typing glyphs the need]] for a keyboard layout containing these, each primitive can also be spelled using a name that consists of lowercase letters (user-defined names must have at least one uppercase letter). By default, the language formats source files when run to convert these names into the corresponding glyphs.
Uiua uses concatenative evaluation (a [[wikipedia:context-free grammar|context-free grammar]]) with a right-to-left ordering as in [[Wikipedia: Polish notation|Polish notation]]. The language supports [[tacit programming]] using stack manipulation [[primitive]]s, and all complex functions must be defined this way as there is no explicit function form that allows local variables. [[Function]]s have a fixed number of input and output values, meaning the overloading of [[ambivalent function]]s is removed. Because of this, Uiua often splits APL primitives into two functions. Its primitives use [[Unicode]] glyphs including many not found in other languages. To avoid [[typing glyphs]] necessitating a keyboard layout containing these, each primitive can also be spelled using a name that consists of lowercase letters (user-defined names must have at least one uppercase letter). By default, the language formats source files when run to convert these names into the corresponding glyphs.


Like the [[SHARP APL]] family, Uiua supports only [[Array_model#Flat_array_theory|flat arrays]] with a homogeneous [[type]], and has a dedicated [[box]] type for [[Nested array|array nesting]]. However, arithmetic is [[pervasion|pervasive]] as in the nested array model. Arithmetic also follows [[leading axis agreement]], extended so that a length-1 axis is matched with an axis of any length by replicating along it (like the broadcasting system of [[wikipedia:Julia (programming language)|Julia]] and [[wikipedia:NumPy|NumPy]]). It supports character arithmetic as in [[BQN]], as well as other primitives characteristic of BQN such as [[structural Under]], [[Classify]], and a [[Transpose]] that rotates the axes of its argument by one.
Like the [[SHARP APL]] family, Uiua supports only [[Array_model#Flat_array_theory|flat arrays]] with a homogeneous [[type]], and has a dedicated [[box]] type for [[Nested array|array nesting]]. However, arithmetic is [[pervasion|pervasive]] as in the nested array model. Arithmetic also follows [[leading axis agreement]], extended so that a length-1 axis is matched with an axis of any length by replicating along it (like the broadcasting system of [[wikipedia:Julia (programming language)|Julia]] and [[wikipedia:NumPy|NumPy]]). It supports [[character arithmetic]] as in [[BQN]], as well as other primitives characteristic of BQN such as [[structural Under]], [[Classify]], and a [[Transpose]] that rotates the axes of its argument by one.


== Primitives ==
== Primitives ==  
=== Function with unique glyph ===
=== Functions with unique glyphs ===
In the web version of Uiua, we can type in the name of the function or a part of it and when run, the interpreter will format the name to Unicode Symbol, so that we don't need use of non-ASCII keyboards.
In Uiua, we can type in the name of the function or a part of it and when formatted, it will format the name to its corresponding Unicode Symbol, so that we don't have to use non-ASCII keyboards (or Alt-codes).


All table below are based on Uiua version 0.8.0-1/28/2024.
The tables below are based on Uiua version 0.12.0, with since-removed primitives taken out.


<span style="color:black; background-color: yellow">Yellow background text </span> mean that the glyph is deprecated and will be removed in a future version
And 🧪 emoji mean that the glyph is experimental and may be changed or removed in the future.
==== Stack ====
==== Stack ====
Work with the stack
Work with the stack
{| class="wikitable"
{| class="wikitable"
|+ Table of Stack function in Uiua
|+ Table of Stack functions in Uiua
|-
|-
! Glyph !! Name !! Type !! Definition
! Glyph !! Name !! Type !! Definition
Line 49: Line 46:
| <code>:</code> || Flip || Dyadic 2-output function || Swap the top two values on the stack  
| <code>:</code> || Flip || Dyadic 2-output function || Swap the top two values on the stack  
|-
|-
| <code>◌(;)</code> || Pop ||Monadic 0-output function || Discard the top stack value
| <code>◌</code> || Pop || Monadic 0-output function || Discard the top stack value
|-
| <code>⟜</code> || On || Monadic modifier || Call a function but keep its top argument on top of the stack
|-
| <code>⤙</code> || But || Monadic modifier || Call a function but keep its last argument on top of the stack
|-
| <code>⤚</code> || With || Monadic modifier || Call a function but keep its top argument below the outputs on the stack
|-
| <code>⊸</code> || By || Monadic modifier || Duplicate a function's last argument before calling it
|-
| <code>¨</code> || Backward || Monadic modifier || Call a function with its arguments reversed
|-
|-
| <code>?</code> || Stack || Noadic 0-output function || Debug print all stack values without popping them
| <code>?</code> || Stack || Noadic 0-output function || Debug print all stack values without popping them
Line 74: Line 81:
Operate on every element in an array
Operate on every element in an array
{| class="wikitable"
{| class="wikitable"
|+ Table of Monadic Pervasive in Uiua
|+ Table of Monadic Pervasive functions in Uiua
! Glyph !! Name !! Definition
! Glyph !! Name !! Definition
|-
|-
Line 87: Line 94:
| <code>√</code> || [[Square Root|Sqrt]] || Take the square root of a number
| <code>√</code> || [[Square Root|Sqrt]] || Take the square root of a number
|-
|-
| <code></code> || Sine || Get the sine of a number
| <code></code> || Sine || Get the sine of a number
|-
|-
| <code>⌊</code> || [[Floor]] || Round to the nearest integer towards <code>¯∞</code>
| <code>⌊</code> || [[Floor]] || Round to the nearest integer towards <code>¯∞</code>
Line 96: Line 103:
|}
|}
==== Dyadic Pervasive ====
==== Dyadic Pervasive ====
Operate on every pair of elements in two arrays (Note that True is 1 and False is 0)
Operate on every pair of elements in two arrays
{| class="wikitable"
{| class="wikitable"
|+ Table of Monadic Pervasive in Uiua
|+ Table of Dyadic Pervasive functions in Uiua
! Glyph !! Name !! Definition !! Formats from:
! Glyph !! Name !! Definition !! Formats from:
|-
|-
Line 138: Line 145:
Operate on a single array
Operate on a single array
{| class="wikitable"
{| class="wikitable"
|+ Table of Monadic Array in Uiua
|+ Table of Monadic Array functions in Uiua
! Glyph !! Name !! Definition  
! Glyph !! Name !! Definition  
|-
|-
Line 153: Line 160:
| <code>♭</code> || [[Deshape]] || Make an array 1-dimensional
| <code>♭</code> || [[Deshape]] || Make an array 1-dimensional
|-
|-
| <code>¤</code> || [[Fix]] || Add a length-1 axis to an array
| <code>¤</code> || [[Promote|Fix]] || Add a length-1 axis to an array
|-
|-
| <code>⋯</code> || [[Encode|Bits]] || Encode an array as bits (LSB-first)
| <code>⋯</code> || [[Encode|Bits]] || Encode an array as bits (LSB-first)
Line 169: Line 176:
| <code>◴</code> || [[Deduplicate]] || Remove duplicate elements from an array
| <code>◴</code> || [[Deduplicate]] || Remove duplicate elements from an array
|-
|-
| <code>◰</code> || [[Nub Sieve|Unique]] || Get a mask of first occurrences of items in an array
| <code>◰</code> || [[Nub Sieve|Unique]] || Get a mask of the first occurrences of items in an array
|-
|-
| <code>□</code> || [[Box]] || Turn an array into a box
| <code>□</code> || [[Box]] || Turn an array into a box
This is Uiua's primary way to create nested or mixed-type arrays.
Normally, arrays can only be created if their rows have the same shape and type.
⬚ fill can help you with the shape part, but it is not always wanted, and it can't help with the type part.
You can go to ([https://www.uiua.org/docs/box To See more information about the <code>□ box</code> function])
|-
|-
|}
|}
Line 182: Line 185:
Operate on two arrays
Operate on two arrays
{| class="wikitable"
{| class="wikitable"
|+ Table of Monadic Array in Uiua
|+ Table of Dyadic Array functions in Uiua
! Glyph !! Name !! Definition  
! Glyph !! Name !! Definition  
|-
|-
Line 204: Line 207:
|-
|-
| <code>↻</code> || [[Rotate]] || Rotate the elements of an array by n
| <code>↻</code> || [[Rotate]] || Rotate the elements of an array by n
|-
| <code>⮌</code> || [[Orient]] || Change the order of the axes of an array.
|-
|-
| <code>◫</code> || [[Windows]] || The n-wise windows of an array
| <code>◫</code> || [[Windows]] || The n-wise windows of an array
Line 214: Line 219:
|-
|-
| <code>⊗</code> || [[Index Of|Indexof]] || Find the first index of each row of one array in another
| <code>⊗</code> || [[Index Of|Indexof]] || Find the first index of each row of one array in another
|-
| <code>⟔</code> || Coordinate || Find the first deep index of an array in another
|}
|}
==== Iterating Modifiers ====
==== Iterating Modifiers ====
Line 222: Line 229:
|-
|-
| <code>∵</code> || [[Each]] || Monadic modifier || Apply a function to each element of an array or arrays.
| <code>∵</code> || [[Each]] || Monadic modifier || Apply a function to each element of an array or arrays.
This is the element-wise version of <code>≡ rows.</code>
|-
|-
| <code>≡</code> || [[Rows]] || Monadic modifier ||Apply a function to each row of an array or arrays.
| <code>≡</code> || Rows || Monadic modifier || Apply a function to each row of an array or arrays.
This is the row-wise version of <code>∵ each.</code>
|-
|-
| <code>⊞</code> || [[Table]] || Monadic 2-argument modifier || Apply a function to each combination of rows of two arrays.
| <code>⊞</code> || [[Outer Product|Table]] || Monadic 2-argument modifier || Apply a function to each combination of rows of two arrays.
This is often what you want instead of <code>∵ each.</code>
|-
|-
| <code></code> || <span style="color:black; background-color: yellow">[[Cross]]</span> || Monadic 2-argument modifier || Apply a function to each combination of rows of arrays.
| <code></code> || Inventory || Monadic modifier || Apply a function to each unboxed row of an array and re-box the results.
This was the row-wise version of <code>⊞ Table</code>
|-
|-
| <code>⍥</code> || [[Repeat]] || Monadic modifier || Repeat a function a number of times
| <code>⍥</code> || [[Repeat]] || Monadic modifier || Repeat a function a number of times
Line 246: Line 249:
For reducing with an initial value, see <code>∧ fold</code>
For reducing with an initial value, see <code>∧ fold</code>
|-
|-
| <code>∧</code> || [[Fold]] || Apply a function to aggregate arrays.
| <code>∧</code> || Fold || Apply a function to aggregate arrays.
|-
|-
| <code>\</code> || [[Scan]] || Reduce, but keep intermediate values
| <code>\</code> || [[Scan]] || Reduce, but keep intermediate values
|-
|-
| <code>⊕</code> || [[Group]] || Group elements of an array into buckets by index
| <code>⊕</code> || [[Group (BQN)|Group]] || Group elements of an array into buckets by index
Takes a function and two arrays.
The arrays must be the same <code>⧻ length.</code>
The first array must be rank <code>1</code> and contain integers.
Rows in the second array will be grouped into buckets by the indices in the first array.
Keys <code><0</code> will be omitted.
The function then processes each group in order. The result depends on what the function is.
If the function takes 0 or 1 arguments, then <code>⊕ group</code> behaves like <code>≡ rows.</code> This is called iterating <code>⊕ group.</code>
Expects as many arguments as its function takes.
The function must take at least 1 more argument than it returns outputs.
Arguments that are lower on the stack that will be used as accumulators.
Arguments that are higher on the stack will be iterated over.
The function will be repeatdely called with the rows of the iterated arrays followed by the accumulators.
On each iteration, the returned values will be used as the new accumulators.
|-
|-
| <code>⊜</code> || [[Partition]] || Group sequential sections of an array
| <code>⊜</code> || [[Partition]] || Group sequential sections of an array
The most common use of <code>⊜ partition</code> is to split an array by a delimiter.
|-
| <code></code> || Triangle || Apply a function to each shrinking row of an array
|}


Takes a function and two arrays.
The arrays must be the same <code>⧻ length.</code>
The first array must be rank <code>1</code> and contain integers.
Consecutive rows in the second array that line up with groups of the same key in the first array will be grouped together.
Keys <code>≤0</code> will be omitted.
The function then processes each group in order. The result depends on what the function is.
If the function takes 0 or 1 arguments, then <code>⊜ partition</code> behaves like <code>≡ rows</code>. This is called iterating <code>⊜ partition.</code>
|}
==== Inversion Modifiers ====
==== Inversion Modifiers ====
Work with the inverses of functions
Work with the inverses of functions
{| class="wikitable"
{| class="wikitable"
|+ Table of Iterating Modifiers in Uiua
|+ Table of Inversion Modifiers in Uiua
! Glyph !! Name !! Type !! Definition
! Glyph !! Name !! Type !! Definition
|-
|-
| <code>°</code> || [[Un]] || Monadic modifier || Invert the behavior of a function
| <code>°</code> || [[Un]] || Monadic modifier || Invert the behavior of a function
Most functions are not invertible.
|-
| <code>⌅</code> || <span style="color:black; background-color: yellow">🧪[[Rectify]]</span> || Monadic modifier ||🧪Set a function as its own inverse
|-
|-
| <code>⍜</code> || [[Under]] || Dyadic modifier || Apply a function under another
| <code>⍜</code> || [[Under]] || Dyadic modifier || Apply a function under another
This is a more powerful version of <code>° un.</code>
Conceptually, <code>⍜ under</code> transforms a value, modifies it, then reverses the transformation.
<code>⍜ under</code> takes 2 functions <code>f</code> and <code>g</code> and another argument <code>x</code>.
It applies <code>f</code> to <code>x</code>, then applies <code>g</code> to the result.
It then applies the inverse of <code>f</code> to the result of <code>g</code>.
Any function that can be <code>° un</code>ed can be used with <code>⍜ under</code>.
Some functions that can't be <code>° un</code>ed can still be used with <code>⍜ under</code>.
You can go to ([https://www.uiua.org/docs/under To See more information about the <code>⍜ under</code> function])
|}
|}
==== 🌎 Planet 🪐 ====
==== 🌎 Planet 🪐 ====
Advanced stack manipulation
Advanced stack manipulation
{| class="wikitable"
{| class="wikitable"
|+ Table of Iterating Modifiers in Uiua
|+ Table of Planet modifiers in Uiua
! Glyph !! Name !! Type !! Definition
! Glyph !! Name !! Type !! Definition
|-
|-
| <code>∘</code> || [[Identity]] || Monadic function || Do nothing with one value
| <code>∘</code> || [[Identity]] || Monadic function || Do nothing with one value
|-
|-
| <code>⋅</code> || [[Gap]] || Monadic modifier || Discard the top stack value then call a function
| <code>⋅</code> || Gap || Monadic modifier || Discard the top stack value then call a function
|-
|-
| <code>⊙</code> || [[Dip]] || Monadic modifier || Temporarily pop the top value off the stack and call a function
| <code>⊙</code> || Dip || Monadic modifier || Temporarily pop the top value off the stack and call a function
|-
|-
| <code>∩</code> || [[Both]] || Monadic 2-argument modifier || Call a function on two sets of values
| <code>∩</code> || Both || Monadic 2-argument modifier || Call a function on two sets of values
For monadic functions, <code>∩ both</code> calls its function on each of the top 2 values on the stack.
|-
|-
| <code>⊃</code> || [[Fork]] || Dyadic modifier || Call two functions on the same values
| <code>⊃</code> || [[Fork]] || Dyadic modifier || Call two functions on the same values
<code>⊃ fork</code> is one of the most important functions for working with the stack.
|-
|-
| <code></code> || <span style="color:black; background-color: yellow">🧪[[Cascade]] || Dyadic modifier || 🧪Call one function after another, reusing some values
| <code></code> || Bracket || Dyadic modifier || Call two functions on two distinct sets of values
<code>⪾ cascade</code>'s second function is called, then its first argument(s) are reused, along with its output, as arguments to the first function.
|}
 
==== Other Modifiers ====
{| class="wikitable"
|+ Table of Other Modifiers in Uiua
! Glyph !! Name !! Type !! Definition
|-
|-
| <code></code> || [[Bracket]] || Dyadic modifier || Call two functions on two distinct sets of values
| <code></code> || Content || Monadic Modifier || Unbox the arguments to a function before calling it
|-
|-
| <code></code> || 🧪[[All]] || Dyadic modifier || 🧪Call a function on many distinct sets of values
| <code></code> || Fill || Dyadic Modifier || Set the fill value for a function
For just 2 sets of values, <code>∩ both</code> is often simpler.
|-
| <code></code> || Switch || Dyadic modifier || Call the function at the given index
|}


The second function will be called, then the first function will be called on groups of values.
To do something similar to ∩ both on more than 2 sets of values, you can use <code>⊙ dip</code> and <code>∘</code> identity to select values.
|}
== External links ==
== External links ==
* [https://concatenative.org/wiki/view/Uiua Uiua] on the concatenative language wiki
* [https://concatenative.org/wiki/view/Uiua Uiua] on the concatenative language wiki
* [https://www.arraycast.com/episodes/episode63-uiua Uiua, a Stack based Array language] on the [[Array Cast]]
* [https://www.arraycast.com/episodes/episode63-uiua Uiua, a Stack-based Array language] on the [[Array Cast]]
* [https://www.uiua.org/docs Doc] for the Documentation
* [https://www.uiua.org/docs Documentation]
* [https://www.uiua.org Interpreter] for the interpreter
* [https://www.uiua.org/pad Interpreter]
* [https://www.uiua.org/docs/basic Basic] to start learning Uiua
* [https://www.uiua.org/tutorial/basic Basic tutorial]


{{APL dialects}}[[Category:Flat array languages]][[Category:Stack-based languages]][[Category:Leading axis languages]][[Category:Languages with tacit programming]][[Category:IR compilers]]
{{APL dialects}}[[Category:Flat array languages]][[Category:Stack-based languages]][[Category:Leading axis languages]][[Category:Languages with tacit programming]][[Category:IR compilers]]

Latest revision as of 21:09, 28 August 2024


Uiua is a stack-based array language emphasizing tacit programming, designed by Kai Schmidt. Initially influenced strongly by BQN, Uiua has added original stack-based features and glyphs and moved to the boxed array model of SHARP APL and J. It also makes functions second-class rather than first-class to facilitate features that depend on the number of arguments functions take.

Overview

Uiua uses concatenative evaluation (a context-free grammar) with a right-to-left ordering as in Polish notation. The language supports tacit programming using stack manipulation primitives, and all complex functions must be defined this way as there is no explicit function form that allows local variables. Functions have a fixed number of input and output values, meaning the overloading of ambivalent functions is removed. Because of this, Uiua often splits APL primitives into two functions. Its primitives use Unicode glyphs including many not found in other languages. To avoid typing glyphs necessitating a keyboard layout containing these, each primitive can also be spelled using a name that consists of lowercase letters (user-defined names must have at least one uppercase letter). By default, the language formats source files when run to convert these names into the corresponding glyphs.

Like the SHARP APL family, Uiua supports only flat arrays with a homogeneous type, and has a dedicated box type for array nesting. However, arithmetic is pervasive as in the nested array model. Arithmetic also follows leading axis agreement, extended so that a length-1 axis is matched with an axis of any length by replicating along it (like the broadcasting system of Julia and NumPy). It supports character arithmetic as in BQN, as well as other primitives characteristic of BQN such as structural Under, Classify, and a Transpose that rotates the axes of its argument by one.

Primitives

Functions with unique glyphs

In Uiua, we can type in the name of the function or a part of it and when formatted, it will format the name to its corresponding Unicode Symbol, so that we don't have to use non-ASCII keyboards (or Alt-codes).

The tables below are based on Uiua version 0.12.0, with since-removed primitives taken out.

Stack

Work with the stack

Table of Stack functions in Uiua
Glyph Name Type Definition
. Duplicate Monadic 2-output function Duplicate the top value on the stack
, Over Dyadic 3-output function Duplicate the second-to-top value to the top of the stack
: Flip Dyadic 2-output function Swap the top two values on the stack
Pop Monadic 0-output function Discard the top stack value
On Monadic modifier Call a function but keep its top argument on top of the stack
But Monadic modifier Call a function but keep its last argument on top of the stack
With Monadic modifier Call a function but keep its top argument below the outputs on the stack
By Monadic modifier Duplicate a function's last argument before calling it
¨ Backward Monadic modifier Call a function with its arguments reversed
? Stack Noadic 0-output function Debug print all stack values without popping them
Trace Monadic function Debug print the top value on the stack without popping it

Constants

Push a constant value onto the stack

Table of Constants in Uiua
Glyph Name Definition
η Eta The number of radians in a quarter circle
π Pi The ratio of a circle's circumference to its diameter
τ Tau The ratio of a circle's circumference to its radius
Infinity The biggest number

Monadic Pervasive

Operate on every element in an array

Table of Monadic Pervasive functions in Uiua
Glyph Name Definition
¬ Not Logical not
± Sign Numerical sign (1, ¯1, or 0)
¯ Negate Negate a number
Absolute value Get the absolute value of a number
Sqrt Take the square root of a number
Sine Get the sine of a number
Floor Round to the nearest integer towards ¯∞
Ceiling Round to the nearest integer towards
Round Round to the nearest integer

Dyadic Pervasive

Operate on every pair of elements in two arrays

Table of Dyadic Pervasive functions in Uiua
Glyph Name Definition Formats from:
= Equals Compare for equality =
Not equals Compare for inequality !=
< Less than Compare for less than <
> Greater than Compare for greater than >
Less or equal Compare for less than or equal <=
Greater or equal Compare for greater than or equal >=
+ Add Add values +
- Subtract Subtract values -
× Multiply Multiply values *
÷ Divide Divide values %
Modulus Modulo values mod
Power Raise a value to a power pow
Logarithm Get the based logarithm of a number log
Minimum/Logical And Take the minimum of two arrays (Can use for logical AND.) min
Maximum/Logical Or Take the maximum of two arrays (Can use for logical OR.) max
Atangent Take the arctangent of two numbers atan
Complex Make a complex number from imaginary and real parts com

Monadic Array

Operate on a single array

Table of Monadic Array functions in Uiua
Glyph Name Definition
Length Get the number of rows in an array
Shape Get the dimensions of an array
Range Make an array of all natural numbers less than a number
First Get the first row of an array
Reverse Reverse the rows of an array
Deshape Make an array 1-dimensional
¤ Fix Add a length-1 axis to an array
Bits Encode an array as bits (LSB-first)
Transpose Rotate the shape of an array
Rise Get the indices into an array if it were sorted ascending
Fall Get the indices into an array if it were sorted descending
Where Get indices where array values are not equal to zero
Classify Assign a unique index to each unique element in an array
Deduplicate Remove duplicate elements from an array
Unique Get a mask of the first occurrences of items in an array
Box Turn an array into a box

Dyadic Array

Operate on two arrays

Table of Dyadic Array functions in Uiua
Glyph Name Definition
Match Check if two arrays are exactly the same
Couple Combine two arrays as rows of a new array
Join Append two arrays end-to-end
Select Select multiple rows from an array
Pick Index a row or elements from an array
Reshape Change the shape of an array
Rerank Change the rank of an array's rows
Take Take the first n elements of an array
Drop Drop the first n elements of an array
Rotate Rotate the elements of an array by n
Orient Change the order of the axes of an array.
Windows The n-wise windows of an array
Keep Discard or copy some rows of an array
Find Find the occurrence's of one array in another
Member Check if each row of one array exists in another
Indexof Find the first index of each row of one array in another
Coordinate Find the first deep index of an array in another

Iterating Modifiers

Iterate and apply a function to an array or arrays

Table of Iterating Modifiers in Uiua
Glyph Name Type Definition
Each Monadic modifier Apply a function to each element of an array or arrays.
Rows Monadic modifier Apply a function to each row of an array or arrays.
Table Monadic 2-argument modifier Apply a function to each combination of rows of two arrays.
Inventory Monadic modifier Apply a function to each unboxed row of an array and re-box the results.
Repeat Monadic modifier Repeat a function a number of times
Do Dyadic modifier Repeat a function while a condition holds

Aggregating Modifiers

Apply a function to aggregate an array

Table of Aggregating Modifiers in Uiua
Glyph Name Definition
/ Reduce Apply a reducing function to an array.

For reducing with an initial value, see ∧ fold

Fold Apply a function to aggregate arrays.
\ Scan Reduce, but keep intermediate values
Group Group elements of an array into buckets by index
Partition Group sequential sections of an array
Triangle Apply a function to each shrinking row of an array

Inversion Modifiers

Work with the inverses of functions

Table of Inversion Modifiers in Uiua
Glyph Name Type Definition
° Un Monadic modifier Invert the behavior of a function
Under Dyadic modifier Apply a function under another

🌎 Planet 🪐

Advanced stack manipulation

Table of Planet modifiers in Uiua
Glyph Name Type Definition
Identity Monadic function Do nothing with one value
Gap Monadic modifier Discard the top stack value then call a function
Dip Monadic modifier Temporarily pop the top value off the stack and call a function
Both Monadic 2-argument modifier Call a function on two sets of values
Fork Dyadic modifier Call two functions on the same values
Bracket Dyadic modifier Call two functions on two distinct sets of values

Other Modifiers

Table of Other Modifiers in Uiua
Glyph Name Type Definition
Content Monadic Modifier Unbox the arguments to a function before calling it
Fill Dyadic Modifier Set the fill value for a function
Switch Dyadic modifier Call the function at the given index

External links


APL dialects [edit]
Maintained APL+WinAPL2APL64APL\ivApletteAprilCo-dfnsDyalog APLDyalog APL Visiondzaima/APLGNU APLKapNARS2000PometoTinyAPL
Historical A Programming LanguageA+ (A) ∙ APL#APL2CAPL\360APL/700APL\1130APL\3000APL.68000APL*PLUSAPL.jlAPL.SVAPLXExtended Dyalog APLIverson notationIVSYS/7090NARSngn/aplopenAPLOperators and FunctionsPATRowanSAXSHARP APLRationalized APLVisualAPL (APLNext) ∙ VS APLYork APL
Derivatives AHPLBQNCoSyELIGleeIIvyJJellyK (Goal, Klong, Q) ∙ KamilaLispLang5LilNialRADUiua
Overviews Comparison of APL dialectsTimeline of array languagesTimeline of influential array languagesFamily tree of array languages