June 2013 - Beginners

14 Aug '13

Every OO language which supports generics allows a declaration such as List<Show> alist, where Show is an interface. Any type implementing Show can be put in alist, and any Show operation can be performed on the alist's members. No casts, wrappers, or other special types and plumbing are needed. Why isn't it possible to do this directly in Haskell?

10 14

Fake Conference Fake: WORLDCOMP and Hamid Arabnia
by jimpeter＠countermail.com 29 Jun '13

29 Jun '13

Fake Conference Fake: WORLDCOMP and Hamid Arabnia Have you heard of any international conference that has no chair (or organizer or committee members or reviewers) for it and the conference is going to take place in the next 2-3weeks? If you didn’t know about it then you must visit the website https://sites.google.com/site/worlddump1 or https://sites.google.com/site/dumpconf or http://worldcomp-fake-bogus.blogspot.com that contains the details of world’s biggest fake conference in computer science, WORLDCOMP, organized by Hamid Arabnia who is hiding behind the scenes but collecting the registration fee of the conference quietly. He is not satisfied with the millions of dollars he has accumulated for more than 12 years from innocent researchers! Except the names of keynote speakers and tutorial presents (these names are used as baits) to attract paper submissions (i.e, registration fee) from innocent researchers, there is no other person name or address at this fake conference website! WORLDCOMP has many credentials and you can get those details by accessing the above websites are search Google using the keywords worldcomp fake

1 0

Re: [Haskell-beginners] How to Lex, Parse, and Serialize-to-XML email messages
by Costello, Roger L. 28 Jun '13

28 Jun '13

