imp/src/main/java/org/imp/jvm/runtime/Glue.java
vs.
imp/src/main/java/org/imp/jvm/runtime/GlueOld.java
I'm not sure what the difference between these two files is.

Add the capability for multiple returns from a single return statement. Requires iterator destructuring to work.

Support boolean and and or logical operations.

Decide how to implement structs.

Should imp support void or unit for functions called only for their side effects?

http://james-iry.blogspot.com/2009/07/void-vs-unit.html

This behavior probably exists in other places.

Potential fix is to type-check arguments to the batteries.log method.

Support defining functions that operate on structs in Uniform Function Call Syntax.

Here's the tentative syntax:

struct Vector {
    x float
    y float
}

func add(a Vector, b Vector) Vector {
    return new Vector(a.x + b.x, a.y + b.y)
}

func +(a Vector, b Vector) Vector {
    return add(a,b)
}

val sum = add(new Vector(4, 9), new Vector(5, 7))   // (9, 16)
val sum2 = sum.add(new Vector(1, 7))                       // (10, 23)
val sum4 = sum + sum2                                              // (19, 37)

This is the method by which Imp supports "methods" on "objects", however, it's really functions on structs. Important to note that while structs are implemented as classes currently the goal has been to treat them as value types.

This is just an idea, but maybe any errors generated while a program is running could have an error message and numerical error code, and that message could be placed on a stack, while the numerical error code could be printed to the console. Then, people could pop the errors off the stack when they need to, to help keep the console clear, and also to allow for debugging from specific locations in the code. Again, just an idea

The code

for mut i = 0; i < 4; i = i + 1 {
    log(myFunctionReturns(i))
}

sends i to the outer scope, disallowing another for loop with i to be declared.

Urgent.

The default branch is currently "main", which If I remember correctly has ceased development

Log needs to map to println better. Right now it only supports strings.

Now that closures are implemented need to finalize the story on aliasing functions to variables.

To support recursive struct types, or struct types that reference other types, we need to have two passes in the type checking.

• a registration pass, which saves all structs and function signatures
• a validation pass, which validates the types using the list of registered types

This will enable referencing types defined further down in a file, like this:

struct Person {
    fname string
    lname string
    dob Date
}

struct Date {
    year int
    month int
    day int
}

It will also make the following possible:

struct Node {
    data string
    next Node
}

It seems that the first "registration" pass should happen during the parsing stage, and all "validation" should be moved to a new pass after the AST is generated.

log("words\n") should work fine but instead it gives the ANTLR error:

line 2:4 token recognition error at: '"declarations\'
line 2:19 token recognition error at: '")\r'
line 2:22 no viable alternative at input '(n\n'

Or between integers and floating point types.

Probably wait for operator overloading to settle before this gets touched.

Something about the for loops causes them not to execute for certain values.

I'm not sure how possible this is, as I'm not aware if your able to do this in java, but something that I think could be useful is the ability to pass a variable as the name for another variable. For example, in pseudo-code:
string name = "intVariable";
int name.content = 10;
this would create an integer variable with the name intVariable
let me know what you think

this happens if you either:

• a. assign a value to a variable directly
• b. assign the return value of a function to a variable

when trying to print a boolean that was returned from a method from the stdlib, it makes the code that is being tested by the CompileTest script not print out anything

Functions should always be owned by an object. With top-level function declarations, the owner of the functions should be the name of the class (the name of the imp file being compiled).

Devise a way to allow Function body blocks to access the outside scope.

Compile and run the compiled class file in one step.

if a test file tries to print out the return value from a method directly, then the CompilerTest cannot initialize the test file. This also happens if you try to assign a variable the return value of a method directly

Without the long data type, the double data type has very few uses, as its often important to convert from double to long when writing the math library

Implement all comparisons between integer types

Implement arithmetic between integer types.

Add the ability to do reverse for loops, such as...
for i in range(11, 0)
Currently this is not possible, as the loop is simply not run if the first argument(11) is larger than second argument(0)
I believe this could be done easily by checking if the first argument is larger than the second argument, and if it is, swapping the arguments

While implementing FizzBuzz in imp, found a number of bugs.

• negative integer literals do not parse
• and and or in conditionals do not work
• change loop to for

Idea:
If statement could be written as if (varName > 0 && < 10 and the second condition would have varName inferred. This would make the code more closely mimic natural language, while still feeling logical. Note: The snippet provided is just an example. The code would infer a variable name whenever no variable name is not specified. The inferred variable name is always the same as the previous variable name that has been provided

This makes perfect sense as currently the compiler runs on the JVM. Perhaps prefix user-defined functions named main with _ like we do in the standard library. So the body of an imp file would run in Java main and a user defined function named main would run in the _main function.

• errors emit suggestions. When multiple errors of the same code are found, the suggestion should only print once.
• separate syntax and semantics logging

Currently i++ and i-- don't generate code, so you have to use i=i+1 or i=i-1 instead. This should be fixed.

My guess is that that class isn't running because it doesn't have a main class, but I'm not sure, because I haven't fully investigated the code

For example, if i try to write:
val a = constant
then the VM crashes.
The same thing happens if you use a constant as a parameter inside of a function, for example:
log(constant)
also crashes the VM.