March 2016 - Haskell-Cafe

GADTs and Exponentiated Functors
by Daniel Filonik 12 Mar '16

12 Mar '16

Hi, I have been recently playing around with GADTs, using them to keep track of how many times a functor has been applied. This provides a solution to what seems to be a long standing problem, summarized here: https://byorgey.wordpress.com/2007/08/16/mapping-over-a-nested-functor/ If the nesting depth is part of the type, it is possible to apply fmap automatically as needed. This allows you to write fairly elegant expressions like: data Person = Person { name :: String, age :: Integer, gender :: String, status :: String } deriving Show let persons = fromList' [Person {name="Alice", age=20, gender="F", status="Good"}, Person {name="Bob", age=18, gender="M", status="Good"}, Person {name="Chuck", age=16, gender="M", status="Bad"}] :: NList N1 Person persons `select` age -- [20,18,16] persons `groupby` gender `select` age -- [[20],[18,16]] persons `groupby` gender `groupby` status `select` age -- [[[20]],[[18],[16]]] Note that "`select` age" works regardless of nesting depth. You can also append or remove nesting levels: persons `groupby` gender `select` age `produce` (\x -> [0..x]) -- [[[0..20]],[[0..18],[0..16]]] persons `groupby` gender `reduce` (sumof age) -- [20, 34] Would this kind of thing be of interest? The code is here: https://github.com/filonik/nlists Please feel free to suggest improvements. Cheers, Daniel

3 6

GHC API arguments via cabal/stack?
by David Turner 12 Mar '16

12 Mar '16

