printastable :: [([Int],Word)] -> String

printastable l = concat $ map (\(xs,w) -> (show xs) ++ " " ++ w ++ "\n") l

I'd use [ c | (xs,w) <- l, c <- (show xs) ++ " " ++ w ++ "\n" ] instead -- after all, list comprehensions provide a much nicer syntax for map, filter and concat. -- Thomas

On Fri, 10 Dec 2004, Thomas Johnsson wrote:

...

printastable :: [([Int],Word)] -> String

printastable l = concat $ map (\(xs,w) -> (show xs) ++ " " ++ w ++ "\n") l

I'd use

[ c | (xs,w) <- l, c <- (show xs) ++ " " ++ w ++ "\n" ]

instead -- after all, list comprehensions provide a much nicer syntax for map, filter and concat.

I try to stay away from list comprehension because I can't memorize in which order the conditions are processed and I have to introduce new variables. List comprehension means thinking with variables, using 'map' and 'concat' means thinking with functions. Btw. if you want to save characters you can also use 'concatMap': printAsTable = concatMap (\(xs,w) -> show xs ++ " " ++ w ++ "\n") or printAsTable = unlines . map (\(xs,w) -> show xs ++ " " ++ w)

...

...

printastable :: [([Int],Word)] -> String

printastable l = concat $ map (\(xs,w) -> (show xs) ++ " " ++ w ++ "\n") l

I'd use

[ c | (xs,w) <- l, c <- (show xs) ++ " " ++ w ++ "\n" ]

instead -- after all, list comprehensions provide a much nicer syntax for map, filter and concat.

I try to stay away from list comprehension because I can't memorize in which order the conditions are processed and I have to introduce new variables. [..]

I find it helpful to compare list comprehensions to nested loops & ifs in imperative languages, so that eg [ E | v1 <- E1, pred2, v3 <- E3 ] 'does the same thing as' for( v1 <- E1 ){ if( pred2 ){ for( v3 <- E3){ put-elem-in-resulting-list( E ) } } } -- Thomas

And I thought that most programmers used "zipWith", which has to be prefix.

Is this true? Can you not use backticks on a partially applied function? If so, it seems like such a thing would be pretty useful (although I've never actually had occasion to need it, so....) I'll dig out the report and check sometime, but does anyone know for sure that the following wouldn't work? [1..5] `zipWith (+)` [7..]

Ketil Malde wrote:

Robert Dockins writes:

...

...

And I thought that most programmers used "zipWith", which has to be prefix.

...

[1..5] `zipWith (+)` [7..]

You don't have a computer at your end of the internet? :-)

Yes, but I'm at work, and I try to limit the amount of time I spend on my hobbies while on the clock; thus I have not haskell compilers/interpreters here because otherwise I'd spend all of my time playing around with haskell instead of doing what I'm supposed to ;-) Haskell is a lot more fun than Java.

Prelude> [1..5] `zipWith (+)` [7..] <interactive>:1: parse error on input `(' Prelude> let zwp = zipWith (+) in [1..5] `zwp` [7..] [8,10,12,14,16]

I thought that might be the case. To the haskell gods: is there a technical reason for this or did it just happen?

Malcolm Wallace wrote:

...

...

Prelude> [1..5] `zipWith (+)` [7..] <interactive>:1: parse error on input `('

is there a technical reason for this or did it just happen?

If you are asking why general expressions are prohibited between backticks, yes, there is a reason. The expression could be arbitrarily large, so you might have to search many lines to find the closing backtick. But in such a situation, it is surely much more likely that the programmer has simply forgotten to close the ticks around a simple identifier. Just think of the potential for delightfully baffling type error messages that might result!

There's also the issue that you wouldn't be allowed to use backticks within such an expression, so you would need additional grammar rules describing expressions which are allowed within backticks. -- Glynn Clements

On Thu, 09 Dec 2004 10:18:12 -0500, Robert Dockins wrote:

...

And I thought that most programmers used "zipWith", which has to be prefix.

Is this true? Can you not use backticks on a partially applied function? If so, it seems like such a thing would be pretty useful (although I've never actually had occasion to need it, so....) I'll dig out the report and check sometime, but does anyone know for sure that the following wouldn't work?

[1..5] `zipWith (+)` [7..]

It is possible to emulate this behaviour with some operator trickery. See: http://www.haskell.org/pipermail/haskell-cafe/2002-July/003215.html /Josef

Tomasz Zielonka wrote:

On Thu, Dec 09, 2004 at 10:02:39AM -0500, Jan-Willem Maessen - Sun Labs East wrote:

...

And I thought that most programmers used "zipWith", which has to be prefix.

You can also use zipWith to simulate zipN, for any N (however, the following code uses infix notation):

Prelude> let l = words "Haskell is great" Prelude> let zwApply = zipWith ($) Prelude> repeat (,,) `zwApply` [1..] `zwApply` l `zwApply` map length l [(1,"Haskell",7),(2,"is",2),(3,"great",5)] Prelude> map (,,) l `zwApply` [1..] `zwApply` map length l [("Haskell",1,7),("is",2,2),("great",3,5)]

I found it useful recently, when I needed zip functions for Trees - this way I didn't have to define functions for 3 trees, 4 trees, and so on.

Note also that: repeat f `zwApply` xs = map f xs When cooking up my own collection-y things (including splittable supplies, for example), I generally provide fmap and an equivalent of zwApply (a generic repeat is not quite so simple or useful). It's a nice little idiom, and a recommend it highly. -Jan-Willem Maessen

Best regards, Tomasz _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe@haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

On Thu, Dec 09, 2004 at 05:55:09PM +0000, Conor McBride wrote:

Funny you should choose that word:

http://www.mail-archive.com/haskell@haskell.org/msg15073.html

saves me banging the same old drum.

Is ap alias <# alias <%> for [] really the same as zwApply? Probably I am missing something. Best regards, Tomasz

Tomasz Zielonka writes:

On Thu, Dec 09, 2004 at 10:02:39AM -0500, Jan-Willem Maessen - Sun Labs East wrote:

...

And I thought that most programmers used "zipWith", which has to be prefix.

You can also use zipWith to simulate zipN, for any N (however, the following code uses infix notation):

Here's my favorite method, which I picked up from a paper whose title I have forgotten: Prelude> let zipWithN = (.repeat) Prelude> let succ d f x = d (zipWith ($) f x) Prelude> let zero = id Prelude> let one = succ zero Prelude> let two = succ one Prelude> :t zipWithN two zipWithN two :: forall b b1 b2. (b -> b1 -> b2) -> [b] -> [b1] -> [b2] Prelude> zipWithN two (,) [1..] (words "Haskell is great") [(1,"Haskell"),(2,"is"),(3,"great")] Prelude> let three = succ two Prelude> :t zipWithN three zipWithN three :: forall b b1 b2 b3. (b -> b1 -> b2 -> b3) -> [b] -> [b1] -> [b2] -> [b3] Prelude> :t zipWithN (succ three) zipWithN (succ three) :: forall b b1 b2 b3 b4. (b -> b1 -> b2 -> b3 -> b4) -> [b] -> [b1] -> [b2] -> [b3] -> [b4] Note that zipWithN zero == repeat and zipWithN one == map -- David Menendez | "In this house, we obey the laws http://www.eyrie.org/~zednenem | of thermodynamics!"