-
Notifications
You must be signed in to change notification settings - Fork 6
Commands
Ilkka Törmä edited this page Nov 11, 2017
·
80 revisions
This page documents the currently implemented commands of Husk in the order that they appear on the codepage.
Char | Alias | Name | Type | Description |
---|---|---|---|---|
¤ |
cur |
combin |
(y -> y -> z) -> (x -> y) -> x -> x -> z |
Compose both arguments of binary function |
½ |
hlf |
halve |
TNum -> TNum |
Divide by 2 |
islowr |
TChar -> TNum |
Is it a lowercase letter | ||
halfL |
[x] -> [[x]] |
Split a list into two halves. If the length is odd, the first half will be longer. | ||
↕ |
ud |
span |
(Concrete y) => (x -> y) -> [x] -> ([x], [x]) |
Split at first value where function gives falsy result |
↑ |
up |
take |
TNum -> [x] -> [x] |
Take n elements from list. Negative n takes from the end |
take2 |
[x] -> TNum -> [x] |
Flipped version of take
|
||
takew |
(Concrete y) => (x -> y) -> [x] -> [x] |
Longest prefix where function gives truthy result | ||
↓ |
dow |
drop |
TNum -> [x] -> [x] |
Drop n elements from list. Negative n drops from the end |
drop2 |
[x] -> TNum -> [x] |
Flipped version of drop
|
||
dropw |
(Concrete y) => (x -> y) -> [x] -> [x] |
Drop longest prefix where function gives truthy result | ||
↔ |
lr |
swap |
(x, y) -> (y, x) |
Swap a pair |
rev |
[x] -> [x] |
Reverse a list | ||
← |
lft |
head |
[x] -> x |
First value of a list |
fst |
(x, y) -> x |
Left value of a pair | ||
predN |
TNum -> TNum |
Decrement number | ||
predC |
TChar -> TChar |
Decrement character | ||
→ |
rgt |
last |
[x] -> x |
Last value of a list |
snd |
(x, y) -> y |
Right value of a pair | ||
succN |
TNum -> TNum |
Increment number | ||
succC |
TChar -> TChar |
Increment character | ||
\n |
Newline | Separates lines in program | ||
¦ |
bar |
divds |
TNum -> TNum -> TNum |
Does first argument divide the second |
subset |
Concrete x => [x] -> [x] -> TNum |
Is the second argument a subset of the first (counting multiplicities but not order) | ||
¡ |
exc |
iter |
(x -> x) -> x -> [x] |
Apply function repeatedly, collect values in infinite list |
iterP |
([x] -> x) -> [x] -> [x] |
Apply function repeatedly, obtaining a new value from the list of previous ones | ||
iterL |
(x -> [x]) -> [x] -> [x] |
Apply function repeatedly, concatenate results into infinite list | ||
iter2 |
(x -> (x, y)) -> x -> [y] |
Apply function repeatedly to first result, collect second results into infinite list | ||
‼ |
dex |
twice |
(x -> x) -> (x -> x) |
Apply function twice |
… |
ell |
rangeN |
TNum -> TNum -> [TNum] |
Inclusive numeric range |
rangeC |
TChar -> TChar -> [TChar] |
Inclusive character range | ||
rangeL |
[TNum] -> [TNum] |
Fill gaps with numeric ranges | ||
rangeS |
[TChar] -> [TChar] |
Fill gaps with character ranges | ||
‰ |
ppm |
mod1 |
TNum -> TNum -> TNum |
Like mod , but result is in range [1 .. n] ([n .. -1] for negative n) |
† |
dag |
vec |
(Vect a b x y) => (a -> b) -> x -> y |
Vectorize a function ("deep map") |
‡ |
ddg |
vec2 |
(Vect2 a b c x y z) => (a -> b -> c) -> x -> y -> z |
Bi-vectorize a function ("deep zip") |
√ |
srd |
sqrt |
TNum -> TNum |
Square root |
isalph |
TChar -> TNum |
Is it a letter | ||
≤ |
leq |
le |
(Concrete x) => x -> x -> TNum |
Less than or equal |
≥ |
geq |
ge |
(Concrete x) => x -> x -> TNum |
Greater than or equal |
± |
pm |
sign |
TNum -> TNum |
Sign of a number |
isdigt |
TChar -> TNum |
Is it a digit | ||
∂ |
ptl |
adiags |
[[x]] -> [[x]] |
Antidiagonals |
∫ |
int |
cumsum |
[TNum] -> [TNum] |
Cumulative sum |
cumcat |
[[a]] -> [[a]] |
Cumulative concatenation | ||
∞ |
inf |
rep |
x -> [x] |
Infinite list of copies of the argument |
≈ |
apx |
simil |
(Concrete x) => x -> x -> TNum |
Similar. For numbers or chars checks if the absolute difference is <=1. For lists checks if they are the same length. For Pairs checks if both elements are similar. |
≠ |
neq |
neq |
(Concrete x) => x -> x -> TNum |
Not equal |
≡ |
cng |
congr |
(Concrete x) => x -> x -> TNum |
Recursively check if the two arguments have the same shape and the same distribution of truthy/falsy values. Returns 1 or 0. |
¬ |
neg |
not |
(Concrete x) => x -> TNum |
Negation of truthiness |
÷ |
div |
idiv |
TNum -> TNum -> TNum |
Integer division |
× |
eks |
mix |
(x -> y -> z) -> [x] -> [y] -> [z] |
Function applied to all pairs drawn from the lists |
|
Space | Token separator, flag for multi-digit labels and marked lines | ||
! |
index |
TNum -> [x] -> x |
Value at modular index | |
index2 |
[x] -> TNum -> x |
index with flipped arguments |
||
\ |
inv |
TNum -> TNum |
Reciprocal number | |
swcase |
TChar -> TChar |
Swap case | ||
" |
Double quote | String delimiter | ||
# |
countf |
(Concrete y) => (x -> y) -> [x] -> TNum |
Number of list elems where function result is truthy | |
count |
(Concrete x) => x -> [x] -> TNum |
Number of occurrences of value in list | ||
count' |
(Concrete x) => [x] -> x -> TNum |
Flipped version of count
|
||
count2 |
(Concrete y) => (x -> x -> y) -> [x] -> TNum |
Number of adjacent pairs of elements where function result is truthy | ||
% |
mod |
TNum -> TNum -> TNum |
Modulus of second argument by first | |
& |
and |
(Concrete x) => x -> x -> x |
Second argument if falsy, else first | |
and' |
(Concrete x, Concrete y) => x -> y -> TNum |
Are both arguments truthy? | ||
' |
Single quote | Character delimiter | ||
() |
Parentheses | Group expressions | ||
* |
mul |
TNum -> TNum -> TNum |
Multiply numbers | |
replen |
[x] -> TNum -> [x] |
Repeat list to multiply its length by n | ||
repln' |
TNum -> [x] -> [x] |
replen with flipped arguments |
||
cart2 |
[x] -> [x] -> [[x]] |
Cartesian product with 2-element lists | ||
ccons |
[x] -> [[x]] -> [[x]] |
Cartesian product with cons
|
||
csnoc |
[[x]] -> [x] -> [[x]] |
Cartesian product with snoc
|
||
+ |
add |
TNum -> TNum -> TNum |
Add numbers | |
cat |
[x] -> [x] -> [x] |
Concatenate lists | ||
, |
pair |
x -> y -> (x, y) |
Construct pair | |
- |
sub |
TNum -> TNum -> TNum |
Subtract first argument from second | |
diffl |
(Concrete x) => [x] -> [x] -> [x] |
List difference | ||
del |
(Concrete x) => x -> [x] -> [x] |
Remove first occurrence of element from list | ||
. |
Decimal point | Used in floating point literals | ||
/ |
div |
TNum -> TNum -> TNum |
Floating point division | |
0 -9
|
Digits | Used in numeric literals | ||
: |
cons |
x -> [x] -> [x] |
Prepend a value to a list | |
snoc |
[x] -> x -> [x] |
Append a value to a list | ||
; |
pure |
x -> [x] |
Create singleton list | |
< |
lt |
(Concrete x) => x -> x -> TNum |
Less than | |
= |
eq |
(Concrete x) => x -> x -> TNum |
Equals | |
> |
gt |
(Concrete x) => x -> x -> TNum |
Greater than | |
? |
if |
(Concrete x) => y -> y -> x -> y |
Ternary if conditioned on third argument | |
if2 |
(Concrete x) => (x -> y) -> y -> x -> y |
If truthy, apply function, else give default value | ||
fif |
(Concrete x) => (z -> y) -> (z -> y) -> (z -> x) -> z -> y |
Ternary if for functions | ||
A |
mean |
[TNum] -> TNum |
Average of a list | |
B |
base |
TNum -> TNum -> [TNum] |
Digits in given base | |
abase |
TNum -> [TNum] -> TNum |
Interpret as digits in given base | ||
C |
cut |
TNum -> [a] -> [[a]] |
Cut into sublists of given length. Negative n counts lengths from the end. | |
cuts |
[TNum] -> [a] -> [[a]] |
Cut off substrings of given lengths. Negative n cuts from the end. | ||
D |
double |
TNum -> TNum |
Multiply by 2 | |
isuppr |
TChar -> TNum |
Is it an uppercase letter | ||
doubL |
[x]->[x] |
Repeats a list twice | ||
E |
same |
Concrete x => [x] -> TNum |
Are all elements equal? | |
F |
foldl |
(y -> x -> y) -> y -> [x] -> y |
Left fold | |
foldl1 |
(x -> x -> x) -> [x] -> x |
Left fold without initial value | ||
aptp |
(x -> y -> z) -> (x, y) -> z |
Apply binary function to tuple | ||
G |
scanl |
(y -> x -> y) -> y -> [x] -> [y] |
Scan from left | |
scanl1 |
(x -> x -> x) -> [x] -> [x] |
Scan from left without initial value | ||
scltp |
(x -> y -> z) -> (x, y) -> (z, y) |
Apply binary function to tuple, updating left element | ||
I |
id |
x -> x |
Identity function | |
J |
join |
[x] -> [[x]] -> [x] |
Join by a list | |
join' |
x -> [[x]] -> [x] |
Join by an element | ||
joinE |
[x] -> [x] -> [x] |
Join elements by a list | ||
joinV |
x -> [x] -> [x] |
Insert value between all elements | ||
K |
const |
x -> y -> x |
Constant function | |
L |
len |
[x] -> TNum |
Length of list | |
nlen |
TNum -> TNum |
Length of string representation | ||
M |
lmap |
(x -> y -> z) -> [x] -> y -> [z] |
Map over left argument | |
lmaptp |
(x -> z) -> (x, y) -> (z, y) |
Apply function to left element of tuple | ||
N |
nats |
[TNum] |
Infinite list of natural numbers | |
O |
sort |
(Concrete x) => [x] -> [x] |
Sort list in ascending order | |
P |
perms |
[a] -> [[a]] |
List of all permutations of the given list | |
Q |
slices |
[a] -> [[a]] |
All contiguous sublists | |
R |
replic |
TInt -> a -> [a] |
List composed by a given number of copies of a value | |
replif |
a -> TInt -> [a] |
replic with flipped arguments |
||
S |
hook |
(x -> y -> z) -> (x -> y) -> x -> z |
S-combinator | |
bhook |
(x -> y -> z) -> (x -> u -> y) -> x -> u -> z |
S-combinator with extra argument: S f g a b means f a (g a b)
|
||
T |
trsp |
[[a]] -> [[a]] |
Transpose a 2-d list, elements missing from shorter rows are skipped | |
trspw |
a -> [[a]] -> [[a]] |
Transpose using the given element to pad shorter rows | ||
unzip |
[(a, b)] -> ([a], [b]) |
Unzip a list of pairs | ||
U |
nubw |
Concrete a => [a] -> [a] |
Longest prefix of a list with all unique elements | |
V |
any |
Concrete b => (a->b) -> [a] -> TNum |
Index of first element satisfying predicate, 0 if not found | |
any2 |
Concrete b => (a->a->b) -> [a] -> TNum |
Index of first element satisfying the predicate in respect to the next element in the list, 0 if not found | ||
X |
slice |
TNum -> [a] -> [[a]] |
All subslists of length n. Negative n includes final stubs. | |
^ |
power |
TNum -> TNum -> TNum |
Second argument raised to the power of the first | |
_ |
neg |
TNum -> TNum |
Negate a number | |
tolowr |
TChar -> TChar |
Covert to lowercase | ||
` |
flip |
(x -> y -> z) -> y -> x -> z |
Invert order of arguments | |
a |
abs |
TNum -> TNum |
Absolute value | |
touppr |
TChar -> TChar |
Convert to uppercase | ||
c |
chr |
TNum -> TChar |
Convert integer to character | |
ord |
TChar -> TNum |
Convert character to integer | ||
chrL |
[TNum] -> [TChar] |
Convert list of codepoints to string | ||
ordL |
[TChar] -> [TNum] |
Convert string to list of codepoints | ||
d |
base10 |
TNum -> [TNum] |
Base-10 digits | |
abas10 |
[TNum] -> TNum |
Interpret in base 10 | ||
e |
list2 |
x -> x -> [x] |
Create a list with two elements | |
f |
filter |
(Concrete y) => (x -> y) -> [x] -> [x] |
Filter list by predicate | |
select |
(Concrete x) => [x] -> [y] -> [y] |
Filter list by another list | ||
g |
group |
(Concrete x) => [x] -> [[x]] |
Group equal adjacent values | |
h |
init |
[x] -> [x] |
Remove last element | |
i |
d2i |
TDouble -> TNum |
Convert from Double to Int by rounding (round half to even) | |
c2i |
TChar -> TNum |
Chars in "0123456789" return their digit value, other Chars return 0 | ||
s21 |
[TChar] -> TNum |
Return the first integer found inside the string | ||
k |
keyon |
Concrete y => (x -> y) -> [x] -> [[x]] |
Group list elements into classes by function value. Classes are ordered by the function values. | |
keyby |
Concrete y => (x -> x -> y) -> [x] -> [[x]] |
Group list elements into classes by equality predicate. Classes are ordered by occurrence. | ||
m |
map |
(x -> y) -> [x] -> [y] |
Map function over list | |
mapr |
[x -> y] -> x -> [y] |
Map list of functions over value | ||
maptp |
(x -> y) -> (x, x) -> (y, y) |
Map function over tuple | ||
n |
bwand |
TNum -> TNum -> TNum |
Bitwise AND | |
isect |
Concrete x => [x] -> [x] -> [x] |
List intersection, counting multiplicities | ||
o |
com |
(y -> z) -> (x -> y) -> x -> z |
Function composition | |
com2 |
(z -> u) -> (x -> y -> z) -> x -> y -> u |
Binary composition | ||
com3 |
(u -> v) -> (x -> y -> z -> u) -> x -> y -> z -> v |
Ternary composition | ||
com4 |
(v -> w) -> (x -> y -> z -> u -> v) -> x -> y -> z -> u -> w |
Quaternary composition | ||
p |
pfac |
TNum -> [TNum] |
Prime factorization | |
r |
read |
(Concrete x) => [TChar] -> x |
Convert string to value | |
s |
show |
(Concrete x) => x -> [TChar] |
Convert value to string | |
t |
tail |
[x] -> [x] |
Remove first element | |
u |
nub |
(Concrete x) => [x] -> [x] |
Remove duplicates | |
v |
bwor |
TNum -> TNum -> TNum |
Bitwise OR | |
union |
Concrete x => [x] -> [x] -> [x] |
List union: concatenate, removing duplicates from first argument | ||
ucons |
Concrete x => x -> [x] -> [x] |
Prepend unless already present | ||
usnoc |
Concrete x => [x] -> x -> [x] |
Append unless already present | ||
w |
words |
[TChar] -> [[TChar]] |
Split on spaces | |
unwords |
[[TChar]] -> [TChar] |
Join with spaces | ||
uwshow |
Concrete x => [x] -> [TChar] |
Join string representations with spaces | ||
uwpshw |
(Concrete x, Concrete y) => (x, y) -> [TChar] |
Join string representations with space | ||
x |
split |
Concrete x => x -> [x] -> [[x]] |
Split on given element | |
split' |
Concrete x => [x] -> x -> [[x]] |
Flipped version of split
|
||
splitL |
Concrete x => [x] -> [x] -> [[x]] |
Split on occurrences of sublist | ||
z |
zip |
(x -> y -> z) -> [x] -> [y] -> [z] |
Zip lists with function | |
| |
or |
(Concrete x) => x -> x -> x |
Second argument if truthy, else first | |
or' |
(Concrete x, Concrete y) => x -> y -> TNum |
Is any of the arguments truthy? | ||
~ |
branch |
(x -> y -> z) -> (u -> x) -> (v -> y) -> (u -> v -> z) |
Compose both arguments of binary function separately | |
₀ -₉
|
nul -nin
|
Subscript digits | Line labels | |
⌈ |
lce |
ceil |
TNum -> TNum |
Ceiling function |
⌉ |
rce |
lcm |
TNum -> TNum -> TNum |
Lowest common multiple |
⌊ |
lfl |
floor |
TNum -> TNum |
Floor function |
⌋ |
rfl |
gcd |
TNum -> TNum -> TNum |
Greatest common divisor |
Γ |
Gam |
list |
y -> (x -> [x] -> y) -> [x] -> y |
Pattern match on list |
listN |
(x -> [x] -> y) -> [x] -> y |
Pattern match on nonempty list | ||
listF |
y -> (([x] -> y) -> (x -> [x] -> y)) -> [x] -> y |
Recursive pattern match on list | ||
listNF |
(([x] -> y) -> (x -> [x] -> y)) -> [x] -> y |
Recursive pattern match on nonempty list | ||
Θ |
The |
prep0 |
[x]->[x] |
Prepends a default value of the appropriate type to a list. Default values are either falsy values (0,[],...) or functions returning those values. |
Λ |
Lam |
all |
Concrete b => (a->b) -> [a] -> TNum |
Check if all elements satisfy predicate, return 1/0 |
all2 |
Concrete b => (a->a->b) -> [a] -> TNum |
Check if all adjacent pairs of elements satisfy the predicate, return 1/0 | ||
Ξ |
Xi |
merge |
Concrete b => (a -> a -> b) -> [[a]] -> [a] |
Ξ f x merges the list of lists x preserving the order given by f . Each list should be ordered, and if there are more than 2 lists, their heads should also be ordered. Works on infinite lists. |
merge2 |
Concrete b => (a -> b) -> [[a]] -> [a] |
Like merge , but preserves order obtained by applying f to each value. |
||
Π |
Pi |
prod |
[TNum] -> TNum |
Product of list |
fact |
TNum -> TNum |
Factorial | ||
cartes |
[[x]] -> [[x]] |
Cartesian product | ||
Σ |
Sig |
sum |
[TNum] -> TNum |
Sum of list |
trianI |
TNum -> TNum |
Triangular number | ||
concat |
[[x]] -> [x] |
Concatenate lists | ||
Ψ |
Psi |
toadjM |
(((a, a) -> c) -> [(a,a)] -> [[(a, a)]]) -> (a -> a -> c) -> [a] -> [[a]] |
Apply higher-order function on adjacent pairs instead of single elements |
toadjL |
(((a, a) -> c) -> [(a,a)] -> [(a, a)]) -> (a -> a -> c) -> [a] -> [a] |
Like toadjL but result is a flat list |
||
toadjV |
(((a, a) -> c) -> [(a,a)] -> (a, a)) -> (a -> a -> c) -> [a] -> a |
Like toadjL but result is an element |
||
toadjN |
(((a, a) -> c) -> [(a,a)] -> b) -> (a -> a -> c) -> [a] -> b |
Like toadjL but result is any value |
||
Ω |
Ohm |
until |
Concrete y => (x -> y) -> (x -> x) -> x -> x |
Iterate function until test result is truthy |
ε |
eps |
small |
TNum -> TNum |
Has absolute value at most 1 |
single |
[x] -> TNum |
Has length 1 | ||
δ |
del |
decorM |
(((a, b) -> c) -> [(a,b)] -> [[(a,d)]]) -> (a -> b -> c) -> [a] -> [b] -> [[d]] |
Apply higher-order function using auxiliary list |
decorL |
(((a, b) -> c) -> [(a,b)] -> [(a,d)]) -> (a -> b -> c) -> [a] -> [b] -> [d] |
Like decorM but result is a flat list |
||
decorV |
(((a, b) -> c) -> [(a,b)] -> (a,d)) -> (a -> b -> c) -> [a] -> [b] -> d |
Like decorM but result is an element |
||
decorN |
(((a, b) -> c) -> [(a,b)] -> d) -> (a -> b -> c) -> [a] -> [b] -> d |
Like decorM but result is any value |
||
λ |
lam |
Small lambda | One-argument anonymous function | |
μ |
mu |
Small mu | Two-argument anonymous function | |
ξ |
xi |
Small xi | Three-argument anonymous function | |
π |
pi |
cpow |
TNum -> [x] -> [[x]] |
Cartesian power |
cpow' |
[x] -> TNum -> [[x]] |
Flipped version of cpow
|
||
cpowN |
TNum -> TNum -> [[TNum]] |
Cartesian power of range [1..n] | ||
σ |
sjg |
subs |
(Concrete x) => x -> x -> [x] -> [x] |
Substitute value in list |
subs2 |
(Concrete x) => [x] -> [x] -> [x] -> [x] |
Substitute sublist in list | ||
φ |
phi |
Small phi | Self-referential anonymous function | |
χ |
chi |
Small chi | Self-referential anonymous function with 2 extra arguments | |
ψ |
psi |
Small psi | Self-referential anonymous function with extra argument | |
ω |
ohm |
fixp |
(Concrete x) => (x -> x) -> x -> x |
Find periodic point by iterating |
fixpL |
(Concrete x) => (x -> [x]) -> x -> [x] |
Find periodic point under concatenation | ||
⁰ -⁹
|
Nul -Nin
|
Superscript digits | Lambda arguments | |
¢ |
cnt |
cycle |
[x] -> [x] |
Repeat list infinitely |
£ |
gbp |
oelem |
(Concrete x) => [x] -> x -> TNum |
Like elem , but the list is supposed to be sorted |
oelem' |
(Concrete x) => x -> [x] -> TNum |
oelem with flipped arguments |
||
€ |
eur |
elem |
(Concrete x) => [x] -> x -> TNum |
Index of first occurrence, or 0 if not found |
elem' |
(Concrete x) => x -> [x] -> TNum |
elem with flipped arguments |
||
subl |
(Concrete x) => [x] -> [x] -> TNum |
Index of first beginning of the sublist, or 0 if not found | ||
ƒ |
fl |
fix |
(x -> x) -> x |
Least fixed point (used for recursion) |
´ |
acu |
argdup |
(x -> x -> y) -> x -> y |
Apply twice to same argument |
▲ |
top |
max |
(Concrete x) => x -> x -> x |
Maximum of two values |
maxl |
(Concrete x) => [x] -> x |
Maximum of list | ||
▼ |
bot |
min |
(Concrete x) => x -> x -> x |
Minimum of two values |
minl |
(Concrete x) => [x] -> x |
Minimum of list | ||
► |
est |
minby |
Concrete y => (x -> x -> y) -> x -> x -> x |
Minimum of two values with custom ordering predicate |
minon |
Concrete y => (x -> y) -> x -> x -> x |
Value that minimizes function result | ||
minlby |
Concrete y => (x -> x -> y) -> [x] -> x |
Minimum element with custom ordering predicate | ||
minlon |
Concrete y => (x -> y) -> [x] -> x |
Element that minimizes function result | ||
◄ |
wst |
maxby |
Concrete y => (x -> x -> y) -> x -> x -> x |
Maximum of two values with custom ordering predicate |
maxon |
Concrete y => (x -> y) -> x -> x -> x |
Value that maximizes function result | ||
maxlby |
Concrete y => (x -> x -> y) -> [x] -> x |
Maximum element with custom ordering predicate | ||
maxlon |
Concrete y => (x -> y) -> [x] -> x |
Element that maximizes function result | ||
§ |
sec |
fork |
(x -> y -> z) -> (u -> x) -> (u -> y) -> u -> z |
Compose each argument of binary function |
fork2 |
(x -> y -> z) -> (u -> v -> x) -> (u -> v -> y) -> u -> v -> z |
Compose each argument of binary function with binary function | ||
Ḋ |
dD |
divs |
TNum -> [TNum] |
List of divisors |
Ḟ |
dF |
foldr |
(x -> y -> y) -> y -> [x] -> y |
Right fold |
foldr1 |
(x -> x -> x) -> [x] -> x |
Right fold without initial value | ||
apftp |
(y -> x -> z) -> (x, y) -> z |
Apply flipped function to tuple | ||
Ġ |
dG |
scanr |
(x -> y -> y) -> y -> [x] -> [y] |
Scan from right |
scanr1 |
(x -> x -> x) -> [x] -> [x] |
Scan from right without initial value | ||
scrtp |
(x -> y -> z) -> (x, y) -> (x, z) |
Apply binary function to tuple, updating right element | ||
İ |
dI |
Dotted capital I | Access built-in integer sequences | |
Ṁ |
dM |
rmap |
(x -> y -> z) -> x -> [y] -> [z] |
Map over right argument |
rmaptp |
(y -> z) -> (x, y) -> (x, z) |
Apply function to right element | ||
Ṗ |
dP |
powset |
[x] -> [[x]] |
All finite subsequences |
powstN |
TNum -> [x] -> [[x]] |
Subsequences of length n. Negative n gives subsequences of length up to -n. | ||
Ṙ |
dR |
clone |
TNum -> [x] -> [x] |
Replicate each element by given number |
clone' |
[x] -> TNum -> [x] |
clone with flipped arguments |
||
clones |
[TNum] -> [x] -> [x] |
Replicate each element by corresponding number | ||
Ṡ |
dS |
hookf |
(x -> y -> z) -> (y -> x) -> y -> z |
Like S , but composes on other argument |
bhookf |
(x -> y -> z) -> (u -> y -> x) -> u -> y -> z |
Like binary S , but composes on other argument: Ṡ f g a b means f (g a b) b
|
||
Ṫ |
dT |
table |
(x -> y -> z) -> [x] -> [y] -> [[z]] |
Outer product, or "multiplication table" |
Ẋ |
dX |
mapad2 |
(x -> x -> y) -> [x] -> [y] |
Map over pairs of adjacent values |
mapad3 |
(x -> x -> x -> y) -> [x] -> [y] |
Map over triples of adjacent values | ||
ḋ |
dd |
base2 |
TNum -> [TNum] |
Binary digits |
abase2 |
[TNum] -> TNum |
Interpret in base 2 | ||
ė |
de |
list3 |
x -> x -> x -> [x] |
Create a list with three elements |
ḟ |
df |
find |
(Concrete y) => (x -> y) -> [x] -> x |
Return first value that gives truthy result |
findN |
(Concrete x) => (TNum -> x) -> TNum -> TNum |
Return first number at least n that gives truthy result | ||
ġ |
dg |
groupOn |
(Concrete y) => (x -> y) -> [x] -> [[x]] |
Group on function result |
groupBy |
(Concrete y) => (x -> x -> y) -> [x] -> [[x]] |
Group by equality predicate | ||
ḣ |
dh |
heads |
(Concrete x) => x -> [x] |
Prefixes for lists, range for numbers |
ŀ |
dl |
lrange |
TNum -> [TNum] |
Lowered range (from 0 to n-1) |
ixes |
[x] -> [TNum] |
The range [1 .. length(x)] | ||
ṁ |
dm |
cmap |
(x -> [y]) -> [x] -> [y] |
Map function over list and concat the result |
smap |
(x -> TNum) -> [x] -> TNum |
Map function over list and sum the result | ||
cmapr |
[x -> [y]] -> x -> [y] |
Map list of functions over value and concat the result | ||
smapr |
[x -> TNum] -> x -> TNum |
Map list of functions over value and sum the result | ||
ȯ |
do |
Too many to list | Composition of three functions; ȯABC is roughly equivalent to (ABC)
|
|
ṗ |
dp |
isprime |
TNum -> TNum |
Return the index of the argument in the list of all primes, or 0 if it is not a prime number |
ṙ |
dr |
rotate |
TNum -> [a] -> [a] |
Rotate n steps to the left |
rotatf |
[a] -> TNum -> [a] |
rotate with flipped arguments |
||
ṡ |
ds |
srange |
TNum -> [TNum] |
Symmetric range (from -n to n) |
rvixes |
[x] -> [TNum] |
ixes reversed |
||
ṫ |
dt |
tails |
(Concrete x) => x -> [x] |
Suffixes for lists, reversed range for numbers |
ż |
dz |
zip' |
(a -> a -> a) -> [a] -> [a] -> [a] |
Like zip, but keeps trailing elements from the longer list unchanged. |
¨ |
die |
Dieresis | Delimiter for compressed strings | |
Ë |
DE |
sameon |
Concrete y => (x -> y) -> [x] -> TNum |
Are function results all equal |
sameby |
Concrete y => (x -> x -> y) -> [x] -> TNum |
Are all values equal by a predicate? Checks p x y for all pairs x, y that occur in this order. |
||
Ö |
DO |
sorton |
(Concrete y) => (x -> y) -> [x] -> [x] |
Sort by function result |
sortby |
(Concrete y) => (x -> x -> y) -> [x] -> [x] |
Sort using ordering predicate. In Ö p , p x y is interpreted as "x is greater than y ". |
||
ë |
De |
list4 |
x -> x -> x -> x -> [x] |
Create a list with four elements |
ö |
Do |
Too many to list | Composition of four functions; öABCD is roughly equivalent to (ABCD)
|
|
ü |
Du |
nubon |
(Concrete x) => (x -> y) -> [x] -> [x] |
Remove duplicates by function result |
nubby |
(Concrete x) => (x -> x -> y) -> [x] -> [x] |
Remove duplicates using equality predicate | ||
ø |
so |
empty |
[x] |
Empty list |
□ |
squ |
square |
TNum -> TNum |
Raise to second power |
isanum |
Is it alphanumeric | |||
¶ |
pgf |
lines |
[TChar] -> [[TChar]] |
Split on newlines |
unlines |
[[TChar]] -> [TChar] |
Join by newlines | ||
ulshow |
Concrete x => [x] -> [TChar] |
Join string representations by newlines | ||
ulpshw |
(Concrete x, Concrete y) => (x, y) -> [TChar] |
Join string representations with newline | ||
« |
ll |
mapacL |
(x -> y -> x) -> (x -> y -> z) -> x -> [y] -> [z] |
Scanl over a list with the first function, but results are produced by applying the second function to intermediate steps |
» |
rr |
mapacR |
(y -> x -> x) -> (y -> x -> z) -> x -> [y] -> [z] |
Scanr over a list with the first function, but results are produced by applying the second function to intermediate steps |
This is the list of functions applied to overflowing line labels:
| argdup
| flip
| map
| zip
| hook
|