Comparison between different syntaxes for declarations
======================================================

Style 1:                    Style 2:                      Style 3:
    int x                   int x                         x: int
    Thing a                 obj Thing a                   a: Thing
    var Thing b             var obj Thing b               b: var Thing

    type T = struct {       type T = struct {             type T = struct {
        int x                   int x                         x: int
        int y                   int y                         y: int
        Thing a                 obj Thing a                   a: Thing
        Thing b                 obj Thing b                   b: Thing
        var Other c             var rec Other c               c: var Other
    }                       }                             }
    func f(Th t) -> Th      func f(obj Th t) -> obj Th    func f(t: Th) -> Th

Style 4:                            Style 5:                Style 6:
    x: int                          int x                   int x
    a: obj Thing                    def Thing a             obj a
    b: var obj Thing                def var Thing b         var obj b

    type T = struct {               type T = struct {       type T = struct {
        x: int                          int x                   int x
        y: int                          int y                   int y
        a: obj Thing                    Thing a                 Thing a
        b: obj Thing                    Thing b                 Thing b
        c: var rec Other                var Other c             var Other c
    }                                }                      }
    func f(t: obj Th) -> obj Th      func f(Th t) -> Th     func f(Th t) -> Th

Style 7: ?

(Style 6 relies on type inference, which is something I don't like)
Also, if style 1,3 and 5 is combined with implicit ref, then it is not clear
whether a defined variable is an object (reference type) or record (not a
reference type).

Style 1:
+ Similar to existing languages
+ Concise
Style 2
+ Logical
+ Simple to parse
Style 3:
+ Concise
Style 4:
+ Logical
Style 5:
+ Logical
Style 6:
+ Concise