[plt-scheme] redex: meta-function with alternatives

Ok, good to know. Thanks!

-- Éric


On Sep 11, 2009, at 10:02 PM, Robby Findler wrote:

> FWIW, I doubt it will matter. If you ever need speed, probably you
> want to rewrite some core thing using match, since pattern matching
> tends to swamp all other things.
>
> Robby
>
> On Fri, Sep 11, 2009 at 8:58 PM, Eric Tanter <etanter at dcc.uchile.cl>  
> wrote:
>> no, not at all -- just prototyping semantics. I was just wondering,  
>> in case
>> it actually becomes important at some point. If that turns out to  
>> be the
>> case, I'll try with a macro.
>>
>> thanks again,
>>
>> -- Éric
>>
>>
>> On Sep 11, 2009, at 9:34 PM, Robby Findler wrote:
>>
>>> Yes, it means that. I suppose you could define a macro somehow that
>>> would shortcircuit evaluation.
>>>
>>> Is it really a performance problem for you?
>>>
>>> Robby
>>>
>>> On Fri, Sep 11, 2009 at 8:29 PM, Eric Tanter <etanter at dcc.uchile.cl>
>>> wrote:
>>>>
>>>> Thanks Robby, that effectively does the job!
>>>>
>>>> Just out of curiosity, this means lookup will always go fully in  
>>>> both
>>>> branches, even when that would not really be needed (right?). Any  
>>>> simple
>>>> way
>>>> to avoid that?
>>>>
>>>> Cheers,
>>>>
>>>> -- Éric
>>>>
>>>>
>>>> On Sep 11, 2009, at 8:34 PM, Robby Findler wrote:
>>>>
>>>>> I think you want something like this for the case with two  
>>>>> options:
>>>>>
>>>>> (pick   ;; try that first
>>>>> (lookup os_2 f (store (l_3 os_3) ...))
>>>>>
>>>>> ;; if above fails (exception or #f) then try that:
>>>>> (lookup os_1 f (store (l_3 os_3) ...)))
>>>>>
>>>>> and then to use this pick metafunction:
>>>>>
>>>>> (define-metafunction foo
>>>>>  [(pick #f any) any]
>>>>>  [(pick any_1 any_2) any_1])
>>>>>
>>>>> hth,
>>>>> Robby
>>>>>
>>>>> On Fri, Sep 11, 2009 at 6:46 PM, Eric Tanter <etanter at dcc.uchile.cl 
>>>>> >
>>>>> wrote:
>>>>>>
>>>>>> Hi,
>>>>>>
>>>>>> I want to define a simple recursive metafunction, but which has  
>>>>>> the
>>>>>> particularity of needing to somehow backtrack. It is doing a  
>>>>>> lookup in
>>>>>> terms, but some terms have two branches, and if the first one  
>>>>>> fails, it
>>>>>> should go in the second one.
>>>>>>
>>>>>> I see two options to do it:
>>>>>> - use exception handling (the "not found in first branch" case  
>>>>>> being
>>>>>> caught
>>>>>> as a "no match for clause...")
>>>>>> - have a base case returns #f, and then somehow distinguish  
>>>>>> whether the
>>>>>> recursive call returned a normal term or #f, if normal term  
>>>>>> return it,
>>>>>> otherwise go through second branch.
>>>>>>
>>>>>> I actually can't figure out how to make either case work... I  
>>>>>> imagine
>>>>>> the
>>>>>> latter solution is cleaner than exceptions, but couldn't make  
>>>>>> it work
>>>>>> (with
>>>>>> term-let).
>>>>>>
>>>>>> This is a simplified version of what I have:
>>>>>>
>>>>>> (define-metafunction foo
>>>>>>  lookup : os f S -> any
>>>>>>  ;; lookup f in os
>>>>>>  ; os = (def f v)
>>>>>>  ((lookup (def f v) f (store (l os) ...)) v)
>>>>>>
>>>>>>  ; 'fail case'
>>>>>>  ((lookup (def f_1 v) f_2 (store (l os) ...)) #f
>>>>>>  (side-condition (not (eq? (term f_1) (term f_2)))))
>>>>>>
>>>>>>  ; os = (with os1 os2)
>>>>>>  ((lookup (with os_1 os_2) f (store (l_3 os_3) ...))
>>>>>>
>>>>>>  ;; try that first
>>>>>>   (lookup os_2 f (store (l_3 os_3) ...)
>>>>>>
>>>>>>  ;; if above fails (exception or #f) then try that:
>>>>>>   (lookup os_1 f (store (l_3 os_3) ...))
>>>>>> )
>>>>>>
>>>>>> any idea?
>>>>>>
>>>>>> Thanks in advance,
>>>>>>
>>>>>> -- Éric
>>>>>>
>>>>>>
>>>>>> _________________________________________________
>>>>>>  For list-related administrative tasks:
>>>>>>  http://list.cs.brown.edu/mailman/listinfo/plt-scheme
>>>>>>
>>>>
>>>>
>>
>>