# TODO items ## Typechecking - look at https://rickyhan.com/jekyll/update/2018/05/26/hindley-milner-tutorial-rust.html - cf. the notation mentioned in the cardelli paper, the debug information for the `typechecking` pass should print the generated type variable for every subexpression in an expression - change 'trait' to 'interface' - think about idris-related ideas of multiple implementations of a type for an interface (+ vs * impl for monoids, for preorder/inorder/postorder for Foldable) -should have an Idris-like `cast To From` function ## Schala-lang syntax -idea: the `type` declaration should have some kind of GADT-like syntax -idea: I should make the BNF grammar part of the documentation... - Idea: if you have a pattern-match where one variant has a variable and the other lacks it instead of treating this as a type error, promote the bound variable to an option type - Include extensible scala-style html"string ${var}" string interpolations - A neat idea for pattern matching optimization would be if you could match on one of several things in a list ex: ```if x { is (comp, LHSPat, RHSPat) if comp in ["==, "<"] -> ... }``` - Schala should have both currying *and* default arguments! ```fn a(b: Int, c:Int, d:Int = 1) -> Int a(1,2) : Int a(1,2,d=2): Int a(_,1,3) : Int -> Int a(1,2, c=_): Int -> Int a(_,_,_) : Int -> Int -> Int -> Int ``` - scoped types - be able to define a quick enum type scoped to a function or other type for something, that only is meant to be used as a quick bespoke interface between two other things ex. ```type enum { type enum MySubVariant { SubVariant1, SubVariant2, etc. } Variant1(MySubVariant), Variant2(...), }``` - inclusive/exclusive range syntax like .. vs ..= ## Compilation -look into Inkwell for rust LLVM bindings -https://cranelift.readthedocs.io/en/latest/?badge=latest ## Other links of note - https://nshipster.com/never/ -consult http://gluon-lang.org/book/embedding-api.html ## Playing around with conditional syntax ideas - if/match playground simple if `if x == 1.0 { "a" } else { "b" }` one comparison multiple targets: `if x == { 1.0 -> "a", 2.0 -> "b", else -> "c" }` different comparison operators/ method calls: `if x { == 1.0 -> "a", eq NaN -> "n", .hella() -> "h", else -> "z" }` pattern matching/introducing bindings: `if alice { .age < 18 -> "18", is Person("Alice", age) -> "${age}", else -> "none" }` pattern matching w/ if-let: `if person is Person("Alice", age) { "${age}" } else { "nope" }` -https://soc.github.io/languages/unified-condition-syntax syntax: `if " then else ` `if \n then \n then else ` -and rest-exprs (or "targets") can have 'is' for pattern-matching, actually so can a full cond-expr UNIFIED IF EXPRESSIONS FINAL WORK: basic syntax: `if_expr := if discriminator '{' (guard_expr)* '}'` `guard_expr := pattern 'then' block_or_expr'` `pattern := rhs | is_pattern` `is_pattern := 'is' ???` `rhs := expression | ???` if the only two guard patterns are true and false, then the abbreviated syntax: `'if' discriminator 'then' block_or_expr 'else' block_or_expr` can replace `'if' discriminator '{' 'true' 'then' block_or_expr; 'false' 'then' block_or_expr '}'`