POC for "Syntactic sugar for destructuring patterns" or MATCH*?

[Inc0n]

I implemented a POC of what is a much welcomed feature to coalton as discussed in #280. And specifically from my comments onwards #280 (comment).

I would like to share my work with all of you.

fn* and match*

(progn
 (define fatorial
   (fn (n acc)
	 (match* (n acc)
	   ((0 acc) acc)
	   ((1 acc) acc)
	   ((n acc) (fatorial (- n 1) (* n acc))))))

 (define fatorial
   (fn* (acc n)
	 (acc 0) := acc
	 (acc 1) := acc
	 (acc n) := (fatorial (* n acc) (- n 1))))

 (define fatorial
   (fn*-bare (acc n)
	 acc 0 := acc
	 acc 1 := acc
	 acc n := (fatorial (* n acc) (- n 1)))
   ))

From the snippet above. The first is the base form fn match*, where the macro match* where transform itself into single nested coalton:match (a good analogy is match* is the let* version of match.
fn* and fn*-bare are the two different syntax flavours over match*, they are macros which expands to the first form. Personally I would prefer fn*-bare, I considered it to be cleaner.

So which syntax to go with, or whatever nuances should be taken care of could come later. Perhaps there should be a macro fn-macro* that expands to the fn macro* form instead or what not. So please share your opinions!

The code is shown below (as of now, the macro fn*-bare is ommited):

Code

(cl:defvar *clause-break-sym* :=)
(cl:defmacro define* ((fn-name cl:&body args) cl:&body fn*-body)
  `(define ,fn-name
	 (fn* ,args
		  ,@fn*-body)))

(defun parse-fn*-body (body)
  (cl:loop
	 :for (patterns clause-break expr) :on body :by #'cl:cdddr
	 :do (cl:unless (cl:and (cl:symbolp clause-break)
							(cl:string= *clause-break-sym*
										clause-break))
		   (cl:error "~a not found between expression, in ~a"
					 *clause-break-sym*
					 body))
	 :collect (cl:list patterns expr)))

(cl:defmacro fn* (args cl:&body fn*-body)
  `(fn ,args
	 (trvia:match* ,args ,@(parse-fn*-body fn*-body))))

(defmacro fn*-bare (args cl:&body fn*-body)
  `(fn ,args
	 (trivia:match* ,args ,@(parse-form fn*-body))))

(defun reduce-match% (args clauses)
  (if (null args)
	  ;; Should be just left with one pattern clause, returns its
	  ;; clause body
	  (second (car clauses))
	  (progn
		`(coalton:match ,(car args)
		   ;; group duplicate pats into one group, also merging
		   ;; subsequent pats
		   ,@(loop
			   :with patterns := (mapcar #'car clauses)
			   :for pat :in (remove-duplicates ; Pats reductions
							 (mapcar #'car	 ; Extract first pats
									 patterns))
			   :for subclauses := (remove-if-not (lambda (x) (eq x pat))
												 clauses
												 :key #'caar)
			   :for inner-clause
				 := (reduce-match%
					 (cdr args)
					 (loop :for (pat . body) :in subclauses
						   :collect (cons (cdr pat) body)))
			   :collect (list pat inner-clause))))))

EDIT1: added missing reduce-match% function.
EDIT2: Some rewording,