Hi Tim, Ø I realize you've already finished with the project ... Actually, your message comes at an excellent time. I am not finished with the project. I have only finished one of the email headers -- the From Header. Just today I was wondering how to proceed next: - Should I extend my parser so that it deals with each of the other email headers? That is, create one monolithic parser for the entire email message? That doesn't seem very modular. I don't think that Happy supports importing other Happy parsers. Ideally I would create a parser for the From Header, a parser for the To Header, a parser for the Subject Header, and so forth. Then I would import each of them to create one unified email parser. If Happy doesn't support importing, I figured it might be better to switch to something that can combine parsers - a parser combinator - such as parsec. Unfortunately, I don't know anything about Parsec, but am eager to learn. - I wonder if I can use Happy to generate individual parsers - a parser for the From Header, a parser for the To Header, a parser for the Subject Header - and then use Parsec to combine them? As you see Tim, your suggestion to use parsec falls on receptive ears. I welcome all suggestions. /Roger From: beginners-bounces(a)haskell.org [mailto:beginners-bounces@haskell.org] On Behalf Of Tim Holland Sent: Friday, June 28, 2013 12:18 PM To: beginners(a)haskell.org Subject: Re: [Haskell-beginners] How to Lex, Parse, and Serialize-to-XML email messages Hi Roger, I realize you've already finished with the project, but for the future I think its a lot easier to use a parser combinator with Text.Parsec and Text.Parsec.String to do a similar thing. For example, if you were parsing XML to get a parse a single tag, you would try something like this: parseTag :: Parser Tag parseTag = many1 alphanum <?> "tag" To get a tagged form, try parseTagged :: Parser (Tag, [Elem]) parseTagged = do char '<' name <- parseTag char '>' content <- many (try parseElem) string "</" parseTag char '>' return (name, content) <?> "tagged form" and so one. I haven't tried this out, but a parser similar to yours would go something like this: --Datatypes type DisplayName = String type EmailAddress = String data Mailbox = Mailbox DisplayName EmailAddress deriving (Show) parseFromHeader :: Parser [Mailbox] parseFromHeader = do string "From: " mailboxes = many (try parseMailbox) return mailboxes parseMailbox :: Parser Mailbox parseMailbox = do parseComments -- Names are optional parseComments name <- try parseDisplayName parseComments address <- parseEmailAddress parseComments try char ',' return Mailbox name address <?> "Parse an indidivuals mailbox" parseEmailAddress :: Parser EmailAddress parseEmailAddress = do try char '<' handle <- many1 (noneof "@") -- Or whatever is valid here char '@' domain <- parseDomain try char '<' return handle++@++domain parseDomain :: Parser String parseDomain = (char '[' >> parseDomain >>= (\domainName -> do char ']' return domainName)) <|> parseWebsiteName >>= return And so on. Again, I've tested none of the Email header bits but the XML bit works. It requires some level of comfort with monadic operations, but beyond that I think it's a much simpler may to parse. Regards, Tim Holland On 28 June 2013 03:00, <beginners-request(a)haskell.org<mailto:beginners-request@haskell.org>> wrote: Send Beginners mailing list submissions to beginners(a)haskell.org<mailto: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-request(a)haskell.org<mailto:beginners-request@haskell.org> You can reach the person managing the list at beginners-owner(a)haskell.org<mailto:beginners-owner@haskell.org> When replying, please edit your Subject line so it is more specific than "Re: Contents of Beginners digest..." Today's Topics: 1. data declaration using other type's names? (Patrick Redmond) 2. Re: data declaration using other type's names? (Brandon Allbery) 3. Re: data declaration using other type's names? (Nikita Danilenko) 4. Re: what to do about excess memory usage (Chadda? Fouch?) 5. Re: what to do about excess memory usage (James Jones) 6. How to Lex, Parse, and Serialize-to-XML email messages (Costello, Roger L.) ---------------------------------------------------------------------- Message: 1 Date: Thu, 27 Jun 2013 11:24:51 -0400 From: Patrick Redmond <plredmond(a)gmail.com<mailto:plredmond@gmail.com>> Subject: [Haskell-beginners] data declaration using other type's names? To: beginners(a)haskell.org<mailto:beginners@haskell.org> Message-ID: <CAHUea4FfBP8L1kU+tS1-2cVPvAB4h22j35JcNwRC-jGds0=v6g(a)mail.gmail.com<mailto:v6g@mail.gmail.com>> Content-Type: text/plain; charset=UTF-8 Hey Haskellers, I noticed that ghci lets me do this: > data Foo = Int Int | Float > :t Int Int :: Int -> Foo > :t Float Float :: Foo > :t Int 4 Int 4 :: Foo It's confusing to have type constructors that use names of existing types. It's not intuitive that the name "Int" could refer to two different things, which brings me to: > data Bar = Bar Int > :t Bar Bar :: Int -> Bar Yay? I can have a simple type with one constructor named the same as the type. Why is this allowed? Is it useful somehow? --Patrick ------------------------------ Message: 2 Date: Thu, 27 Jun 2013 11:37:46 -0400 From: Brandon Allbery <allbery.b(a)gmail.com<mailto:allbery.b@gmail.com>> Subject: Re: [Haskell-beginners] data declaration using other type's names? To: The Haskell-Beginners Mailing List - Discussion of primarily beginner-level topics related to Haskell <beginners(a)haskell.org<mailto:beginners@haskell.org>> Message-ID: <CAKFCL4U-E4B_+cts0vpNX8Ar9wccQDjgzWOYHLXLsLAv+Qn_cg(a)mail.gmail.com<mailto:CAKFCL4U-E4B_%2Bcts0vpNX8Ar9wccQDjgzWOYHLXLsLAv%2BQn_cg@mail.gmail.com>> Content-Type: text/plain; charset="utf-8" On Thu, Jun 27, 2013 at 11:24 AM, Patrick Redmond <plredmond(a)gmail.com<mailto:plredmond@gmail.com>>wrote: > I noticed that ghci lets me do this: > Not just ghci, but ghc as well. > Yay? I can have a simple type with one constructor named the same as the > type. > Why is this allowed? Is it useful somehow? > It's convenient for pretty much the situation you showed, where the type constructor and data constructor have the same name. A number of people do advocate that it not be used, though, because it can be confusing for people. (Not for the compiler; data and type constructors can't be used in the same places, it never has trouble keeping straight which is which.) It might be best to consider this as "there is no good reason to *prevent* it from happening, from a language standpoint". -- brandon s allbery kf8nh sine nomine associates allbery.b(a)gmail.com<mailto:allbery.b@gmail.com> ballbery(a)sinenomine.net<mailto:ballbery@sinenomine.net> unix, openafs, kerberos, infrastructure, xmonad http://sinenomine.net

1 0

Re: [Haskell-beginners] How to Lex, Parse, and Serialize-to-XML email messages
by Tim Holland 28 Jun '13

28 Jun '13

Hi Roger, I realize you've already finished with the project, but for the future I think its a lot easier to use a parser combinator with Text.Parsec and Text.Parsec.String to do a similar thing. For example, if you were parsing XML to get a parse a single tag, you would try something like this: parseTag :: Parser Tag parseTag = many1 alphanum <?> "tag" To get a tagged form, try parseTagged :: Parser (Tag, [Elem]) parseTagged = do char '<' name <- parseTag char '>' content <- many (try parseElem) string "</" parseTag char '>' return (name, content) <?> "tagged form" and so one. I haven't tried this out, but a parser similar to yours would go something like this: --Datatypes type DisplayName = String type EmailAddress = String data Mailbox = Mailbox DisplayName EmailAddress deriving (Show) parseFromHeader :: Parser [Mailbox] parseFromHeader = do string "From: " mailboxes = many (try parseMailbox) return mailboxes parseMailbox :: Parser Mailbox parseMailbox = do parseComments -- Names are optional parseComments name <- try parseDisplayName parseComments address <- parseEmailAddress parseComments try char ',' return Mailbox name address <?> "Parse an indidivuals mailbox" parseEmailAddress :: Parser EmailAddress parseEmailAddress = do try char '<' handle <- many1 (noneof "@") -- Or whatever is valid here char '@' domain <- parseDomain try char '<' return handle++@++domain parseDomain :: Parser String parseDomain = (char '[' >> parseDomain >>= (\domainName -> do char ']' return domainName)) <|> parseWebsiteName >>= return And so on. Again, I've tested none of the Email header bits but the XML bit works. It requires some level of comfort with monadic operations, but beyond that I think it's a much simpler may to parse. Regards, Tim Holland On 28 June 2013 03:00, <beginners-request(a)haskell.org> wrote: > Send Beginners mailing list submissions to > beginners(a)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-request(a)haskell.org > > You can reach the person managing the list at > beginners-owner(a)haskell.org > > When replying, please edit your Subject line so it is more specific > than "Re: Contents of Beginners digest..." > > > Today's Topics: > > 1. data declaration using other type's names? (Patrick Redmond) > 2. Re: data declaration using other type's names? (Brandon Allbery) > 3. Re: data declaration using other type's names? (Nikita Danilenko) > 4. Re: what to do about excess memory usage (Chadda? Fouch?) > 5. Re: what to do about excess memory usage (James Jones) > 6. How to Lex, Parse, and Serialize-to-XML email messages > (Costello, Roger L.) > > > ---------------------------------------------------------------------- > > Message: 1 > Date: Thu, 27 Jun 2013 11:24:51 -0400 > From: Patrick Redmond <plredmond(a)gmail.com> > Subject: [Haskell-beginners] data declaration using other type's > names? > To: beginners(a)haskell.org > Message-ID: > <CAHUea4FfBP8L1kU+tS1-2cVPvAB4h22j35JcNwRC-jGds0= > v6g(a)mail.gmail.com> > Content-Type: text/plain; charset=UTF-8 > > Hey Haskellers, > > I noticed that ghci lets me do this: > > > data Foo = Int Int | Float > > :t Int > Int :: Int -> Foo > > :t Float > Float :: Foo > > :t Int 4 > Int 4 :: Foo > > It's confusing to have type constructors that use names of existing > types. It's not intuitive that the name "Int" could refer to two > different things, which brings me to: > > > data Bar = Bar Int > > :t Bar > Bar :: Int -> Bar > > Yay? I can have a simple type with one constructor named the same as the > type. > > Why is this allowed? Is it useful somehow? > > --Patrick > > > > ------------------------------ > > Message: 2 > Date: Thu, 27 Jun 2013 11:37:46 -0400 > From: Brandon Allbery <allbery.b(a)gmail.com> > Subject: Re: [Haskell-beginners] data declaration using other type's > names? > To: The Haskell-Beginners Mailing List - Discussion of primarily > beginner-level topics related to Haskell <beginners(a)haskell.org> > Message-ID: > < > CAKFCL4U-E4B_+cts0vpNX8Ar9wccQDjgzWOYHLXLsLAv+Qn_cg(a)mail.gmail.com> > Content-Type: text/plain; charset="utf-8" > > On Thu, Jun 27, 2013 at 11:24 AM, Patrick Redmond <plredmond(a)gmail.com > >wrote: > > > I noticed that ghci lets me do this: > > > > Not just ghci, but ghc as well. > > > > Yay? I can have a simple type with one constructor named the same as the > > type. > > Why is this allowed? Is it useful somehow? > > > > It's convenient for pretty much the situation you showed, where the type > constructor and data constructor have the same name. A number of people do > advocate that it not be used, though, because it can be confusing for > people. (Not for the compiler; data and type constructors can't be used in > the same places, it never has trouble keeping straight which is which.) > > It might be best to consider this as "there is no good reason to *prevent* > it from happening, from a language standpoint". > > -- > brandon s allbery kf8nh sine nomine > associates > allbery.b(a)gmail.com > ballbery(a)sinenomine.net > unix, openafs, kerberos, infrastructure, xmonad > http://sinenomine.net >

