scizzorz/mask

A programming language, revisited in Rust.

mask's Issues

Make better samples / tests

MASKPATH idea

From here:

The first argument to require() is a string name. picotool finds the file that goes with the string name using a library lookup path. This is a semicolon-delimited (;) list of filesystem path patterns, where each pattern uses a question mark (?) where the string name would go.

Add metatable assignment via leading .

eg: (*local).cur =5 --> .cur = 5

Clear the metatable when assigning it to null

ie, x :: null should remove the metatable of x rather than setting it to the object null

Add assert statement

Pipe operator?

Add string concatenation operator

Proxy non-table indexing to its metatable

Add failure to the lexer

Right now the lexer can't fail, even in weird cases like forbidden characters and unclosed strings. That's not right.

Add argument count checks

Syntax for assigning function supertables

Right now, you need to do this funky thing:

f = fn(...)
  ...

f = f :: whatever

but I think something like this might be more fun:

f = fn(...) :: whatever
  ...

Add a --nocache flag

Seriously, caches can be annoying when you're changing the compiler internals. I think Python might use -b for this?

Add a symbol type

Maybe with the : or @ sigil or something. I dunno.

Destructuring

The groundwork is in the parser right now, but it doesn't do much.

Use supertables for operator junk

Or something... hmm.

Some sort of `match` operator?

Rust's match blocks have some neato features, like range matching and stuff. Is there a way to make an operator that can work like that?

~Rust:

match x {
  0 => ...
  1..9 => ...
  10 | 20 | 30 | 40 | 50 | 60 | 70 | 80 | 90 => ...
  _ => ...
}

Python:

if x == 0: ...
elif 1 <= x <= 9: ...
elif x in (10, 20, 30, 40, 50, 60, 70, 80, 90): ...
else: ...

Mask:

if x ? 0: ...
elif x ? 1..9: ...
elif x ? [10, 20, 30, 40, 50, 60, 70, 80, 90]: ...

DUNNO.

Fix the REPL and -c flags

Fix if-elif-else

semck needs to do some transformation here.

Catch blocks

And correspond panic statements.

Function definitions

Comprehensions

Function / method calls

Unify dict/array syntax

Ehh something like this:

x = ["zero", "one", "two", age=5, [3] = "three"]

Where the first set of things are 0-indexed per usual, but once you go to a Mask-style kwarg, you can't go back.

Add local expression

Importing other modules

Polish the error messages from the compiler

ie, instead of just a panic message

Protect against stack corruption / growth during early exits

eg return, break, continue, panics

Labels / breakouts

Some way to break out of multiple loops? Possibly even 'break' out of an if block?!

Syntax for making a new scope / namespace

Something like this:

x = 'x'
y = 'y'
s = scope
  x = 'hello'
  print(x) # 'hello'
  print(y) # 'y'

print(x) # 'x'
print(s.x) # 'hello'

And then maybe borrow the initial supertable assignment from the #33?

s = scope :: some_other_table
  ...

Replace ExecuteErrors with panics

Also, rename ExecuteErrorKind::Exception -> ::Panic

Add panic statement

Global scope as a metatable of module scope

Whoaaaa this is where the prelude / builtins can goooo

Fix functions

• calls are bad
• defs are bad

While / loop

For loops

Add source coordinates to error messages somehow

Extensions / embedding

How is this gonna work

Implement basic unary operators

I don't think - works right now.