December 2013 - Haskell-Cafe

How to determine the right path to haddock html documentation?
by Carlo Hamalainen 09 Jan '14

09 Jan '14

Hi, I'm writing a patch for ghcmod-vim so that a user can look up the haddock html documentation for a symbol. My code makes three system calls, e.g. to look up "Just" it does: $ ghc-mod info foo.hs Foo Just data Maybe a = ... | Just a -- Defined in `Data.Maybe' $ ghc-pkg find-module Data.Maybe --simple-output haskell2010-1.1.1.0 base-4.6.0.1 $ ghc-pkg field base-4.6.0.1 haddock-html haddock-html: /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1 Then "Data.Maybe" is changed to Data-Maybe.html" and appended to the haddock-html value. But this procedure doesn't work in general, for example when looking up String: $ ghc-mod info foo.hs Foo String type String = [Char] -- Defined in `GHC.Base' $ ghc-pkg find-module GHC.Base /home/carlo/opt/ghc-7.6.3_build/lib/ghc-7.6.3/package.conf.d base-4.6.0.1 /home/carlo/.ghc/x86_64-linux-7.6.3/package.conf.d $ ghc-pkg field base-4.6.0.1 haddock-html haddock-html: /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1 $ ls /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1/GHC-Base.html ls: cannot access /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1/GHC-Base.html: No such file or directory because the html is in the src subdirectory: $ ls /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1/src/GHC-Base.html /home/carlo/opt/ghc-7.6.3_build/share/doc/ghc/html/libraries/base-4.6.0.1/src/GHC-Base.html But this isn't even the right place to go, one should look at the Prelude file http://hackage.haskell.org/package/base-4.6.0.1/docs/Prelude.html#t:String which is what Hoogle suggests. How does Hoogle get it right? It looks like haskell-mode for emacs runs into a similar problem: https://github.com/haskell/haskell-mode/blob/master/inf-haskell.el#L734-L740 ------------------------------- (defvar inferior-haskell-ghc-internal-ident-alist ;; FIXME: Fill this table, ideally semi-automatically. '(("GHC.Base.return" . "Control.Monad.return") ("GHC.List" . "Data.List"))) (defun inferior-haskell-map-internal-ghc-ident (ident) "Try to translate some internal GHC identifier to its alter ego in haskell docs." ------------------------------- Thanks, -- Carlo Hamalainen http://carlo-hamalainen.net

3 9

(automatically) adding import statements in vim
by cdep.illabout＠gmail.com 04 Jan '14

04 Jan '14

Are there any tools or vim-plugins that will automatically add import statements? For instance, I have the following code: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError) import Text.Printf (printf) ... parseMyString :: String -> Either ParseError String parseMyString stringToParse = parse myParser "(unknown)" stringToParse Here's what I want to have happen. I put my cursor over "parse" and press some keystroke. It automatically adds the parse function to the list of import statements from the Text.ParserCombinators.Parsec module (hopefully sorted alphabetically). So the import statements end up looking like this: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError, parse) import Text.Printf (printf) ... The haskellmode vim plugin (https://github.com/lukerandall/haskellmode-vim) has functionality similar to this, but it can only add new import lines. It can't add functions/types to existing import lines. The best it can do is something like this: ... import Data.Maybe (fromJust) import Text.ParserCombinators.Parsec (ParseError) import Text.Printf (printf) import Text.ParserCombinators.Parsec (parse) ... This is alright, but I have to go back and edit it by hand to make it look like the above. Are there any tools or vim-plugins that can do this automatically?

5 6

Consistency issue with type level numeric literals
by oleg＠okmij.org 01 Jan '14

01 Jan '14