1 0

question about ghci printing process
by TP 28 Jun '13

28 Jun '13

Hi all, Learning Template Haskell, I try to understand what happens when experimenting in ghci: $ ghci -XTemplateHaskell > :m + Language.Haskell.TH > runQ [| \x -> 1 |] LamE [VarP x_0] (LitE (IntegerL 1)) Indeed, we have: > :t runQ [| \x -> 1 |] runQ [| \x -> 1 |] :: Language.Haskell.TH.Syntax.Quasi m => m Exp where m is any monad instance of Language.Haskell.TH.Syntax.Quasi. I believed that to be able to print a value in ghci, its type has to be an instance of Show. But `Exp` is an instance of Show, not `m Exp`: > :i Show [...] -- Defined in `Language.Haskell.TH.Syntax' instance Show Fixity -- Defined in `Language.Haskell.TH.Syntax' instance Show FamFlavour -- Defined in `Language.Haskell.TH.Syntax' instance Show Exp -- Defined in `Language.Haskell.TH.Syntax' instance Show Dec -- Defined in `Language.Haskell.TH.Syntax' instance Show Con -- Defined in `Language.Haskell.TH.Syntax' instance Show Clause -- Defined in `Language.Haskell.TH.Syntax' instance Show Callconv -- Defined in `Language.Haskell.TH.Syntax' instance Show Body -- Defined in `Language.Haskell.TH.Syntax' instance Show Float -- Defined in `GHC.Float' instance Show Double -- Defined in `GHC.Float' So, how does gchi print `runQ [| \x -> 1 |]`? Thanks in advance, TP

