Be able to select all unhandled values in a discriminated union switch

[godalming123]

Something like:

package main

import "core:fmt"

foo :: proc(value: union{int, f64, f32, string, []string}) {
	switch val in value {
	case string:
		fmt.fprintln("String: %s", val)
	case int:
		fmt.fprintln("Int: %d", val)
	else:
		// I think that it would be more consistant if this branch was labelled with
		// `case` instead of `else`, although that would be a breaking change
		fmt.fprintln("Unknown", val)
	case:
		// I think that it would be more consistand if this branch was labbelled with
		// `case nil` instead of `case`, although that would be a breaking change
		fmt.println("Nil")
	}
}

main :: proc() {
	foo("bar") // outputs "String: bar"
	foo(3)     // outputs "Int: 3"
	foo(3.4)   // outputs "Unknown"
	foo(nil)   // outputs "Nil"
}

[dozn]

It already works like this =b https://godbolt.org/z/9f8Tv8T4s

package main; import "core:fmt"

main :: proc() {
	foo("bar")    // outputs "String: bar"
	foo(3)        // outputs "Int: 3"
	foo(f32(3.4)) // outputs "Unknown 3.4"
	foo(nil)      // outputs "Nil"
}

foo :: proc(value: union{int, f64, f32, string, []string}) {
	#partial switch val in value {
	case string:
		fmt.printfln("String: %s", val)
	case int:
		fmt.printfln("Int: %d", val)
	case nil:
		fmt.println("Nil")
	case:
		fmt.println("Unknown", val)
	}
}

[blob1807]

Yo can already do what you want.

foo :: proc(value: union{int, f64, f32, string, []string}) {
    #partial switch val in value {
    case string:
        fmt.printfln("String: %w", val)
    case int:
        fmt.printfln("Int: %d", val)
    case nil:
        fmt.println("Nil")
    case: 
        fmt.printfln("Unknown: %v", val)
    }
}

main :: proc() {
    foo("bar")    // String: "bar"
    foo(3)        // Int: 3
    foo(f64(3.4)) // Unknown: 3.39999999999
    foo(nil)      // Nil
}

[gingerBill]

else: would be syntactically ambiguous, also case nil: already exists.