Pie documentation
These docs go from your first line of Pie to the strange corners. Every example with a Run button opens in the playground, so you can poke at it.
Getting started
Hello, world
__builtin_print("Hello, world!");Hello, world!
Anything whose name starts with __builtin_ is provided by the interpreter.
Those names are long on purpose: you are meant to give them nicer names
yourself.
print = __builtin_print;
print("Much better.");Much better.
Every expression ends with a semicolon, including the last one in a block.
Running Pie
Install Pie from the releases page or build it from source (see Installing). Then:
| Command | What it does |
|---|---|
pie file.pie |
Run a file |
pie |
Start the REPL |
pie -c "code" |
Run code passed on the command line |
pie -t file.pie |
Print the tokens before running |
pie -a file.pie |
Print the parsed program before running |
pie -n file.pie |
Parse only, don't run |
pie -v |
Print the version |
The starter operators
Pie ships with zero operators. Even + is something you define:
infix + = (a, b) => __builtin_add(a, b);
__builtin_print(1 + 2);3
Most examples below use a small set of operators so they can focus on one idea at a time. Examples marked uses the starter operators run with this code in front of them:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));By the end of the Operators chapter, you'll understand every line of it.
Comments
.: A line comment starts with a dot and a colon.
.::
A block comment can span
starts with a dot and 2 colons
and ends with 2 colons and a dot
::.Values
Numbers
Ints have arbitrary precision, so they never overflow. Doubles are regular
64-bit floating point numbers.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));print(2 * 3);
print(10 / 4);
print(10.0 / 4);
print(__builtin_pow(2, 100));6 2 2.500000 1267650600228229401496703205376
Dividing two Ints gives an Int. Use a Double on either side to get a
Double.
There are no negative literals. Names in Pie can contain symbols, so
-3is a name, not a number. Write- 3(with the starterprefix -) or__builtin_neg(3). The same goes for operators in general: put spaces around them, becausen-1is a single name.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));n = 10;
print(n - 1);
print(- 3);9 -3
Booleans
true and false. Combine them with __builtin_and, __builtin_or and
__builtin_not, or with the starter operators and, or and not.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));print(1 < 2 and 2 < 3);
print(not true or false);true false
Strings
Strings use double quotes and the usual escapes (\n, \t, \", \\).
Any {expression} inside a string is evaluated and spliced in, so every string
is a format string. Escape a brace with \{.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));name = "Pie";
age = 3;
print("{name} is {age} years old. Next year: {age + 1}.");
print("Literal braces: \{like this\}");Pie is 3 years old. Next year: 4.
Literal braces: {like this}Lists
A list is a comma-separated sequence in braces. {} is the empty list.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));fruits = {"apple", "cherry", "pecan"};
print(fruits);
print(__builtin_len(fruits));
print(__builtin_get(fruits, 1));
__builtin_push(fruits, "pumpkin");
__builtin_set(fruits, 0, "blueberry");
print(fruits);{apple, cherry, pecan}
3
cherry
{blueberry, cherry, pecan, pumpkin}Maps
A map is a set of key: value pairs in braces. {:} is the empty map. Keys can
be any value.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));stock = {"apple": 3, "cherry": 0};
print(__builtin_get(stock, "apple"));
__builtin_set(stock, "cherry", 12);
print(__builtin_get(stock, "cherry"));
print(__builtin_len(stock));3 12 2
Maps don't keep insertion order, so printing a whole map can list its pairs in any order.
Tuples
A tuple is a comma-separated sequence in parentheses. Where a list is a row of
things of the same kind, a tuple is a few things that belong together, like a
point's x and y.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));point = (3, 4);
print(point);
print(__builtin_len(point));
print(__builtin_get(point, 0));
print((5,));
print(());(3, 4) 2 3 (5,) ()
A one-element tuple needs a trailing comma, because (5) is just 5 in
parentheses. () is the empty tuple. Pie uses it as its unit: the value
that means "nothing to report".
A pack can be spread into a tuple with a trailing ...:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));wrap = (...xs) => (0, xs..., 9);
print(wrap(1, 2));(0, 1, 2, 9)
Blocks
A block is a list of expressions in braces. It runs them in order and becomes the value of the last one.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));answer = {
a = 40;
b = 2;
a + b;
};
print(answer);42
{ }is an empty list, not an empty block. A block always has at least one expression followed by a;.
Variables
Assignment
The first assignment to a name declares it. Later assignments change it.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));x = 1;
x = "now a string";
print(x);now a string
Types
Add a type after the name to restrict what it can hold. A name without a type
has type Any.
count: Int = 1;
count = 2;
count = "three";Running this stops at the last line:
error: In assignment: count = "three" Type mis-match! Expected: Int, got: String
Writing a type again declares a new variable that replaces the old one, even with a different type:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));value: Int = 5;
value: String = "five";
print(value);five
Inferred types
:= declares a variable whose type is the type of its value.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));x := 10;
print(__builtin_decltype(x));
y = 10;
print(__builtin_decltype(y));Int Any
__builtin_type gives the type of a value. __builtin_decltype gives the
declared type of a variable.
Scopes
Blocks create scopes. Assigning to a name that already exists outside changes the outer variable. Adding a type declares a fresh one that only lives inside the block.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));x = 5;
y = "hi";
{
x = 10;
y: Any = "bye";
};
print(x);
print(y);10 hi
Prefix a name with :: to reach the global variable, skipping anything in
between that shadows it.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));x = "global";
f = () => {
x: String = "local";
::x = "changed from inside";
x;
};
print(f());
print(x);local changed from inside
Assign to anything
The left side of = can be any expression. Pie remembers the assignment
and uses it whenever that exact expression shows up again.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));1 = 2;
print(1);
print(1 + 1);
2 + 2 = 5;
print(2 + 2);
"Hello" = "Goodbye";
print("Hello");2 4 5 Goodbye
Only plain names can have a type annotation. 1: Int = 5; is an error.
Functions
Closures
A function is a parameter list, => and a body.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));square = (x) => x * x;
print(square(7));
greet = (name) => {
message = "Hello, {name}!";
print(message);
};
greet("Pie");49 Hello, Pie!
Functions are values like any other. There is no return: a function gives
back the value of its body.
Typed parameters
Parameters and the result can have types. Anything left out is Any.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));area = (w: Int, h: Int): Int => w * h;
print(area(3, 4));12
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));area = (w: Int, h: Int): Int => w * h;
area(3, "four");Named arguments
Arguments can be passed by name, in any order, and mixed with positional ones. (Unless the parameter is positional-only.)
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));describe = (name, food, count) => print("{name} ate {count} {food}");
describe("Ali", "pies", 3);
describe(count = 2, food = "tarts", name = "Pie");
describe(food = "muffins", "Sam", 9);Ali ate 3 pies Pie ate 2 tarts Sam ate 9 muffins
Default values
Parameters can have default values.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));slice = (size, count = 8) => print("{count} slices of {size}");
slice("large");
slice("small", 4);8 slices of large 4 slices of small
Variadic functions
A parameter written ...name collects any number of arguments into a pack.
A function can have one, anywhere in its parameter list.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));first = (head, ...rest) => head;
last = (...init, end) => end;
print(first(1, 2, 3));
print(last(1, 2, 3));
count = (...things) => __builtin_len(things);
print(count());
print(count("a", "b", "c"));1 3 0 3
Put ... after a pack to spread it back out into separate arguments:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));add3 = (a, b, c) => a + b + c;
forward = (...args) => add3(args...);
print(forward(1, 2, 3));6
Packs get their own chapter: Packs and folds.
Positional-only and keyword-only parameters
A ; in a parameter list is a wall between "by position" and "by name".
Everything before it is positional-only, and everything after it is
keyword-only.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));point = (x, y;) => print(x, y);
point(1, 2);
greet = (; name, greeting = "Hello") => print("{greeting}, {name}!");
greet(name = "Pie");
greet(greeting = "Hi", name = "Ali");1 2 Hello, Pie! Hi, Ali!
With two walls, the parameters in the middle can be passed either way:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));bake = (flavor; size, slices = 8; hot = false) => print("{flavor} {size} {slices} {hot}");
bake("apple", "large");
bake("cherry", slices = 6, size = "small", hot = true);apple large 8 false cherry small 6 true
| You write | Positional-only | Either | Keyword-only |
|---|---|---|---|
(a, b) |
a, b |
||
(a, b;) |
a, b |
||
(; a, b) |
a, b |
||
(a; b) |
a |
b |
|
(a; b;) |
a |
b |
|
(; a; b) |
a |
b |
|
(a; b; c) |
a |
b |
c |
Keyword-only parameters are what make options after a pack work. Without the
;, end would take the last word instead:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));shout = (...words; end = "!") => print((words + ... + " ") + end);
shout("pie", "is", "great");
shout("really", end = "?");pie is great! really?
Keyword-only defaults can come in any order, since they're never filled by
position: (; mode = "fast", target) is fine.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));point = (x, y;) => print(x, y);
point(x = 1, y = 2);Currying
Call a function with fewer arguments than it needs and you get back a function waiting for the rest.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));add = (a, b) => a + b;
addTen = add(10);
print(addTen(5));
print(add(1)(2));15 3
A missing keyword-only argument curries too:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));greet = (; name, greeting = "Hello") => print("{greeting}, {name}!");
welcome = greet(greeting = "Welcome");
welcome(name = "Ali");Welcome, Ali!
Calling right away
A function literal followed by (...) runs immediately.
() => {
__builtin_print("I ran!");
}();I ran!
Destructuring parameters
A parameter can be a pattern that pulls apart its argument. Patterns are explained in Unpacking.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));sum = ({a, b}) => a + b;
print(sum({3, 4}));
Point = class { x = 0; y = 0; };
norm1 = ({x, y}: Point) => x + y;
print(norm1(Point(2, 5)));7 7
Operators
Defining operators
An operator is a function bound to a symbol (or a word) with one of five keywords. The keyword says where the operator goes:
| Kind | Looks like | Function takes |
|---|---|---|
prefix |
- x |
1 argument |
infix |
a + b |
2 arguments |
suffix |
n ! |
1 argument |
exfix |
| x | |
1 argument |
mixfix |
if a then b else c |
one per : |
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
prefix(!) double = (x) => x + x;
suffix([]) squared = (x) => __builtin_mul(x, x);
print(double 21);
print(5 squared);42 25
Operator names can be symbols, words or a mix of both. Because operators are just names, any symbol you haven't defined is free to use as a variable name.
Precedence
The parentheses after the keyword set the precedence. Use an existing operator
to say "the same as this one". When the operator is one Pie already knows
(like + or *), you can leave the precedence out.
print = __builtin_print;
infix(+) plus = (a, b) => __builtin_add(a, b);
infix(*) times = (a, b) => __builtin_mul(a, b);
print(1 plus 2 times 3);7
Add + or - to nudge it one step higher or lower. Nudges never cross into
the next level: * - is still above +.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix(+ +) times = (a, b) => __builtin_mul(a, b);
print(1 + 2 times 3);7
Your own operators can be precedence levels too: infix(plus +) .... The
special levels LOW and HIGH sit below and above everything else and are
always nudged: LOW + or HIGH -.
The built-in precedence levels, from lowest to highest:
| Level | Operators |
|---|---|
| Assignment | = |
| Logical or | || |
| Logical and | && |
| Bitwise or | | |
| Bitwise xor | ^ |
| Bitwise and | & |
| Equality | == != |
| Comparison | < <= > >= |
| Three-way | <=> |
| Shift | << >> |
| Additive | + - |
| Multiplicative | * / % |
| Unary | ! ~ |
| Subscript | [] |
| Call | () |
| Scope | :: |
Exfix operators
An exfix operator wraps its argument. Separate the opening and closing names
with a :.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));exfix | : | = (x) => if x < 0 then - x else x;
print(| 3 - 10 |);7
Mixfix operators
A mixfix operator is a sentence with holes. Write a : wherever an argument
goes.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));mixfix(LOW +) clamp : between : and : =
(x, lo, hi) => if x < lo then lo else if x > hi then hi else x;
print(clamp 15 between 0 and 10);
print(clamp 5 between 0 and 10);10 5
The starter if : then : else : is a mixfix operator. It uses
syntax parameters so that only one branch runs.
Overloading
Define an operator more than once with different parameter types, and Pie picks the definition that fits the arguments.
print = __builtin_print;
infix + = (a: Int, b: Int) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
print(1 + 2);
print("Pie" + " is sweet");3 Pie is sweet
Operators are scoped
An operator only exists in the block where it was defined, just like a variable.
{
infix + = (a, b) => __builtin_add(a, b);
__builtin_print(1 + 2);
};
__builtin_print("+ is gone out here");3 + is gone out here
Operators can also be recursive:
suffix ! = (n) => __builtin_conditional(
__builtin_lt(n, 2),
1,
__builtin_mul(n, __builtin_sub(n, 1) !)
);
__builtin_print(20 !);2432902008176640000
Control flow
Conditionals
The only built-in conditional is __builtin_conditional(cond, then, else).
It only evaluates the branch it picks.
age = 12;
__builtin_print(__builtin_conditional(__builtin_geq(age, 13), "teen", "kid"));kid
That's enough to build any if you like. The starter operators define
if : then : else ::
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));fib = (n) => if n < 2 then n else fib(n - 1) + fib(n - 2);
print(fib(20));
grade = (score) =>
if score >= 90 then "A"
else if score >= 80 then "B"
else "keep practicing";
print(grade(95));
print(grade(70));6765 A keep practicing
For a match-based alternative, see Pattern matching.
Loops
There is one loop keyword, loop. What it does depends on what you give it.
| You give it | It runs |
|---|---|
an Int n |
n times, counting from 0 |
a Bool |
while the condition is true |
| a list, tuple, string or pack | once per element |
| an object | once per value from its next() |
| nothing | forever, until break |
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));loop 3 {
print("hip hip");
};
loop i : 3 {
print("i = {i}");
};hip hip hip hip hip hip i = 0 i = 1 i = 2
name : before the operand names the loop variable. The braces are optional
when the body is a single expression.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));loop fruit : {"apple", "cherry"} print("I like {fruit} pie");
n = 3;
loop n > 0 {
print(n);
n = n - 1;
};I like apple pie I like cherry pie 3 2 1
Break and continue
break value stops the loop, and the loop evaluates to value. continue
skips to the next round.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));firstBig = loop x : {3, 8, 12, 20} {
if x > 10 then (break x) else 0;
};
print(firstBig);
loop i : 5 {
if i % 2 == 0 then (continue) else 0;
print(i);
};12 1 3
break and continue grab everything after them, so wrap them in parentheses
when they sit inside a bigger expression like if ... then ... else.
A loop that finishes without break evaluates to the value of its last round.
Iterators
Any object with a hasNext() method and a next() method can be looped over.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Countdown = class {
from = 0;
hasNext = () => from > 0;
next = () => {
current = from;
from = from - 1;
current;
};
};
loop n : Countdown(3) print(n);
print("liftoff");3 2 1 liftoff
Comprehensions
Put a loop inside braces with => to build a list, or with key: value to
build a map. A , after the loop operand adds a filter.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));squares = { loop i : 6 => i * i };
print(squares);
odds = { loop i : 10, i % 2 == 1 => i };
print(odds);
doubled = { loop i : 3 => i : i * 2 };
print(__builtin_get(doubled, 2));{0, 1, 4, 9, 16, 25}
{1, 3, 5, 7, 9}
4Defer
__builtin_defer(expr) runs expr when the current function, loop round or
program ends. Deferred expressions run last-in, first-out.
cleanup = () => {
__builtin_defer(__builtin_print("closing the oven"));
__builtin_defer(__builtin_print("taking the pie out"));
__builtin_print("baking");
};
cleanup();baking taking the pie out closing the oven
Classes
Defining a class
A class is a block of assignments after the class keyword. Every member must
have a starting value. Calling the class constructs an object: arguments fill
the members in order, and members without an argument keep their starting
value.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Pie = class {
filling: String = "apple";
slices: Int = 8;
describe = () => print("A {filling} pie with {slices} slices");
};
Pie().describe();
Pie("cherry").describe();
Pie("pecan", 6).describe();A apple pie with 8 slices A cherry pie with 8 slices A pecan pie with 6 slices
Classes are values: Pie above is a variable that holds a class, and it can be
used as a type.
Members and self
Methods can read and change members directly. self is the object itself.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Counter = class {
count = 0;
bump = () => count = count + 1;
me = () => self;
};
c = Counter();
c.bump();
c.bump();
print(c.count);
print(c.me().count);2 2
Printing objects
Objects print their members. Give a class a toString method that returns a
string to control how it prints.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Fraction = class {
top = 1;
bottom = 2;
toString = () => "{top}/{bottom}";
};
print(Fraction(3, 4));3/4
Cascades
object..method() calls a method and gives back the object instead of the
method's result. Chain them to build objects step by step.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Order = class {
items = {};
add = (item) => __builtin_push(items, item);
};
order = Order()..add("apple pie")..add("tea");
print(order.items);{apple pie, tea}Structural typing
An object fits a class type when it has all of that class's members with matching types. The class it was built from doesn't matter.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Named = class { name = ""; };
Person = class { name = ""; age = 0; };
hello = (who: Named) => print("Hello, {who.name}!");
hello(Person("Ali", 30));Hello, Ali!
Types
Built-in types
| Type | Values |
|---|---|
Int |
Whole numbers of any size |
Double |
Floating point numbers |
Bool |
true and false |
String |
Text |
Any |
Anything at all |
Type |
Types themselves |
Syntax |
Unevaluated code (see Syntax and eval) |
() |
The empty tuple, Pie's unit |
Compound types
| Type | Meaning |
|---|---|
{T} |
A list of T |
{K: V} |
A map from K to V |
(A, B) |
A tuple of an A and a B ((A,) has one element) |
(A, B) -> R |
A function from A and B to R |
...T |
A pack of T |
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));names: {String} = {"Ali", "Pie"};
ages: {String: Int} = {"Ali": 30};
origin: (Int, Int) = (0, 0);
twice: (Int) -> Int = (x: Int): Int => x * 2;
print(twice(21));42
A function type is the parameter types in parentheses, ->, then the result
type. => always makes a function and -> always makes a function type.
Function types
Function types have the same walls as parameter lists. Keyword-only entries need a name, because that's how they're passed.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Greeter = (String; times: Int) -> Any;
print(Greeter);
print(__builtin_type((a; b; c) => 0));(String; times: Int) -> Any (Any; Any; c: Any) -> Any
A function fits a function type when it accepts every call the type allows:
- Positional-only and either are the same in a type, since a type has no names to pass them by.
- Extra parameters are fine, as long as they have defaults.
- Keyword-only parameters are matched by name, in any order.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Draw = (Int; color: String) -> Any;
d: Draw = (size: Int, outline = false; alpha = 1.0, color: String) => print("{size} {color}");
d(3, color = "red");3 red
Draw = (Int; color: String) -> Any;
d: Draw = (size: Int; colour: String) => 0;Tuple types
A tuple type lists a type for each position.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));pair: (String, Int) = ("Pie", 3);
print(pair);
print(__builtin_type((1, "a", true)));(Pie, 3) (Int, String, Bool)
pair: (Int, Int) = (1, "two");A tuple can be given to a shorter tuple type. Only the first elements are kept:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));full = (1, true, 3.14);
short: (Int, Bool) = full;
print(short);(1, true)
pair: (Int, Int) = (1,);Types are values
Types can be stored in variables, passed to functions and printed. A type alias is just a variable.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Number = Int;
x: Number = 42;
print(Number);
print(__builtin_type(x));Int Int
Some types don't look like expressions. Put a : in front of them to write
them where an expression is expected.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Pair = :(Int, Int);
p: Pair = (1, 2);
print(Pair);(Int, Int)
Without the :, (Int, Int) is a tuple holding two types.
Since types are values, a parameter's type can depend on an earlier parameter:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));same = (T: Type, a: T, b: T) => print("both are {T}");
same(Int, 1, 2);
same(String, "x", "y");both are Int both are String
Unions
A union accepts a value of any of its member types.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Number = union { Int; Double; };
x: Number = 5;
x = 2.5;
print(x);2.500000
Number = union { Int; Double; };
x: Number = "five";Values as types
A value can be used as a type that only that value fits. Combined with unions, that gives you enumerations.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Size = union { "small"; "medium"; "large"; };
order: Size = "medium";
order = "large";
print(order);large
Size = union { "small"; "medium"; "large"; };
order: Size = "huge";Concepts
A function that returns a Bool can be used as a type. A value fits the type
when the function returns true for it.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Positive = (n: Int) => n > 0;
Small = (n: Int) => n < 10;
grow = (n: Positive): Small => n + 1;
print(grow(5));6
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Positive = (n: Int) => n > 0;
Small = (n: Int) => n < 10;
grow = (n: Positive): Small => n + 1;
grow(9);Parameter types act as preconditions and the return type as a postcondition, so this is design by contract for free.
Conversions
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));print(__builtin_to_int("42") + 1);
print(__builtin_to_double(3));
print(__builtin_to_string(12) + "!");43 3.000000 12!
Unpacking
Unpacking lists and objects
Put a pattern of names in braces on the left of = to pull a list or object
apart. This is called an unpackment.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{a, b, c} = {1, 2, 3};
print(a, b, c);
Person = class { name = ""; age = 0; };
{who, years} = Person("Ali", 30);
print("{who} is {years}");1 2 3 Ali is 30
Object members are matched by position, not by name. Tuples unpack the same way:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{x, y} = (3, 4);
print(x + y);7
Collecting the rest
...name collects any number of elements into a pack. It can go anywhere in
the pattern. A bare ... skips elements without naming them.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{first, ...rest} = {1, 2, 3, 4};
print(first);
print(rest);
{head, ..., tail} = {"a", "b", "c", "d"};
print(head, tail);1 2, 3, 4 a d
Checking while unpacking
Each name in a pattern can have a type (: T) and a value (= v) that the
element must match. If it doesn't, the program stops with an error. The name
itself is optional.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{name: String, = 3} = {"Pie", 3};
print(name);Pie
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{name: String, = 3} = {"Pie", 4};Nested patterns
Patterns can contain patterns.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));{x, {y, z}} = {1, {2, 3}};
print(x + y + z);6
A ... followed by a pattern unpacks every remaining element with that
pattern, collecting each name into a pack.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Person = class { name = ""; age = 0; };
people = {Person("Ali", 30), Person("Pie", 3)};
{...{names, ages}} = people;
print(names);
print(ages);Ali, Pie 30, 3
Pattern matching
match compares a value against a list of patterns and runs the first one
that fits. Each case is pattern => expression;.
Matching values and types
= value matches a value, : Type matches a type, and a plain name matches
anything (and names it).
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));describe = (x) => match x {
= 0 => "zero";
: String => "some text";
: Double => "a decimal";
n => "the number {n}";
};
print(describe(0));
print(describe("hi"));
print(describe(2.5));
print(describe(7));zero some text a decimal the number 7
If no case matches, the program stops with an error.
Matching structure
Patterns from Unpacking work in match too, so you can match on
the shape of lists and objects. Put : ClassName after a pattern to require
an exact class.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Circle = class { r = 0; };
Rect = class { w = 0; h = 0; };
area = (shape) => match shape {
{r}: Circle => 3 * r * r;
{w, h}: Rect => w * h;
};
print(area(Circle(2)));
print(area(Rect(3, 4)));12 12
Guards
Add , condition after a pattern to only match when the condition is true.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));sign = (n) => match n {
x, x < 0 => "negative";
= 0 => "zero";
_ => "positive";
};
print(sign(- 4));
print(sign(0));
print(sign(9));negative zero positive
A bigger example
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Leaf = class { value = 0; };
Node = class { left = 0; right = 0; };
sum = (tree) => match tree {
{v}: Leaf => v;
{l, r}: Node => sum(l) + sum(r);
};
tree = Node(Leaf(1), Node(Leaf(2), Leaf(3)));
print(sum(tree));6
Packs and folds
Packs
A pack is a group of values that travels together. You get one from a
variadic parameter or a ... in a pattern. __builtin_len and __builtin_get
work on packs, and loop walks through them.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));show = (...items) => {
n = __builtin_len(items);
print("{n} items:");
loop item : items print("- {item}");
};
show("flour", "butter", "sugar");3 items: - flour - butter - sugar
Spread a pack with a trailing ... inside calls, lists or tuples:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));both = (...xs) => {xs..., xs...};
print(both(1, 2));{1, 2, 1, 2}Expressions on packs
Accessing a member or calling a method on a pack does it for every element and gives you a pack back.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));Person = class { name = ""; age = 0; };
names = (...people) => people.name;
print(names(Person("Ali"), Person("Pie")));Ali, Pie
Folds
A fold combines every element of a pack with an operator. Folds are always written in parentheses.
| Fold | Expands to |
|---|---|
(pack + ...) |
((a + b) + c) |
(... + pack) |
(a + (b + c)) |
(init + pack + ...) |
(((init + a) + b) + c) |
(... + pack + init) |
(a + (b + (c + init))) |
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));sum = (...xs) => (0 + xs + ...);
print(sum(1, 2, 3, 4));
print(sum());10 0
Folds without an initial value need at least one element.
Separated folds
A separated fold puts a value between the elements as it goes. It's handy for joining strings.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));join = (...words) => (words + ... + ", ");
print(join("flour", "butter", "sugar"));flour, butter, sugar
| Fold | Expands to |
|---|---|
(pack + ... + sep) |
((((a + sep) + b) + sep) + c) |
(sep + ... + pack) |
the same, folded from the right |
(init + pack + ... + sep) |
like the first, starting from init |
(sep + ... + pack + init) |
like the second, ending with init |
The operator on each side can differ: (xs + ... - 1) adds the elements and
subtracts 1 between them.
Syntax and eval
Syntax literals
Code in backticks is not run. It becomes a Syntax value you can run later
with __builtin_eval. Names in it are looked up when it runs, not when it's
written.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));later: Syntax = `price * 2`;
price = 5;
print(__builtin_eval(later));
price = 50;
print(__builtin_eval(later));10 100
Syntax parameters
Wrap a parameter name in backticks and the argument arrives as Syntax
instead of being evaluated. This is how you write your own control flow.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));twice = (`action`) => {
__builtin_eval(action);
__builtin_eval(action);
};
twice(print("pie!"));
unless = (cond, `body`) =>
__builtin_eval(__builtin_conditional(cond, `0`, body));
unless(1 > 2, print("1 is not bigger than 2"));pie! pie! 1 is not bigger than 2
Printing a Syntax value shows the code it holds:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));show = (`code`) => print(code);
show(1 + 2 * 3);Syntax {
(1 + (2 * 3))
}Matching code
A match case can be a piece of code in backticks. It matches a Syntax
value with the same shape. Inside it, $name is a hole: it matches any
code, and the case gets that code as Syntax under name.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));describe = (code) => match code {
`$a + $b` => print("adding", a, "and", b);
`$a * $b` => print("multiplying", a, "and", b);
_ => print("something else");
};
describe(`1 + 2`);
describe(`3 * 4`);
describe(`- 5`);adding Syntax {
1
} and Syntax {
2
}
multiplying Syntax {
3
} and Syntax {
4
}
something elseEverything outside the holes has to be the same. Using the same hole twice means "the same code both times":
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));double = (code) => match code {
`$a + $a` => "doubles it";
_ => "doesn't";
};
print(double(`x + x`));
print(double(`x + y`));doubles it doesn't
Pack holes
$...name matches any number of things in a row, like a function's arguments.
The case gets them as a pack:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));shape = (code) => match code {
`f()` => "no arguments";
`f($only)` => "one argument";
`f($first, $...rest, $last)` => "{__builtin_len({rest...})} in the middle";
};
print(shape(`f()`));
print(shape(`f(9)`));
print(shape(`f(1, 2, 3, 4)`));no arguments one argument 2 in the middle
Splicing
Holes work in syntax literals too. When the literal runs, each hole is filled in, so you can build new code out of old code:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));swap = (code) => match code {
`$a + $b` => `$b + $a`;
};
print(swap(`1 + 2 * 3`));Syntax {
((2 * 3) + 1)
}A hole is filled with whatever its name holds. Code goes in as it is, and numbers, strings and booleans go in as the code that writes them:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));n = 10;
name = "Pie";
print(`greet($name, $n * 2)`);Syntax {
greet("Pie", (10 * 2))
}That's enough to build working functions out of pieces:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));make = (param, body) => `($param) => $body`;
inc = __builtin_eval(make(`v`, `v + 1`));
print(inc(41));42
$...name splices every element of a pack or a list:
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));reverse = (code) => match code {
`$func($...args)` => {
backwards = __builtin_reverse({args...});
`$func($...backwards)`;
};
};
code = reverse(`print(1, 2, 3)`);
print(code);
__builtin_eval(code);Syntax {
print(3, 2, 1)
}
3 2 1Namespaces and modules
Namespaces
space groups names together. Unlike a class, a namespace can contain any
code, and it runs right away. Reach inside with ::.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));space bakery {
owner = "Pie";
open = (hour) => hour >= 7;
space menu {
special = "pecan";
};
};
print(bakery::owner);
print(bakery::open(9));
print(bakery::menu::special);Pie true pecan
Declaring a namespace again adds to it, so one namespace can be spread across several files.
.: Starter operators: Pie has none built in, so we make our own.
print = __builtin_print;
infix + = (a, b) => __builtin_add(a, b);
infix + = (a: String, b: String) => __builtin_concat(a, b);
infix - = (a, b) => __builtin_sub(a, b);
infix * = (a, b) => __builtin_mul(a, b);
infix / = (a, b) => __builtin_div(a, b);
infix % = (a, b) => __builtin_mod(a, b);
prefix - = (x) => __builtin_neg(x);
infix == = (a, b) => __builtin_eq(a, b);
infix != = (a, b) => __builtin_not(__builtin_eq(a, b));
infix < = (a, b) => __builtin_lt(a, b);
infix <= = (a, b) => __builtin_leq(a, b);
infix > = (a, b) => __builtin_gt(a, b);
infix >= = (a, b) => __builtin_geq(a, b);
infix(&&) and = (a, b) => __builtin_and(a, b);
infix(||) or = (a, b) => __builtin_or(a, b);
prefix(!) not = (x) => __builtin_not(x);
mixfix(LOW +) if : then : else : =
(cond, `yes`, `no`) => __builtin_eval(__builtin_conditional(cond, yes, no));space shop { a = 1; };
space shop { b = 2; };
print(shop::a + shop::b);3
use
use brings one name into the current scope. It is a reference, so changes go
both ways. use space brings in every name, and use name:: brings in only
the operators.
space math {
pi = 3.14159;
tau = 6.28318;
infix + = (a, b) => __builtin_add(a, b);
};
use math::pi;
__builtin_print(pi);
use math::;
__builtin_print(1 + 1);
use space math;
__builtin_print(tau);3.141590 2 6.283180
Imports
import path; runs another file (without the .pie) and makes its top-level
namespaces available. Its plain global variables stay private to it.
.: shapes.pie
space shapes {
square = (x) => __builtin_mul(x, x);
};.: main.pie
import shapes;
__builtin_print(shapes::square(4));The import expression evaluates to the last value in the imported file.
The playground runs a single file, so
importonly works with Pie installed on your computer.
The standard library
Pie comes with a small standard library in the std folder of the repository.
import std; gives you a std namespace with print, the arithmetic and
comparison operators, as for conversions ("5" as Int), the : ? : else :
conditional, Iota and Enumerate iterators, and more. Use use std::; to
bring its operators into scope.
Built-in functions
These are always available. Many accept named arguments.
Input and output
| Function | What it does |
|---|---|
__builtin_print(...values, sep = " ", end = "\n") |
Prints values, returns the last one |
__builtin_input_str() |
Reads a line as a String |
__builtin_input_int() |
Reads an Int |
__builtin_panic(...values) |
Stops the program with a message |
Arithmetic
| Function | What it does |
|---|---|
__builtin_add(a, b) |
a + b |
__builtin_sub(a, b) |
a - b |
__builtin_mul(a, b) |
a * b |
__builtin_div(a, b) |
a / b (whole numbers stay whole) |
__builtin_mod(a, b) |
Remainder |
__builtin_pow(a, b) |
a to the power b |
__builtin_neg(a) |
-a |
__builtin_abs(a) |
Absolute value |
__builtin_rand_int(lo, hi) |
Random Int between lo and hi |
Comparison and logic
| Function | What it does |
|---|---|
__builtin_eq(a, b) |
Equal (works on every value) |
__builtin_lt, __builtin_leq, __builtin_gt, __builtin_geq |
<, <=, >, >= |
__builtin_and(a, b), __builtin_or(a, b), __builtin_not(a) |
Logic |
__builtin_conditional(cond, then, else) |
Picks a branch, evaluating only that one |
Collections and strings
| Function | What it does |
|---|---|
__builtin_len(x) |
Length of a string, list, tuple, map or pack |
__builtin_get(x, i) |
Element i of a list, tuple or pack (or key i of a map) |
__builtin_set(x, i, v) |
Sets an element or map key |
__builtin_push(list, v) |
Adds to the end |
__builtin_pop(list) |
Removes and returns the last element |
__builtin_pop_front(list) |
Removes and returns the first element |
__builtin_insert_at(list, i, v) |
Inserts before position i |
__builtin_remove_at(list, i) |
Removes position i |
__builtin_reverse(x) |
Reversed copy |
__builtin_into_pack(list) |
Turns a list into a pack |
__builtin_concat(...strings) |
Joins strings |
__builtin_str_slice(s, start, end, step) |
Part of a string |
__builtin_str_split(s, sep) |
Splits into a list |
Types and conversion
| Function | What it does |
|---|---|
__builtin_type(x) |
Type of a value |
__builtin_decltype(x) |
Declared type of a variable |
__builtin_to_int, __builtin_to_double, __builtin_to_string |
Conversions |
__builtin_object_has(obj, "name") |
Whether an object has a member |
Evaluation
| Function | What it does |
|---|---|
__builtin_eval(syntax) |
Runs a Syntax value |
__builtin_defer(expr) |
Runs expr when the current scope ends |
__builtin_reset(x) |
Undoes an assign-to-anything for x |
The interpreter also has built-ins for files (__builtin_open_file and
friends) and for calling C libraries (__builtin_dlopen, __builtin_ffi_call).
The std/file.pie and std/ffi.pie modules wrap them. Neither works in the
playground.
Reference
Keywords
| Group | Keywords |
|---|---|
| Operators | prefix infix suffix exfix mixfix |
| Types | class union |
| Control | loop break continue match |
| Modules | space use import |
true, false, self and the built-in type names are values, not keywords,
so they can be reassigned. Everything else, including every operator, is a
name you define.
Reserved punctuation
( ) { } , ; : :: = := => -> . .. ... and backticks.
Installing
Prebuilt binaries for Linux and macOS are on the
releases page. To build from
source you need git, cmake, make and a C++23 compiler:
git clone https://github.com/AliAlmutawaJr/Pie cd Pie mkdir build && cd build cmake .. make