GHC 7.6.3 has quite convenient type-level numeric literals. We can use numbers like 1 and 2 in types. However, using the type level numeral has been quite a bit of a challenge, illustrated, for example, by the following SO question. http://stackoverflow.com/questions/20809998/type-level-nats-with-literals-a… It seems the challenge has the reason: the type level numerals and their operations provided in GHC.TypeLits have a consistency issue. The following code demonstrates the issue: it constructs two distinct values of the type Sing 2. Singletons aren't singletons. {-# LANGUAGE KindSignatures #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} module NotSing where import GHC.TypeLits -- GHC strangely enough lets us define instances for (+) type instance 1 + 1 = 0 type instance 0 + 1 = 2 -- A singular representative of 1::Nat s1 :: Sing 1 s1 = withSing id -- A singular representative of 2::Nat s2 :: Sing 2 s2 = withSing id is2 :: IsZero 0 is2 = IsSucc s1 tran :: IsZero 0 -> Sing 2 tran (IsSucc x) = case isZero x of IsSucc y -> case isZero y of IsZero -> x -- Another singular representative of 2::Nat -- A singular representative of 2::Nat s2' :: Sing 2 s2' = tran is2 {- *NotSing> s2 2 *NotSing> s2' 1 -}

3 3

[ANN] Laborantin: experimentation framework
by lucas di cioccio 31 Dec '13

31 Dec '13

Dear all, I am happy to announce Laborantin. Laborantin is a Haskell library and DSL for running and analyzing controlled experiments. Repository: https://github.com/lucasdicioccio/laborantin-hs Hackage page: http://hackage.haskell.org/package/laborantin-hs Laborantin's opinion is that running proper experiments is a non-trivial and often overlooked problem. Therefore, we should provide good tools to assist experimenters. The hope is that, with Laborantin, experimenters will spend more time on their core problem while racing through the menial tasks of editing scripts because one data point is missing in a plot. At the same time, Laborantin is also an effort within the broad open-science movement. Indeed, Laborantin's DSL separates boilerplate from the actual experiment implementation. Thus, Laborantin could reduce the friction for code and data-reuse. One family of experiments that fit well Laborantin are benchmarks with tedious setup and teardown procedures (for instance starting, configuring, and stopping remote machines). Analyses that require measurements from a variety of data points in a multi-dimensional parameter space also fall in the scope of Laborantin. When using Laborantin, the experimenter: * Can express experimental scenarios using a readable and familiar DSL. This feature, albeit subjective, was confirmed by non-Haskeller colleagues. * Saves time on boilerplate such as writing command-line parsers or encoding dependencies between experiments and analysis results in a Makefile. * Benefits from auto-documentation and result introspection features when one comes back to a project, possibly months or weeks later. * Harnesses the power of Haskell type-system to catch common errors at compile time If you had to read one story to understand the pain points that Laborantin tries to address, it should be Section 5 of "Strategies for Sound Internet Measurement" (V. Paxson, IMC 2004). I'd be glad to take question and comments (or, even better, code reviews and pull requests). Kind regards, --Lucas DiCioccio (@lucasdicioccio on GitHub/Twitter)

4 5

parametrized data types and Template Haskell
by Maarten Faddegon 31 Dec '13

31 Dec '13

Dear Cafe, Hope you all had a nice Christmas. I have been playing with generating method instances using Template Haskell but am a bit stuck now trying to generate an instance for a parametrized data type. I would like to generate the following: > instance (MyClass a) => MyClass (Tree a) where > mymethod _ = "todo" I defined a genMyClassInstance that is working fine for unparametrized data types, but clearly there is nothing here that inserts the '(MyClass a) =>' part here. My first question is: how should I instruct Template Haskell to insert the beforementioned code when appropriate? > genMyClassInstance :: Name -> Q [Dec] > genMyClassInstance name > = [d|instance MyClass $(conT name) where > mymethod _ = "todo" > |] My second question is how to pass the Name of a parametrized data type? I tried the following, but GHC does not seem to like that: "Not in scope: type constructor or class `Tree a' Perhaps you meant `Tree'" > $(genMyInstance (mkName "Tree a")) Thank you! Maarten Faddegon

3 5

December 31 deadline for Haskell.org donations
by Adam Foltzer 30 Dec '13

30 Dec '13

