**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*, s:s}

> GroupBy(T, A, Nested)
GroupBy(T, A, Nested) : {A:r8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>)
###
> GroupBy(T, B, Nested)
GroupBy(T, B, Nested) : {B:b, Nested:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] B:*1.B, [auto] Nested:<auto>)
###
> GroupBy(T, C, Nested)
GroupBy(T, C, Nested) : {C:i4, Nested:{A:r8, B:b, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] C:*1.C, [auto] Nested:<auto>)
###
> GroupBy(T, D, Nested)
GroupBy(T, D, Nested) : {D:d, Nested:{A:r8, B:b, C:i4, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] D:*1.D, [auto] Nested:<auto>)
###
> GroupBy(T, E, Nested)
GroupBy(T, E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, F, Nested)
GroupBy(T, F, Nested) : {F:r4, Nested:{A:r8, B:b, C:i4, D:d, E:s, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] F:*1.F, [auto] Nested:<auto>)
###
> GroupBy(T, G, Nested)
GroupBy(T, G, Nested) : {G:g, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, H:{X:i, Y:r8}, I:i}*}*
*** Error: (11,12) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, H, Nested)
GroupBy(T, H, Nested) : {H:{X:i, Y:r8}, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, I:i}*}*
Binder : GroupBy(*1: T, [key] H:*1.H, [auto] Nested:<auto>)
###
> GroupBy(T, I, Nested)
GroupBy(T, I, Nested) : {I:i, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}}*}*
Binder : GroupBy(*1: T, [key] I:*1.I, [auto] Nested:<auto>)
###
> GroupBy(T, [=] A, Nested)
GroupBy(T, [=] A, Nested) : {A:r8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>)
###
> GroupBy(T, [=] B, Nested)
GroupBy(T, [=] B, Nested) : {B:b, Nested:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] B:*1.B, [auto] Nested:<auto>)
###
> GroupBy(T, [=] C, Nested)
GroupBy(T, [=] C, Nested) : {C:i4, Nested:{A:r8, B:b, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] C:*1.C, [auto] Nested:<auto>)
###
> GroupBy(T, [=] D, Nested)
GroupBy(T, [=] D, Nested) : {D:d, Nested:{A:r8, B:b, C:i4, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] D:*1.D, [auto] Nested:<auto>)
###
> GroupBy(T, [=] E, Nested)
GroupBy(T, [=] E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, [=] F, Nested)
GroupBy(T, [=] F, Nested) : {F:r4, Nested:{A:r8, B:b, C:i4, D:d, E:s, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] F:*1.F, [auto] Nested:<auto>)
###
> GroupBy(T, [=] G, Nested)
GroupBy(T, [=] G, Nested) : {G:g, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, H:{X:i, Y:r8}, I:i}*}*
*** Error: (15,16) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, [=] H, Nested)
GroupBy(T, [=] H, Nested) : {H:{X:i, Y:r8}, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, I:i}*}*
Binder : GroupBy(*1: T, [key] H:*1.H, [auto] Nested:<auto>)
###
> GroupBy(T, [=] I, Nested)
GroupBy(T, [=] I, Nested) : {I:i, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}}*}*
Binder : GroupBy(*1: T, [key] I:*1.I, [auto] Nested:<auto>)
###
> GroupBy(T, [~] A, Nested)
Corrected by binder: [GroupBy(T, [key] A, Nested)]
GroupBy(T, [~] A, Nested) : {A:r8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Warning: (11,14) Node: [~] A, Message: Case insensitive comparison doesn't apply to type 'r8'
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>)
###
> GroupBy(T, [~] B, Nested)
Corrected by binder: [GroupBy(T, [key] B, Nested)]
GroupBy(T, [~] B, Nested) : {B:b, Nested:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Warning: (11,14) Node: [~] B, Message: Case insensitive comparison doesn't apply to type 'b'
Binder : GroupBy(*1: T, [key] B:*1.B, [auto] Nested:<auto>)
###
> GroupBy(T, [~] C, Nested)
Corrected by binder: [GroupBy(T, [key] C, Nested)]
GroupBy(T, [~] C, Nested) : {C:i4, Nested:{A:r8, B:b, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Warning: (11,14) Node: [~] C, Message: Case insensitive comparison doesn't apply to type 'i4'
Binder : GroupBy(*1: T, [key] C:*1.C, [auto] Nested:<auto>)
###
> GroupBy(T, [~] D, Nested)
Corrected by binder: [GroupBy(T, [key] D, Nested)]
GroupBy(T, [~] D, Nested) : {D:d, Nested:{A:r8, B:b, C:i4, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Warning: (11,14) Node: [~] D, Message: Case insensitive comparison doesn't apply to type 'd'
Binder : GroupBy(*1: T, [key] D:*1.D, [auto] Nested:<auto>)
###
> GroupBy(T, [~] E, Nested)
GroupBy(T, [~] E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [~] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, [~] F, Nested)
Corrected by binder: [GroupBy(T, [key] F, Nested)]
GroupBy(T, [~] F, Nested) : {F:r4, Nested:{A:r8, B:b, C:i4, D:d, E:s, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Warning: (11,14) Node: [~] F, Message: Case insensitive comparison doesn't apply to type 'r4'
Binder : GroupBy(*1: T, [key] F:*1.F, [auto] Nested:<auto>)
###
> GroupBy(T, [~] G, Nested)
GroupBy(T, [~] G, Nested) : {G:g, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (15,16) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, [~] H, Nested)
Corrected by binder: [GroupBy(T, [key] H, Nested)]
GroupBy(T, [~] H, Nested) : {H:{X:i, Y:r8}, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, I:i}*}*
*** Warning: (11,14) Node: [~] H, Message: Case insensitive comparison doesn't apply to type '{X:i, Y:r8}'
Binder : GroupBy(*1: T, [key] H:*1.H, [auto] Nested:<auto>)
###
> GroupBy(T, [~] I, Nested)
Corrected by binder: [GroupBy(T, [key] I, Nested)]
GroupBy(T, [~] I, Nested) : {I:i, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}}*}*
*** Warning: (11,14) Node: [~] I, Message: Case insensitive comparison doesn't apply to type 'i'
Binder : GroupBy(*1: T, [key] I:*1.I, [auto] Nested:<auto>)
###
> GroupBy(T, [=] _: A)
GroupBy(T, [=] _ : A) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.A)
###
> GroupBy(T, [=] _: B)
GroupBy(T, [=] _ : B) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.B)
###
> GroupBy(T, [=] _: C)
GroupBy(T, [=] _ : C) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.C)
###
> GroupBy(T, [=] _: D)
GroupBy(T, [=] _ : D) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.D)
###
> GroupBy(T, [=] _: E)
GroupBy(T, [=] _ : E) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.E)
###
> GroupBy(T, [=] _: F)
GroupBy(T, [=] _ : F) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.F)
###
> GroupBy(T, [=] _: G)
GroupBy(T, [=] _ : G) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Error: (16,17) Node: _ : G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, [=] _: H)
GroupBy(T, [=] _ : H) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.H)
###
> GroupBy(T, [=] _: I)
GroupBy(T, [=] _ : I) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.I)
###
> GroupBy(T, [~] _: A)
Corrected by binder: [GroupBy(T, [key] _: A)]
GroupBy(T, [~] _ : A) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : A, Message: Case insensitive comparison doesn't apply to type 'r8'
Binder : GroupBy(*1: T, [key] *1.A)
###
> GroupBy(T, [~] _: B)
Corrected by binder: [GroupBy(T, [key] _: B)]
GroupBy(T, [~] _ : B) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : B, Message: Case insensitive comparison doesn't apply to type 'b'
Binder : GroupBy(*1: T, [key] *1.B)
###
> GroupBy(T, [~] _: C)
Corrected by binder: [GroupBy(T, [key] _: C)]
GroupBy(T, [~] _ : C) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : C, Message: Case insensitive comparison doesn't apply to type 'i4'
Binder : GroupBy(*1: T, [key] *1.C)
###
> GroupBy(T, [~] _: D)
Corrected by binder: [GroupBy(T, [key] _: D)]
GroupBy(T, [~] _ : D) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : D, Message: Case insensitive comparison doesn't apply to type 'd'
Binder : GroupBy(*1: T, [key] *1.D)
###
> GroupBy(T, [~] _: E)
GroupBy(T, [~] _ : E) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [~] *1.E)
###
> GroupBy(T, [~] _: F)
Corrected by binder: [GroupBy(T, [key] _: F)]
GroupBy(T, [~] _ : F) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : F, Message: Case insensitive comparison doesn't apply to type 'r4'
Binder : GroupBy(*1: T, [key] *1.F)
###
> GroupBy(T, [~] _: G)
GroupBy(T, [~] _ : G) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Error: (16,17) Node: _ : G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, [~] _: H)
Corrected by binder: [GroupBy(T, [key] _: H)]
GroupBy(T, [~] _ : H) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : H, Message: Case insensitive comparison doesn't apply to type '{X:i, Y:r8}'
Binder : GroupBy(*1: T, [key] *1.H)
###
> GroupBy(T, [~] _: I)
Corrected by binder: [GroupBy(T, [key] _: I)]
GroupBy(T, [~] _ : I) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
*** Warning: (11,14) Node: [~] _ : I, Message: Case insensitive comparison doesn't apply to type 'i'
Binder : GroupBy(*1: T, [key] *1.I)
###
> GroupBy(T, [=] E, Nested)
GroupBy(T, [=] E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, [~] E, Nested)
GroupBy(T, [~] E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [~] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, [~=] E, Nested)
GroupBy(T, [~=] E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [~] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, -A, Nested)
GroupBy(T, -A, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] Add([-] *1.A), [auto] Nested:<auto>)
###
> GroupBy(T, K: -A, Nested)
GroupBy(T, K : -A, Nested) : {K:r8, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K:Add([-] *1.A), [auto] Nested:<auto>)
###
> GroupBy(T, A * A, Nested)
GroupBy(T, A * A, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] Mul(*1.A, *1.A), [auto] Nested:<auto>)
###
> GroupBy(T, K: A * A, Nested)
GroupBy(T, K : A * A, Nested) : {K:r8, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K:Mul(*1.A, *1.A), [auto] Nested:<auto>)
###
> GroupBy(T, K1: A, K2: C * C, Nested)
GroupBy(T, K1 : A, K2 : C * C, Nested) : {K1:r8, K2:i8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K1:*1.A, [key] K2:Mul(Num<i8>(*1.C), Num<i8>(*1.C)), [auto] Nested:<auto>)
###
> GroupBy(x : T, K1: A, K2: C * C, Nested: x)
GroupBy(x : T, K1 : A, K2 : C * C, Nested : x) : {K1:r8, K2:i8, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K1:*1.A, [key] K2:Mul(Num<i8>(*1.C), Num<i8>(*1.C)), [map] Nested:*2)
###
> GroupBy(x: T.A, x * x, Nested: x)
GroupBy(x : T.A, x * x, Nested : x) : {Nested:r8*}*
Binder : GroupBy(*2: ForEach(*1: T, *1.A), [key] Mul(*2, *2), [map] Nested:*3)
###
> GroupBy(T, A, Nested: {AA: A, BB: not B})
GroupBy(T, A, Nested : { AA : A, BB : not B }) : {A:r8, Nested:{AA:r8, BB:b}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [map] Nested:{AA:*2.A, BB:Xor(*2.B, true)})
###
> GroupBy(T, A * A, H) // REVIEW: This might be surprising.
GroupBy(T, A * A, H) : {H:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] Mul(*1.A, *1.A), [auto] H:<auto>)
###
> GroupBy(x:T, A * A, x.H) // Work-around.
GroupBy(x : T, A * A, x.H) : {X:i, Y:r8}**
Binder : GroupBy(*1: T, [key] Mul(*1.A, *1.A), [map] *2.H)
###

