A statically-typed functional language with polymorphism, typeclasses, sum types, pattern-matching, first-class functions, currying, good diagnostics, and much more!
For more example programs, see...
examples/hello.tao
: Hello world in Taoexamples/adventure.tao
: A text adventure game written in Taoexamples/brainfuck.tao
: A brainfuck interpreter written in Tao
Right now, Tao is a hobby project and I have no plans to turn it into a production-worthy language. This may change as the project evolves, but I'd rather spend as much time experimenting with new language features for now. That said, I do have a few goals for the language itself:
-
Totality
- All programs must explicitly handle all inputs. There are no mechanisms for panicking, exceptions, etc. The goal is to build a type system that's expressive enough to prove the totality of a wide range of programs.
- In time, I'd like to see the language develop support for termination analysis techniques like Walther recursion.
-
Extreme optimisation
- A rather dogged and obnoxious opinion of mine is that the 'optimisation ceiling' for statically-typed, total functional programming languages is significantly higher than traditional imperative languages with comparably weak type systems. I want Tao to be a practical example of this that I can point to rather than deploying nebulous talking points about invariants.
- I've deliberately made sure that the core MIR of Tao has a very small surface area, making it amenable to a variety of optimisations and static analyses.
-
Learning
- I have only a high-school knowledge of mathematics. I want to use Tao as a test bench to help me learn more about mathematics, proofs, type systems, logic, and computation.
- In addition, I hope that Tao can serve as a useful tool for others looking to get into language design, compiler development, or simply functional programming in general.
- Hindley-Milner type inference
- Useful error messages
- Algebraic data types
- Sum types
- Record types
- Type generic
- Nominal aliases (i.e:
data Metres = Real
)
- Type alises
- Pattern matching
- Destructuring and binding
- ADT patterns
- List patterns (
[a, b, c]
,[a, b .. c]
, etc.) - Arithmetic patterns (i.e:
n + k
) - Inhabitance checks (i.e:
None
exhaustively coversMaybe Never
) - Recursive exhaustivity checks
-
let
does pattern matching
- First-class functions
- Functions support pattern-matching
- Currying
- Type polymorphism (for both types and values)
- Typeclasses
- Associated types
- Built-in lists
- Dedicated list construction syntax (
[a, b, c]
,[a, b .. c, d]
, etc.)
- Dedicated list construction syntax (
- Explicit tail call optimisation
- MIR optimiser
- Monomorphisation of generic code
- Inlining
- Const folding
- Symbolic execution
- Dead code removal
- Exhaustive pattern flattening
- Unused function pruning
- Bytecode compiler
- Bytecode virtual machine
- Pattern exhaustivity checking (sound, but unnecessarily conservative)
- Arithmetic patterns (only nat addition is currently implemented)
- Typeclasses
- Type parameters
- More expressive bounds (
where
clauses) - Coherence checker
- MIR optimiser
- Unboxing
- Automatic repr changes for recursive types
- Transform
data Nat = Succ Nat | Zero
into a runtime integer - Transform
data List A = Cons (A, List A) | Nil
into a vector
- Transform
- Better syntax
- Module system
- Monadic IO (or an effect system?)
- Do notation
- LLVM/Cranelift backend
Here follows a selection of features that are either unique to Tao or are uncommon among other languages.
Tao's type system is intended to be completely sound (i.e: impossible to trigger runtime errors beyond 'implementation' factors such as OOM, stack overflow, etc.). For this reason, subtraction of natural numbers yields a signed integer, not a natural number. However, many algorithms still require that numbers be counted down to zero!
To solve this problem, Tao has support for performing arithmetic operations within patterns, binding the result. Because the compiler intuitively understands these operations, it's possible to statically determine the soundness of such operations and guarantee that no runtime errors or overflows can ever occur. Check out this 100% sound factorial program!
def factorial =
| 0 => 1
\ y ~ x + 1 => y * factorial(x)
Excluding syntax sugar (like type aliases), Tao has only two high-level constructs: values and types. Every 'function' is actually just a value that corresponds to an line lambda, and the inline lambda syntax naturally generalises to allow pattern matching. Multiple pattern arguments are permitted, each corresponding to a parameter of the function.
def five =
let identity = fn x => x in
identity(5)
Tao requires that pattern matching is exhaustive and will produce errors if patterns are not handled.
In Tao, every value is an expression. Even let
, usually a statement in most languages, is an expression. Tao requires
no semicolons and no code blocks because of this fact.
In Tao, arg:f
is shorthand for f(arg)
(function application). Additionally, this prefix syntax can be chained,
resulting in very natural, first-class pipeline syntax.
my_list
:filter(fn x => x % 2 == 0) # Include only even elements
:map(fn x => x * x) # Square elements
:sum # Sum elements
This one is better demonstrated with an image.
Tao preserves useful information about the input code such as the span of each element, allowing for rich error messages that guide users towards solutions to their programs. Diagnostic rendering itself is done by my crate Ariadne.
Compile/run a .tao
file
cargo run -- <FILE>
Run compiler tests
cargo test
Compile/run the standard library
cargo run -- lib/std.tao
-
--opt
: Specify an optimisation mode (none
,fast
,size
) -
--debug
: Enable debugging output for a compilation stage (tokens
,ast
,hir
,mir
,bytecode
)