132 lines
7.6 KiB
Markdown
132 lines
7.6 KiB
Markdown
# 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](docs/manual.md)
|
|
|
|
|
|
## DISCLAIMER
|
|
|
|
Peon is currently in the process of being rewritten, but the current design just doesn't allow for that. Hence, a [new repository](https://git.nocturn9x.space/nocturn9x/peon-rewrite)
|
|
has been created, to start from a blank slate and take what I learned from Peon 0.1.x and make it significantly better
|
|
|
|
## 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, although more garbage
|
|
collection strategies (such as generational GC or deferred reference counting) are planned to be added in the future.
|
|
|
|
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](https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/) 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](https://en.wikipedia.org/wiki/Uniform_Function_Call_Syntax), [Name stropping](https://en.wikipedia.org/wiki/Stropping_(syntax)) 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 `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](src/peon/stdlib) 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
|
|
- 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]`)
|
|
- The `commutative` pragma, which allows to define just one implementation of an operator
|
|
and have it become commutative
|
|
- Easy C/Nim interop via FFI
|
|
- C/C++ backend
|
|
- Nim backend
|
|
- [Structured concurrency](https://vorpus.org/blog/notes-on-structured-concurrency-or-go-statement-considered-harmful/) (must-have!)
|
|
- Simple OOP (with multiple dispatch!)
|
|
- RTTI, with methods that dispatch at runtime based on the true (aka runtime) 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](https://git.nocturn9x.space/prod2) genius cute brain, and is a result of shortening
|
|
the name of the fastest animal on earth: the **Pe**regrine Falc**on**. 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](https://nocturn9x.space/contact) me
|
|
or open an issue/PR!
|
|
|
|
|
|
# Credits
|
|
|
|
- Araq, for creating the amazing language that is [Nim](https://nim-lang.org) (as well as all of its contributors!)
|
|
- Guido Van Rossum, aka the chad who created [Python](https://python.org) and its awesome community and resources
|
|
- The Nim community and contributors, for making Nim what it is today
|
|
- Bob Nystrom, for his amazing [book](https://craftinginterpreters.com) that inspired me
|
|
and taught me how to actually make a programming language (kinda, I'm still very dumb)
|
|
- [Njsmith](https://vorpus.org/), for his awesome articles on structured concurrency
|
|
- All the amazing people in the [r/ProgrammingLanguages](https://reddit.com/r/ProgrammingLanguages) subreddit and its [Discord](https://discord.gg/tuFCPmB7Un) server
|
|
- [Art](https://git.nocturn9x.space/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
|
|
|
|
|
|
## Ok, cool, how do I use it?
|
|
|
|
Great question! If this README somehow didn't turn you away already (thanks, by the way), then you may want to try peon
|
|
out for yourself. Fortunately, the process is quite straightforward:
|
|
|
|
- First, you're gonna have to install [Nim](https://nim-lang.org/), the language peon is written in. I highly recommend
|
|
using [choosenim](https://github.com/dom96/choosenim) to manage your Nim installations as it makes switching between them and updating them a breeze
|
|
- Then, clone this repository and compile peon in release mode with `nim c -d:release --passC:"-flto" -o:peon src/main`, which should produce`peon` binary
|
|
ready for you to play with (if your C toolchain doesn't support LTO then you can just omit the `--passC` option, although that would be pretty weird for
|
|
a modern linker)
|
|
- If you want to move the executable to a different directory (say, into your `PATH`), you should copy peon's standard
|
|
library (found in `/src/peon/stdlib`) into a known folder, edit the `moduleLookupPaths` variable inside `src/config.nim`
|
|
by adding said folder to it so that the peon compiler knows where to find modules when you `import std;` and then recompile
|
|
peon. Hopefully I will automate this soon, but as of right now the work is all manual
|
|
|
|
|
|
__Note__: On Linux, peon will also look into `~/.local/peon/stdlib` by default, so you can just create the `~/.local/peon` folder and copy `src/peon/stdlib` there
|