**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*, s:s}

> GroupBy(T, A, Nested)
GroupBy(T, A, Nested) : {A:r8?, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] A:Guard(?2: *1, ?2.A), [auto] Nested:<auto>)
###
> GroupBy(T, B, Nested)
GroupBy(T, B, Nested) : {B:b?, Nested:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] B:Guard(?2: *1, ?2.B), [auto] Nested:<auto>)
###
> GroupBy(T, C, Nested)
GroupBy(T, C, Nested) : {C:i4?, Nested:{A:r8, B:b, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] C:Guard(?2: *1, ?2.C), [auto] Nested:<auto>)
###
> GroupBy(T, D, Nested)
GroupBy(T, D, Nested) : {D:d?, Nested:{A:r8, B:b, C:i4, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] D:Guard(?2: *1, ?2.D), [auto] Nested:<auto>)
###
> GroupBy(T, E, Nested)
GroupBy(T, E, Nested) : {E:s, Nested:{A:r8, B:b, C:i4, D:d, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] E:Guard(?2: *1, ?2.E), [auto] Nested:<auto>)
###
> GroupBy(T, F, Nested)
GroupBy(T, F, Nested) : {F:r4?, Nested:{A:r8, B:b, C:i4, D:d, E:s, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] F:Guard(?2: *1, ?2.F), [auto] Nested:<auto>)
###
> GroupBy(T, G, Nested)
GroupBy(T, G, Nested) : {G:g, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, H:{X:i, Y:r8}, I:i}?*}*
*** Error: (11,12) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, H, Nested)
GroupBy(T, H, Nested) : {H:{X:i, Y:r8}?, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, I:i}?*}*
Binder : GroupBy(*1: T, [key] H:Guard(?2: *1, ?2.H), [auto] Nested:<auto>)
###
> GroupBy(T, I, Nested)
GroupBy(T, I, Nested) : {I:i?, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}}?*}*
Binder : GroupBy(*1: T, [key] I:Guard(?2: *1, ?2.I), [auto] Nested:<auto>)
###
> GroupBy(T, -A, Nested)
GroupBy(T, -A, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] Guard(?3: Guard(?2: *1, ?2.A), Add([-] ?3)), [auto] Nested:<auto>)
Reducer: GroupBy(*1: T, [key] Guard(?2: *1, Add([-] ?2.A)), [auto] Nested:<auto>)
###
> GroupBy(T, K: -A, Nested)
GroupBy(T, K : -A, Nested) : {K:r8?, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] K:Guard(?3: Guard(?2: *1, ?2.A), Add([-] ?3)), [auto] Nested:<auto>)
Reducer: GroupBy(*1: T, [key] K:Guard(?2: *1, Add([-] ?2.A)), [auto] Nested:<auto>)
###
> GroupBy(T, A * A, Nested)
GroupBy(T, A * A, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] Guard(?3: Guard(?2: *1, ?2.A), ?5: Guard(?4: *1, ?4.A), Mul(?3, ?5)), [auto] Nested:<auto>)
Reducer: GroupBy(*1: T, [key] Guard(?2: *1, Mul(?2.A, ?2.A)), [auto] Nested:<auto>)
###
> GroupBy(T, K: A * A, Nested)
GroupBy(T, K : A * A, Nested) : {K:r8?, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}?*}*
Binder : GroupBy(*1: T, [key] K:Guard(?3: Guard(?2: *1, ?2.A), ?5: Guard(?4: *1, ?4.A), Mul(?3, ?5)), [auto] Nested:<auto>)
Reducer: GroupBy(*1: T, [key] K:Guard(?2: *1, Mul(?2.A, ?2.A)), [auto] Nested:<auto>)
###
> GroupBy(T, A, Nested: {AA: A, BB: not B})
GroupBy(T, A, Nested : { AA : A, BB : not B }) : {A:r8?, Nested:{AA:r8?, BB:b?}*}*
Binder : GroupBy(*1: T, [key] A:Guard(?2: *1, ?2.A), [map] Nested:{AA:Guard(?4: *3, ?4.A), BB:Guard(?6: Guard(?5: *3, ?5.B), Xor(?6, true))})
Reducer: GroupBy(*1: T, [key] A:Guard(?2: *1, ?2.A), [map] Nested:{AA:Guard(?4: *3, ?4.A), BB:Guard(?5: *3, Xor(?5.B, true))})
###

