::: {A:i4*, B:i4?*, X:i4, R:{X:i4, Y:i2, S:{X:i4, Z:r8}*}*, Q:{X:i4, Y:i2, S:{X:i4, Z:r8}?*}?*, S:i4**, }

// Each matching group is started with a "// Match" comment on the first line, so it shows in the baselines.

-A // Match
Map(   A, -it)
Map(_: A, -it)
Map(a: A, - a)
Map(A as a, - a)

A * A // Match
Map(   A, it * it)
Map(a: A,  a *  a)

B * B // Match
Map(   B, it * it)
Map(b: B,  b *  b)

-R.X // Match
Map(    R, -   X)
Map(    R, -it.X)
Map(r : R, - r.X)

R.X * R.Y // Match
Map(   R,    X *    Y)
Map(   R, it.X * it.Y)
Map(r: R,  r.X *  r.Y)

-R.S.X // Match
Map(R, -   S.X)
Map(R, -it.S.X)
Map(   R, Map(     S, -   X))
Map(   R, Map(  it.S, -it.X))
Map(r: R, Map(s: r.S, - s.X))

R.S.X * R.S.X // Match
Map(   R, Map(     S,    X *    X))
Map(   R, Map(  it.S, it.X * it.X))
Map(r: R, Map(s: r.S,  s.X *  s.X))

R.S.X * R.Y // Match
Map(   R, Map(     S,    X *      Y))
Map(   R, Map(  it.S, it.X * it$1.Y))
Map(r: R, Map(s: r.S,  s.X *    r.Y))

R.S.X * R.X // Match - requires at least one up/var.
Map(   R, Map(     S,    X * it$1.X))
Map(   R, Map(  it.S, it.X * it$1.X))
Map(r: R, Map(     S,    X *    r.X))
Map(r: R, Map(   r.S,    X *    r.X))
Map(r: R, Map(s: r.S,  s.X *    r.X))

R.S.X * R.X * X // Match - requires at least one up/var.
Map(   R, Map(     S,    X * it$1.X * @X))
Map(   R, Map(  it.S, it.X * it$1.X * @X))
Map(r: R, Map(     S,    X *    r.X * @X))
Map(r: R, Map(   r.S,    X *    r.X * @X))
Map(r: R, Map(s: r.S,  s.X *    r.X * @X))

// Zip.
A + B // Match
Zip(   A,    B, it$1 + it$0)
Zip(a: A, b: B,    a +    b)

A * R.X // Match
Zip(   A,    R, it$1 +    X)
Zip(   A,    R, it$1 + it.X)
Zip(a: A, r: R,    a +  r.X)

R.X * R.Y * R.S.X // Match
Map(R, X * Y * S.X)
Map(R, Map(S, it$1.X * Y * X))
Map(r: R, Map(s: S, r.X * r.Y * s.X))

// There is no longer a limit on the number of sequences in ForEach.
ForEach(a: Range(1, 11), b: Range(2, 13), c: Range(3, 15), d: Range(4, 17), e: Range(5, 19), f: Range(6, 21), g: Range(7, 23), h: Range(8, 25), a * b * c * d * e * f * g * h)
ForEach(a: Range(1, 11), b: Range(2, 13), c: Range(3, 15), d: Range(4, 17), e: Range(5, 19), f: Range(6, 21), g: Range(7, 23), h: Range(8, 25), i: Range(9, 27), a * b * c * d * e * f * g * h * i)
Range(1, 11) * Range(2, 13) * Range(3, 15) * Range(4, 17) * Range(5, 19) * Range(6, 21) * Range(7, 23) * Range(8, 25)
Range(1, 11) * Range(2, 13) * Range(3, 15) * Range(4, 17) * Range(5, 19) * Range(6, 21) * Range(7, 23) * Range(8, 25) * Range(9, 27)

// Identity.
Map(A, it)
Map(R, it)
Map(S, it)
Map(S, Map(it, it))
Map(s: S, Map(x: s, x))
Map(r: R, SetFields(r, X))

