('app (map f x))
('lambda `(lambda ,(lambda-args x) ,(f (lambda-body x))))
('if `(if ,@(map f (cdr x))))
- ('case `(case ,(f (case-expr x))
+ ('case `(case ,(f (case-switch x))
,@(map (lambda (x)
(list (car x) (f (cadr x))))
(case-cases x))))
['if (append (f x)
(flat-map inner (cdr x)))]
['case (append (f x)
- (inner (case-expr x))
+ (inner (case-switch x))
(flat-map inner (map cadr (case-cases x))))]
['stack (append (f x)
(inner (caddr x)))]
['lambda (either (p x)
(inner (lambda-body x)))]
['if (either (p x) (any inner (cdr x)))]
+ ['case (either (p x)
+ (any inner (map cadr (case-cases x)))
+ (inner (case-switch x)))]
['stack (either (p x) (inner (caddr x)))]
[else (p x)]))
(define let-bindings cadr)
(define let-body cddr)
-(define case-expr cadr)
+(define case-switch cadr)
(define case-cases cddr)
+;; (define (verify-cases data-layouts annotated-program)
+
+;; (define allowed-match-ast-types
+;; '((Int . (int-literal var))
+;; (Bool . (bool-literal var))
+;; (String . (string-literal var))))
+
+;; (define (check-pattern switch-type pat)
+
+;; (define (impossible-match)
+;; (error "Can't pattern match ~a with ~a" switch-type (ann-expr pat)))
+
+;; (if (assoc switch-type data-layouts)
+;; (begin
+;; (let ([sums (cdr (assoc switch-type data-layouts))])
+;; (unless (eqv? (ast-type (ann-expr pat)) 'var) (impossible-match))
+;; (unless (assoc (car (ann-expr pat)) sums) (impossible-match))
+;; (unless
+;; )
+;; (begin
+;; (unless (assoc switch-type allowed-match-ast-types)
+;; (error #f "Can't pattern match on ~a" switch-type))
+
+;; (let ([allowed (cdr (assoc switch-type allowed-match-ast-types))])
+;; (unless (assoc (ast-type (ann-expr pat)) allowed) (impossible-match)))))))
+
+
+;; (let ([expr (ann-expr annotated-program)])
+;; (case (ast-type expr)
+;; ['case
+;; (let* ([switch-type (ann-type (case-switch expr))]
+;; [allowed (cdr (assoc switch-type allowed-match-ast-types))])
+;; (for-each
+;; []))]))))
+
+
; (let ([(foo a b) (foo 123 345)]) a)
; |
; v
; [b (foo~1 (foo 123 345)]) a)
(define (expand-pattern-matches program)
(define (go x)
- (define (pattern-match binding)
+ (define (let-pattern-match binding)
(let ([binding-name (car binding)]
[body (cadr binding)])
(if (eqv? (ast-type binding-name) 'var)
binding)))
(flat-map (lambda (y i)
- (pattern-match (list y `(,(destructor i) ,body))))
+ (let-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))
+ ['let `(let ,(flat-map let-pattern-match (let-bindings x))
,@(map go (let-body x)))]
[else (ast-traverse go x)]))
(program-map-exprs go program))