+ ; (let ([(foo a b) (foo 123 345)]) a)
+ ; |
+ ; v
+ ; (let ([a (foo~0 (foo 123 345)]
+ ; [b (foo~1 (foo 123 345)]) a)
+(define (expand-pattern-matches program)
+ (define (go x)
+ (define (pattern-match binding)
+ (let ([binding-name (car binding)]
+ [body (cadr binding)])
+ (if (eqv? (ast-type binding-name) 'var)
+ (list (list binding-name body))
+
+ (let* ([sum-name (car binding-name)]
+ [destructor (lambda (i) (dtor-name sum-name i))]
+ [products (cdr binding-name)]
+
+ [data-layouts (program-data-layouts program)]
+
+ [type (data-tor-type data-layouts sum-name)]
+
+ [sums (cdr (assoc type data-layouts))]
+ [sum (assoc sum-name sums)]
+
+ [expected-number (length (cdr sum))])
+
+ ; assert that we only do a let pattern match on an ADT with exactly one sum
+ (when (not (= 1 (length sums)))
+ (error #f (format "Cannot pattern match a ~a in a let since it has ~a possible constructors"
+ type
+ (length sums))))
+
+ ; assert that there is the correct number of bindings
+ (when (not (= (length products)
+ expected-number))
+ (error #f (format "Got ~a bindings: expected ~a for ~a"
+ (length products)
+ expected-number
+ binding)))
+
+ (flat-map (lambda (y i)
+ (pattern-match (list y `(,(destructor i) ,body))))
+ products
+ (range 0 (length products)))))))
+ (case (ast-type x)
+ ['let `(let ,(flat-map pattern-match (let-bindings x))
+ ,@(map go (let-body x)))]
+ [else (ast-traverse go x)]))
+ (program-map-exprs go program))
+