- Haskell-Cafe - Haskell.org

WORLDCOMP Strikes Again for the Last Time
by chrisrogersrogers＠aol.com 13 Mar '13

13 Mar '13

I graduated from University of Florida (UFL) and am currently running a computer firm in Florida. I have attended WORLDCOMP http://www.world-academy-of-science.org in 2010. Except for few keynote speeches and presentations, the conference was very disappointing due to a large number of poor quality papers and cancellation of some sessions. I was instantly suspicious of this conference. Me and my UFL and UGA friends started a study on WORLDCOMP. We submitted a paper to WORLDCOMP 2011 and again (the same paper with a modified title) to WORLDCOMP 2012. This paper had numerous fundamental mistakes. Sample statements from that paper include: (1). Binary logic is fuzzy logic and vice versa (2). Pascal developed fuzzy logic (3). Object oriented languages do not exhibit any polymorphism or inheritance (4). TCP and IP are synonyms and are part of OSI model (5). Distributed systems deal with only one computer (6). Laptop is an example for a super computer (7). Operating system is an example for computer hardware Also, our paper did not express any conceptual meaning. However, it was accepted both the times without any modifications (and without any reviews) and we were invited to submit the final paper and a payment of $500+ fee to present the paper. We decided to use the fee for better purposes than making Prof. Hamid Arabnia (Chairman of WORLDCOMP) rich. After that, we received few reminders from WORLDCOMP to pay the fee but we never responded. We MUST say that you should look at the website http://sites.google.com/site/worlddump1 if you have any thoughts to submit a paper to WORLDCOMP. DBLP and other indexing agencies have stopped indexing WORLDCOMP’s proceedings since 2011 due to its fakeness. The status of your WORLDCOMP papers can be changed from “scientific” to “other” (i.e., junk or non-technical) at anytime. See the comments http://www.mail-archive.com/tccc@lists.cs.columbia.edu/msg05168.html of a respected researcher on this. Better not to have a paper than having it in WORLDCOMP and spoil the resume and peace of mind forever! Our study revealed that WORLDCOMP is a money making business, using UGA mask, for Prof. Hamid Arabnia. He is throwing out a small chunk of that money (around 20 dollars per paper published in WORLDCOMP’s proceedings) to his puppet who publicizes WORLDCOMP and also defends it at various forums, using fake/anonymous names. The puppet uses fake names and defames other conferences/people to divert traffic to WORLDCOMP. That is, the puppet does all his best to get a maximum number of papers published at WORLDCOMP to get more money into his (and Prof. Hamid Arabnia’s) pockets. Monte Carlo Resort (the venue of WORLDCOMP until 2012) has refused to provide the venue for WORLDCOMP’13 because of the fears of their image being tarnished due to WORLDCOMP’s fraudulent activities. WORLDCOMP will not be held after 2013. The paper submission deadline for WORLDCOMP’13 is March 18, 2013 (it will be extended many times, as usual) but still there are no committee members, no reviewers, and there is no conference Chairman. The only contact details available on WORLDCOMP’s website is just an email address! What bothers us the most is that Prof. Hamid Arabnia never posted an apology for the damage he has done to the research community. He is still trying to defend WORLDCOMP. Let us make a direct request to him: publish all reviews for all the papers (after blocking identifiable details) since 2000 conference. Reveal the names and affiliations of all the reviewers (for each year) and how many papers each reviewer had reviewed on average. We also request him to look at the Open Challenge at http://sites.google.com/site/dumpconf We think that it is our professional obligation to spread this message to alert the computer science community. Sorry for posting to multiple lists. Spreading the word is the only way to stop this bogus conference. Please forward this message to other mailing lists and people. We are shocked with Prof. Hamid Arabnia and his puppet’s activities http://worldcomp-fake-bogus.blogspot.com Search Google using the keywords “worldcomp, fake” for additional links. Sincerely, Chris

1 0

ANN: retry 0.1 - retry combinators for monadic actions that often fail
by Ozgun Ataman 13 Mar '13

13 Mar '13