**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*, s:s}

> GroupBy(T, 3, Nested)
GroupBy(T, 3, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] 3, [auto] Nested:<auto>)
###
> GroupBy(T, K: 3, Nested)
GroupBy(T, K : 3, Nested) : {K:i8, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K:3, [auto] Nested:<auto>)
###
> GroupBy(T, s, Nested)
GroupBy(T, s, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] s, [auto] Nested:<auto>)
###
> GroupBy(T, K: s, Nested)
GroupBy(T, K : s, Nested) : {K:s, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] K:s, [auto] Nested:<auto>)
###
> GroupBy(T, A, s)
GroupBy(T, A, s) : {A:r8, s:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] s:<auto>)
###
> GroupBy(T, A, L: s)
GroupBy(T, A, L : s) : {A:r8, L:s*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [map] L:s)
###
> GroupBy(T, A, "")
GroupBy(T, A, "") : {A:r8}*
*** Error: (14,16) Node: "", Message: The argument in position 3 of 'GroupBy' should include a field name
Binder : Error(ErrNeedFieldName_Slot_Func)
###
> GroupBy(T, X, Nested)
GroupBy(T, X, Nested) : {Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (11,12) Node: X, Message: Name does not exist in the current context
*** Error: (11,12) Node: X, Message: Invalid key type for GroupBy: 'v'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, A, A)
GroupBy(T, A, A) : {A:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (14,15) Node: A, Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A, A:B)
GroupBy(T, A, A : B) : {A:b*}*
*** Error: (15,16) Node: A : B, Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A:B, A)
GroupBy(T, A : B, A) : {A:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (16,17) Node: A, Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A, A, X)
GroupBy(T, A, A, X) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (14,15) Node: A, Tok: 'A', Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A, A:B, X)
GroupBy(T, A, A : B, X) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (14,15) Node: A : B, Tok: 'A', Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A:B, A, X)
GroupBy(T, A : B, A, X) : {A:b, X:{A:r8, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (16,17) Node: A, Tok: 'A', Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> GroupBy(T, A, B, Nested)
GroupBy(T, A, B, Nested) : {A:r8, B:b, Nested:{C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [auto] Nested:<auto>)
###
> GroupBy(T, A, B, C, Nested)
GroupBy(T, A, B, C, Nested) : {A:r8, B:b, C:i4, Nested:{D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [auto] Nested:<auto>)
###
> GroupBy(T, A, B, C, D, Nested)
GroupBy(T, A, B, C, D, Nested) : {A:r8, B:b, C:i4, D:d, Nested:{E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [key] D:*1.D, [auto] Nested:<auto>)
###
> GroupBy(T, A, B, C, D, E, Nested)
GroupBy(T, A, B, C, D, E, Nested) : {A:r8, B:b, C:i4, D:d, E:s, Nested:{F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [key] D:*1.D, [key] E:*1.E, [auto] Nested:<auto>)
###
> GroupBy(T, A, B, C, D, E, F, Nested)
GroupBy(T, A, B, C, D, E, F, Nested) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, Nested:{G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [key] D:*1.D, [key] E:*1.E, [key] F:*1.F, [auto] Nested:<auto>)
###
> GroupBy(T, A, B, C, D, E, F, G, Nested)
GroupBy(T, A, B, C, D, E, F, G, Nested) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, Nested:{H:{X:i, Y:r8}, I:i}*}*
*** Error: (29,30) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, A, B, C, D, E, F, G, H, Nested)
GroupBy(T, A, B, C, D, E, F, G, H, Nested) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, Nested:{I:i}*}*
*** Error: (29,30) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(T, A, B, C, D, E, F, G, H, I, Nested)
GroupBy(T, A, B, C, D, E, F, G, H, I, Nested) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, Nested:{}*}*
*** Error: (29,30) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : Error(ErrNotGroupableType_Type)
###
> SetFields(GroupBy(T, A, B, C, D, E, F, I, Nested), Ints : Map(Nested, 1))
SetFields(GroupBy(T, A, B, C, D, E, F, I, Nested), Ints : Map(Nested, 1)) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, I:i, Ints:i8*, Nested:{G:g, H:{X:i, Y:r8}}*}*
Binder : ForEach(*3: GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [key] D:*1.D, [key] E:*1.E, [key] F:*1.F, [key] I:*1.I, [auto] Nested:<auto>), SetFields(!4: *3, Ints : ForEach(*5: !4.Nested, 1)))
###
> SetFields(GroupBy(T, A, B, C, D, E, F, I, Nested), Count : Sum(Nested, 1))
SetFields(GroupBy(T, A, B, C, D, E, F, I, Nested), Count : Sum(Nested, 1)) : {A:r8, B:b, C:i4, Count:i8, D:d, E:s, F:r4, I:i, Nested:{G:g, H:{X:i, Y:r8}}*}*
Binder : ForEach(*3: GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B, [key] C:*1.C, [key] D:*1.D, [key] E:*1.E, [key] F:*1.F, [key] I:*1.I, [auto] Nested:<auto>), SetFields(!4: *3, Count : Sum(*5: !4.Nested, 1)))
###
> SetFields(GroupBy(T, A, B, C, D, E, F, G, H, I, Nested), Ints : Map(Nested, 1))
SetFields(GroupBy(T, A, B, C, D, E, F, G, H, I, Nested), Ints : Map(Nested, 1)) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, Ints:i8*, Nested:{}*}*
*** Error: (39,40) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : ForEach(*1: Error(ErrNotGroupableType_Type), SetFields(!2: *1, Ints : ForEach(*3: !2.Nested, 1)))
###
> SetFields(GroupBy(T, A, B, C, D, E, F, G, H, I, Nested), Count : Sum(Nested, 1))
SetFields(GroupBy(T, A, B, C, D, E, F, G, H, I, Nested), Count : Sum(Nested, 1)) : {A:r8, B:b, C:i4, Count:i8, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, Nested:{}*}*
*** Error: (39,40) Node: G, Message: Invalid key type for GroupBy: 'g'
Binder : ForEach(*1: Error(ErrNotGroupableType_Type), SetFields(!2: *1, Count : Sum(*3: !2.Nested, 1)))
###

