# How parameter and field lists are spaced. Names sharing a type are separated
# like any other pair of arguments (`x, y:Int`); only the type they share waits
# for the last of them, and it stays against the name it belongs to.

func grouped(one, two:Int, three:Text -> Int)
    return two

func spread(a, b, c, d:Int -> Int)
    return a

# The same, long enough that the list has to break across lines: the two code
# paths that render an argument list used to disagree about this spacing.
func lengthy(first_argument, second_argument:Int, third_argument:Text, fourth_argument:[Int], fifth_argument:{Text:Int} -> Int)
    return first_argument

# The return type and the flags are part of what has to fit, so a signature can
# break on them alone. Once it does, they take a line of their own: left on the
# last parameter's line, after the comma that separates it from the next, they
# read as one more parameter.
func on_the_suffix(arg1:Int, arg2:Int, arg3:Int, arg4:Int, arg5:Int, arg6:Int, arg7:Int, arg8:Int -> {Text:[Int]})
    return {}

func flagged(arg1xx:Int, arg2:Int, arg3:Int, arg4:Int, arg5:Int, arg6:Int, arg7:Int, arg8:Int -> Int; inline; cached)
    return arg2

convert (arg1xxxxxxxx:Int, arg2:Int, arg3:Int, arg4:Int, arg5:Int, arg6:Int, arg7:Int, arg8:Int -> Text)
    return "$arg2"

func anonymous(-> func(a,b,c,d,e,f:Int -> Int))
    # An anonymous function's signature breaks the same way a named one's does:
    return func(first_argument:Int, second_argument:Int, third:Int, fourth:Int, fifth:Int, sixth:Int -> Int)
        first_argument

# A short flag alias travels with the name it aliases:
func main.go(paths:[Text], force|f:Bool=no, count|n:Int=1)
    say("$paths $force $count")

# A struct's fields and an enum's variants break the same way a parameter list
# does, and the flags follow the same rule the return type does: a line of
# their own, since after the last field's comma they would read as a field.
struct Packed{f1x:Bool, f2:Bool, f3:Bool, f4:Bool, f5:Bool, f6:Bool, f7:Bool, f8:Bool, f9:Bool; packed_bools}

enum Wide(Variant1{x:Int, y:Int}, Variant2{x:Int, y:Int}, Variant3{x:Int, y:Int}, Variant4{x:Int, y:Int}, Variant5{x:Int, y:Int}, Variant6{x:Int, y:Int})

# A variant is a field list too, so one that doesn't fit breaks inside the
# enum that holds it:
enum Nested(Small, Roomy{f1xxxxxxxxxxxxxxxxxxxxxxxxx:Float64, f2:Float64, f3:Float64, f4:Float64, f5:Float64, f6:Float64; packed_bools})

struct Grouped{x, y, z:Float64}
struct Mixed{pos, vel:Grouped, mass:Float64}
enum Tagged(Pair{a, b:Int}, Solo{t:Text})