Dear Haskellers, HaskellWiki, Hackage, Hoogle, and all the other haskell.org sites we depend on are hosted with funds donated by you, the Haskell community. As many of us are in tax jurisdictions where December 31st is a deadline for charitable giving, I’d like to remind you that donations to support these activities are tax-deductible. You can donate online right now at https://co.clickandpledge.com/advanced/default.aspx?wid=69561. Thank you to Jason Dagit and the rest of last year’s Haskell.org Committee for making these donations possible by establishing a partnership with Software in the Public Interest, and thank you to all those who have already donated both money and time to advance our infrastructure and community. It has been a momentous year for Haskell.org: Hackage 2 was launched on a community server, and the HaskellWiki is now available via HTTPS. Let’s keep making progress in 2014! Thank you and best wishes for a happy new year, Adam Foltzer

1 0

ANN: treeviz-0.0.4 - a tool for visualizing Divide&Conquer computational breakdown.
by David Banas 30 Dec '13

30 Dec '13

I just posted v0.0.4 of treeviz, a Haskell package for visualizing how various divide & conquer algorithms break down computations. The specific example provided is the classic fast Fourier transform (FFT). http://hackage.haskell.org/package/treeviz-0.0.4 https://github.com/capn-freako/treeviz Happy holidays, -db

2 1

Top-down inserts in Persistent
by Michael Orlitzky 30 Dec '13

30 Dec '13

I'm loading data from XML into a Haskell data type, and I'd like to use Persistent to save it to a database. The examples from the Yesod book have you manually define a FooId field and create the relationships yourself from the bottom up. For example, "a person has many cars": blah blah [persistLowerCase| Person name String Car ownerId PersonId Eq name String |] This works well if you're responsible for creating every person/car manually. But what if the data are given to you? If I were to parse people from an XML file, the cars wouldn't have people_ids in them. Instead I'd get, blah blah [persistLowerCase| Person name String cars [Car] Car name String |] As long as the cars list contains another Persistent type, it seems like I should be able to insert a person and have it insert the cars, with proper foreign keys, automatically. Doing it manually isn't straight-forward because I can't add the "ownerId" field to my Car type and still expect to parse it from the XML (which has no such field). Any ideas? I'm not married to Persistent yet; I just want to read in some XML and save it to a database without having to specify the names and types in three places (preferred place: in Haskell). I don't care too much about the schema I get as long as it's relational.

3 4

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 124, Issue 39
by Hans Höglund 29 Dec '13

29 Dec '13

> On Sat, Dec 28, 2013 at 5:13 PM, Tom Ellis > <tom-lists-haskell-cafe-2013 at jaguarpaw.co.uk> wrote: > > data Wrap m n a = Wrap (m (n a)) > > This is Compose [0] from traversable. It doesn't have a Monad > instance, though... > > Erik > > [0] http://hackage.haskell.org/package/transformers-0.3.0.0/docs/Data-Functor-C… According to [1], Wrap/Compose does indeed have a Monad instance terms of traverse (here called 'swap'). As far as I understand the paper includes a proof that all the Monad laws holds for such as composition, however there is no mention of transformers as the paper predates them. Personally I am not sure that the transformer composition is useful. Would it be as simple as adding this instance to Data.Functor.Compose: > instance (Functor m, Traversable n, Monad m, Monad n) => Monad (Compose m n) or can anyone spot a problem with this approach? Hans [1]: http://web.cecs.pdx.edu/~mpj/pubs/RR-1004.pdf, page 9 [2]: http://strictlypositive.org/IdiomLite.pdf

2 3

Re: [Haskell-cafe] Question on nested State monads.
by Benjamin Edwards 29 Dec '13

29 Dec '13

(Forwarding to the list, sorry Albert) On Sunday, 29 December 2013 08:32:06, Benjamin Edwards < edwards.benj(a)gmail.com> wrote: I would also recommend looking at use / zoom from the lens package. I find them indispensable for when you want to use a compound state. If you just have two parts you can write all your state calculations on the separate parts then user StateT m (a,b) r and zoom _1 / zoom _2 to access them in the same do block.

1 0