wafelack / orion

Orion is a high level, purely functional programming language with a LISP based syntax.

Orion

---

Orion is a high level, purely functional programming language with a LISP based syntax.

---

Features

• Lightness: Orion source code fits under 3k SLOC and its binary is under 2MB.
• Portable: Orion code is run on a virtual machine, that avoids architecture-specific problems.
• Purely functional: Pattern matching, immutability, side effects control.
• Elegant: It embeds shorthands such as '<expr> for (\ () <expr>), [x y z] for (Cons x (Cons y (Cons z Nil))) or { <expr>* } for (begin <expr>*).

Installation

You will need: the Rust toolchain (1.50+), a "make" program, a POSIX shell (linked in /bin/sh) and Git.

$ git clone https://github.com/orion-lang/orion.git
$ cd orion/
$ chmod +x configure
$ ./configure
$ make
$ make install PREFIX=/wherever/you/want/

Documentation

You can find a detailed tutorial, the standard library, the core and the builtins documentation here.

Quick Example

Factorial function:

(def factorial (λ (n)
    (match n
    (0 1)
    (_ (* n (factorial (- n 1)))))))

Performance Tests

ack 3 3

Language	Average	Median	Amplitude
Nixt	126ms	121ms	134ms
Orion Interpreter	76.106ms	75ms	21ms
Orion VM	4.168ms	4ms	4ms
CPython	0.516ms	0.482ms	0.541ms

Acknowledgments

Special thanks to @Mesabloo and @felko for support and help about implementation details.

License

This software and all associated items (assets, documentation, etc) are licensed under the GNU General Public License version 3.0 and higher.

orion's Issues

Bytecode deserializer

The bytecode deserializer (src/bytecode.rs) should be fixed, it fails on matches deserialization.

Add command line arguments to main function

(def main
    (λ (args)))

Just push a List onto the stack before call.
Should take around 15 minutes.

Webassembly Support

Currently orion does not compile on the wasm32-unknown-unknown target because of a few function calls in fs2.

It would be nice to have a default feature that enables IO functionality so this project can be used from wasm.

Self-contained documentation and maybe namespacing

Hello @Wafelack,
This is an interesting language written in my favorite language. I have some discussion regarding the roadmap.

What do you think about including a documentation inside the binding?
It is interesting on how bindings are separated from the value, even from the function at all times. But, I'm curious if–like other lisp–we can put the documentation into the binding, especially the standard library. We can then inspect it in the REPL and that will enable best practice enforced when making libraries.

Do you plan to have namespace? Or even module? More roadmap?
Curiously, I imagine this toy language (despite already good) will scale one day. I'm interested to see some namespace or module system. Well, currently I'm learning the source, but I'd like to hear the roadmap or plan that you may have devised.

Efficiency?

I would love to use this for scripting of downstream items on my package manager.

@Wafelack Will you handle the efficiency so that it's not so slow?

Youth Hacking 4 Freedom

Consider submitting this proiect for YH4F organized by The Free Software Foundation Europe

https://freespeech.firedragonstudios.com/@kreyren/107008739205851180

Update ARCHITECTURE.md

ARCHITECTURE.md is not up to date.
It should take around 1 hour to fix it.

Recursive macro support

Adding recursive macro support could transform Orion in a powerful language because :

Recursive macros woudln't be dependent on callstack because they would be translated directly in parsing step. I already see a way of implementing that : Tail call optimisation system.

Recursive macros would just transform some recursive code into simple iterative code.

(macro factorial (x) {
  (if (= x 0) (return 1))
  (return (* x (factorial (- x 1))))
})

Regards,
Thomas.

String functions

Add functions for string mainuplation in the builtins and in the standard library.
Here a non exhaustive list:

• strlen
• @
• substr
• strcat
• split
• replace
  Of course do not forget to add documentation for every function.

Authorize double imports

Currently, this kind of codes does not work:

(load "core/math.orn")
(load "core/bool.orn")

because math.orn imports bool.orn.

It may be good to have an "import checker" to check if it has already been imported, and if yes, skip the load call.

A prelude

It could be good to automatically import useful files on interpreter startup, like core/*.orn, std/list.orn, std/maybe.orn, etc.

Token Comments and documentation

While reading the documentation, I didn't find the comment syntax.

Orion doesn't have token comment syntax from R7RS. It's useful to comment a block like ;#(abc def).
It's also useful as REPL prompt too.

For example, the (mock) REPL output below can be used directly.

#;orion:001> 1
; => 1

Common Lisp like `restart`s

A restart interface would be great, e.g.,

(defun apply (f x)
  (if (not (eq? (type-of f) 'function))
    (restart "Not a function"
                 '(("Abort" . 'nil)
                   ("Supply another function" . `(apply (eval (read)) ,x))))
    (f x)))