Hi all, I'm working on a little program that uses GHC as a library to do some static analysis on a project I'm working on. It runs things as far as the typechecker (so there's no Template Haskell remaining) and then does the analysis on the resulting AST. Here is how I'm calling GHC at the moment: runAnalyser :: FilePath -> [String] -> [String] -> IO [(Module, [Fact], [Assertion])] runAnalyser srcDir args modules = do defaultErrorHandler defaultFatalMessager defaultFlushOut $ do runGhc (Just libdir) $ do dflags <- getSessionDynFlags (dflags', leftover, warnings) <- parseDynamicFlagsCmdLine dflags (map noLoc $ args ++ modules) setSessionDynFlags dflags' setTargets =<< forM modules (\exampleModule -> guessTarget (exampleModuleFile srcDir exampleModule) Nothing) load LoadAllTargets execWriterT $ forM_ modules $ \exampleModule -> do modSum <- lift $ getModSummary $ mkModuleName exampleModule p <- lift $ parseModule modSum t <- lift $ typecheckModule p case tm_renamed_source t of Nothing -> return () Just (hsGroup, _, _, _) -> do assertions <- liftIO $ loadAssertions $ exampleModuleFile srcDir exampleModule let mod = ms_mod $ pm_mod_summary $ tm_parsed_module t tell [( mod , runFactM (moduleName mod) (facts hsGroup) , assertions)] The problem I'm currently facing is that this requires me to pass in the arguments to GHC, including where all the package databases are and all the package ids that stack has decided to use. So far, I've just copy-pasted this from the stack log and hard-coded it, but that's clearly not a good long-term solution. I've half-heartedly tried to fool stack into running my analyser as the compiler, but stack calls ghc more times than just the one call that I need the arguments from. I could make it pass through to the real ghc but this feels like piling hacks on top of hacks. I've also briefly contemplated using the Cabal library to read my .cabal file and work out what to do, but I'm unsure that this would work nicely under stack. At least, I'm not sure quite what to do with all the package databases and other stuff that stack does for you. Is there a sensible and robust way to get these args as stack would make them? Many thanks, David

5 5

Can't get any memory profile data
by Cody Goodman 12 Mar '16

12 Mar '16

Here is the command line log of my attempt following real world haskell's memory profiling example: src λ stack exec -- ghc --version The Glorious Glasgow Haskell Compilation System, version 7.10.3 src λ cat Main.hs module Main where main :: IO () main = do let x = {-# SCC sum #-}sum [1..500] print x {-# SCC helloworld #-} putStrLn "hello world" src λ stack exec -- ghc -O2 --make Main.hs -prof -auto-all -caf-all -fforce-recomp [1 of 1] Compiling Main ( Main.hs, Main.o ) Linking Main ... src λ ./Main +RTS -hc -p 125250 hello world src λ cat Main.hp JOB "Main +RTS -hc -p" DATE "Fri Mar 11 22:51 2016" SAMPLE_UNIT "seconds" VALUE_UNIT "bytes" BEGIN_SAMPLE 0.00 END_SAMPLE 0.00 BEGIN_SAMPLE 0.00 END_SAMPLE 0.00

2 1

MPTC vs. constructor class
by David Feuer 11 Mar '16

11 Mar '16

I've been messing around with type-aligned sequences for a while, and I'm currently exploring the design space of classes for them. The type-aligned package uses this: class TASequence s where tempty :: s c x x Source tsingleton :: c x y -> s c x y -- can default to tsingleton = ( <| tempty ) -- but doesn't for some reason (><) :: s c x y -> s c y z -> s c x z tviewl :: s c x y -> TAViewL s c x y tviewr :: s c x y -> TAViewR s c x y (|>) :: s c x y -> c y z -> s c x z (<|) :: c x y -> s c y z -> s c x z tmap :: (forall x y. c x y -> d x y) -> s c x y -> s d x y An obvious (to me) improvement is to add TAFunctor, TAFoldable, and TATraversable classes, make TASequence a subclass of TATraversable, and remove tmap from TASequence. That's one pleasant direction. Another class expressing some of these ideas: class Category s => TASequence' s c | s -> c where tviewl :: s x y -> TAViewL s c x y tviewr :: s x y -> TAViewR s c x y (|>) :: s x y -> c y z -> s x z (<|) :: c x y -> s y z -> s x z This variant actually offers all the functionality of the original except tmap, which it has no way to talk about whatsoever. The Category s constraint allows id to replace tempty and (>>>) to replace (><). I really like this aspect. Unfortunately, losing tmap et al sucks. It's possible to glue that on to the original TASequence using Data.Constraint: class ForallF Category s => TASequence s where ... but then accessing the Category instances requires mucking about with (\\) and instF and throwing a bunch of explicit type signatures around. Is there any good "design pattern" to resolve this conflict? David Feuer

1 0

Materials on Compiling Functional Languages.
by Maksymilian Owsianny 11 Mar '16

11 Mar '16

Hi Cafe, I'm looking for materials on compiling functional languages. The materials that I was able to gather from the web were kind of all over the place, so I'm hoping someone could help me out with something more in order for a novice. Starting from something specific and simple so I could have something small and concrete to implement, play and ponder about. And then going forward with more advanced materials about different optimization strategies for eager and lazy languages or what could be achieved when limiting yourself only to a total language, etc. Cheers, Max.

9 10

Use cases of empty type classes
by Tomas Tauber 10 Mar '16

10 Mar '16

Hi everyone, I have one question. What are current use cases of type classes with no methods? I saw early uses in type-level programming (e.g. HList [1]). In the OO world, interfaces with no methods are called marker interfaces -- their use cases range from things that could be done with datatype generic programming in Haskell (e.g. serialization) to metadata annotations (e.g. RandomAccess [2]). Regards, Tomas Tauber [1] http://okmij.org/ftp/Haskell/HList-ext.pdf [2] https://docs.oracle.com/javase/8/docs/api/java/util/RandomAccess.html

8 7

Re: [Haskell-cafe] Materials on Compiling Functional Languages. (Gil Mizrahi)
by Kei Davis 10 Mar '16

10 Mar '16

>> Hi Cafe, >> >> I'm looking for materials on compiling functional languages. The >> materials that I was able to gather from the web were kind of all over >> the place, so I'm hoping someone could help me out with something more >> in order for a novice. >> >> Starting from something specific and simple so I could have something >> small and concrete to implement, play and ponder about. And then >> going forward with more advanced materials about different >> optimization strategies for eager and lazy languages or what could be >> achieved when limiting yourself only to a total language, etc. >> >> Cheers, >> Max. >> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe <at> haskell.org >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> > > Hi Maksymilian, > > Here you'll find a (perhaps not so) short list I've accumulated: > > http://pastemarkdown.com/XUEvs > > > and here it is in markdown format: > > - [Implementing a JIT Compiled Language with Haskell and > LLVM](http://www.stephendiehl.com/llvm/) > - [Write You a Haskell](http://dev.stephendiehl.com/fun/index.html) > - [Theory and Implementation of a Functional Programming > Language](http://www.rose-hulman.edu/mathjournal/archives/2000/vol1-n2/pape… > - [Implementing Functional Programming > Languages](http://research.microsoft.com/en-us/um/people/simonpj/papers/slp… > - SPJ > - [Implementing Functional Langauges: a > tutorial](http://research.microsoft.com/en-us/um/people/simonpj/Papers/pj-l… > - SPJ > - [Practical Implementation of a Dependently Typed Functional Programming > Language | Brady](http://compsoc.dur.ac.uk/~ecb/proofread/thesis.pdf) > - > [PLAI](http://cs.brown.edu/~sk/Publications/Books/ProgLangs/2007-04-26/plai-… > - [STG > Machine](http://www.dcc.fc.up.pt/~pbv/aulas/linguagens/peytonjones92implementing.pdf) > - [Typing Haskell in > Haskell](http://web.cecs.pdx.edu/~mpj/thih/TypingHaskellInHaskell.html > - [Practical type inference for arbitrary-rank types / SPJ et > al.](http://research.microsoft.com/en-us/um/people/simonpj/papers/higher-ra… > - Compiling with Continuations - Appel > - [PureScript Compiler](https://github.com/purescript/purescript) > > > Cheers and good luck, > Gil > Nice list Gil. We've recently implemented a pure FL compiler. We started with the "stock hardware" paper ([STG Machine] in Gil's list), but it's somewhat dated (e.g. they're still using a trampoline). Our main reference was the "fast curry" paper: http://community.haskell.org/~simonmar/papers/evalapplyjfp06.pdf Bernie Pope's MiniSTG is a useful learning tool based on that paper: https://wiki.haskell.org/Ministg Our type inferencer currently handles ADTs including unboxed types. I strongly recommend http://soft.vub.ac.be/~cfscholl/Capita-Selecta-2015/papers/2002%20Heeren.pdf supplemented by https://galois.com/wp-content/uploads/2014/08/pub_JL_UnboxedValuesAsFirstCl… Then if you get serious [Typing Haskell in Haskell] in Gil's list. For compiling pattern matching we started with one of the [Implementing Functional ...] in Gil's list, then found some other references online (I don't know exactly which--I didn't implement that part). For a parallel implementation we started with http://community.haskell.org/~simonmar/papers/multiproc.pdf Then there are subsequent papers that can be found on SPJ's publication page. Hope this helps, it helped us! Kei -- Kei Davis Applied Computer Science Group CCS-7, Mail Stop B287 Los Alamos National Laboratory Los Alamos, NM 87545, U.S.A.

1 0

Type equality with "forall"
by Tom Murphy 09 Mar '16

09 Mar '16

So I've written a library I'm pretty excited about, and there's just one type issue keeping it from all working! I've got a graph that represents functions and function composition, and I've written a class (pretty directly from Oleg's "TypeEq" work [0]) that tells whether two types are equal. The problem is it doesn't always say they're equal. Here's a simplified version that has the same issue: [pragmas [1]] data Fs a c where F :: (a -> c) -> Fs a c Compose :: forall a b c. Fs b c -> Fs a b -> Fs a c -- Type equality: class TEq x0 x1 y0 y1 (b :: Bool) | x0 x1 y0 y1 -> b where isEq :: Fs x0 x1 -> (y0 -> y1) -> String -- The case where the types are equal: instance {-# OVERLAPS #-} TEq x y x y 'True where isEq _ _ = "yes!" -- The case where they're unequal: instance (b ~ 'False) => TEq x0 x1 y0 y1 b where isEq (F _) = "no" isEq (Compose a b) f = "compose("++isEq a f++", "++isEq b f++")" When I try this on example programs, I see weird results: > isEq (F not) not "yes!" -- expected > isEq (Compose (F (\_->"")) (F not)) not "compose(no, no)" -- weird! I would expect the result of the second one to be "compose(no, yes!)". It seems to think that the (F not) in the Compose has a different type than (F not) not in a Compose. Anyone spot my problem? Thanks! Tom [0] http://okmij.org/ftp/Haskell/typeEQ.html [1] {-# LANGUAGE DataKinds #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE GADTs, NoMonoLocalBinds #-} {-# LANGUAGE KindSignatures #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE Rank2Types #-} {-# LANGUAGE UndecidableInstances #-}

