Lagoon is a dynamic, weakly-typed and minimal scripting language. 🏞

Last update: Jul 5, 2022

Overview

🏞 The Lagoon Language

Lagoon is a dynamic, weakly-typed and minimal scripting language. It draws inspiration from a handful of modern languages including JavaScript, Rust and PHP.

If you want to learn more about the language itself, you can read the SPECIFICATION or take a look at the collection of examples in this repository.

Example

-- This is a recursive fibonacci function. It accepts a number `n`.
fn fib(n) {
    if n < 2 {
        return n
    }

    return fib(n - 1) + fib(n - 2)
}

println(fib(10)) -- `println` is a function in the standard library.

Theory

Lagoon parses a string of source code into a token stream and abstract syntax tree (AST).

The generated AST is then passed to an interpreter. It uses a tree-walk approach to recursively iterate through each node in the tree.

A tree-walk interpreter is one of the slowest methods of execution, but it's also one of the simplest. In the future Lagoon will likely move to a bytecode interpreter but whilst the language itself is still in early development, a tree-walk interpreter will continue to be used.

At the highest level, all operations in Lagoon are parsed as statements. A statement can contain one or more expressions. Those expressions are generally used to manipulate the execution environment and provide information to your script.

Development Checklist

Lagoon is nowhere near being feature complete or syntax complete. Below is a small checklist of things that we still need to add and design before marking it as "stable".

Contributing

If you would like to contribute to Lagoon, please feel free to fork this repository and open a pull request. All contributions are highly appreciated, no matter your Rust knowledge.

Credit

Comments

feature: bytecode VM
This is the start of a bytecode virtual machine for Lagoon.

I'm not well versed in bytecode machines, so I've winged it and built some sort of stack machine. Whether it's any good, I don't know.

Using this pull request to track the progress made on the machine, as it'll take some time to figure things out.

TODO:

[ ] Implement all scalar values

[ ] Implement support for native functions

[ ] Implement support for user defined functions

[ ] Implement support for if/else statements

[ ] Implement return statements

[ ] Add support for while statements

[ ] Implement support for lists

[ ] Implement support for for..in statements

[ ] Implement support for assignments

[ ] Implement support for infix operations

[ ] Implement support for prefix operations

[ ] Implement support for structs

[ ] Implement support for struct methods

[ ] Implement support for struct instantiation

[ ] Implement support for constants

[ ] Implement support for native methods / objects

[ ] Implement support closures

[ ] Implement support for require() calls
opened by ryangjchandler 0
Feature/require
Adds a native require() function that accepts a relative path.

The relative path should be relative to the current file.

It allows you to execute another file in the current context, meaning all functions, variables and structs are then available inside of the current context.

Person.lag

struct Person { name }

main.lag

require("./Person") const Ryan = Person { name: "Ryan" }

This is the simplest form of modules really. I'll likely try to implement an explicit export / import syntax in the future but this should help separate things for now.
opened by ryangjchandler 0
feature: JS transpilation
This pull request adds a new JS transpiler to Lagoon.

You can run it through lagoon js ./path/to/source.lag ./path/to/output.js.

It's very much a work-in-progress but functional enough to merge.

Here's a list of everything that is currently supported:

[x] Strings, numbers, booleans, null

[x] Struct definitions (become JS classes with explicit field declaration and constructor)

[x] All mathematical operators, as well as polyfilled in/not in support.

[x] If/else statements

[x] for..in statements

[x] Closures

[x] Index expressions

[x] Assignments

[x] Struct methods (transpile to prototype modifications...?)

[x] List object methods

[x] String object methods

[x] Numeric object methods
opened by ryangjchandler 0
chore: migrate to workspace folders
This pull request migrates all of the old files into a workspace structure.

Move to workspace / crate folders.

Use more intelligent exports to reduce namespace scope.
opened by ryangjchandler 0
feature: better error reporting

This isn't everything that I want to do but it's definitely a good start.

Will output ParseError and InterpreterResult errors in bold red text to stderr, instead of the panic that it was doing before.

opened by ryangjchandler 0
feature: `in` / `not in`

Adds new in and not in infix operators.

Can currently be used to check if a list contains, or doesn't contain, a scalar value (anything but a struct or list). Can also be used to check if a string contains, or doesn't contain, another string.

opened by ryangjchandler 0
feature: for..in
Adds support for for..in statements.

At the moment, the only iterable value is the new list value. (#1)

In the future, I'll likely add support for iterating over strings too. Or perhaps a .chars() method on the string type that returns a list is smarter.

let names = ["Ryan"] for name in names { } for (i, name) in names { }
enhancement
opened by ryangjchandler 0
feature: add support for lists
This pull request adds support for lists (arrays).

A list can be created using [] tokens:

let items = ["Ryan", "John", "Jane"]

You can retrieve an item from the list at a particular index using the postfix index notation:

let ryan = items[0]

Lists are not limited to one type of data, you can use any type of data.

If you wish to assign a new value to a particular index, you can use the postfix index notation on the left hand side of an assignment expression:

items[1] = "Jimmy"

If you wish to append an item to the list, use the postfix index notation with an empty index:

items[] = "Nora"
enhancement
opened by ryangjchandler 0