coalton:match to codegen cl:case when possible

[garlic0x1]

No description provided.

[YarinHeffes]

Currently, we only codegen if when

(match bool
  ((True) ...)
  ((False) ...))

but not for

(match bool
  (True ...)
  (False ...))

I think this simple change could allow both:

Suggested change

	(make-pattern-constructor :type tc:*boolean-type* :name 'coalton:False :patterns nil))
	(or (make-pattern-constructor :type tc:*boolean-type* :name 'coalton:False :patterns nil))
	(make-pattern-literal ...))

EDIT:

Actually, no, this won't work! In the main branch

(match True
  (True "hi")
  (False "bye"))

returns "hi"... but so does this:

(match True
  (False "hi")
  (True "bye"))

because False is being read as a variable!

So actually, I think we should emit an "unused variable" error in this case. And, that's a separate issue not related to this PR.

EDIT no. 2:

I think this problem only creates confusion for Enums and Booleans, so your PR will actually fix this, and if this is merged, I don't think there is a reason to open a separate issue.

[stylewarning]

It's a long-standing issue that pattern variables can be confused as constructors by the programmer and we emit no good warning for this.

[YarinHeffes]

This can be

Suggested change

	(case ,(codegen-expression (node-match-expr expr) env)
	(case ,subexpr

or even

Suggested change

	(case ,(codegen-expression (node-match-expr expr) env)
	(case ,match-var

[YarinHeffes]

I get a bad error message for this example

(coalton-toplevel
  (repr :enum)
  (define-type MyEnum A B C))

(coalton
  (match A
    (A "hi")
    (B "bye")))

Because the patterns are read as pattern-vars and fall into t, and codegen otherwise for both of them:

(COMMON-LISP:LET ((#:MATCH4047
                   (COMMON-LISP:THE
                    (COMMON-LISP:MEMBER MYENUM/D MYENUM/C MYENUM/B MYENUM/A)
                    A)))
  (COMMON-LISP:DECLARE (COMMON-LISP:IGNORABLE #:MATCH4047))
  (COMMON-LISP:CASE A
    (COMMON-LISP:OTHERWISE
     (COMMON-LISP:LET ((A-3464 #:MATCH4047))
       "hi"))
    (COMMON-LISP:OTHERWISE
     (COMMON-LISP:LET ((B-3465 #:MATCH4047))
       "bye"))))

I think there should be a check to ensure that a variable or _ is only passed in the last branch.

[stylewarning]

If we add this check (it makes sense) we should do this before codegen.

[YarinHeffes]

If a check is done to ensure that a variable or _ is only passed in the last branch (see comment above), then this check here can just be a check on the last branch.