sminnee/dysphasia

Toy programming language as a learning exercise.

dysphasia's Issues

Single-assignment variables

Although mutable variables are something I'd like to stay away from initially, single-assignment variables should be supported, to do stuff like this:

main {
   x = [1,4,9,5];
   for(i in x) {
     printf("x[%i] = %i", i, x[i]);
   }
}

Once compiled, the printf should probably still refer directly to a const array.

IntelliJ doesn't recognize the language

IntelliJ sanity inspector gives all red squiggly lines.

array.map

Amend the range synax to use [ and ]. It will make chaining easier. Implement array.map, using a lambda as a function argument.

main {
   for(i in [1..5].map(x | x*x)) puts(i);
}

Lambdas

Add support for lambdas, as a first step towards adding array.map. Could use arrow or guard syntax. While we're add it, allow single-statement for loops, for the example below :-)

main {
  int(int) square = (x) => x * x;
  int(int) cube = (x | x * x * x);
  for(i in 1..5) puts(square(i));
  for(i in 1..5) puts(cube(i));
}

Don't worry about closure variable binding for now.

Better type inferencing

In the following example:

main {
   for(x in [1..5]) {
    puts(square(x));
   }
}

square(x) => x*x;

The following type inferences should be made:

• x is int because it's used to iterate on an int array
• square takes and int argument because it's called with an int argument
• square returns an int because it's x*x return operation is an int

Conflicts should throw a syntax error.

Inferred generic function

In this example:

main {
    puts(square(2));
    puts(square(3.5));
   }
}

square(x) => x*x;

The following type inferencing should occur:

• square(x) should first be inferred to be int(int)
• It should secondly be inferred to be float(float)
• A separate copy of the function should be generated for each argument signature

Internally the the code should get transformed to something like this:

main {
    puts(int square<int>(2));
    puts(float square<float>(3.5));
   }
}

T square<T>(T x) => x*x;
// expanded
int square<int>(int x) => x*x;
float square<float>(float x) => x*x;

Note: It might be easier if all method calls have type suffixes added to them, regardless of whether there are multi-type calls.

array.reduce

Let's add a companion to array.map and we can bask in our functional goodness.

main {
  square = (x) => x*x;
  sum = (x) => x+x;
  sumSquares = a => a.map(square).reduce(sum);
  puts(sumSquares([1,2,3])); // 14
}

Ideally, the output of map can be piped into reduce without first creating an intermediary array, so that the compiled code is more of this form:

sumSquares(a) {
  for(i in a) {
    mapped = i*i;
    reduced = reduced+mapped;
  }
  return reduced;
}

array literals and operations

Two features:

• Array literals that don't simply get inlined as constants
• Array operations: multiplication with a similarly sized array, or with a scalar

The following script:

x = [1, 2, 3, 5];
y = x * 2;
z = y * y;

for(i in z) {
  puts(i);
}

Should output:

4
16
36
100