**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**, n:r8, s:s}

> GroupBy(T, A, Nested)
GroupBy(T, A, Nested) : v**
*** Error: (11,12) Node: A, Message: Invalid key type for GroupBy: 'r8*'
*** Error: (14,20) Node: Nested, Message: Name does not exist in the current context
Binder : Error(ErrNotGroupableType_Type)
###
> GroupBy(s, A, Nested)
GroupBy(s, A, Nested) : v**
*** Error: (8,9) Node: s, Message: The argument in position 1 of 'GroupBy' should be a sequence
*** Error: (11,12) Node: A, Message: Name does not exist in the current context
*** Error: (11,12) Node: A, Message: Invalid key type for GroupBy: 'v'
*** Error: (14,20) Node: Nested, Message: Name does not exist in the current context
Binder : Error(ErrNeedSequence_Slot_Func)
###
> GroupBy(n, A, Nested)
GroupBy(n, A, Nested) : v**
*** Error: (8,9) Node: n, Message: The argument in position 1 of 'GroupBy' should be a sequence
*** Error: (11,12) Node: A, Message: Name does not exist in the current context
*** Error: (11,12) Node: A, Message: Invalid key type for GroupBy: 'v'
*** Error: (14,20) Node: Nested, Message: Name does not exist in the current context
Binder : Error(ErrNeedSequence_Slot_Func)
###

