Data declarations with types with {} are hard to read:

    var struct {
        int a
        bool b
    } thing = (0, false)

    var enum {
        a
        b
    } choice


Alternative solutions:
 1:
    var + thing = (0, false)
         \ struct {
               int a
               bool b
           }
 2:
    given type T = struct {
            int a
            bool b
    } var T thing = (0, false)
 3:
    where type T = struct {
            int a
            bool b
    } var T thing = (0, false)
 4:
    var ... thing = (0, false)
        struct {
            int a
            bool b
        }    

"where" blocks could be useful for local macros:

    where {
        data int a = 1
        type Pair = struct {
            SomeLongType<Xxxx,Yyyy> a
            ref SomeOtherLongType<Xxxx> b
        }
    } in {
        ...
    }

And also for function definitions with struct paramters:
    where {
        type Pair = struct {
            SomeLongType<Xxxx,Yyyy> a
            ref SomeOtherLongType<Xxxx> b
        }
    } in {
        func do_stuff(ref Pair a, ref Pair b)
    }
    - in this case, the Pair type should work like an anonymous type.
    - this makes it harder to grep for functions (can start at column != 1).
      but the "in { }" part could be avoided, and it could apply only to
      the following line.