case! looks like case, but it checks exhaustiveness like Scala and Rust.

case! spec:

1. case! checks exhaustiveness for enums, union types, Bool (true or false) and nil.

   foo = true ? 42 : "foo"
   
   case! foo
   when  Int32
     p :int32
   end
   
   # Error in foo.cr:3: found non-exhaustive pattern: String

2. Not such a type (e.g. Int32, String) cannot check exhaustiveness, but case! raises a compilation error in this case. It means:

   foo = 42
   
   case! foo
   when  42
     p :foo
   end
   
   # Error in foo.cr:3: found non-exhaustive pattern: Int32

   But, this case can be compiled:

   foo = 42
   
   case! foo
   when  Int32
     p :foo
   end

3. Of course tuple conditions can be checked:

   foo = true ? 42 : "foo"
   bar = true ? 3.14 : :bar
   
   case! {foo, bar}
   when  {String, _}
     p :left_string
   when  {_, Symbol}
     p :right_symbol
   end
   
   # Error in foo.cr:4: found non-exhaustive pattern: {Int32, Float64}

4. case! must have a condition, it's a syntax error:

   case!
   when  true
   end
   
   # Syntax error in foo.cr:2: unexpected token: when ('case!' must have a condition)

5. case! must not have else clause, and can use when _ instead:

   # foo = true ? 42 : "foo"
   #
   # case! foo
   # when  Int32
   #   p :int32
   # else
   #   p :others
   # end
   #
   # # Syntax error in foo.cr:6: unexpected token: else ('case!' cannot have 'else', use 'when _' instead)
   
   foo = true ? 42 : "foo"
   
   case! foo
   when  Int32
     p :int32
   when  _
     p :others
   end

6. crystal tool format appends 2 spaces after when of case! to align when conditions. For example:

   foo = true ? 42 : "foo"
   case! foo
   when  Int32
     p :int32
   when  String
     p :string
   end

   It is my preference, but I believe this is more beautiful than that:

   foo = true ? 42 : "foo"
   case! foo
   when Int32
     p :int32
   when String
     p :string
   end