2 2

ICFP 2016 Call for Sponsorships
by Lindsey Kuper 09 Mar '16

09 Mar '16

ICFP 2016 The 21st ACM SIGPLAN International Conference on Functional Programming http://conf.researchr.org/home/icfp-2016 Call for Sponsorships Web version of this call for sponsorships: http://conf.researchr.org/info/icfp-2016/call-for-sponsorships ## Why Sponsor ICFP 2016? ICFP is the premier conference on functional programming languages, covering all aspects of theory, implementation, and application. Every year, we bring over 400 world-leading researchers, practitioners, and students together to discuss the latest findings, collaborate on new ideas, and meet new people. By sponsoring ICFP, your organization can demonstrate its commitment to supporting high quality research and to developing the next generation of functional programming experts. Most of our sponsorship funds are used to help students from around the world afford to attend the conference and get the most out of their experience. We believe that this commitment will pay dividends for our students, our sponsors, and the public good for years to come. ## Sponsorship Opportunities and Benefits Bronze: $500: Logo on website, poster at industrial reception, listed in proceedings. Silver: $2500: As above, plus: logo in proceedings, logo on publicity materials (e.g., posters, etc.) Gold: $5000: As above, plus: named supporter of industrial reception with opportunity to speak to the audience, and opportunity to include branded merchandise in participants’ swag bag. Platinum: $10000: As above, plus: named supporter of whole event, logo on lanyards, badge ribbon, table/booth-like space available (in coffee break areas), other negotiated benefits (subject to ACM restrictions on commercial involvement). ## How to Become a Sponsor If you’re interested in becoming a sponsor, we’d love to hear from you. You can get in touch with our Industrial Relations Chair at ryan.trinkle(a)gmail.com.

