What should happen with match exprs which have non-exhaustive cases?

[StachuDotNet]

This match expression exhausts all possible cases of the value it matches against:

let b = Json.parse<Bool>("true")
match b with
| true -> ...
| false -> ...

This one does not:

let b = Json.parse<Bool>("true")
match b with
| true -> ...

F# warns about non-exhaustive match exprs, whenever it can, noting something like
warning FS0025: Incomplete pattern matches on this expression. For example, the value 'false' may indicate a case not covered by the pattern(s).

Dark currently doesn't type-check to ensure matches are "exhaustive." (rather, it just deals with any missing matches at run-time)
Should it? If so, how and when?

Some quick thoughts:

• it's often really convenient to be lazy and only write cases you think are realistic
• if we were to pursue this to it end, it could be pretty tough to check for exhaustiveness.
• one way to handle this might be to demand a | _ -> case at the end
• this doesn't feel super pressing to me, but def something worth thinking about

[pbiggar]

imo the correct way to handle this is sorta like we did it in Darklang classic, which was explicitly designed with the idea that you can run incomplete code. In the current version, the design is:

• type checking is an optional layer - the code will run anyway
• runtime type checks only check for things on the execution path

These rules seem fine to handle exhaustiveness checking I think?