2 1

How to Lex, Parse, and Serialize-to-XML email messages
by Costello, Roger L. 28 Jun '13

28 Jun '13

Hi Folks, I am working toward being able to input any email message and output an equivalent XML encoding. I am starting small, with one of the email headers -- the "From Header" Here is an example of a From Header: From: John Doe <john(a)doe.org> I have successfully transformed it into this XML: <From> <Mailbox> <DisplayName>John Doe</DisplayName> <Address>john(a)doe.org</Address> </Mailbox> </From> I used the lexical analyzer "Alex" [1] to break apart (tokenize) the From Header. I used the parser "Happy" [2] to process the tokens and generate a parse tree. Then I used a serializer to walk the parse tree and output XML. I posted to stackoverflow a complete description of how to lex, parse, and serialize-to-XML email From Headers: http://stackoverflow.com/questions/17354442/how-to-lex-parse-and-serialize-… /Roger [1] The Alex User's Guide may be found at this URL: http://www.haskell.org/alex/doc/html/ [2] The Happy User's Guide may be found at this URL: http://www.haskell.org/happy/

2 1

what to do about excess memory usage
by James Jones 27 Jun '13

27 Jun '13

I finally got serious about learning Haskell and have started by trying to write as efficient and clear a program to solve the Code Jam 2013 "Fair and Square" problem as I can. (Since the qualifying round is long over, I have "cheated" some; I peeked at the analysis to see what I had missed when working on it by myself, and borrowed some very nice semilattice tree search code by Twan van Laarhoven and an integer square root routine.) You can see the result at http://pastebin.com/JuyaNLRp (apologies for what pastebin's Haskell source highlighting does when you have an identifier with an apostrophe). The result now processes the test input with values up to a googol in about 0.2 seconds on my not particularly high-end computer. I'd say that's as good as I can do and go on to the next problem, but profiling turns up that * it's spending 45% of its time garbage collecting. (ouch!) * one function, pairSum, is consuming a lot of RAM--about two megabytes at the end. It seems like a simple function. Here it is, along with most of the things it uses. **powersOfTen = map (10 ^) [0..] halfN = n `div` 2 shell = pair 0 memoPair = zipWith (+) powersOfTen (take halfN (reverse (take n powersOfTen))) pair i = memoPair !! i pairSum xs = foldl' (+) shell (map pair xs) (pair i gives the matching 1s in the top and bottom half of a palindrome that has only ones and zeroes; pairsum takes a list of positions of ones and generates the corresponding palindrome.) I suspect thunks are accumulating, but I don't know how to get rid of them. I've tried bang patterns and $!, to no avail. I still haven't wrapped my brain around seq. There are other things that should be improved about the code, but I think I can figure those out myself. I've leaned heavily on Chapter 25 of Real World Haskell to get the code to this point, but it's not getting through to me how to apply its techniques here. Any suggestions or pointers would be greatly appreciated.

