• Friendlier output
• parse world module rule should check if rule exists and is non-empty

Fix in Semantal - Symboltable; remove the hardcoded fqnp

• add & !"--" to expressions

What would be the best syntax for lists?

Patterns:

[a,b:as]  = a + b + f as
[a:b:as]  = a + b + f as

In combination with tuples

[(a,b):abs]
[a,b:c,d:abs]

Right hand side

a:as
[a:as]
[a,b:as]
[a:b:as]
[a,b] ++ as

In combination with tuples

[a,b:c,d:abs]

It's not meta info anymore

Way neater syntax

Test when everything is ready if this works.

Somehow, somewhere, the docstrings vanish!

Casts crash now;

Implement guards

f : a -> a -> a
|(>=2) b  = b
_ b          = b

max : (a:Ord) -> a -> a
a |(<a)   = a   -- first arg= a; take this clause if second arg (<a)
_ b         = b

Guards should work both for booleans and Maybe ()

Implement deconstructor expressions

f : { Int --> v } -> v
((lookup 0) v)  = v
dict                  = ...

The syntax [Just a:as] is a syntax error now ([(Just a):as] is ugly)

Important for stuff as:

(:) : b: >a => b -> [a] -> [b]
f   : b : <a => a -> [a] -> [a]

• Syntax in BNF, Parser and ASTs
• Bind (SemanticAnalysis/TypeBinding) does not crash on subtypes/supertype binding

In functions:

f  : a in Ord; b is Eq => a -> a -> b -> b -> Bool

In ADT defs:

data _ BalancedTree (a is Ord) = Top content:a left:(BalancedTree a) right:(BalancedTree a)
    | Nil

In class defs:

class Dict k v where:
    lookup : k -> Dict k v -> v

class Ord a => SortedSet a where:
    getMin : SortedSet a -> a


class SortedSet (a is Ord) where:
    getMin : SortedSet a -> a

class SortedSet a where a is Ord:
    getMin : SortedSet a -> a

e.g.

empty : a -> Maybe x
f : a -> ...
empty   = 

Should empty be treated as deconstructor function or new variable name.

• think about decent syntax
• Check list/map/set deconstructor syntax (also for empty)
• implement parsers

Automatically add lensing to records.

(Haskell syntax)

Suppose we have a record

data Game = {
    score :: Int,
    player :: Entity
    entities :: [Entity]
}

with Entity:

data Entity = {
    name :: String
    position :: Point
}

and Point:

data Point = {
    x :: Int,
    y :: Int
}

Each record would get automatic lensing. If you want the player entity to go up, you could write:

let game2 = game.player.position.y `modify` (+1)

or

(+=) = flip modify (+)
let game2 = game.player.position.y += 1

To do something for each element in a list, forEach would be a solution:

let game2 = game.entities `forEach` y *= 2

In some cases modify could be left out with automatic function renaming:

let game2 = game.score `modify` (\x -> function x 3)
--equivalent to
let game2 = game.score `function=` 3

let game2 = game.score `modify` double
--equivalent to
let game2 = game.score double!

Maybe operations could be chained together with do by providing a correct Monad instance:

let game2 = do
    game.player.position.y += 1
    game.player.position.x -= 3
    game.entities `update=` game

The type interference allows us to know what function we should take in implementation -> equivalent for haskells "module.function" syntax

When a rule is declared twice, an error should be thrown

"a b" matches strings as "ab"

What would be neat?

e.g. ~~ (with name) or >> (without name). Code snippets written there should always evaluate to true.

• Check collections to update to new syntax

Caused by checkOne, as it makes function selection nondeterministic.

e.g.

f : a -> (b,c)
f : a -> (d,e,f)

What should we do in a deconstruct?

(f *)

Esp. {k --> {v}} and {k --> [v]}

This should be a 'graph library'

With >>

Very few laws have good titles

• Change from "class" to "cat" or "category"
• Rename class-rulename to cat-rulename in bnf-files
• Drop ":" on the end
• Subtypes: allow ":" also (together with "in" and "is", already defined) (also see #49 )

The : means that the type on the left is a subclass from the type on the right. E.g. in type declarations (a:Eq), category decls: cat Map k v : Set k.

For multiple subclassing, both "&" and "," should be possible: (a:Eq & Ord), (a:Eq, Ord);
cat Map k v : Set k, List b, cat X a b: Monad a & List b

• Functions: declaration, lawDeclaration (do not touch law!)
• Typedefs: optNamed, named, subclass
• Types: reqSep (reuse this rule with a different name). ReqSep is the rule denoting "is subtype"
• Types: add "disjunction" token, which can be , or &. Also see #54

Neat extension to a?

Something is broken with the local scope...

f << g << h (where << is left associative) merges to <<(f <<(g h)) instead of <<( <<(f g) h)

It's a bit dirty that the typechecker crashes on non-existant stuff

• When fixed: add "==" to operator in bnf

e.g., so that localident can be written as

localIdent ::= "[a..z]" "[a..zA..Z0..9]"

Without having to worry that the parser can parse "a a" as a single localident