March 2017 - Haskell-Cafe

Archival of community.haskell.org
by Mario Rogic 19 May '18

19 May '18

Hi all As announced back in 2015 <http://blog.haskell.org/post/7/the_future_of_community.haskell.org/> we have started archiving community.haskell.org services. We've created https://archives.haskell.org/, and the old projects mailing lists have been the first to be archived. Next on the list is the remainder of projects.haskell.org, and the code.haskell.org site. As always, you can email admin(a)h.o or hop on the #haskell-infrastructure freenode channel to provide feedback / concerns. Thanks - Mario

1 2

Join a transformer
by Michael Snoyman 11 Apr '18

11 Apr '18

I'm wondering if this pattern exists and has a name. We have the concept of joining a Monad: join :: Monad m => m (m a) -> ma How about joining a monad transformer? joinT :: (Monad m, MonadTrans t) => t (t m) a -> t m a I believe implementing this in terms of MonadTransControl[1] might be possible, but I was wondering if there's an already existing idiom for this. Michael [1] http://haddocks.fpcomplete.com/fp/7.4.2/20130301-40/monad-control/Control-M…

5 5

PatternSignatures (rant)
by Johannes Waldmann 06 Apr '18

06 Apr '18

Dear all, (this is a rant - please ignore) why has "PatternSignatures" been renamed to "ScopedTypeVariables" (in ghc-6.10)? show me the alleged "type variable" in this code: do x :: Int <- [ 1 .. 10 ] ; return $ x^2 and why on earth do I need to use a language extension at all to get to the most basic thing of declarative programming: to declare the type of an identifier? This seriously hurts (me, at least) when teaching Haskell. Thanks - J.W.

4 4

Source code location in IO?
by Tom Ellis 30 Jun '17

30 Jun '17

Is it compatible with the semantics of Haskell to have a function sourceLocation :: IO String which when run returns the source file location at which it is used? For example, suppose Main.hs is module Main where main = do putStrLn =<< sourceLocation putStrLn "Hello" putStrLn =<< sourceLocation It would print the following when run Main.hs:4 Hello Main.hs:6 and module Main where main = do let s = sourceLocation putStrLn =<< s putStrLn "Hello" putStrLn =<< s It would print the following when run Main.hs:4 Hello Main.hs:4 If this is not compatible with the semantics of Haskell, why not? I agree that the two programs must have the same denotation, but is there anything that requires them to have the same output when run? Tom

6 7

Why is Megaparsec treating these two operators differently?
by Jeffrey Brown 14 May '17

14 May '17

I used Text.Megaparsec.Expr to write a minimal (56 lines) 2-operator recursive parser. It's on github[1]. It outputs a binary tree of the following form: data AExpr = Var String | Pair AExpr AExpr deriving (Show) The operator table supplied to makeExprParser defines two operators, # and ##. ## binds after #, but both of them refer to the same function, the Pair constructor of the AExpr data type: aOperators :: [[Operator Parser AExpr]] aOperators = [ [ InfixN # symbol "#" *> pure (Pair) ] , [ InfixN # symbol "##" *> pure (Pair) ] ] The # operator works in isolation: > parseMaybe aExpr "a # b" Just (Pair (Var "a") (Var "b")) Parentheses work with the # operator: > parseMaybe aExpr "(a # b) # (c # d)" Just (Pair (Pair (Var "a") (Var "b")) -- whitespace added by hand (Pair (Var "c") (Var "d"))) And the # and ## operators work together as intended: > parseMaybe aExpr "a # b ## c # d" Just (Pair (Pair (Var "a") (Var "b")) -- whitespace added by hand (Pair (Var "c") (Var "d"))) But the ## operator in isolation does not parse! > parseMaybe aExpr "a ## b" Nothing [1] https://github.com/JeffreyBenjaminBrown/digraphs-with-text/blob/master/howt… -- Jeff Brown | Jeffrey Benjamin Brown Website <https://msu.edu/~brown202/> | Facebook <https://www.facebook.com/mejeff.younotjeff> | LinkedIn <https://www.linkedin.com/in/jeffreybenjaminbrown>(I often miss messages here) | Github <https://github.com/jeffreybenjaminbrown>

3 6

Looking for maintainers or comaintainers on my Haskell projects
by Christopher Done 27 Apr '17

27 Apr '17

