Personal tools

Singleton list confusion

From HaskellWiki

(Difference between revisions)
Jump to: navigation, search
(link to list notation)
(example)
 
Line 1: Line 1:
 
Why do Haskell newcomers frequently believe, that list variables must be enclosed in brackets?
 
Why do Haskell newcomers frequently believe, that list variables must be enclosed in brackets?
 
People sometimes write argument patterns like <hask>[x]</hask>, hoping that <hask>x</hask> will assume all values of a list successively.
 
People sometimes write argument patterns like <hask>[x]</hask>, hoping that <hask>x</hask> will assume all values of a list successively.
Maybe they expect some kind of [[list comprehension]].
+
Example:
  +
<haskell>
  +
case xs of
  +
[x] -> [f x]
  +
</haskell>
  +
although they meant
  +
<haskell>
  +
[f x | x <- xs]
  +
</haskell>
  +
or just <hask>map f xs</hask>.
  +
It seems like they expect some kind of [[list comprehension]].
 
However, if there wouldn't be a special [[list notation]] and if there wouldn't be the special syntax for the list type constructor (thus we must write <hask>[a]</hask> instead of <hask>List a</hask>),
 
However, if there wouldn't be a special [[list notation]] and if there wouldn't be the special syntax for the list type constructor (thus we must write <hask>[a]</hask> instead of <hask>List a</hask>),
 
then there would be certainly less confusion.
 
then there would be certainly less confusion.

Latest revision as of 07:16, 11 April 2008

Why do Haskell newcomers frequently believe, that list variables must be enclosed in brackets?

People sometimes write argument patterns like
[x]
, hoping that
x
will assume all values of a list successively.

Example:

case xs of
   [x] -> [f x]

although they meant

[f x | x <- xs]
or just
map f xs
.

It seems like they expect some kind of list comprehension.

However, if there wouldn't be a special list notation and if there wouldn't be the special syntax for the list type constructor (thus we must write
[a]
instead of
List a
),

then there would be certainly less confusion.

See for example Haskell-Cafe about testing for same characters in lists of strings, Pattern match failure