One somewhat neat thing about Haskell is that you can say case list of [[x], [y,_], [z,_,_]] -> x + y + z _ -> 0 In Java, you'd have to write something like if (list.length() == 3) { List t1 = list.at(0); if (t1.length() == 1) { int x = t1.at(0); List t2 = list.at(1); if (t2.length() == 2) ... I can't even be bothered to finish typing all that lot! However, as somebody pointed out, the Java version is polymorphic. Assuming that length() is defined for multiple types of container, the Java version works with lists, arrays, sets, etc. If you try to do this in Haskell, you end up with case size c of 3 -> case (c ! 0, c ! 1, c ! 2) of (xs, ys, zs) | size x == 1 && size y == 2 & size z == 3 -> (xs ! 0) + (ys ! 0) + (zs ! 0) _ -> 0 _ -> 0 or similar. Which is shorter than Java, but nowhere near as nice as the original list-only version. Now I was under the impression that "view patterns" fix this problem, but it seems they don't: case c of (size -> 3) -> case (c ! 0, c ! 1, c ! 2) of (size -> 1, size -> 2, size -> 3) -> (c ! 0 ! 0) + (c ! 1 ! 0) + (c ! 2 ! 0) Any suggestions?
A humble suggestion: Have a *lazy* "to list" method for your *lists, arrays,
sets, etc.* and use the nice list-only version.
On 27 February 2010 18:11, Andrew Coppin
One somewhat neat thing about Haskell is that you can say
case list of [[x], [y,_], [z,_,_]] -> x + y + z _ -> 0
In Java, you'd have to write something like
if (list.length() == 3) { List t1 = list.at(0); if (t1.length() == 1) { int x = t1.at(0); List t2 = list.at(1); if (t2.length() == 2) ...
I can't even be bothered to finish typing all that lot!
However, as somebody pointed out, the Java version is polymorphic. Assuming that length() is defined for multiple types of container, the Java version works with lists, arrays, sets, etc. If you try to do this in Haskell, you end up with
case size c of 3 -> case (c ! 0, c ! 1, c ! 2) of (xs, ys, zs) | size x == 1 && size y == 2 & size z == 3 -> (xs ! 0) + (ys ! 0) + (zs ! 0) _ -> 0 _ -> 0
or similar. Which is shorter than Java, but nowhere near as nice as the original list-only version.
Now I was under the impression that "view patterns" fix this problem, but it seems they don't:
case c of (size -> 3) -> case (c ! 0, c ! 1, c ! 2) of (size -> 1, size -> 2, size -> 3) -> (c ! 0 ! 0) + (c ! 1 ! 0) + (c ! 2 ! 0)
Any suggestions?
_______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
-- Ozgur Akgun
Ozgur Akgun wrote:
A humble suggestion: Have a *lazy* "to list" method for your /lists, arrays, sets, etc./ and use the nice list-only version.
Yeah, that works quite nicely. It won't work for arbitrarily complex structures, however. My main point was that if you make the constructors abstract and provide functions to query the structure, now you can't pattern match against it.
Andrew Coppin
Ozgur Akgun wrote:
A humble suggestion: Have a *lazy* "to list" method for your /lists, arrays, sets, etc./ and use the nice list-only version.
Yeah, that works quite nicely.
It won't work for arbitrarily complex structures, however. My main point was that if you make the constructors abstract and provide functions to query the structure, now you can't pattern match against it.
http://hackage.haskell.org/trac/ghc/ticket/3583 ...I think the issue just has to be nailed down precisely, and then someone has to volunteer implementing it. -- (c) this sig last receiving data processing entity. Inspect headers for copyright history. All rights reserved. Copying, hiring, renting, performance and/or quoting of this signature prohibited.
On 28 February 2010 05:55, Andrew Coppin
It won't work for arbitrarily complex structures, however. My main point was that if you make the constructors abstract and provide functions to query the structure, now you can't pattern match against it.
We do, however, have guards which helps reduce the boiler plate (nested if statements, etc.). -- Ivan Lazar Miljenovic Ivan.Miljenovic@gmail.com IvanMiljenovic.wordpress.com
| However, as somebody pointed out, the Java version is polymorphic. | Assuming that length() is defined for multiple types of container, the | Java version works with lists, arrays, sets, etc. If you try to do this | in Haskell, you end up with A standard way to do it would be this: class ListLike c where lcase :: c a -> LCase a (c a) lcons :: a -> c a -> c a lnil :: c a data LCase a b = LNil | LCons a b f :: ListLike c => c (c Int) -> Int f (lcase -> LCons (lcase -> LCons x (lcase -> LNil)) (lcase -> LCons (lcase -> LCons y (lcase -> LCons _ (lcase -> LNil))) (lcase -> LNil))) = x+y Simon | -----Original Message----- | From: haskell-cafe-bounces@haskell.org [mailto:haskell-cafe-bounces@haskell.org] On | Behalf Of Andrew Coppin | Sent: 27 February 2010 18:11 | To: haskell-cafe@haskell.org | Subject: [Haskell-cafe] View patterns | | One somewhat neat thing about Haskell is that you can say | | case list of | [[x], [y,_], [z,_,_]] -> x + y + z | _ -> 0 | | In Java, you'd have to write something like | | if (list.length() == 3) | { | List t1 = list.at(0); | if (t1.length() == 1) | { | int x = t1.at(0); | List t2 = list.at(1); | if (t2.length() == 2) | ... | | I can't even be bothered to finish typing all that lot! | | However, as somebody pointed out, the Java version is polymorphic. | Assuming that length() is defined for multiple types of container, the | Java version works with lists, arrays, sets, etc. If you try to do this | in Haskell, you end up with | | case size c of | 3 -> | case (c ! 0, c ! 1, c ! 2) of | (xs, ys, zs) | size x == 1 && size y == 2 & size z == 3 -> (xs ! | 0) + (ys ! 0) + (zs ! 0) | _ -> 0 | _ -> 0 | | or similar. Which is shorter than Java, but nowhere near as nice as the | original list-only version. | | Now I was under the impression that "view patterns" fix this problem, | but it seems they don't: | | case c of | (size -> 3) -> | case (c ! 0, c ! 1, c ! 2) of | (size -> 1, size -> 2, size -> 3) -> (c ! 0 ! 0) + (c ! 1 ! 0) + | (c ! 2 ! 0) | | Any suggestions? | | _______________________________________________ | Haskell-Cafe mailing list | Haskell-Cafe@haskell.org | http://www.haskell.org/mailman/listinfo/haskell-cafe
participants (5)
-
Achim Schneider -
Andrew Coppin -
Ivan Miljenovic -
Ozgur Akgun -
Simon Peyton-Jones