Safe pattern matching

Safe pattern matching

[Nikita Karetnikov]

[-- Attachment #1: Type: text/plain, Size: 581 bytes --]

Any Haskellers here?

How would you rewrite the following function in Guile?

foo :: [Int] -> String -> [Int]
foo (x:y:ys) "+" = (x + y):ys
foo (x:y:ys) "-" = (x - y):ys
foo xs       num = read num:xs

*Main> foo [] "42"
[42]
*Main> foo [1,2] "42"
[42,1,2]
*Main> foo [1,2] "+"
[3]
*Main> foo [1..10] "42"
[42,1,2,3,4,5,6,7,8,9,10]
*Main> foo [1..10] "+"
[3,3,4,5,6,7,8,9,10]

It will fail if you call it like this:

*Main> foo [] "+"
[*** Exception: Prelude.read: no parse

But let's assume that it's OK.

I guess that 'match' is the answer, but I don't understand how to use
it.

[-- Attachment #2: Type: application/pgp-signature, Size: 835 bytes --]

Re: Safe pattern matching

[Daniel Hartwig]

On 9 February 2013 17:57, Nikita Karetnikov <nikita@karetnikov.org> wrote:
> Any Haskellers here?
>
> How would you rewrite the following function in Guile?
>
> foo :: [Int] -> String -> [Int]
> foo (x:y:ys) "+" = (x + y):ys
> foo (x:y:ys) "-" = (x - y):ys
> foo xs       num = read num:xs

Indeed, match can do this.  The style is very similar.

Using symbols and literals, rather than strings:

> (use-modules (ice-9 match))
> (define (foo . args)
    (match args
      (((x y . ys) '+)
       (cons (+ x y) ys))
      (((x y . ys) '-)
       (cons (- x y) ys))
      ((xs num)
       (cons num xs))))
> (foo '() 42)
$1 = (42)
> (foo '(1 2) 42)
$2 = (42 1 2)
> (foo '(1 2) '+)
$3 = (3)
> (use-modules (srfi srfi-1))
> (foo (iota 10 1) 42)
$4 = (42 1 2 3 4 5 6 7 8 9 10)
> (foo (iota 10 1) '+)
$5 = (3 3 4 5 6 7 8 9 10)

Re: Safe pattern matching

[Daniel Hartwig]

On 9 February 2013 18:12, Daniel Hartwig <mandyke@gmail.com> wrote:
> Using symbols and literals, rather than strings:

Though strings work just as well as symbols :-)

Re: Safe pattern matching

[Ian Price]

Nikita Karetnikov <nikita@karetnikov.org> writes:

> How would you rewrite the following function in Guile?
>
> foo :: [Int] -> String -> [Int]
> foo (x:y:ys) "+" = (x + y):ys
> foo (x:y:ys) "-" = (x - y):ys
> foo xs       num = read num:xs

Daniel covered most of this already, but instead you might consider
(define foo
  (match-lambda* ....))
rather than
(define (foo . args)
   (match args
     ....))

the nearest analogue to read is object->string, but it is not a generic.

-- 
Ian Price -- shift-reset.com

"Programming is like pinball. The reward for doing it well is
the opportunity to do it again" - from "The Wizardy Compiled"

Re: Safe pattern matching

[Ian Price]

> the nearest analogue to read is object->string, but it is not a generic.
That should be string->object. It's funny how often I mix up a->b and b->a

-- 
Ian Price -- shift-reset.com

"Programming is like pinball. The reward for doing it well is
the opportunity to do it again" - from "The Wizardy Compiled"