zesterer
commented
2 years ago The syntax is, broadly, a strange combination of Haskell, ML, and Rust. It has first-class functions, pattern-matching, and a variety of other features typical for functional languages.
Expression syntax is broadly similar to C-likes (you call a function f like f(a, b, c)) but differs a little in that it lacks block delimiters. This is because Tao is a pure language: no expression has side-effects, so there's never a need to execute statements, only return values. For this reason, almost everything in Tao is an expression. Here are a few examples:
Function calls
f(a, b)alternatively, the following syntax is equivalent to the above (but makes chaining function calls easier in many cases)
b:f(a)Conditionals
(ternary operators, in most C-like languages)
if condition then a else bVariable declaration
let five = 5 in
let six = 6 in
five + sixPattern matching:
(the final branch uses \ instead of | to avoid ambiguity)
match x in
| 0 => "zero"
| 1 => "one"
\ n => "a large number"Pattern-matching in particular is interesting and arises very often. If you're not used to functional languages, it might feel a little unintuitive but, but it's basically like C's switch on steroids: instead of just checking a single value, it can be used to check the structure of many different properties of a value, extracting sub-values from it. It works for many different types too: lists, data types, union types, integers, reals, and others can all be matched against.
Functions also support pattern-matching on their arguments directly. Consider a factorial function written in C:
int factorial(int n) {
if (n == 0) {
return 1;
} else {
return n * factorial(n - 1);
}
}In Tao, we can very efficiently express this with pattern-matching in a way that allows the compiler to check the exhaustivity of our logic (i.e: ensure that we've covered all cases, and that no runtime errors are possible):
fn factorial =
| 0 => 1
\ m ~ n + 1 => m * factorial(n)This m ~ n + 1 syntax might look a little confusing, but it might make more sense when I say that ~ allows us to bind a pattern to a variable (Rust uses @ for this). n + 1 is itself a pattern that matches any natural number greater than or equal to 1, and binds the value that's one less than it.
The end result of this is that the compiler can automatically determine that no underflow or unhandled cases exist in the resulting problem, allowing writing programs with significantly more confidence that they work correctly.
Another example is the len function which calculates the length of a list
fn len =
| [] => 0
\ [_ .. tail] => 1 + len(tail)Here, we have two patterns. The first binds on the empty list, [], the second on a list with 'at least one' item, [_ .. tail]. The first case is the 'base case': an empty list always has a length of 0. In the 'at least one element' case, we simply call the function len recursively with the tail of the list, adding 1 to the result.
As before, the compiler verifies that we're handling all possible cases and will throw an error if this is not the case. Definitely give it a try!
There is a lot more to explain about the syntax: I've not touched on sum types, tuples, classes (called 'typeclasses' or 'traits' in other languages: they aren't the same as C++-style classes!), etc. but hopefully this gives a taste of what Tao can do!
One thing I would mention is that Tao is still very experimental. I change the syntax relatively often and I'm still doing some pretty fundamental work on the compiler internals. I don't expect it to be usable for general-purpose programming for quite a while yet, if ever. If that's fine by you, then feel free to play around with it to see what you can get it to do (or, alternatively, figure out how it can be broken!).
Person-93
venil7
matthiasbeyer
Hi,
I think this language looks pretty cool and it'll be informative to see chumsky being used as intended by you, the original author.
However, I'm having trouble learning the language's syntax from the examples. If you have the time, would you be willing to write a brief explanation of the syntax?
I understand that this is a hobby project so I'm not looking for anything fancy, it's just that I'm interested in your thoughts on language design and I'd like to understand it a bit better. If I end writing any programs in tao that actually work, that would be entirely incidental.
If it'd be helpful/interesting to you, I can write an itemized list of things I find confusing with links to the relevant lines of code.