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

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