**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*, s:s}

> T->GroupBy(_: A)
T->GroupBy(_ : A) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.A)
###
> T->GroupBy(+A)
T->GroupBy(+A) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] *1.A)
###
> T->GroupBy(A)
T->GroupBy(A) : {A:r8}*
Binder : GroupBy(*1: T, [key] A:*1.A)
###
> T->GroupBy(_: A, [agg] {N: Count(group)})
T->GroupBy(_ : A, [agg] { N : Count(group) }) : {N:i8}*
Binder : GroupBy(*1: T, [key] *1.A, [agg] {N:Count(!2)})
###
> T->GroupBy(_: A, [agg] {N: Count(it)})
T->GroupBy(_ : A, [agg] { N : Count(it) }) : {N:i8}*
Binder : GroupBy(*1: T, [key] *1.A, [agg] {N:Count(!2)})
###
> T->GroupBy(A, C)
T->GroupBy(A, C) : {A:r8, C:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] C:<auto>)
###
> T->GroupBy(A, [auto] C)
T->GroupBy(A, [auto] C) : {A:r8, C:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] C:<auto>)
###
> T->GroupBy(A, [map] C)
T->GroupBy(A, [map] C) : {A:r8, C:i4*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [map] C:*2.C)
###
> T->GroupBy(A, [agg] C)
T->GroupBy(A, [agg] C) : {A:r8, C:i4*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [agg] C:ForEach(*3: !2, *3.C))
###
> T->GroupBy(_: A, C)
T->GroupBy(_ : A, C) : {C:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] *1.A, [auto] C:<auto>)
###
> T->GroupBy(_: A, [auto] C)
T->GroupBy(_ : A, [auto] C) : {C:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] *1.A, [auto] C:<auto>)
###
> T->GroupBy(_: A, [map] C)
T->GroupBy(_ : A, [map] C) : i4**
Binder : GroupBy(*1: T, [key] *1.A, [map] *2.C)
###
> T->GroupBy(_: A, [map] +C)
T->GroupBy(_ : A, [map] +C) : i4**
Binder : GroupBy(*1: T, [key] *1.A, [map] *2.C)
###
> T->GroupBy(A as _, [map] C as _)
T->GroupBy(_ : A, [map] _ : C) : i4**
Binder : GroupBy(*1: T, [key] *1.A, [map] *2.C)
###
> GroupBy(T, [key] A, [auto] Nested)
GroupBy(T, [key] A, [auto] Nested) : {A:r8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>)
###
> GroupBy(T, [auto] Nested, [key] A)
GroupBy(T, [auto] Nested, [key] A) : {A:r8, Nested:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>)
###
> GroupBy(T, [key] A, [agg] Count: Count(group), [agg] Sum: Sum(group, C))
GroupBy(T, [key] A, [agg] Count : Count(group), [agg] Sum : Sum(group, C)) : {A:r8, Count:i8, Sum:i8}*
Binder : GroupBy(*1: T, [key] A:*1.A, [agg] Count:Count(!2), [agg] Sum:Sum(*3: !2, Num<i8>(*3.C)))
###
> GroupBy(T, [key] A, [agg] Count: Count(it), [agg] Sum: Sum(it, C))
GroupBy(T, [key] A, [agg] Count : Count(it), [agg] Sum : Sum(it, C)) : {A:r8, Count:i8, Sum:i8}*
Binder : GroupBy(*1: T, [key] A:*1.A, [agg] Count:Count(!2), [agg] Sum:Sum(*3: !2, Num<i8>(*3.C)))
###
> GroupBy(T, [key] A * A, [key] B and B) // OK.
GroupBy(T, [key] A * A, [key] B and B) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}**
Binder : GroupBy(*1: T, [key] Mul(*1.A, *1.A), [key] And(*1.B, *1.B))
###
> GroupBy(T, [key] A * A, [key] B and B, [agg] Count(it)) // OK.
GroupBy(T, [key] A * A, [key] B and B, [agg] Count(it)) : i8*
Binder : GroupBy(*1: T, [key] Mul(*1.A, *1.A), [key] And(*1.B, *1.B), [agg] Count(!2))
###
> GroupBy(T, [key] A * A, [key] B and B, [agg] Count(it), [agg] Sum(it, C)) // Error: need names.
GroupBy(T, [key] A * A, [key] B and B, [agg] Count(it), [agg] Sum(it, C)) : i8*
*** Error: (50,51) Node: Count(it), Message: The argument in position 4 of 'GroupBy' should include a field name
*** Error: (65,66) Node: Sum(it, C), Message: The argument in position 5 of 'GroupBy' should include a field name
Binder : Error(ErrNeedFieldName_Slot_Func)
###
> GroupBy(T, [agg] Count(it)) // Error: need a key.
GroupBy(T, [agg] Count(it)) : i8*
*** Error: (7,8) Node: GroupBy(T, [agg] Count(it)), Message: GroupBy needs at least one key
Binder : Error(ErrGroupByNeedsKey)
###
> T->GroupBy(A, Nested)->ChainMap(Nested)
T->GroupBy(A, Nested)->ChainMap(Nested) : {B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*
Binder : ChainMap(*3: GroupBy(*1: T, [key] A:*1.A, [auto] Nested:<auto>), *3.Nested)
###
> T->GroupBy(A, Nested: it).Nested->ChainMap()
T->GroupBy(A, Nested : it).Nested->ChainMap() : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*
Binder : ChainMap(ForEach(*3: GroupBy(*1: T, [key] A:*1.A, [map] Nested:*2), *3.Nested))
###
> T | GroupBy(r: _, A, Nested: r) | _.Nested | ChainMap(_)
T | GroupBy(r : _, A, Nested : r) | _.Nested | ChainMap(_) : {A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*
Binder : ChainMap(ForEach(*3: GroupBy(*1: T, [key] A:*1.A, [map] Nested:*2), *3.Nested))
###
> GroupBy(T, A, [map] N: {X: C > F}, [agg] Count(it))
GroupBy(T, A, [map] N : { X : C $> F }, [agg] Count(it)) : {A:r8, N:{X:b}*}*
*** Error: (46,47) Node: Count(it), Message: The argument in position 4 of 'GroupBy' should include a field name
Binder : Error(ErrNeedFieldName_Slot_Func)
###
> T->GroupBy(A, [>] X)
T->GroupBy(A, [>] X) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (14,17) Node: [>] X, Tok: '[>]', Message: Unexpected directive
Binder : Error(ErrBadDirective)
###
> T->GroupBy(A, A: C, X)
T->GroupBy(A, A : C, X) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
*** Error: (14,15) Node: A : C, Tok: 'A', Message: Duplicate field name: 'A'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, C, [agg] C: Count(group))
T->GroupBy(A, C, [agg] C : Count(group)) : {A:r8, C:i8}*
*** Error: (23,24) Node: C : Count(group), Tok: 'C', Message: Duplicate field name: 'C'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [map]N:C, [map]N:E)
T->GroupBy(A, [map] N : C, [map] N : E) : {A:r8, N:s*}*
*** Error: (30,31) Node: N : E, Message: Duplicate field name: 'N'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [map]N:C, [agg]N:First(group.B))
T->GroupBy(A, [map] N : C, [agg] N : First(group.B)) : {A:r8, N:b?}*
*** Error: (29,30) Node: N : First(group.B), Tok: 'N', Message: Duplicate field name: 'N'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [agg]N:First(group.B), [agg]N:First(group.D))
T->GroupBy(A, [agg] N : First(group.B), [agg] N : First(group.D)) : {A:r8, N:d?}*
*** Error: (42,43) Node: N : First(group.D), Tok: 'N', Message: Duplicate field name: 'N'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [map]N:C, [agg]N:First(group.B), [agg]N:First(group.D))
T->GroupBy(A, [map] N : C, [agg] N : First(group.B), [agg] N : First(group.D)) : {A:r8, N:d?}*
*** Error: (29,30) Node: N : First(group.B), Tok: 'N', Message: Duplicate field name: 'N'
*** Error: (52,53) Node: N : First(group.D), Tok: 'N', Message: Duplicate field name: 'N'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [map]N:C, [map]N:E, [agg]N:First(group.B))
T->GroupBy(A, [map] N : C, [map] N : E, [agg] N : First(group.B)) : {A:r8, N:b?}*
*** Error: (30,31) Node: N : E, Message: Duplicate field name: 'N'
*** Error: (39,40) Node: N : First(group.B), Tok: 'N', Message: Duplicate field name: 'N'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [map]C+1, C+2) // Multiple no-name.
T->GroupBy(A, [map] C + 1, C + 2) : {A:r8}*
*** Error: (20,21) Node: C + 1, Message: The argument in position 3 of 'GroupBy' should include a field name
*** Error: (25,26) Node: C + 2, Message: The argument in position 4 of 'GroupBy' should include a field name
Binder : Error(ErrNeedFieldName_Slot_Func)
###
> T->GroupBy(A, [item] X: item->&{ V: F + C}, [group] Y: group->&{ V: F + C})
T->GroupBy(A, [map] X : item+>{ V : F + C }, [agg] Y : group+>{ V : F + C }) : {A:r8, X:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, V:r8}*, Y:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, V:r8}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [map] X:SetFields(!3: *2, V : Add(Num<r8>(!3.F), Num<r8>(!3.C))), [agg] Y:ForEach(*5: !4, SetFields(!6: *5, V : Add(Num<r8>(!6.F), Num<r8>(!6.C)))))
###
> T->GroupBy([key] a, [key] b)
Corrected by binder: [T->GroupBy([key] A, [key] B)]
T->GroupBy([key] a, [key] b) : {A:r8, B:b}*
*** Error: (17,18) Node: a, Tok: 'a', Message: Unknown field, did you intend 'A' in type: '{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}'
*** Error: (26,27) Node: b, Tok: 'b', Message: Unknown field, did you intend 'B' in type: '{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}'
Binder : GroupBy(*1: T, [key] A:*1.A, [key] B:*1.B)
###
> T->GroupBy(as _, A, X)
T->GroupBy(as _, A, X) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] X:<auto>)
###
> T->GroupBy(as x, A, x.C)
T->GroupBy(as x, A, x.C) : {A:r8, C:i4*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [map] C:*2.C)
###
> T->GroupBy(A, [auto] it.C)
T->GroupBy(A, [auto] it.C) : {A:r8, C:i4*}*
*** Error: (14,20) Node: [auto] it.C, Tok: '[auto]', Message: '[auto]' directive requires just a field name
Binder : Error(ErrBadAutoDirective)
###
> T->GroupBy(A, [agg] C, [map] C)
T->GroupBy(A, [agg] C, [map] C) : {A:r8, C:i4*}*
*** Error: (20,21) Node: C, Message: Duplicate field name: 'C'
Binder : Error(ErrDuplicateFieldName_Name)
###
> T->GroupBy(A, [auto] X, Y)
T->GroupBy(A, [auto] X, Y) : {A:r8, X:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*, Y:{B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] A:*1.A, [auto] X:<auto>, [auto] Y:<auto>)
###

**** New globals: {T:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i, M:U<Image>}*, s:s}

> GroupBy(T, M, Nested)
GroupBy(T, M, Nested) : {M:U<Image>, Nested:{A:r8, B:b, C:i4, D:d, E:s, F:r4, G:g, H:{X:i, Y:r8}, I:i}*}*
Binder : GroupBy(*1: T, [key] M:*1.M, [auto] Nested:<auto>)
###
