wadackel / rs-monkey-lang

Monkey Programming Language written in Rust.

rs-monkey-lang

Monkey Programming Language written in Rust.

What's Monkey?

The official Monkey logo

Monkey is a programming language designed to learn interpreters.
It's came from Writing An Interpreter In Go.

Try Monkey!

with REPL

$ git clone https://github.com/wadackel/rs-monkey-lang.git
$ make repl

with Online Playground

Working with Wasm!! Awesome 🐶
https://wadackel.github.io/rs-monkey-lang/

Documentation

I created the document with reference to Writing An Interpreter In Go.

⚠️ Please note that there may be some mistakes.

Table of Contents

• Summary
• Syntax overview
  • If
  • Operators
  • Return
• Variable bindings
• Literals
  • Integer
  • Boolean
  • String
  • Array
  • Hashes
  • Function
• Built-in Functions
  • puts(<arg1>, <arg2>, ...): void
  • len(<arg>): Intger
  • first(<arg>): any
  • last(<arg>): any
  • rest(<arg>): Array
  • push(<arg1>, <arg2>): Array

Summary

• C-like syntax
• variable bindings
• integers and booleans
• a string data structure
• an array data structure
• a hash data structure
• arithmetic expressions
• built-in functions
• first-class and higher-order functions • closures

Syntax overview

An example of Fibonacci function.

let fibonacci = fn(x) {
  if (x == 0) {
    0;
  } else {
    if (x == 1) {
      1;
    } else {
      fibonacci(x - 1) + fibonacci(x - 2);
    }
  }
};

fibonacci(10);

If

It supports the general if. else exists, but else if does not exist.

if (true) {
  10;
} else {
  5;
}

Operators

It supports the general operations.

1 + 2 + (3 * 4) - (10 / 5);
!true;
!false;
+10;
-5;
"Hello" + " " + "World";

Return

It returns the value immediately. No further processing will be executed.

if (true) {
  return;
}

let identity = fn(x) {
  return x;
};

identity("Monkey");

Variable bindings

Variable bindings, such as those supported by many programming languages, are implemented. Variables can be defined using the let keyword.

Format:

let <identifier> = <expression>;

Example:

let x = 0;
let y = 10;
let foobar = add(5, 5);
let alias = foobar;
let identity = fn(x) { x };

Literals

Five types of literals are implemented.

Integer

Integer represents an integer value. Floating point numbers can not be handled.

Format:

[-+]?[1-9][0-9]*;

Example:

10;
1234;

Boolean

Boolean represents a general boolean types.

Format:

true | false;

Example:

true;
false;

let truthy = !false;
let falsy = !true;

String

String represents a string. Only double quotes can be used.

Format:

"<value>";

Example:

"Monkey Programming Language";
"Hello" + " " + "World";

Array

Array represents an ordered contiguous element. Each element can contain different data types.

Format:

[<expression>, <expression>, ...];

Example:

[1, 2, 3 + 3, fn(x) { x }, add(2, 2), true];

let arr = [1, true, fn(x) { x }];

arr[0];
arr[1];
arr[2](10);
arr[1 + 1](10);

Hashes

Hash expresses data associating keys with values.

Format:

{ <expression>: <expression>, <expression>: <expression>, ... };

Example:

let hash = {
  "name": "Jimmy",
  "age": 72,
  true: "a boolean",
  99: "an integer"
};

hash["name"];
hash["a" + "ge"];
hash[true];
hash[99];
hash[100 - 1];

Function

Function supports functions like those supported by other programming languages.

Format:

fn (<parameter one>, <parameter two>, ...) { <block statement> };

Example:

let add = fn(x, y) {
  return x + y;
};

add(10, 20);

let add = fn(x, y) {
  x + y;
};

add(10, 20);

If return does not exist, it returns the result of the last evaluated expression.

let addThree = fn(x) { x + 3 };
let callTwoTimes = fn(x, f) { f(f(x)) };

callTwoTimes(3, addThree);

Passing around functions, higher-order functions and closures will also work.

Built-in Functions

You can use 6 built-in functions 🚀

puts(<arg1>, <arg2>, ...): void

It outputs the specified value to stdout. In the case of Playground, it is output to console.

puts("Hello");
puts("World!");

len(<arg>): Intger

For String, it returns the number of characters. If it's Array, it returns the number of elements.

len("Monkey");
len([0, 1, 2]);

first(<arg>): any

Returns the element at the beginning of Array.

first([0, 1, 2]);

last(<arg>): any

Returns the element at the last of Array.

last([0, 1, 2]);

rest(<arg>): Array

Returns a new Array with the first element removed.

rest([0, 1, 2]);

push(<arg1>, <arg2>): Array

Returns a new Array with the element specified at the end added.

push([0, 1], 2);

---

Enjoy Monkey 🐵 !

---

License

MIT © wadackel

rs-monkey-lang's Issues

Add the "." getter access

#14

Cascading returns are not collapsed

Add the following test cases

("return if (true) { return 10; };", Some(Object::Int(10))),
("return if (true) { return if (true) { return 10; }; };", Some(Object::Int(10))),
("return if (true) { return if (false) { return 10; } else { return 5; }; };", Some(Object::Int(5))),

to the test_return_stmt function in src/evaluator/mod.rs to see what I mean.

For e.g. the tests fail as follows:

left: `Some(Int(10))`,
right: `Some(ReturnValue(Int(10)))`

left: `Some(Int(10))`,
right: `Some(ReturnValue(ReturnValue(Int(10))))`

left: `Some(Int(5))`,
right: `Some(ReturnValue(ReturnValue(Int(5))))`

Three possible solutions:

1. Implement Eq for Object such that ReturnValue(ReturnValue(Int(10)) would be equal to Int(10) etc. For e.g. that approach taken here.
2. Add a smart constructor specifically for ReturnValue, say makeReturnValue v, such that if v is already a ReturnValue we simply return v otherwise we return ReturnValue v.
3. Collapse the ReturnValue when the final output from the evaluator is a ReturnValue.

Note: If these examples are tried in the online interpreter they will display the correct result because of how Display is implemented for Object. Hence, it hides the issue.

Using multiple operators causes failure

I noticed this in the Online Playground.

When you enter let a = 1 ++ 1 it spits out the expected error... "Unexpected Token: no prefix parse function for "Plus" found".

But if you enter more operators... let a = 1 ++++ 1, it outputs nothing. It's the same for other operators like slash and multiply.

What about the syntax of `while` `break` `continue`

#11

Can you explain the WASM part.

I'm looking at the code just for reference implementation could you tell me how WASM compilation works?

Firefox support

Cool project!

I was just trying out https://tsuyoshiwada.github.io/rs-monkey-lang/ and noticed that while it works well in Chrome, the run button doesn't seem to work in Firefox.

In the debugger, I see: