The peon programming language

Peon is a modern, multi-paradigm, async-first programming language with a focus on correctness and speed.

Go to the Manual

What's peon?

Note: For simplicity reasons, the verbs in this section refer to the present even though part of what's described here is not implemented yet.

Peon is a multi-paradigm, statically-typed programming language inspired by C, Nim, Python, Rust and C++: it supports modern, high-level features such as automatic type inference, parametrically polymorphic generic types, pure functions, closures, interfaces, single inheritance, reference types, templates, coroutines, raw pointers and exceptions.

The memory management model is rather simple: a Mark and Sweep garbage collector is employed to reclaim unused memory.

Peon features a native cooperative concurrency model designed to take advantage of the inherent waiting of typical I/O workloads, without the use of more than one OS thread (wherever possible), allowing for much greater efficiency and a smaller memory footprint. The asynchronous model used forces developers to write code that is both easy to reason about, thanks to the Structured concurrency model that is core to peon's async event loop implementation, and works as expected every time (without dropping signals, exceptions, or task return values).

Other notable features are the ability to define (and overload) custom operators with ease by implementing them as language-level functions, Universal function call syntax, Name stropping and named scopes.

In peon, all objects are first-class (this includes functions, iterators, closures and coroutines).

Disclaimers

Disclaimer 1: The project is still in its very early days: lots of stuff is not implemented, a work in progress or otherwise outright broken. Feel free to report bugs!

Disclaimer 2: Currently the REPL is very basic (it adds your code to previous input plus a newline, as if it was compiling a new file every time), because incremental compilation is designed for modules and it doesn't play well with the interactive nature of a REPL session. To show the current state of the REPL, type #show (this will print all the code that has been typed so far), while to reset everything, type #reset. You can also type #clear if you want a clean slate to type in, but note that it won't reset the REPL state. If adding a new piece of code causes compilation to fail, the REPL will not add the last piece of code to the input so you can type it again and recompile without having to exit the program and start from scratch. You can move through the code using left/right arrows and go to a new line by pressing Ctrl+Enter. Using the up/down keys on your keyboard will move through the input history (which is never reset). Also note that UTF-8 is currently unsupported in the REPL (it will be soon though!)

Disclaimer 3: Currently, the std module has to be always imported explicitly for even the most basic snippets to work. This is because intrinsic types and builtin operators are defined within it: if it is not imported, peon won't even know how to parse 2 + 2 (and even if it could, it would have no idea what the type of the expression would be). You can have a look at the peon standard library to see how the builtins are defined (be aware that they heavily rely on compiler black magic to work) and can even provide your own implementation if you're so inclined.

TODO List

In no particular order, here's a list of stuff that's done/to do (might be incomplete/out of date):

• User-defined types
• Function calls ✅
• Control flow (if-then-else, switch) ✅
• Looping (while) ✅
• Iteration (foreach)
• Type conversions
• Type casting
• Intrinsics ✅
• Type unions ✅
• Functions ✅
• Closures
• Managed references
• Unmanaged references
• Named scopes/blocks ✅
• Inheritance
• Interfaces
• Indexing operator
• Generics ✅
• Automatic types ✅
• Iterators/Generators
• Coroutines
• Pragmas ✅
• Attribute resolution ✅
• Universal Function Call Syntax
• Import system ✅
• Exceptions
• Templates (not like C++ templates) ✅
• Optimizations (constant folding, branch and dead code elimination, inlining)

Feature wishlist

Here's a random list of high-level features I would like peon to have and that I think are kinda neat (some may have been implemented alredady):

• Reference types are not nullable by default (must use #pragma[nullable])
• Easy C/Nim interop via FFI
• C/C++ backend
• Nim backend
• Structured concurrency (must-have!)
• Simple OOP (with multiple dispatch!)
• RTTI, with methods that dispatch at runtime based on the true type of a value
• Limited compile-time evaluation (embed the Peon VM in the C/C++/Nim backend and use that to execute peon code at compile time)

The name

The name for peon comes from Productive2's genius cute brain, and is a result of shortening the name of the fastest animal on earth: the Peregrine Falcon. I guess I wanted this to mean peon will be blazing fast (I certainly hope so!)

Peon needs you.

No, but really. I need help. This project is huge and (IMHO) awesome, but there's a lot of non-trivial work to do and doing it with other people is just plain more fun and rewarding. If you want to get involved, definitely try contacting me or open an issue/PR!

Credits

• Araq, for creating the amazing language that is Nim (as well as all of its contributors!)
• Guido Van Rossum, aka the chad who created Python and its awesome community and resources
• The Nim community and contributors, for making Nim what it is today
• Bob Nystrom, for his amazing book that inspired me and taught me how to actually make a programming language (kinda, I'm still very dumb)
• Njsmith, for his awesome articles on structured concurrency
• All the amazing people in the r/ProgrammingLanguages subreddit and its Discord server
• Art <3
• Everyone to listened (and still listens to) me ramble about compilers, programming languages and the likes (and for giving me ideas and testing peon!)
• ... More? (I'd thank the contributors but it's just me :P)
• Me! I guess