2 2

data declaration using other type's names?
by Patrick Redmond 27 Jun '13

27 Jun '13

Hey Haskellers, I noticed that ghci lets me do this: > data Foo = Int Int | Float > :t Int Int :: Int -> Foo > :t Float Float :: Foo > :t Int 4 Int 4 :: Foo It's confusing to have type constructors that use names of existing types. It's not intuitive that the name "Int" could refer to two different things, which brings me to: > data Bar = Bar Int > :t Bar Bar :: Int -> Bar Yay? I can have a simple type with one constructor named the same as the type. Why is this allowed? Is it useful somehow? --Patrick

3 2

Inconsistencies in type inference
by Stefan Jaax 26 Jun '13

26 Jun '13

Hey, While trying to wrap my head around how type inference works in haskell I stumbled across the following inconsistency: If I type :t (*) in ghci, I obtain (*) :: Num a => a -> a -> a But if I write let mul = (*) :t mul I get the less generic type signature mul :: Integer -> Integer -> Integer How is this inconsistency explained? After all, I would expect the haskell compiler to deduce the most generic type possible. Thanks in advance, Stefan.

5 6

pattern matching on function names or algebraic type data constructors
by TP 23 Jun '13

23 Jun '13

Hi, I ask myself if there is a way to make the following code work. I would like to pattern match on function names: ----------- f :: Float -> Int f x = 1 g :: Float -> Int g x = 2 pat :: (Float -> Int) -> Bool pat t = case t of f -> True g -> False main = do print $ pat f print $ pat g ----------- I don't understand the output: ----------- $ runghc test_pattern_match_on_function_2.hs test_pattern_match_on_function_2.hs:8:9: Warning: Pattern match(es) are overlapped In a case alternative: g -> ... True True ----------- What is the reason for this message? Now, I want to do it on data constructors in a GADT (which are functions if I am right): ----------- {-# LANGUAGE GADTs #-} data Foobar where Mult :: Float -> Foobar Plus :: Float -> Foobar pat :: (Float -> Foobar) -> Bool pat t = case t of Mult -> True Plus -> False main = do print $ pat Mult print $ pat Plus ----------- I obtain: ----------- $ runghc test_pattern_match_on_function.hs test_pattern_match_on_function.hs:9:9: Constructor `Mult' should have 1 argument, but has been given none In the pattern: Mult In a case alternative: Mult -> True In the expression: case t of { Mult -> True Plus -> False } test_pattern_match_on_function.hs:9:9: Couldn't match expected type `Float -> Foobar' with actual type `Foobar' In the pattern: Mult In a case alternative: Mult -> True In the expression: case t of { Mult -> True Plus -> False } ----------- Why does it not work? If Mult and Plus are functions, then I should not need to put their arguments in pattern matching. Thanks in advance, TP

3 2