1 0

extensible effects + classy lenses
by Mitchell Rosen 09 Mar '16

09 Mar '16

Hi all, I'm trying to combine an extensible effects style state with classy lenses. That is, instead of pinning the type of my state down, I'd like to only require the pieces I need. For example, {-# language FlexibleContexts #-} import Control.Monad.Freer import Control.Monad.Freer.State class HasInt s where getInt :: s -> Int foo :: (Member (State s) effs, HasInt s) => Eff effs Int foo = get However, this fails to typecheck: Overlapping instances for Member (State s0) effs Matching givens (or their superclasses): (Member (State s) effs) bound by the type signature for foo :: (Member (State s) effs, HasInt s) => Eff effs Int at example.hs:9:8-56 Matching instances: instance Data.Open.Union.Member' t r (Data.Open.Union.FindElem t r) => Member t r -- Defined in ‘Data.Open.Union’ (The choice depends on the instantiation of ‘effs, s0’) In the ambiguity check for the type signature for ‘foo’: foo :: forall (effs :: [* -> *]) s. (Member (State s) effs, HasInt s) => Eff effs Int To defer the ambiguity check to use sites, enable AllowAmbiguousTypes In the type signature for ‘foo’: foo :: (Member (State s) effs, HasInt s) => Eff effs Int Is this a weakness of extensible effects, or is there another way to express this function? Thanks, Mitchell

3 3