0. #lang typed/racket
1.  
2. (require (for-syntax racket/syntax
3.                      racket/list
4.                      syntax/parse))
5.  
6. (provide struct/fields)
7.  
8.  
9. (begin-for-syntax
10.   (define (syntax->keyword stx)
11.     (string->keyword (symbol->string (syntax->datum stx)))))
12.  
13. (define-syntax struct/fields
14.   (syntax-parser
15.     [(_ id ([field : type] ...))
16.      (with-syntax ([constructor/kw (format-id #'id "~a/kw" #'id)]
17.                    [constructor/fields (format-id #'id "~a/fields" #'id)]
18.                    [(kw+type ...) (append*
19.                                    (map (lambda (fld type)
20.                                           (list (syntax->keyword fld)
21.                                                 type))
22.                                         (syntax->list #'(field ...))
23.                                         (syntax->list #'(type ...))))]
24.                    [(kw+field ...) (append*
25.                                     (map (lambda (fld)
26.                                            (list (syntax->keyword fld)
27.                                                  fld))
28.                                          (syntax->list #'(field ...))))]
29.                    [ooo #'(... ...)])
30.        #'(begin
31.            (struct id ([field : type] ...))
32.            (define constructor/kw
33.              (ann (lambda (kw+field ...)
34.                     (id field ...))
35.                   (kw+type ... -> id)))
36.            (define-syntax constructor/fields
37.              (syntax-parser
38.                [(_ [fld val] ooo)
39.                 #'(cons constructor/kw (flatten (list (syntax->keyword #'fld) val) ooo))]))))]))
40.  
41. (struct/fields
42.  foo
43.  ([a : Integer]
44.   [b : Symbol]))
45.  
46. (foo/fields
47.  [b 'x]
48.  [a 5])

=>