felipesabino / lox-kotlin

Kotlin implementation of Lox from Crafting Interpreters book

Lox-kotlin

Implementation of Lox in Kotlin for studying purposes.

Notable differences to jLox

• Division by 0 causes a RuntimeError instead of NaN

lox-kotlin's Issues

[chapter 7] Add support to + for mixed type string conversion and concatenation

Many languages define + such that if either operand is a string, the other is converted to a string and the results are then concatenated. For example, "scone" + 4 would yield scone4. Extend the code in visitBinaryExpr() to support that.

https://craftinginterpreters.com/evaluating-expressions.html#challenges

[chapter 11] Error if a local variable is never used.

Extend the resolver to report an error if a local variable is never used.

https://craftinginterpreters.com/resolving-and-binding.html#challenges

[chapter 6] Add support for C-style ternary operator

Likewise, add support for the C-style conditional or “ternary” operator ?:. What precedence level is allowed between the ? and :? Is the whole operator left-associative or right-associative?

https://craftinginterpreters.com/parsing-expressions.html#challenges

[chapter 12] Support class fields getter and setters

Most modern languages support “getters” and “setters”—members on a class that look like field reads and writes but that actually execute user-defined code. Extend Lox to support getter methods. These are declared without a parameter list. The body of the getter is executed when a property with that name is accessed:

class Circle {
  init(radius) {
    this.radius = radius;
  }

  area {
    return 3.141592653 * this.radius * this.radius;
  }
}

var circle = Circle(4);
print circle.area; // Prints roughly "50.2655".

http://www.craftinginterpreters.com/classes.html#challenges

[chapter 8] REPL support for expressions

The REPL no longer supports entering a single expression and automatically printing its result value. That’s a drag. Add support to the REPL to let users type in both statements and expressions. If they enter a statement, execute it. If they enter an expression, evaluate it and display the result value.

https://craftinginterpreters.com/statements-and-state.html#challenges

[chapter 5] expression grammar challenge

Earlier, I said that the |, *, and + forms we added to our grammar metasyntax were just syntactic sugar. Given this grammar:

expr → expr ( "(" ( expr ( "," expr )* )? ")" | "." IDENTIFIER )*
| IDENTIFIER
| NUMBER
Produce a grammar that matches the same language but does not use any of that notational sugar.

Bonus: What kind of expression does this bit of grammar encode?

https://craftinginterpreters.com/representing-code.html#challenges

[chapter 6] error on binary operator without a left-hand operand

Add error productions to handle each binary operator appearing without a left-hand operand. In other words, detect a binary operator appearing at the beginning of an expression. Report that as an error, but also parse and discard a right-hand operand with the appropriate precedence.

https://craftinginterpreters.com/parsing-expressions.html#challenges

[chapter 11] Environment quickly access a variable by its index instead of using a map

Our resolver calculates which environment the variable is found in, but it’s still looked up by name in that map. A more efficient environment representation would store local variables in an array and look them up by index.

Extend the resolver to associate a unique index for each local variable declared in a scope. When resolving a variable access, look up both the scope the variable is in and its index and store that. In the interpreter, use that to quickly access a variable by its index instead of using a map.

https://craftinginterpreters.com/resolving-and-binding.html#challenges

[chapter 10] Add anonymous function syntax

Lox’s function declaration syntax performs two independent operations. It creates a function and also binds it to a name. This improves usability for the common case where you do want to associate a name with the function. But in functional-styled code, you often want to create a function to immediately pass it to some other function or return it. In that case, it doesn’t need a name.

Languages that encourage a functional style usually support “anonymous functions” or “lambdas”—an expression syntax that creates a function without binding it to a name. Add anonymous function syntax to Lox so that this works:

fun thrice(fn) {
  for (var i = 1; i <= 3; i = i + 1) {
    fn(i);
  }
}

thrice(fun (a) {
  print a;
});
// "1".
// "2".
// "3".

How do you handle the tricky case of an anonymous function expression occurring in an expression statement:

fun () {};

https://craftinginterpreters.com/functions.html#challenges

[chapter 9] support break and continue statements inside loops

Unlike Lox, most other C-style languages also support break and continue statements inside loops. Add support for break statements.

The syntax is a break keyword followed by a semicolon. It should be a syntax error to have a break statement appear outside of any enclosing loop. At runtime, a break statement causes execution to jump to the end of the nearest enclosing loop and proceeds from there. Note that the break may be nested inside other blocks and if statements that also need to be exited.

https://craftinginterpreters.com/control-flow.html#challenges

[chapter 5] RPN visitor class

In Reverse Polish Notation (RPN), the operands to an arithmetic operator are both placed before the operator, so 1 + 2 becomes 1 2 +. Evaluation proceeds from left to right. Numbers are pushed onto an implicit stack. An arithmetic operator pops the top two numbers, performs the operation, and pushes the result. Thus, this:

(1 + 2) * (4 - 3)

in RPN becomes:

1 2 + 4 3 - *

Define a visitor class for our syntax tree classes that takes an expression, converts it to RPN, and returns the resulting string.

https://craftinginterpreters.com/representing-code.html#challenges

[chapter 12] support from static methods

We have methods on instances, but there is no way to define “static” methods that can be called directly on the class object itself. Add support for them. Use a class keyword preceding the method to indicate a static method that hangs off the class object:

class Math {
  class square(n) {
    return n * n;
  }
}

print Math.square(3); // Prints "9".
You can solve this however you like, but the “metaclasses” used by Smalltalk and Ruby are a particularly elegant approach. Hint: Make LoxClass extend LoxInstance and go from there.

http://www.craftinginterpreters.com/classes.html#challenges

[chapter 7] Add support for comparisons among mixed types

Allowing comparisons on types other than numbers could be useful. The syntax is shorter than named function calls and might have a reasonable interpretation for some types like strings. Even comparisons among mixed types, like 3 < "pancake" could be handy to enable things like heterogeneous ordered collections. Or it could lead to bugs and confused users.

Would you extend Lox to support comparing other types? If so, which pairs of types do you allow and how do you define their ordering? Justify your choices and compare them to other languages.

https://craftinginterpreters.com/evaluating-expressions.html#challenges

[chapter 4] Add support to Lox’s scanner for C-style /* ... */ block comments

Add support to Lox’s scanner for C-style /* ... */ block comments. Make sure to handle newlines in them. Consider allowing them to nest. Is adding support for nesting more work than you expected? Why?

https://craftinginterpreters.com/scanning.html#challenges

[chapter 8] runtime error on non initialized variable usage

Maybe you want Lox to be a little more explicit about variable initialization. Instead of implicitly initializing variables to nil, make it a runtime error to access a variable that has not been initialized or assigned to, as in:

var a;
var b;

a = "assigned";
print a; // OK, was assigned first.

print b; // Error!

https://craftinginterpreters.com/statements-and-state.html#challenges

[chapter 6] support for comma expressions

In C, a block is a statement form that allows you to pack a series of statements where a single one is expected. The comma operator is an analogous syntax for expressions. A comma-separated series of expressions can be given where a single expression is expected (except inside a function call’s argument list). At runtime, the comma operator evaluates the left operand and discards the result. Then it evaluates and returns the right operand.

Add support for comma expressions. Give them the same precedence and associativity as in C. Write the grammar, and then implement the necessary parsing code.

https://craftinginterpreters.com/parsing-expressions.html#challenges