On Aug 7, 2014, at 1:28 PM, Kevin Forchione <[email protected]> wrote:
> On Aug 7, 2014, at 9:50 AM, Kevin Forchione <[email protected]> wrote: > >> >> On Aug 7, 2014, at 8:55 AM, Alexander D. Knauth <[email protected]> wrote: >> >>>> >>>> Do you want something like this then: >>>> (syntax-parse stx >>>> [(_ (~or ((((e ...) ...) ...) ...) >>>> (((d ...) ...) ...) >>>> ((c ...) ...) >>>> (b ...) >>>> a) >>>> . . .) >>>> #’(list (list a ... (list b ... (list c ... (list d ... (list e ...) >>>> ...) ...) ...) ...) ...)]) >>> >>> Sorry I meant this: >>> (syntax-parse #'(x (1 2 3 4) (5 (6 7) 8)) >>> [(_ (~or ((~or ((~or ((~or (e ...) d) ...) c) ...) b) ...) a) ...) >>> #'(list (list a ... (list b ... (list c ... (list d ... (list e ...) >>> ...) ...) ...) ...))]) >>> >>>> Except going infinitely? For that I think you would need a recursive >>>> helper function. >>>> >>>> Or do you want to just replace all instances of (a ...) with (list a ...) >>>> ?: >>>> (define-syntax-class thing >>>> #:attributes (norm) >>>> [pattern (a:thing ...) >>>> #:with norm (list a.norm ...)] >>>> [pattern a >>>> #:with norm a]) >>>> >>>> Or what? >> >> Sorry, I should probably clarify the problem I’m attempting to solve. I’ve >> got an application that creates a composite image using classes of objects >> that draw themselves. Essentially the macro Compose-A >> >> (compose-A (<img | (img …)> …) …) >> >> would produce something like: >> >> {compose-A (compose-B <img | (compose-C img …)> …) …) >> >> Compose-A can have an arbitrary number of compose-B clauses. >> compose-B clauses can have an arbitrarily number of elements in any order >> consisting of ing or clause-C. >> The clause-C consist of an arbitrary number of img. >> >> I’ve been wondering about having to go with a recursive macro. Is there any >> code in the current system that can be modeled from? >> >> -Kevin > > Actually, now that I think about it, the pattern can be generalized: > > (compose-macro [func …) <atom ! (<atom | (atom …)> …)> …) > > producing something like: > > {func0 <atom | (func1 <atom | (func2 atom …)> …)> …), etc. > > Essentially each clause consisting of an image or a sub-list, with succeeding > levels of sub-list applying a new compose function to its arguments. I have > to apologize, I don’t think I’ve captured the idea correctly with my > notation. > > —Kevin Ok then would this work for what you want? (define-syntax-class (thing fs) #:attributes (norm) [pattern x #:when (empty? fs) #:with norm #'x] [pattern (x ...) #:declare x (thing (rest fs)) #:with f (first fs) #:with norm #'(f x.norm ...)] [pattern x #:with norm #'x]) (syntax-parse #'(x [f1 f2 f3] (1 2 3 4) (5 (6 7) 8)) [(_ [f ...] . x) #:declare x (thing (syntax->list #'(f ...))) #'x.norm]) ; #<syntax (f1 (f2 1 2 3 4) (f2 5 (f3 6 7) 8))>
____________________ Racket Users list: http://lists.racket-lang.org/users
