This adds random into the Europa math stdlib feature. It should have the following syntax:

var someRandomValue = random(minimum, maximum);

Not sure why it throws this error tho:

Can some of the main devs help me?

As arrays and maps become increasingly hard to implement due to a big problem: references.

Take this example:

var a = {{ array: [1, 2, 3] }};
a."array"[1] = 3;

(figure 1)

at the moment with what we have, implementing this will be pretty much impossible, albeit I haven't implemented it yet.

Also take this planned example:

var a = 5, b = 6;

fn swap(ref a, ref b) {
  var t_a = cpy a, t_b = cpy b;

  a = t_b;
  b = t_a;
}

(figure 2)

Proposed solutions

References is a 'type', and it is:

Ref(Token)

where Token is the variable where the original data is stored.

**Pros: ** figure 2 **Cons: ** figure 1

References are in a new HashMap called the 'heap'. They include values that can get mutated.

**Pros: ** Solves both figures 1 and 2 if implemented correctly. **Cons: ** Very very hard to implement correctly

We make a mutable reference of the environment and just mutate them around **Pros: ** Solves both figures 1 and 2 if implemented correctly. **Cons: ** The ref type still might be needed

I added a version command if that's helpful :)

Also just some things I noticed

For your lexer, instead of getting all the tokens at once, you could also get them when you need them, like this:

fn parser() {
    tok = lexer.eat(); // get next token
    if tok.type == TokType::IF {
        // get next token; if next token is not an open bracket, throw error
        tok = lexer.eat(TokType::OPEN_BRACKET, "expected open bracket after 'if' keyword");
    }
}

It doesn't really matter which way you do it. I kinda like the second way thought since you have more control over the lexing process, and it's much easier to deal with syntax errors.

For your parser, you have a lot of duplicate code with your functions: comp, add, mult, unary. I would just suggest having unary and binary.

Same thing with types.rs, there's a bunch of duplicate code. I'm not sure how it works in Rust, but you could try to have a generic binary expression function, and just pass in a lambda like this:

pub fn evaluate_binary_expression(
    &self,
    other: &Type,
    operation:   &dyn Fn(i32, i32) -> TResult,        // lambda function
    div_by_zero: bool,                                // if false, and division by 0 is encountered, throw error
    op_name:     &str                                 // name of the operator to display in the error message
) -> TResult {

        if let (Self::Float(a), Self::Float(b)) = (self, other) {
            if !div_by_zero && *b == 0f32 {
                return Err("Division by 0.".into());
            }

            return Ok(Self::Float(operation(a, b)));
        }

        // not sure how str concat work in rust :/
        Err("Operator '" + op + "' can only be applied to numbers.".into())
}

Hope it helps :D

Unlike darkdarcool's random function, added a randrange function that actually works. Also added cos and tan. Also also, added dirty parse function impl to Types so it's shorter and more consice to convert to primitives.

Not too big of an issue, but editing tokens in the lexer was a complicated task. Added hashmaps for different types of tokens, such as operators or separators, as well as a group for braces and double braces.

Allows C-style escapes in strings.

• \n: newline/line feed (LF)
• \r: return (CR)
• \t: (horizontal) tab (HT)
• \a: alert (BEL)
• \b: backspace (BS)
• \e: escape (ESC)
• \f: form feed (FF)
• \v: vertical tab (VT)
• \\: backslash/reverse solidus
• \': single quote/apostrophe
• \": double quote/quotation mark
• \?: question mark
• \o___: octal byte
• \x__: hexadecimal byte
• \u____: four-nibble (2B) hexadecimal
• \U________: eight-nibble (4B) hexadecimal

Throws SyntaxError with "Invalid string escape." on error.

Finally, the feature we all want!

use io.println;

fn add(a, b, print = false) {
  if print { println(a + b); }
  return a + b;
}

println(add(1, 2)); // 3
add(1, 2, print = true); // 3

Add enhanced line editing, multi-line editing, bracket pair checking, history, history file ("~/.europa_history" on Unix, "%USERPROFILE%/.europa_history" on Windows), evaluated expression returning in REPL, and allows missing semicolon before EOF.

Also adds as dependency Rustyline 9.1 (101kB) for these features.

Allows future expansion with hints, completion and syntax highlighting.

Addresses #25 and some of #26.

STDLIB features that need to be added

• [ ] io
  • [x] println
  • [x] print
  • [x] flush
  • [x] readln
  • [ ] read (no new line)
  • [ ] passread (get input like read but no output when the user types it, produces no new line, but can if you wanna)
• [ ] Date
  • [ ] now
  • [ ] epoch
  • [ ] get_minute
  • [ ] get_second
  • [ ] get_day
  • [ ] get_month
  • [ ] get_year
• [ ] Path module like JS
  • [ ] join
• [ ] fs
  • [ ] read_file
  • [ ] write_file
  • [ ] file_exists
• [ ] http
  • [ ] get
  • [ ] post
  • [ ] put
  • [ ] all

Thanks to @DynamicSquid's pr #2, we have some things to optimize! Here they are, verbatim:

I added a version command if that's helpful :)

Also just some things I noticed

For your lexer, instead of getting all the tokens at once, you could also get them when you need them, like this:

fn parser() {
    tok = lexer.eat(); // get next token
    if tok.type == TokType::IF {
        // get next token; if next token is not an open bracket, throw error
        tok = lexer.eat(TokType::OPEN_BRACKET, "expected open bracket after 'if' keyword");
    }
}

It doesn't really matter which way you do it. I kinda like the second way of thought since you have more control over the lexing process, and it's much easier to deal with syntax errors.

For your parser, you have a lot of duplicate code with your functions: comp, add, mult, unary. I would just suggest having unary and binary.

Same thing with types.rs, there's a bunch of duplicate code. I'm not sure how it works in Rust, but you could try to have a generic binary expression function, and just pass in a lambda like this:

pub fn evaluate_binary_expression(
    &self,
    other: &Type,
    operation:   &dyn Fn(i32, i32) -> TResult,        // lambda function
    div_by_zero: bool,                                // if false, and division by 0 is encountered, throw error
    op_name:     &str                                 // name of the operator to display in the error message
) -> TResult {

        if let (Self::Float(a), Self::Float(b)) = (self, other) {
            if !div_by_zero && *b == 0f32 {
                return Err("Division by 0.".into());
            }

            return Ok(Self::Float(operation(a, b)));
        }

        // not sure how str concat work in rust :/
        Err("Operator '" + op + "' can only be applied to numbers.".into())
}

Hope it helps :D