# The spaces around a binary operator say where an expression splits, so they
# are kept -- except in the `*` band of an expression that also holds a `+`
# band operator, where dropping them is what shows the split, or of one that
# holds a division, a quotient being written as one quantity. `^` never takes
# them, and a subscript takes none at all: the brackets already bound it.

func foo(v:Int -> Int)
    return v

func main()
    x := 1
    y := 2
    z := 3
    r := 2.0
    arr := [1, 2, 3]

    # One band and no division, so the spaces stay:
    >> x + y
    >> x * y
    >> x == y * z

    # Both bands, so the tighter one gives them up:
    >> x + y*z
    >> foo(x + y*z)
    >> x*(y + z)//2 + x + 1

    # A division does the same on its own, and takes the rest of its band
    # with it: spaces are a claim about grouping, and `x * y/z` would say
    # this multiplies the quotient rather than dividing the product.
    >> 100 / 10 / 2
    >> x / y
    >> x * y / z
    >> x / y == z
    >> x + y / z
    >> x // y
    >> foo(x)/foo(y)

    # A subscript is written compactly, whatever it holds:
    >> arr[x+1]
    >> arr[x+y*z]
    # ...though a call inside one is still a call:
    >> arr[foo(x + y)]
    >> arr[(x + y)*z]

    # An exponent sits against what it raises:
    >> x^2
    >> Float64.PI * r^2
    >> x + y^2
    >> 2^3^2

    # Parentheses start a fresh expression with its own answer:
    >> (x + y) * z
    >> x * (y + z)

    # An operator that is a word keeps its spaces wherever it stands, or it
    # stops being a word: `aandb` is one identifier, and `(x + y)mod3` does not
    # parse. A subscript, which drops them from everything else, is the place
    # that would go wrong first.
    >> arr[x and y]
    >> arr[x or y]
    >> arr[x xor y]
    >> arr[x mod y]
    >> arr[x mod1 y]
    >> arr[x _min_ y]
    >> arr[x _max_ y]
    >> arr[x*y mod 3]
    # A parenthesized operand settles its own spacing rather than inheriting
    # the subscript's, so the tightening stops at the parenthesis:
    >> arr[x+y and y]
    >> x + y mod 3

    # ...so where the operator around it has given its own spaces up, the
    # word operator takes parentheses instead: without them `a mod b/c` reads
    # as the modulus of a quotient, when it divides the modulus. A tight
    # operator inside a spaced one is already read the right way round and
    # needs nothing.
    #
    # `mod` and `mod1` take them against any other arithmetic operator, spaced
    # or not: they are words sitting somewhere in the middle of that band, and
    # where exactly is not something a reader carries around the way they do
    # `*` before `+`. Against a comparison they need nothing, arithmetic
    # binding tighter than one wherever it is written.
    >> x mod y / z
    >> x mod1 y / z
    >> x / y mod z
    >> x + y mod z*x
    >> arr[x+y mod z]
    >> (x and y)^2

    # `!=` keeps them for the same reason: `a!=b` reads as the `!` suffix on
    # `a`, followed by `= b`.
    >> arr[x != y]
    >> arr[x+y != y]

func decimal_runs(x:Num)
    # A tightened operator keeps its spaces where giving them up would leave it
    # against a `.`: `3.` written straight onto `*3` gives `3.*3`, with no
    # boundary left between the number and the operator. A division is the
    # exception, being how a quotient is written as a single quantity.
    >> 1./3. * 3
    >> 1./3.
    >> 1/3*3
    >> 7.5//2
    >> x * 0.5