The stupid question is the question not asked PerlMonks

### Re^9: 99 Problems in Perl6

 on Dec 15, 2006 at 23:51 UTC ( #590157=note: print w/replies, xml ) Need Help??

in reply to Re^8: 99 Problems in Perl6
in thread 99 Problems in Perl6

We'll support matching against sigs using when if you really want ordered guards, but multis are defined to ignore ordering, so it doesn't matter where they're defined, in this file or in any other file. Only the type semantics of the signature matter. Overuse of ordered guards is actually kind of a semantic flaw in Haskell, I think. It's a way of sneaking in sequential dependencies without a monad.

Replies are listed 'Best First'.
Re^10: 99 Problems in Perl6
by gaal (Parson) on Dec 16, 2006 at 07:31 UTC
Pure variants like this one are desugared into a case:

```compress x = case x of
[]       -> []
[a]      -> [a]             -- singleton list
(x:y:xs) -> (if x == y then [] else [x]) ++ compress (y:xs)

And can do no monadic monkey business because compress is pure. In this they are simply a more convenient way of spelling out some branches. You wouldn't say if is a sneaky way of doing sequential dependencies, would you?

Sure, with a monadic function you can also have pattern guards that do monadic stuff, but I don't think you can bind without noticing, and in any case the function type will tell you it's monadic.

Re^10: 99 Problems in Perl6
by gaal (Parson) on Dec 16, 2006 at 09:01 UTC
Ordered variants in Haskell let you do things like

```funky (x:y:xs) = ... -- I'm guaranteed to have two elements or more
funky (x:xs)   = ... {- This pattern would have matched a long list, b
+ut since
the previous variant came first, we know the l
+ist is
of length 1 or 2. *
-}

This is incredibly useful sometimes. Okay, when I want when I know where to find it. :-)

* For folks not familiar with Haskell who count three or two items in the two patterns and don't see why I'm talking of lists of at least two and one or two elements respectively: in Haskell, "(a:b)" means a is an element and b is a list of zero or more elements. That's why by convention you see names like "xs" and "ys", pronounced "exes" and "whys", though there's nothing in the language to enforce names like that. The expression (x:y:xs) means (x:(y:xs)).

I agree with you here that ordered matching of sigs is convenient, even though it isn't as clear.

Standard ML guarantees ordered matching in functions (and also in lambdas and case expressions), so you can say this:

```fun fact 0 = 1 |
fact n = n * fact(n - 1);
(this is not the best way to define factorial though).

Prolog also matches the heads of predicate definitions in order.

Mathematica is a bit different. It matches argument lists to more specific patterns first, and when it is not clear which pattern is more specific, it matches them in order.

Similar syntax exists in Haskell and is called a guard.

```-- Here the |s should be read as one vertical line, like a mathematica
+l function def.
fact n      | n == 0    = 1
| otherwise = n * fact (n - 1)

-- Here's the same thing in different style, the same one as I'd used
+earlier and
-- called "declarative", sometimes called direct pattern matching, bec
+ause each
-- variant gets to bind whatever it managed to match.
fact 0 = 1
fact n = n * fact (n - 1)

There are plenty of non-syntactic variations on this theme. The scanl one is my favorite.

Create A New User
Node Status?
node history
Node Type: note [id://590157]
help
Chatterbox?
and all is quiet...

How do I use this? | Other CB clients
Other Users?
Others making s'mores by the fire in the courtyard of the Monastery: (2)
As of 2018-04-27 01:39 GMT
Sections?
Information?
Find Nodes?
Leftovers?
Voting Booth?
My travels bear the most uncanny semblance to ...

Results (97 votes). Check out past polls.

Notices?