- Haskell-Cafe - Haskell.org

GHCi on Pi Zero
by alex 17 Mar '16

17 Mar '16

Hi all, I'm struggling with getting a working ghci on the Raspberry Pi Zero. I managed to get a ghc with ghci installed via jessie-backports, but when I run ghci from the commandline I simply get a "Illegal instruction" message. Has anyone had more luck, or does anyone have ideas / tips? Best wishes alex -- http://yaxu.org/

2 1

Zoom instance for Coroutine
by Konstantin Saveljev 15 Mar '16

15 Mar '16

Hello, I am using monad-coroutine <https://hackage.haskell.org/package/monad-coroutine> package and have something like Coroutine (Await Int) (State MyState) Int (simplified version, for example purpose). MyState is deeply nested and I do a lot of modifications in it. Previously (with different data types) I was able to use zoom from lens <https://hackage.haskell.org/package/lens>in order to simplify the typing/view of code which operates on some subtree of the state, e.g.: zoom (company.assets) $ do something.a = someComputation anotherthing.b = False this.that = "someString" The problem I am having is that I cannot come up with instance Zoom for the Coroutine and was wondering if anyone is able to help me with that? Best regards, Konstantin

3 2

Foldable/Traversable and Applicative/Monoid?
by David Banas 15 Mar '16

15 Mar '16

Hi all, I don't understand why Foldable is a necessary super-class of Traversable, and I suspect that the Applicative/Monoid duality, which I've just begun discovering in the literature, has something to do with why that is so. Can anyone give me a hint, without giving me the answer? Thanks! -db

2 4

ANN: katip - a new structured logging framework for Haskell
by Ozgun Ataman 15 Mar '16

15 Mar '16

Fellow Haskellers, We're delighted to release a new logging framework today called "katip", centered around the idea of making it easy to include contextual data in individual log items in the form of structured fields. Katip has become, rather quickly, our go-to logging library at Soostone, included in everything from simple ad-hoc scripts to production systems under load. You can find katip on both Hackage[1] and Github[2]. The core library has also been added to Stackage nightly, though the ElasticSearch backend is waiting on a dependency conflict on aeson. We hope you find it useful and look forward to any contributions or feedback! [1] http://hackage.haskell.org/package/katip [2] https://github.com/Soostone/katip As a little summary, here's the features checklist from the README: * *Structured:* Logs are structured, meaning they can be individually tagged with key value data (JSON Objects). This helps you add critical details to log messages before you need them so that when you do, they are available. Katip exposes a typeclass for log payloads so that you can use rich, domain-specific Haskell types to add context that will be automatically merged in with existing log context. * *Easy to Integration:* Katip was designed to be easily integrated into existing monads. By using typeclasses for logging facilities, individual subsystems and even libraries can easily add their own namespacing and context without having any knowledge of their logging environment. * *Practical Use:* Katip comes with a set of convenience facilities built-in, so it can be used without much headache even in small projects. * A `Handle` backend for logging to files in simple settings. * A `AnyLogPayload` key-value type that makes it easy to log structured columns on the fly without having to define new data types. * A `Monadic` interface where logging namespace can be obtained from the monad context. * Multiple variants of the fundamental logging functions for optionally including fields and line-number information. * *Extensible:* Can be easily extended (even at runtime) to output to multiple backends at once (known as scribes). See `katip-elasticsearch` as an example. Backends for other forms of storage are trivial to write, including both hosted database systems and SaaS logging providers. * *Debug-Friendly:* Critical details for monitoring production systems such as host, PID, thread id, module and line location are automatically captured. User-specified attributes such as environment (e.g. Production, Test, Dev) and system name are also captured. * *Configurable:* Can be adjusted on a per-scribe basis both with verbosity and severity. * *Verbosity* dictates how much of the log structure should actually get logged. In code you can capture highly detailed metadata and decide how much of that gets emitted to each backend. * *Severity* AKA "log level" is specified with each message and individual scribes can decide whether or not to record that severity. It is even possible to at runtime swap out and replace loggers, allowing for swapping in verbose debug logging at runtime if you want. * *Battle-Tested:* Katip has been integrated into several production systems since 2015 and has logged hundreds of millions of messages to files and ElasticSearch.

2 1

ANNOUNCE: Frown, Ralf Hinze's LALR(k) parser generator for Haskell, now slightly upkept ☺
by M Farkas-Dyck 14 Mar '16

14 Mar '16

Some years ago, Ralf Hinze wrote this parser generator [0], and i have since been using it, so i cleaned it up and uploaded it to Hackage as "frown" [1]. My repo is here: https://github.com/strake/frown [0] http://www.cs.ox.ac.uk/ralf.hinze/frown/ [1] https://hackage.haskell.org/package/frown

1 0

Module name to package name index
by Harendra Kumar 14 Mar '16

14 Mar '16

Is there something available which can answer questions like this - what all packages on Hackage export "Data.List" module? Another useful question could be - what all packages export symbol named 'x'? Hackage search or hoogle are not helpful in providing a precise answer to these. I am assuming that related functionality usually lands up in the same part of the module namespace. This fact can help us in discovering related or alternative packages or functions available in a given area. For example when I am looking for list related functions I can search for who all exports "Data.List". I guess creating such an index should not be difficult. All the necessary information is available in the packages' .cabal files, we just need to extract it and create a module name to package name index. -harendra

2 2

GADTs and Exponentiated Functors
by Daniel Filonik 13 Mar '16

13 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 12 Mar '16

12 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