Re: behavior of CASE with strings

Hi,

i could used string->symbol instead of stings with the normal CASE but
i finally wrote a macro for CASE with strings,
it was harder than expected , i learned macro at university with the
define-macro style ,i was familiar with this style, now define-syntax is
used, here is my macro:

(define-syntax case-string

  (syntax-rules ( => )


    ;; (define dog "dog")
    ;; (case-string dog (("dog") "animal")   (else => "mineral or
vegetable"))
    ((case-string var
          lst
          (else => res-else  ...))

     (if (member var (car (quote lst)))
       (cadr (quote lst))
       (begin
         res-else
         ...)))

    ;; (define cat "cat")
    ;; (case-string cat (("dog") "animal") (("cat") "my daughter say cats
are not animals!")  (else => "mineral or vegetable"))
    ((case-string var
              lst
              lst2
              ...
              (else => res-else ...))

     (if (member var (car (quote lst)))
     (cadr (quote lst))
     (case-string var
              lst2
              ...
              (else => res-else ...))))



    ;;(case-string dog  (else => "silly case"))
    ((case-string var
          (else => res-else ...))

     (begin
       res-else
       ...))))

i'm not sure if this macro is r5rs compliant but i have test it working.

Regards,

 Damien

On Tue, Jan 17, 2017 at 8:27 PM, Bent Phillipsen <[email protected]>
wrote:

> Hi Damien,
>
> This question has already been answered. Should it be of interest, I would
> like to add the following:
>
> R5RS specifies that the case expression tests equivalence with eqv?
> (p.10), but also that equivalence test of strings with eqv? is
> 'unspecified' (p.18). This has the consequence that stings cannot be used
> as key and clause in case expressions in a well defined way (or at least
> portable way). You can however easily define a macro that *also* can use
> strings. You can write your own; but simply taking the case macro defined
> in R5RS (p.43) ensures that all corner cases are handled correctly. You
> then just need to replace 'memv' with 'member' (this has the effect of
> testing equivalence with equal? instead of eqv?). You probably want to
> change the name of the macro also, for instance to case-member, to avoid
> shadowing the original case expression. You will get something like the
> following, which should work and which I think is portable. (There is of
> cause a (mostly insignificant) performance penalty in testing with equal?
> instead of eqv?):
>
> --------------------------------------
>
> (module test-case-member
>         (main start))
>
> (define-syntax case-member
>         (syntax-rules (else)
>                 ((case-member (key ...)
>                         clauses ...)
>                  (let ((atom-key (key ...)))
>                         (case-member atom-key clauses ...)))
>                 ((case-member key
>                         (else result1 result2 ...))
>                  (begin result1 result2 ...))
>                 ((case-member key
>                         ((atoms ...) result1 result2 ...))
>                  (if (member key '(atoms ...))
>                         (begin result1 result2 ...)))
>                 ((case-member key
>                         ((atoms ...) result1 result2 ...) clause clauses
> ...)
>                  (if (member key '(atoms ...))
>                         (begin result1 result2 ...)
>                         (case-member key clause clauses ...)))))
>
> (define (start argv)
>
>         (define x (string-append "b" "a" "r"))
>         (define y "animal")
>         (define z 'composit)
>
>         (print "next line should be '" y "':")
>         (print (case-member (string-append "do" "g") (("cat" "dog"
> "mouse") y) (else "mineral or vegetable")))
>
>         (print (string-append "next line should be '" x "':"))
>         (case-member x
>                 (("foo")  (print 'foo))
>                 (("bar")  (print 'bar))
>                 (else "it was not foo or bar"))
>
>         (print (string-append "next line should be '" (symbol->string z)
> "':"))
>         (print (case-member (* 2 3) ((2 3 5 7) 'prime)
>                                     ((1 4 6 8 9) z))))
>
> ---------------------------------
>
> Best regards
>
> Bent
>
>
> 2017-01-16 14:32 GMT+01:00 <[email protected]>:
>
>> Hi Damien,
>>
>> Bigloo complies with the R5RS specification (see section 4.2) that says:
>>
>> -----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
>> -----|-----|-----
>> case <key> <clause1> <clause2> ...,     library syntax
>> Syntax: <Key> may be any expression. Each <clause> should have the form
>>
>> ((<datum1> ...,) <expression1> <expression2> ...,),
>>
>> where each <datum> is an external representation of some object. All the
>> <datum>s must be distinct. The last <clause> may be an ``else clause,''
>> which has the form
>>
>> (else <expression1> <expression2> ...,).
>>
>> Semantics: A case expression is evaluated as follows. <Key> is evaluated
>> and its result is compared against each <datum>. If the result of
>> evaluating <key> is equivalent (in the sense of eqv?; see section
>> Equivalence predicates) to a <datum>, then the expressions in the
>> corresponding <clause> are evaluated from left to right and the result(s)
>> of the last expression in the <clause> is(are) returned as the result(s) of
>> the case expression. If the result of evaluating <key> is different from
>> every <datum>, then if there is an else clause its expressions are
>> evaluated and the result(s) of the last is(are) the result(s) of the case
>> expression; otherwise the result of the case expression is unspecified.
>>
>> (case (* 2 3)
>>   ((2 3 5 7) 'prime)
>>   ((1 4 6 8 9) 'composite))            =>  composite
>> (case (car '(c d))
>>   ((a) 'a)
>>   ((b) 'b))                            =>  unspecified
>> (case (car '(c d))
>>   ((a e i o u) 'vowel)
>>   ((w y) 'semivowel)
>>   (else 'consonant))                   =>  consonant
>> -----|-----|-----|-----|-----|-----|-----|-----|-----|-----|
>> -----|-----|-----
>>
>> You can observe that with:
>>
>> (pp (expand '(case x (("foo") 1) (("bar" ) 2))))
>> =>
>> (let ((case-value x))
>>   (if (eqv? case-value '"foo")
>>     1
>>     (if (eqv? case-value '"bar") 2 #unspecified)))
>>
>> Cheers,
>>
>> --
>> Manuel
>>
>
>