SetFields(   R, S: SetFields(     S,      X))
SetFields(r: R, S: SetFields(s: r.S, X: s.X))
Map(   R, SetFields(  it, S: Map(      S, SetFields(  it, X:    X))))
Map(r: R, SetFields(   r, S: Map(s:    S, SetFields(   s, X:    X))))
Map(r: R, SetFields(   r, S: Map(s: it.S, SetFields(   s, X: it.X))))
Map(r: R, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X: s2.X))))
Map(r: R, SetFields(   r, S: Map(s: r .S, SetFields(   s, X: s .X)))) // Wrong variables.
Map(r: R, SetFields(r2:r, S: Map(s: r .S, SetFields(s2:s, X: s .X)))) // Wrong variables.
Map(r: R, SetFields(   r, S: Map(s: r .S, SetFields(s2:s, X: s2.X)))) // Wrong r variable.
Map(r: R, SetFields(r2:r, S: Map(s: r .S, SetFields(s2:s, X: s2.X)))) // Wrong r variable.
Map(r: R, SetFields(r2:r, S: Map(s: r2.S, SetFields(   s, X: s .X)))) // Wrong s variable.
Map(r: R, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X: s .X)))) // Wrong s variable.
SetFields(R, S: SetFields(S, X, ZZ: Z))

SetFields(   Q, S: SetFields(     S,      X))
SetFields(r: Q, S: SetFields(s: r.S, X: s.X))
Map(   Q, SetFields(  it, S: Map(      S, SetFields(  it, X:    X))))
Map(r: Q, SetFields(   r, S: Map(s:    S, SetFields(   s, X:    X))))
Map(r: Q, SetFields(   r, S: Map(s: it.S, SetFields(   s, X: it.X))))
Map(r: Q, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X: s2.X))))
Map(r: Q, SetFields(   r, S: Map(s: r .S, SetFields(   s, X: s .X)))) // Wrong variables, but implicit with/guard variables to the rescue.
Map(r: Q, SetFields(r2:r, S: Map(s: r .S, SetFields(s2:s, X: s .X)))) // Wrong variables.
Map(r: Q, SetFields(   r, S: Map(s: r .S, SetFields(s2:s, X: s2.X)))) // Wrong r variable, but implicit with/guard variables to the rescue.
Map(r: Q, SetFields(r2:r, S: Map(s: r .S, SetFields(s2:s, X: s2.X)))) // Wrong r variable.
Map(r: Q, SetFields(r2:r, S: Map(s: r2.S, SetFields(   s, X: s .X)))) // Wrong s variable, but implicit with/guard variables to the rescue.
Map(r: Q, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X: s .X)))) // Wrong s variable.
SetFields(Q, S: SetFields(S, X, ZZ: Z))

// Intentionally reach back even further, for code coverage.
Map(r: R, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X:  r.X))))
Map(r: Q, SetFields(r2:r, S: Map(s: r2.S, SetFields(s2:s, X:  r.X))))

// Reduction to Repeat and Range.
Map(Range(5,15), X)
Map(Range(5,15), Range(20), X)
Map(Range(5,15), #)
Map(Range(20), Range(5,15), #)
Map(5 - Range(10), X)
Map(5 - Range(10), Range(20), X)
Map(5 - Range(10), #)
Map(Range(20), 5 - Range(10), #)

// Shows a divergence between corrected and uncorrected text from the parser.
:: {i8s:i8*}
Map(x:>> i8s, { B: x*x })

Map(i8s, Range(10)+[A]) // Error.
Map(i8s, Range(10)+[A, A]) // Error.
ForEach(x:Range(10), Range(2), x)

::: { vs: v*}
[]->ForEach({ x: it})
vs->ForEach({ x: it})

// For coverage or ReduceBase reduction of GroupBy. The #n gets replaced with n
ForEach(n: Range(10), GroupBy(Range(20), it mod #n))
ForEach(n: Range(5, 10), GroupBy(Range(20), it mod #n))
