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

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
>>>>
>>
>>