Send Beginners mailing list submissions to
beginners@haskell.org
To subscribe or unsubscribe via the World Wide Web, visit
http://www.haskell.org/mailman/listinfo/beginners
or, via email, send a message with subject or body 'help' to
beginners-requ...@haskell.org
You can reach the person managing the list at
beginners-ow...@haskell.org
When replying, please edit your Subject line so it is more specific
than "Re: Contents of Beginners digest..."
Today's Topics:
1. Re: beginner question (Daniel Fischer)
2. Re: list monad question (Daniel Fischer)
3. Re: beginner question (Shawn Willden)
4. Re: list monad question (Matthias Guedemann)
5. RE: beginner question (Luca Ciciriello)
6. Re: list monad question (Colin Paul Adams)
7. Re: list monad question (Stephen Tetley)
8. Re: beginner question (Brent Yorgey)
9. Re: list monad question (Daniel Fischer)
----------------------------------------------------------------------
Message: 1
Date: Fri, 30 Oct 2009 15:46:33 +0100
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] beginner question
To: beginners@haskell.org
Message-ID: <200910301546.34301.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="iso-8859-15"
Am Freitag 30 Oktober 2009 14:40:13 schrieb Luca Ciciriello:
> Hi all.
>
> Just a very basic question.
>
>
>
> I need to write a function str2lsts :: String -> [[String]] in order to
> transorm a string like:
>
>
>
> "\"1\",\"cat\",\"dog\"§\"2\",\"duck\",\"goose\""
>
>
>
> in the list of lists:
>
>
>
> [["1","cat","dog"],["2","duck","goose"]]
>
>
>
> I've tried to mix recursion, pattern matching and list comprehension, but
> the obtained result was embarrassing complex (> 20 lines of awful code). I
> think that a more simple solution certainly exists.
>
splitOnToken :: Eq a => a -> [a] -> [[a]]
splitOnToken t xs
= case break (== t) xs of
(hd,tl) -> hd:case tl of
(_:r@(_:_)) -> splitOnToken t r
_ -> []
str2lsts = map (map read . splitOnToken ',') . splitOnToken '§'
if things weren't enclosed in quotation marks inside the string, it would be
the nicer
map (splitOnToken ',') . splitOnToken '§'
, provided of course, neither ',' nor '§' are valid characters for the target
strings.
import Text.ParserCombinators.Parsec
simple = between (char '"') (char '"') (many (staisfy (/= '"')))
-- alternative: simple = char '"' >> manyTill anyChar (char '"')
multiple = sepBy simple (char ',')
total = sepBy multiple (char '§')
str2lsts str
= case parse total "" str of
Left err -> error (show err)
Right lsts -> lsts
>
>
>
> Thanks in advance for any idea.
>
>
>
> Luca
------------------------------
Message: 2
Date: Fri, 30 Oct 2009 16:03:37 +0100
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] list monad question
To: Matthias Guedemann <matthias.guedem...@ovgu.de>
Cc: beginners <beginners@haskell.org>
Message-ID: <200910301603.37963.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="utf-8"
Am Freitag 30 Oktober 2009 14:32:35 schrieb Matthias Guedemann:
> Hi Daniel,
>
> > That gives
> >
> > combinations n xs = foldr f [[]] (replicate n xs)
> >
> > pointfree, for extra goodness:
> >
> > -- pointfree f inline
> > combinations n xs = foldr ((. (. (:)) . flip map) . (>>=)) [[]]
> > (replicate n xs) -- eliminate xs
> > combinations n = foldr ((. (. (:)) . flip map) . (>>=)) [[]] . replicate
> > n -- completely pointfree
> > combinations = (foldr ((. (. (:)) . flip map) . (>>=)) [[]] .) .
> > replicate
>
> thank you, looks rather strange to me but works well.
Yes :D The pointfree f is nicely obfuscated. But if your friend is a perl
coder, he should
be able to appreciate that.
The standard way to express f, however, is liftM2 (:), so
combinations = (foldr (liftM2 (:)) [[]] .) . replicate
-- isn't that boring?
But earnestly, replicateM is the thing to use.
>
> regards
------------------------------
Message: 3
Date: Fri, 30 Oct 2009 09:11:48 -0600
From: Shawn Willden <shawn-hask...@willden.org>
Subject: Re: [Haskell-beginners] beginner question
To: beginners@haskell.org
Message-ID: <200910300911.48668.shawn-hask...@willden.org>
Content-Type: text/plain; charset="utf-8"
On Friday 30 October 2009 07:40:13 am Luca Ciciriello wrote:
> I need to write a function str2lsts :: String -> [[String]] in order to
> transorm a string like:
>
> "\"1\",\"cat\",\"dog\"§\"2\",\"duck\",\"goose\""
>
> in the list of lists:
>
> [["1","cat","dog"],["2","duck","goose"]]
A variety of solutions on these blog posts, and the comments:
http://gimbo.org.uk/blog/2007/04/20/splitting-a-string-in-haskell/
http://julipedia.blogspot.com/2006/08/split-function-in-haskell.html
Shawn.
------------------------------
Message: 4
Date: Fri, 30 Oct 2009 16:34:13 +0100
From: Matthias Guedemann <matthias.guedem...@ovgu.de>
Subject: Re: [Haskell-beginners] list monad question
To: Daniel Fischer <daniel.is.fisc...@web.de>
Cc: beginners <beginners@haskell.org>
Message-ID: <1256916789-sup-...@pc44es141.cs.uni-magdeburg.de>
Content-Type: text/plain; charset=UTF-8
> Yes :D The pointfree f is nicely obfuscated. But if your friend is a perl
> coder, he should
> be able to appreciate that.
Honestly, he just wanted a "one-loop-using solution" and was not too interested
in anything using Haskell :-)
> The standard way to express f, however, is liftM2 (:), so
>
> combinations = (foldr (liftM2 (:)) [[]] .) . replicate
> -- isn't that boring?
true, it's almost readable
At the moment trying to use pointfree is basically pointless for me, more
practice is needed.
regards
Matthias
--
__________________________________________________________
___ __ __
Dipl. Inf. Matthias Guedemann / __\/ _\ /__\
Computer Systems in Engineering / / \ \ /_\
Otto-von-Guericke Universitaet Magdeburg / /___ _\ \//__
Tel.: 0391 / 67-19359 \____/ \__/\__/
__________________________________________________________
------------------------------
Message: 5
Date: Fri, 30 Oct 2009 15:51:46 +0000
From: Luca Ciciriello <luca_cicirie...@hotmail.com>
Subject: RE: [Haskell-beginners] beginner question
To: <daniel.is.fisc...@web.de>, <beginners@haskell.org>
Message-ID: <snt128-w51684c7826089525c796ec9a...@phx.gbl>
Content-Type: text/plain; charset="iso-8859-1"
Thanks.
import Text.ParserCombinators.Parsec
simple = between (char '"') (char '"') (many (satisfy (/= '"')))
multiple = sepBy simple (char ',')
total = sepBy multiple (char '@')
str2lsts :: String -> [[String]]
str2lsts str= case parse total "" str of
Left err -> error (show err)
Right lsts -> lsts
solves my problem. As you can see I've replaced '§' with '@' and now all works
fine.
Luca.
> From: daniel.is.fisc...@web.de
> To: beginners@haskell.org
> Subject: Re: [Haskell-beginners] beginner question
> Date: Fri, 30 Oct 2009 15:46:33 +0100
>
> Am Freitag 30 Oktober 2009 14:40:13 schrieb Luca Ciciriello:
> > Hi all.
> >
> > Just a very basic question.
> >
> >
> >
> > I need to write a function str2lsts :: String -> [[String]] in order to
> > transorm a string like:
> >
> >
> >
> > "\"1\",\"cat\",\"dog\"§\"2\",\"duck\",\"goose\""
> >
> >
> >
> > in the list of lists:
> >
> >
> >
> > [["1","cat","dog"],["2","duck","goose"]]
> >
> >
> >
> > I've tried to mix recursion, pattern matching and list comprehension, but
> > the obtained result was embarrassing complex (> 20 lines of awful code). I
> > think that a more simple solution certainly exists.
> >
>
> splitOnToken :: Eq a => a -> [a] -> [[a]]
> splitOnToken t xs
> = case break (== t) xs of
> (hd,tl) -> hd:case tl of
> (_:r@(_:_)) -> splitOnToken t r
> _ -> []
>
> str2lsts = map (map read . splitOnToken ',') . splitOnToken '§'
>
> if things weren't enclosed in quotation marks inside the string, it would be
> the nicer
>
> map (splitOnToken ',') . splitOnToken '§'
>
> , provided of course, neither ',' nor '§' are valid characters for the target
> strings.
>
> import Text.ParserCombinators.Parsec
>
> simple = between (char '"') (char '"') (many (staisfy (/= '"')))
> -- alternative: simple = char '"' >> manyTill anyChar (char '"')
>
> multiple = sepBy simple (char ',')
>
> total = sepBy multiple (char '§')
>
> str2lsts str
> = case parse total "" str of
> Left err -> error (show err)
> Right lsts -> lsts
>
> >
> >
> >
> > Thanks in advance for any idea.
> >
> >
> >
> > Luca
>
>
> _______________________________________________
> Beginners mailing list
> Beginners@haskell.org
> http://www.haskell.org/mailman/listinfo/beginners
_________________________________________________________________
Download Messenger onto your mobile for free
http://clk.atdmt.com/UKM/go/174426567/direct/01/
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
http://www.haskell.org/pipermail/beginners/attachments/20091030/18dff5cb/attachment-0001.html
------------------------------
Message: 6
Date: Fri, 30 Oct 2009 15:55:01 +0000
From: Colin Paul Adams <co...@colina.demon.co.uk>
Subject: Re: [Haskell-beginners] list monad question
To: Matthias Guedemann <matthias.guedem...@ovgu.de>
Cc: beginners <beginners@haskell.org>
Message-ID: <m3zl78lvvu....@colina.demon.co.uk>
Content-Type: text/plain; charset=us-ascii
>>>>> "Matthias" == Matthias Guedemann <matthias.guedem...@ovgu.de> writes:
Matthias> true, it's almost readable At the moment trying to use
Matthias> pointfree is basically pointless for me, more practice
Matthias> is needed.
Actually the pointless style does have a point - like all jargon, it
shows that you're a member of the club, and can look down on those who
don't understand it.
In support of this, it deliberately confuses beginners by omitting the
arguments that should be there according to the signature (this is a
principle purpose of currying, to confuse beginners :-) ).
I cheat - I use hlint, and write the pointless versions that it tells
me I should write instead of the pointed version that I write.
Is there a "Bluffer's guide to Haskell"?
--
Colin Adams
Preston Lancashire
------------------------------
Message: 7
Date: Fri, 30 Oct 2009 16:27:12 +0000
From: Stephen Tetley <stephen.tet...@gmail.com>
Subject: Re: [Haskell-beginners] list monad question
Cc: beginners <beginners@haskell.org>
Message-ID:
<5fdc56d70910300927u53aa011leeb4884052903...@mail.gmail.com>
Content-Type: text/plain; charset=ISO-8859-1
2009/10/30 Colin Paul Adams <co...@colina.demon.co.uk>:
> Is there a "Bluffer's guide to Haskell"?
Whilst not a bluffers guide, this one contains several dozen flavours
of 'obscurantism' (** add your less pejorative term here **)
http://www.willamette.edu/~fruehr/haskell/evolution.html
Methinks your being a bit hard on the pointfree style, but it does
often diminish an _operation reading_ of the code (you can tell what
the code does from looking at it). So you either have to trust it, or
work it out to some expanded form you are happy with.
For what its worth I came up with this bit of golf which saves a few
keystrokes if you're prepare not to count the helper functions (I
consider them generally useful):
combinations :: Int -> [a] -> [[a]]
combinations = foldr (<:>) [[]] `oo` replicate
-- Helpers that I like but are not in the libraries
-- | Applicative 'cons'. Equivalent to - liftA2 (:) - but I like
having it around.
-- The monadic version is attributable to a parser library in Clean.
(<:>) :: Applicative f => f a -> f [a] -> f [a]
(<:>) a b = (:) <$> a <*> b
-- | Compose an arity 1 function and an arity 2 function.
--
-- I call this combinator 'specs' (aka glasses) due to its infix
-- appearance `oo` - I believe fans of Raymond Smullyan's
-- 'To Mock a Mockingbird' call it blackbird...
oo :: (c -> d) -> (a -> b -> c) -> a -> b -> d
oo f g = (f .) . g
Best wishes
Stephen
------------------------------
Message: 8
Date: Fri, 30 Oct 2009 13:47:23 -0400
From: Brent Yorgey <byor...@seas.upenn.edu>
Subject: Re: [Haskell-beginners] beginner question
To: beginners@haskell.org
Message-ID: <20091030174722.ga10...@seas.upenn.edu>
Content-Type: text/plain; charset=iso-8859-1
On Fri, Oct 30, 2009 at 01:40:13PM +0000, Luca Ciciriello wrote:
>
> Hi all.
>
> Just a very basic question.
>
> I need to write a function str2lsts :: String -> [[String]] in order to
> transorm a string like:
>
> "\"1\",\"cat\",\"dog\"§\"2\",\"duck\",\"goose\""
>
> in the list of lists:
>
> [["1","cat","dog"],["2","duck","goose"]]
Another possibility:
import Data.List.Split -- from the 'split' package on Hackage
str2lsts = map (splitOn ",") . splitOn "@" . filter (/='"')
-Brent
------------------------------
Message: 9
Date: Fri, 30 Oct 2009 22:03:50 +0100
From: Daniel Fischer <daniel.is.fisc...@web.de>
Subject: Re: [Haskell-beginners] list monad question
To: beginners@haskell.org
Message-ID: <200910302203.50864.daniel.is.fisc...@web.de>
Content-Type: text/plain; charset="iso-8859-1"
Am Freitag 30 Oktober 2009 17:27:12 schrieb Stephen Tetley:
> 2009/10/30 Colin Paul Adams <co...@colina.demon.co.uk>:
> > Is there a "Bluffer's guide to Haskell"?
>
> Whilst not a bluffers guide, this one contains several dozen flavours
> of 'obscurantism' (** add your less pejorative term here **)
>
> http://www.willamette.edu/~fruehr/haskell/evolution.html
>
> Methinks your being a bit hard on the pointfree style, but it does
> often diminish an _operation reading_ of the code (you can tell what
> the code does from looking at it). So you either have to trust it, or
> work it out to some expanded form you are happy with.
Completely pointfree style tends to be unreadable except for the selected few.
It's fun to create pointfree versions of your functions, and you learn
something by doing
that, but it should appear rarely in your code.
Completely pointful style tends to be not unreadable, but often cluttered.
The most readable is usually a "partially pointfree" style. Which degree of
pointfreeness
is most readable depends of course on the reader, but there's a range which
most can agree
is good.
Function combinators and pipelines should be partially pointfree:
foo = bar . baz . hum
is better than
foo x = bar (baz (hum x))
or
foo x = bar $ baz $ hum x
or
foo x = bar . baz . hum $ x
flurb f g = f . g . f
is better than
flurb f g = f (g (f x))
wibble f g = f &&& g >>> g *** f
is better than
wibble f g x = f &&& g >>> g *** f $ x
- but worse than
wibble f g = (f &&& g) >>> (g *** f)
because the latter doesn't require knowledge of the fixities to parse.
However,
wibble f g = (g . f) &&& (f . g)
is at least as good if you want it only for the Category (->). Whether that is
better than
wibble f g x = (g (f x), f (g x))
depends on how familiar one is with Control.Arrow.
Writing flurb or wibble completely pointfree is a nightmare :)
Which is best:
a) incrementAll n xs = map (\x -> x+n) xs
b) incrementAll n xs = map (+n) xs
c) incrementAll n = map (+n)
d) incrementAll = map . (+)
?
None of them is unreadable - though d) is confusing in the first few weeks of
Haskell -
but b) and c) are clearly better than the other two and c) is a bit better than
b) in my
opinion.
Would you prefer:
a) comb = flip (.) (flip (.)) (flip (.) (flip (.)))
b) comb = (. flip (.)) . flip (.)
c) comb f = (. f) . flip (.)
d) comb f g = (. g) . f
e) comb f g x = f x . g
f) comb f g x y = f x (g y)
?
a) is the prettiest, but honestly, I'd rather not meet it in code.
e) is best, f) is okay, d) acceptable.
>
> For what its worth I came up with this bit of golf which saves a few
> keystrokes if you're prepare not to count the helper functions
That's cheating (until they are in a library).
> (I consider them generally useful):
Yup.
>
>
> combinations :: Int -> [a] -> [[a]]
> combinations = foldr (<:>) [[]] `oo` replicate
>
> -- Helpers that I like but are not in the libraries
>
> -- | Applicative 'cons'. Equivalent to - liftA2 (:) - but I like
> having it around.
> -- The monadic version is attributable to a parser library in Clean.
>
> (<:>) :: Applicative f => f a -> f [a] -> f [a]
> (<:>) a b = (:) <$> a <*> b
I'd prefer either
(<:>) = liftA2 (:)
or
a <:> b = (:) <$> a <*> b
>
> -- | Compose an arity 1 function and an arity 2 function.
> --
> -- I call this combinator 'specs' (aka glasses) due to its infix
> -- appearance `oo` - I believe fans of Raymond Smullyan's
> -- 'To Mock a Mockingbird' call it blackbird...
>
> oo :: (c -> d) -> (a -> b -> c) -> a -> b -> d
> oo f g = (f .) . g
This is sometimes also denoted by (.:), it has the pretty definition
(.:) = (.) . (.)
>
> Best wishes
>
> Stephen
------------------------------
_______________________________________________
Beginners mailing list
Beginners@haskell.org
http://www.haskell.org/mailman/listinfo/beginners
End of Beginners Digest, Vol 16, Issue 28
*****************************************