Hi all, The short version is: I’ve been battling RSI in my fingers for some years. I’m doing various things to mitigate that problem, but I have very limited finger bandwidth these days; enough to work at my usual pace at my job, but not much in the evenings and weekends, and so I can’t manage to do much on my hobby projects. I’m also not as motivated these days to work on my set of open source projects, and am turning my attention to different things. It’s not great, but that’s life. I don’t think that the users of my packages are getting the best maintainership deal. Rather than be “the absentee maintainer”, I’d prefer a straight-forward transition of maintainership or ownership to someone who can put the right energy and time in. In terms of packages, there are really two that have a significant maintenance burden and users aren’t being served very well: - HIndent <https://github.com/chrisdone/hindent> has a significant amount of issues opened for it regularly, and many of them require discussion and debate. If someone would like to become a co-maintainer, let me know. It may (eventually) make sense to move it to a more general GitHub organization like commercialhaskell or haskell. - Intero <https://github.com/commercialhaskell/intero/issues>, which seems to have been a success, has a pretty big maintenance burden on “this doesn’t work” kind of issues which require investigation. There’s some Emacs Lisp work to do on it, and some Haskell work on the intero binary, and a whole lot of platform-specific problems or tooling not working together. On the other hand people really like this project, and there’s a lot of tooling potential. If you want to take xeno <https://github.com/chrisdone/xeno> and make it into a publishable package, please do so. The rest of my projects that are on Stackage are: labels <https://hackage.haskell.org/package/labels>, ace <https://hackage.haskell.org/package/ace>, ical <https://hackage.haskell.org/package/ical>, check-email <https://hackage.haskell.org/package/check-email>, freenect <https://hackage.haskell.org/package/freenect>, frisby <https://hackage.haskell.org/package/frisby>, gd <https://hackage.haskell.org/package/gd>, ini <https://hackage.haskell.org/package/ini>, lucid <https://hackage.haskell.org/package/lucid>, osdkeys <https://hackage.haskell.org/package/osdkeys>, pdfinfo <https://hackage.haskell.org/package/pdfinfo>, present <https://hackage.haskell.org/package/present>, pure-io <https://hackage.haskell.org/package/pure-io>, scrobble <https://hackage.haskell.org/package/scrobble>, shell-conduit <https://hackage.haskell.org/package/shell-conduit>, sourcemap <https://hackage.haskell.org/package/sourcemap>, descriptive <https://hackage.haskell.org/package/descriptive>, wrap <https://hackage.haskell.org/package/wrap>, path <https://hackage.haskell.org/package/path>, weigh <https://hackage.haskell.org/package/weigh>, haskell-docs <https://hackage.haskell.org/package/haskell-docs>, and structured-haskell-mode <https://hackage.haskell.org/package/structured-haskell-mode>. If you’re interested in taking over or co-maintaining any of them, let me know. Some are interesting, others are boring, some are trivial. I have other packages on Hackage, but they’re mostly dead or experiments that don’t need maintenance anyway. I’ve started the process of adding or changing maintainers on my public services: - Haskell News <https://github.com/haskellnews> is now a GitHub organization. Luke Murphy is a co-owner, and has full access to the DigitalOcean account that is running the service. So if you want to work on that project, I’m not in the way. - lpaste <https://github.com/lpaste/lpaste> has been moved to its own DigitalOcean account too. If anyone is interested in taking over the project or co-running it, let me know. - tryhaskell <https://github.com/chrisdone/tryhaskell> doesn’t really require any maintenance, but it’s also on its own DigitalOcean account now too. - IRCBrowse <https://github.com/chrisdone/ircbrowse> is now on its own DigitalOcean account too. It requires maintenance once in a while. If anyone is interested in taking over the project or co-running it, let me know. Cheers!

13 21

formal treatment of module dependencies
by Dimitri DeFigueiredo 02 Apr '17

02 Apr '17

It seems to me that specifying and solving module dependencies is a ubiquitous problem in software development. All the languages that I know try to make the problem go away by using version numbers and maximizing backward compatibility. Does anyone know of references that formalize this problem for Haskell? Thanks, Dimitri -- 2E45 D376 A744 C671 5100 A261 210B 8461 0FB0 CA1F

2 1

Suggestion on how to solve a type issue with Numeric.AD
by Frederic Cogny 01 Apr '17

01 Apr '17