Dear Cafe, I'm happy to announce the availability of the retry package on Hackage[1] and Github[2]. The package provides a few useful combinators for monadic actions that often fail and should be retried in cases of a certain set of exceptions (or failure modes). Such cases are quite common when querying databases (e.g. ResponseTimeout) or uploading files (e.g. socket closed), particularly in busy production systems. The library exposes 'retrying' for failures encoded explicitly in the type and 'recovering' for failures through exceptions, respectively. You can choose either an "exponential back off" series of delays or a simple static delay between retries. In either case, there is a ceiling for the number of total retries. The haddocks provide further documentation and a few examples. This library simply wraps around the given actions and does not really do anything fancy or unexpected. Nevertheless, the widespread applicability of this functionality justified a generic package to address the need centrally. Suggestions and bug reports are most welcome. [1] http://hackage.haskell.org/package/retry [2] https://github.com/Soostone/retry Cheers, Ozgun

2 2

monadic DSL for compile-time parser generator, not possible?
by Jeremy Shaw 13 Mar '13

13 Mar '13

It would be pretty damn cool if you could create a data type for generically describing a monadic parser, and then use template haskell to generate a concrete parser from that data type. That would allow you to create your specification in a generic way and then target different parsers like parsec, attoparsec, etc. There is some code coming up in a few paragraphs that should describe this idea more clearly. I would like to suggest that while it would be cool, it is impossible. As proof, I will attempt to create a simple monadic parser that has only one combinator: anyChar :: ParserSpec Char We need the GADTs extension and some imports: > {-# LANGUAGE GADTs, TemplateHaskell #-} > import Control.Monad (join) > import qualified Text.Parsec.Char as P > import Language.Haskell.TH (ExpQ, appE) > import Language.Haskell.TH.Syntax (Lift(lift)) > import Text.Parsec (parseTest) > import qualified Text.Parsec.Char as P > import Text.Parsec.String (Parser) Next we define a type that has a constructor for each of the different combinators we want to support, plus constructors for the functor and monad methods: > data ParserSpec a where > AnyChar :: ParserSpec Char > Return :: a -> ParserSpec a > Join :: ParserSpec (ParserSpec a) -> ParserSpec a > FMap :: (a -> b) -> ParserSpec a -> ParserSpec b > > instance Lift (ParserSpec a) where > lift _ = error "not defined because we are screwed later anyway." In theory, we would extend that type with things like `Many`, `Some`, `Choice`, etc. In Haskell, we are used to seeing a `Monad` defined in terms of `return` and `>>=`. But, we can also define a monad in terms of `fmap`, `return` and `join`. We will do that in `ParserSpec`, because it makes the fatal flaw more obvious. Now we can define the `Functor` and `Monad` instances: > instance Functor ParserSpec where > fmap f p = FMap f p > instance Monad ParserSpec where > return a = Return a > m >>= f = Join ((FMap f) m) and the `anyChar` combinator: > anyChar :: ParserSpec Char > anyChar = AnyChar And now we can define a simple parser that parses two characters and returns them: > charPair :: ParserSpec (Char, Char) > charPair = > do a <- anyChar > b <- anyChar > return (a, b) Now, we just need to define a template haskell function that generates a `Parser` from a `ParserSpec`: > genParsec :: (Lift a) => ParserSpec a -> ExpQ > genParsec AnyChar = [| anyChar |] > genParsec (Return a) = [| return a |] > genParsec (Join p) = genParsec p > -- genParsec (FMap f p) = appE [| f |] (genParsec p) -- uh-oh Looking at the `FMap` case we see the fatal flaw. In order to generate the parser we would need some way to transform any arbitrary Haskell function of type `a -> b` into Template Haskell. Obviously, that is impossible (for some definition of obvious). Therefore, we can assume that it is not possible to use Template Haskell to generate a monadic parser from a monadic specification. We can also assume that `Applicative` is not available either. Seems likely that `Category` based parsers would also be out. Now, we can, of course, do the transformation at runtime: > interpretParsec :: ParserSpec a -> Parser a > interpretParsec AnyChar = P.anyChar > interpretParsec (Return a) = return a > interpretParsec (FMap f a) = fmap f (interpretParsec a) > interpretParsec (Join mm) = join (fmap interpretParsec (interpretParsec mm)) > test = parseTest (interpretParsec charPair) "ab" My fear is that doing that will result in added runtime overhead. One reason for wanting to create a compile-time parser generator is to have the opportunity to generate very fast parsing code. It seems like here we can only be slower than the parser we are targeting? Though.. perhaps not? Perhaps the parser returned by `interpretParsec` has all the interpret stuff removed and is as fast as if we have constructed it by hand? I don't have an intuitive feel for it.. I guess criterion would know.. Any thoughts? - jeremy

4 5

Re: [Haskell-cafe] monadic DSL for compile-time parser generator, not possible?
by oleg＠okmij.org 13 Mar '13

13 Mar '13

Jeremy Shaw wrote: > It would be pretty damn cool if you could create a data type for > generically describing a monadic parser, and then use template haskell > to generate a concrete parser from that data type. That would allow > you to create your specification in a generic way and then target > different parsers like parsec, attoparsec, etc. There is some code > coming up in a few paragraphs that should describe this idea more > clearly. After rather mild and practical restrictions, the problem is solvable. (BTW, even the problem of lifting arbitrary functional values, let alone handles and other stuff, is solvable in realistic settings -- or even completely, although less practically.) Rather than starting from the top -- implementing monadic or applicative parser, let's start from the bottom and figure out what we really need. It seems that many real-life parsers aren't using the full power of Applicative, let alone monad. So why to pay, a whole lot, for what we don't use. Any parser combinator library has to be able to combine parsers. It seems the applicative rule <*> :: Parser (a->b) -> Parser a -> Parser b is very popular. It is indeed very useful -- although not the only thing possible. One can come up with a set of combinators that are used for realistic parsing. For example, *> :: Parser a -> Parser b -> Parser b for sequential composition, although expressible via <*>, could be defined as primitive. Many other such combinators can be defined as primitives. In other words: the great advantage of Applicative parser combinators is letting the user supply semantic actions, and executing those actions as parsing progresses. There is also a traditional approach: the parser produces an AST or a stream of parsing events, which the user consumes and semantically processes any way they wish. Think of XML parsing: often people parse XML and get a DOM tree, and process it afterwards. An XML parser can be incremental: SAX. Parsers that produce AST need only a small fixed set of combinators. We never need to lift arbitrary functions since those parsers don't accept arbitrary semantic actions from the user. For that reason, these parsers are also much easy to analyze. Let's take the high road however, applicative parsers. The <*> rule is not problematic: it neatly maps to code. Consider newtype Code a = Code Exp which is the type-annotated TH Code. We can easily define app_code :: Code (a->b) -> Code a -> Code b app_code (Code f) (Code x) = Code $ AppE f x So, Code is almost applicative. Almost -- because we only have a restricted pure: pureR :: Lift a => a -> Code a with a Lift constraint. Alas, this is not sufficient for realistic parsers, because often we have to lift functions, as in the example of parsing a pair of characters: pure (\x y -> (x,y)) <*> anyChar <*> anyChar But aren't functions really unliftable? They are unliftable by value, but we can also lift by reference. Here is an example, using tagless final framework, since it is extensible. We define the basic minor Applicative > class Sym repr where > pureR :: Lift a => a -> repr a > app :: repr (a->b) -> repr a -> repr b > > infixl 4 `app` And a primitive parser, with only one primitive parser. > class Sym repr => Parser repr where > anychar :: repr Char For our example, parsing two characters and returning them as a pair, we need pairs. So, we extend our parser with three higher-order _constants_. > class Sym repr => Pair repr where > pair :: repr (a -> b -> (a,b)) > prj1 :: repr ((a,b) -> a) > prj2 :: repr ((a,b) -> b) And here is the example. > test1 = pair `app` anychar `app` anychar One interpretation of Sym is to generate code (another one could analyze the parsers) > data C a = C{unC :: Q Exp} Most interesting is the instance of pairs. Actually, it is not that interesting: we just lift functions by reference. > pair0 x y = (x,y) > > instance Pair C where > pair = C [e| pure pair0 |] > prj1 = C [e| pure fst |] > prj2 = C [e| pure snd |] Because tagless-final is so extensible, any time we need a new functional constant, we can easily introduce it and define its code, either by building a code expression or by referring to a global name that is bound to the desired value. The latter is `lift by reference' (which is what dynamic linking does). The obvious limitation of this approach is that all functions to lift must be named -- because we lift by reference. We can also build anonymous functions, if we just add lambda to our language. If we go this way we obtain something like http://okmij.org/ftp/meta-programming/index.html#meta-haskell (which has lam, let, arrays, loops, etc.) Sample code, for reference {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE NoMonomorphismRestriction #-} module P where import Language.Haskell.TH import Language.Haskell.TH.Syntax import Language.Haskell.TH.Ppr import Control.Applicative import Text.ParserCombinators.ReadP class Sym repr where pureR :: Lift a => a -> repr a app :: repr (a->b) -> repr a -> repr b infixl 4 `app` class Sym repr => Parser repr where anychar :: repr Char -- Higher-order constants class Sym repr => Pair repr where pair :: repr (a -> b -> (a,b)) prj1 :: repr ((a,b) -> a) prj2 :: repr ((a,b) -> b) -- parse two characters and return them as a pair test1 = pair `app` anychar `app` anychar -- Implementations -- we don't need Q monad actually, neither here -- nor anywhere! -- It's a bummer that lift has the signature t -> Q Exp -- rather than t -> Exp! data C a = C{unC :: Q Exp} instance Sym C where pureR = C . lift app f x = C $ appE (appE (varE '(Control.Applicative.<*>)) (unC f)) (unC x) instance Parser C where anychar = C . varE $ 'get pair0 x y = (x,y) instance Pair C where pair = C [e| pure pair0 |] prj1 = C [e| pure fst |] prj2 = C [e| pure snd |] printC :: C a -> IO String printC m = runQ (fmap pprint $ unC m ) test1C = printC test1 {- "(Control.Applicative.<*>) ((Control.Applicative.<*>) (Control.Applicative.pure P.pair0) Text.ParserCombinators.ReadP.get) Text.ParserCombinators.ReadP.get" -}

2 2

Open-source projects for beginning Haskell students?
by Michel Kuhlmann 13 Mar '13

13 Mar '13

Hi Brent, I am myself a haskell-beginner. Too, trying to come to terms with Applicative and Monad. Nevertheless, I forked [1] @tomahawkin's `devsurf` library, with the aim of extending it to triangular-mesh and point-cloud manipulation library. There are lot's of things I still miss. For example: * Point-cloud/mesh simplification * Slicing of meshes/point-clouds (taking cross-sections) * Interpolation from point-cloud to mesh * Merging different meshes * Difference between two meshes, resulting in a diff-mesh * ... Related to that I created a repository for associated executables [3]. The main-program there is `mshConv`, which should convert meshes into and from different file-formats, analog to fabulous `pandoc`. There are several things to be done: * Proper command-line interface * Using Parsec in Readers * More Readers * More Writers Currently mesh-conversion could be done in `meshlab` [4]. On the homepage is also a list with potential Readers and Writers. I am willing to exchange email, but I do not have the competence of mentoring or guidance. Best regards, Michel [1] https://www.github.com/tomahawkins/devsurf [2] https://www.github.com/michelk/devsurf [3] https://www.github.com/michelk/devsurf-bin [4] http://www.meshlab.org

1 0

cabal install oddities
by Tycho Andersen 12 Mar '13

12 Mar '13

Hi all, I'm having some strange issues with cabal install. Some packages installed via `cabal install $foo` are failing for strange (and seemingly unrelated) reasons, but install just fine when I do something like: cabal unpack network cd network cabal configure cabal install Below is some sample output from a failing package: ps168825:~/playground$ cabal install network Resolving dependencies... Configuring network-2.4.1.2... configure: WARNING: unrecognized options: --with-compiler, --with-gcc checking build system type... x86_64-unknown-linux-gnu checking host system type... x86_64-unknown-linux-gnu checking for gcc... gcc checking whether the C compiler works... yes checking for C compiler default output file name... a.out checking for suffix of executables... checking whether we are cross compiling... configure: error: in `/tmp/network-2.4.1.2-28534/network-2.4.1.2': configure: error: cannot run C compiled programs. If you meant to cross compile, use `--host'. See `config.log' for more details Failed to install network-2.4.1.2 cabal: Error: some packages failed to install: network-2.4.1.2 failed during the configure step. The exception was: ExitFailure 1 ps168825:~/playground 1$ cabal --version cabal-install version 1.16.0.2 using version 1.16.0 of the Cabal library ps168825:~/playground$ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.6.2 /tmp/network-* doesn't exist (which is why I tried unpack, but unfortunately that succeeds). Any thoughts on how I can debug this? Thanks, \t

3 3

Overloading
by Peter Caspers 12 Mar '13

12 Mar '13

Hi, I just started playing around a bit with Haskell, so sorry in advance for very basic (and maybe stupid) questions. Coming from the C++ world one thing I would like to do is overloading operators. For example I want to write (Date 6 6 1973) + (Period 2 Months) for some self defined types Date and Period. Another example would be (Period 1 Years) + (Period 3 Months). Just defining the operator (+) does not work because it collides with Prelude.+. I assume using fully qualified names would work, but that is not what I want. So maybe make the types instances of typeclasses? This would be Num for (+) I guess. For the first example above it will not work however, alone for it is not of type a -> a -> a. Also the second example does not fit, because I would have to make Period an instance of Num, which does not make sense, because I can not multiply Periods (for example). Am I missing something or is that what I am trying here just impossible by the language design (and then probably for a good reason) ? A second question concerns the constructors in own datatypes like Date above. Is it possible to restrict the construction of objects to sensible inputs, i.e. reject something like Date 50 23 2013 ? My workaround would be to provide a function say date :: Int->Int->Int->Date checking the input and returning a Date object or throw an error if the input does not correspond to a real date. I could then hide the Date constructor itself (by not exporting it). However this seems not really elegant. Also again, taking this way I can not provide several constructors taking inputs of different types, can I ? Thanks a lot Peter

12 24

newtype a Constraint?
by Roman Cheplyaka 12 Mar '13

12 Mar '13

Is there a way to newtype a constraint? Imagine a type class parameterised over constraints. What do I do if I want multiple instances for (essentially) the same constraint? Roman

3 3

ANNOUNCE xml-conduit-generic
by Dmitry Olshansky 12 Mar '13

12 Mar '13

Hello, cafe! I made a package xml-conduit-generic<https://github.com/odr/xml-conduit-generic> to provide conversion from ADT to xml and vice versa. Conversion works as Conduit (ToXml) or Consumer (FromXml). Example: data T4 = T4 {v4 :: Int, n4 :: Maybe T4} deriving (Eq, Show, Generic) instance ToXml T4 instance FromXml T4 > runToXml $ T4 5 $ Just $ T4 6 Nothing "<T4 v4=\"5\"><n4 v4=\"6\"/></T4>" > runFromXml $ "<T4 v4=\"5\"><n4 v4=\"6\"/></T4>" :: IO (Either String T4) Right $ T4 5 $ Just $ T4 6 Nothing It would be great if someone look to the version on github and give me some notes. Then I am going to put it on hackage. Unfortunately, I didn't find a way to avoid OverlappingInstances (for GFromXml class). Any ideas are welcome. Best regards, Dmitry

1 0

QuickCheck: Why are these instances of Testable?
by Paul Brenman 11 Mar '13

11 Mar '13

Why does QuickCheck (2.6) list the following as instances of class Testable? Testable Result Testable Prop Testable prop => Testable (Gen prop) The Hughes/Claessen paper "QuickCheck: A Lightweight Tool for Random Testing of Haskell Programs" mentions nesting property combinators on page 6, but I didn't understand this reference.

1 0