On Aug 7, 2014, at 1:41 AM, Kevin Forchione <lyss...@gmail.com> wrote:
>
> On Aug 6, 2014, at 11:02 AM, Alexander D. Knauth <alexan...@knauth.org> wrote:
>
>>
>> On Aug 6, 2014, at 1:47 PM, Alexander D. Knauth <alexan...@knauth.org> wrote:
>>
>>>
>>>
>>> On Aug 6, 2014, at 1:10 PM, Kevin Forchione <lyss...@gmail.com> wrote:
>>>
>>>>
>>>> On Aug 5, 2014, at 2:21 PM, Jens Axel Søgaard <jensa...@soegaard.net>
>>>> wrote:
>>>>
>>>>> Is this a step in the right direction?
>>>>>
>>>>> (define-syntax (x stx)
>>>>> (syntax-parse stx
>>>>> [(_ (y ... (z ...) w ...))
>>>>> #'(xf (yf y ... (zf z ...) w ...))]))
>>>>>
>>>>> The pattern (z ...) ... will match a sequence of lists such as (4 5 6) (7
>>>>> 8)
>>>>> but it won't match (4 5 6) 7 8 from your example.
>>>>>
>>>>> /Jens Axel
>>>>
>>>> Closer. It doesn’t match something like ‘( 1 2 3 (4 5 6) 7 (8 9) 10), for
>>>> instance.
>>>
>>> For that I think you want something like this:
>>> (syntax-parse stx
>>> [(_ (~or (z ...)
>>> y)
>>> ...)
>>> #'(xf (yf y ... (zf z ...)))])
>>
>> Sorry I forgot an ellipsis. I meant this:
>> (syntax-parse stx
>> [(_ (~or (z ...)
>> y)
>> ...)
>> #'(xf (yf y ... (zf z ...) ...))])
>
>
> Remarkably difficult just to parse what amounts to nested lists! This doesn’t
> quite do what I want either. For instance:
>
> #lang racket
>
> (require (for-syntax syntax/parse))
>
> #;(define-syntax (x stx)
>
> (define-syntax-class binding
> #:description "binding list"
> (pattern (z:number ...)))
>
> (syntax-parse stx
> [(_ b:binding ...)
> #'(list (list b.z ...) ...)]))
>
> #;(define-syntax (x stx)
>
> (define-syntax-class lbinding
> #:description "binding list"
> (pattern (z:number ...)))
>
> (define-syntax-class orbinding
> #:description "binding or"
> (pattern (y:number ...)
> #:with (z ...) #'(y ...))
> (pattern (lb:lbinding)
> #:with (z ...) #'(lb.z ...)))
>
> (syntax-parse stx
> [(_ ob:orbinding ...)
> #'(list (list ob.z ...) ...)]))
>
> #;(define-syntax (x stx)
>
> (define-syntax-class lbinding
> #:description "binding list"
> (pattern (z:number ...)))
>
> (define-syntax-class orbinding
> #:description "binding or"
> (pattern (y:number ...)
> #:with (z ...) #'(y ...))
> (pattern (lb:lbinding)
> #:with (z ...) #'(lb.z ...)))
>
> (syntax-parse stx
> [(_ ob:orbinding ...)
> #'(list (list ob.z ...) ...)]))
>
> (define-syntax (x stx)
> (syntax-parse stx
> [(_ (~or (z ...)
> y)
> ...)
> #'(list (list y ... (list z ...) ...))]))
>
> (x (1 2 3 4) (5 (6 7) 8))
>
> expands to: (list (list (list 1 2 3 4) (list 5 (6 7) 8))))) instead of
> (list (list (list 1 2 3 4) (list 5 (list 6 7) 8))))).
>
> -Kevin
>
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 ...) ...)
...) ...) ...) ...)])
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?
____________________
Racket Users list:
http://lists.racket-lang.org/users