Hello Café *Issue: * I'm having trouble using the AD package presumably due to a wrong use of types (Sorry I know it's a bit vague) Any help or pointer on how to solve this would be greatly appreciated. Thanks in advance *Background: * I've implemented a symbolic expression tree [full code here: https://pastebin.com/FDpSFuRM] -- | Expression Tree data ExprTree a = Const a -- ^ number | ParamNode ParamName -- ^ parameter | VarNode VarName -- ^ variable | UnaryNode MonoOp (ExprTree a) -- ^ operator of arity 1 | BinaryNode DualOp (ExprTree a) (ExprTree a) -- ^ operator of arity 2 | CondNode (Cond a) (ExprTree a) (ExprTree a) -- ^ conditional node deriving (Eq,Show, Generic) An evaluation function on it -- | evaluates an Expression Tree on its Context (Map ParamName a, Map VarName a) evaluate :: (Eq a, Ord a, Floating a) => ExprTree a -> Context a -> a And a few instances on it: instance Num a => Default (ExprTree a) where ... instance Num a => Num (ExprTree a) where ... instance Fractional a => Fractional (ExprTree a) where ... instance Floating a => Floating (ExprTree a) where ... instance (Arbitrary a) => Arbitrary (ExprTree a) where ... This allows me to easily create (using derivation rules) the derivative(s) of such a tree with respect to its variable(s): diff :: (Eq a, Floating a) => ExprTree a -> VarName -> ExprTree a grad :: (Eq a, Floating a) => ExprTree a -> Map VarName (ExprTree a) hessian :: (Eq a, Floating a) => ExprTree a -> Map VarName (Map VarName (ExprTree a)) So far, so good ... Now, to gain assurance in my implementation I wanted to check the derivatives against the Numeric.AD module so I create the two following -- | helper for AD usage exprTreeToListFun :: (RealFloat a) => ExprTree a -- ^ tree -> Map ParamName a -- ^ paramDict -> ([a] -> a) -- fun from var values to their evaluation exprTreeToListFun tree paramDict vals = res where res = evaluate tree (paramDict, varDict) varDict = Map.fromList $ zip (getVarNames tree) vals gradThroughAD :: RealFloat a => ExprTree a -> Context a -> Map VarName a gradThroughAD tree (paramDict, varDict) = res where varNames = Map.keys varDict varVals = Map.elems varDict gradList = AD.grad (exprTreeToListFun tree paramDict) varVals res = Map.fromList $ zip varNames gradList it unfortunately does not type check with message: • Couldn't match type ‘a’ with ‘Numeric.AD.Internal.Reverse.Reverse s a’ ‘a’ is a rigid type variable bound by the type signature for: gradThroughAD :: forall a. RealFloat a => ExprTree a -> Context a -> Map VarName a at src/ SymbolicExpression.hs:452:18 Expected type: [Numeric.AD.Internal.Reverse. Reverse s a] -> Numeric.AD.Internal.Reverse.Reverse s a Actual type: [a] -> a • In the first argument of ‘AD.grad’, namely ‘(exprTreeToListFun tree paramDict)’ In the expression: AD.grad (exprTreeToListFun tree paramDict) varVals In an equation for ‘gradList’: gradList = AD.grad (exprTreeToListFun tree paramDict) varVals • Relevant bindings include gradList :: [a] (bound at src/SymbolicExpression.hs:457:5) varVals :: [a] (bound at src/ SymbolicExpression.hs:456:5) varDict :: Map VarName a (bound at src/SymbolicExpression.hs:453:32) paramDict :: Map ParamName a (bound at src/SymbolicExpression.hs:453:21) tree :: ExprTree a (bound at src/ SymbolicExpression.hs:453:15) gradThroughAD :: ExprTree a -> Context a -> Map VarName a (bound at src/SymbolicExpression.hs:453:1) I was a bit surprised (I guess naively) by this, since to me, 'a' is polymorphic with RealFloat as type constraint and that is "supposed" to work with AD So anyway, I tried to modify as follow: {-# LANGUAGE Rank2Types #-} -- | helper for AD usage exprTreeToListFun :: (RealFloat a) => ExprTree a -- ^ tree -> Map ParamName a -- ^ paramDict -> *(RealFloat b => *[b] -> b) -- fun from var values to their evaluation exprTreeToListFun tree paramDict vals = res where res = *realToFrac* $ evaluate tree (paramDict, varDict) varDict = Map.fromList $ zip (getVarNames tree) *$ map realToFrac *vals This now typechecks and runs but going through AD returns me *all derivatives as zero* as if treating the variables (that passed through *realToFrac*) as constants, so not that much helpful either. Any idea how this can be solved ? Apologies if this is a question that already has an answer somewhere but poking around SO <http://stackoverflow.com/search?q=%5Bhaskell%5D+ad+package> It looks like I'm not the only one having similar issues and unfortunately none of the answers I found really helped me, if anything it confirms the same issue of null derivatives: http://stackoverflow.com/questions/36878083/ad-type-unification-error-with-… Thanks again -- Frederic Cogny +33 7 83 12 61 69

2 3

[ANN] Accelerate 1.0
by Trevor McDonell 31 Mar '17

31 Mar '17

Friends, After much delay, it is my pleasure to announce the release of Accelerate 1.0. Accelerate is an embedded language for computations on dense, multidimensional arrays. Computations are expressed in the form of parameterised collective operations, such as maps, folds, and permutations. These computations are online compiled and can be executed on a range of architectures, such as multicore CPUs and GPUs. This release includes updates to a number core and support packages: * accelerate: Defines the core language (https://hackage.haskell.org/package/accelerate) * accelerate-llvm-native: Accelerate backend to execute computations on multicore CPUs ( https://hackage.haskell.org/package/accelerate-llvm-native) * accelerate-llvm-ptx: Accelerate backend to execute computations on CUDA GPUs (https://hackage.haskell.org/package/accelerate-llvm-ptx) * accelerate-llvm: For developing new backends targeting LLVM (https://hackage.haskell.org/package/accelerate-llvm) * accelerate-io: Conversions between Accelerate arrays and other formats (including vector and repa) (https://hackage.haskell.org/package/accelerate-io) * accelerate-fft: FFI bindings to discrete Fourier transforms (FFTW and cuFFT) (https://hackage.haskell.org/package/accelerate-fft) * accelerate-bignum: Fixed-width large integer arithmetic (> 64-bits) (https://hackage.haskell.org/package/accelerate-bignum) * accelerate-examples: Computational kernels and example applications, as well as regression test suite (https://hackage.haskell.org/package/accelerate-examples) * mwc-random-accelerate: Generate Accelerate arrays filled with pseudorandom numbers (https://hackage.haskell.org/package/mwc-random-accelerate) * gloss-accelerate: Generate gloss pictures from Accelerate (https://hackage.haskell.org/package/gloss-accelerate) * gloss-raster-accelerate: Parallel rendering of raster images and animations (https://hackage.haskell.org/package/gloss-raster-accelerate) * colour-accelerate: Colour representations in Accelerate, including RGB, sRGB, HSV and HSL (https://hackage.haskell.org/package/colour-accelerate ) * lens-accelerate: Lens operators for Accelerate types (https://hackage.haskell.org/package/lens-accelerate) * (soon) linear-accelerate: Linear vector spaces in Accelerate (https://hackage.haskell.org/package/linear-accelerate) (pending https://github.com/ekmett/linear-accelerate/pull/4) The (still under construction) acceleratehs.org website includes some installation instructions and a short tutorial to help you get started. * http://www.acceleratehs.org/get-started.html * http://www.acceleratehs.org/examples/mandelbrot.html If you find a bug or have a question, head over to the GitHub issue tracker or mailing list. * https://github.com/AccelerateHS/accelerate/issues * accelerate-haskell(a)googlegroups.com We welcome new contributors, so please contact us if you would like to get involved!

1 0

Compose Conference Call for Participation [NYC, May 18-19]
by Gershom B 30 Mar '17

30 Mar '17

=============================================== Call for Participation Compose Conference 2017 May 18-19 2017 New York, NY http://www.composeconference.org/2017 =============================================== The practice and craft of functional programming :: Conference Compose is a conference for typed functional programmers, focused specifically on Haskell, OCaml, F#, SML, and related technologies. Typed functional programming has been taken up widely, by industry and hobbyists alike. For many of us it has renewed our belief that code should be beautiful, and that programming can be as enjoyable as it is practical. Compose is about bringing together functional programmers of all levels of skill and experience — from technical leads to novices, and from long-time hackers to students just getting started. It will feature a keynote by Emily Riehl on aspects of category theory and computation, and two days of great talks. * Invited Talks Emily Riehl: TBA * Local Information (venue): http://www.composeconference.org/2017/ * Accepted Talks and Tutorials Barry Burd - Teaching Haskell David Rhodes - Learning F#: Case study with branch and bound Edmund Cape - Multiplying by 1 - an important form of computation and how it reveals distinctions between kleislis Enzo Alda, et al. - Reactive Sheets: an intuitive approach to functional‑reactive computing Hezekiah Carty and Chris Donaher - Distrest - REST access to distributed services Hongbo Zhang - BuckleScript: Making functional programming accessible to JavaScript developers Jennifer Paykin, Kenneth Foner, Antal Spector-Zabusky - `choose` Your Own Derivative Joachim Breitner - Lock-step simulation is child’s play Martín Ceresa, Gustavo Grieco - QuickFuzz Testing for Fun and Profit Michael Chavinda - Android programming in Froid Nikhil Barthwal - Implementing an Event-Driven Microservices Architecture in F#: A case study of Jet.com Nikita Volkov - New Hasql - a simpler, safer and faster Postgres client Sebastien Mondet - Typed-Tagless Final Bioinformatics Stephen Compall - Working with Monads in OCaml Stuart Popejoy - Smart Contracts and Formal Verification with Z3 with Pact Yaron Minsky - Data Driven UIs, Incrementally * Full abstracts: http://www.composeconference.org/2017/program * Registration: http://composeconference.eventbrite.com * Follow @composeconf on twitter for news: https://twitter.com/composeconf * On freenode irc, chat with fellow attendees at #composeconference * Corporate sponsorships are welcome. Current sponsors list forthcoming. * Policies (diversity and anti-harassment): http://www.composeconference.org/conduct * Email us with any questions at info(a)composeconference.org * Please forward this announcement to interested parties and lists.

1 0