- Haskell-Cafe - Haskell.org

Announcement: Gipeda, the git performance dashboard
by Joachim Breitner 17 May '15

17 May '15

Dear Haskellers, a while ago, I set up a performance dashboard¹ for GHC, based on codespeed², but I was dissatisfied, so in the end, I wrote a new one, called Gipeda for “Git Performance Dashboard”. The git in the name as, in contrast to codespeed, I do not try to be VCS-agnostic but do want to use and expose the structure of your project’s git repository in the output. You can have a look at http://perf.haskell.org/ghc. It should be relatively self-explanatory. Just note that by default it hides boring stuff (commits and results with no significant change), you can select what to show in the top-right corner. The idea behind gipeda is relatively simple. Starting with a directory with one file for each of your project’s benchmarked commit, gipeda digests this to produce a bunch of JSON files. It uses shake³ to avoid unnecessary recalculations. A static HTML file with lots of JavaScript (using handlebars as a templating engine, and other JS libraries like jQuery and flot) then presents this data, in a hopefully snappy and intuitive way. I have announced the GHC instance on the ghc-dev mailing list⁴, so why do I write here as well? Because you can use gipeda for your own projects! And because you can contribute! The program is not GHC-specific, so if you have a way to produce benchmark numbers (or any other kind of metric) for your project, you can feed them to gipeda to be visualized. See the README at https://github.com/nomeata/gipeda for instructions (and ask me if you are stuck). If it makes sense we can host the result at http://perf.haskell.org/ (but you still need to run the benchmarks yourself). And although it is quite nice so far, there are a lot of things it should also be able to do. Here are a few ideas: * Integrate data from multiple build hosts. * Compare the results from arbitrary two commits. * Visualize non-linear git histories, e.g. due to branches. * Know about named branches and tags. * RSS feeds and email notifications. * Find a way to efficiently run gipeda on travis. * General UI polishing. Some of that is possible without touching any JavaScript, some without touching any Haskell, so if you want to contribute, I’m sure you’ll find something. I plan to work on that during ZuriHac⁵ (only two more weeks), so if you are there and looking for a project, please join me! Greetings, Joachim ¹ http://ghcspeed-nomeata.rhcloud.com/ ² https://github.com/tobami/codespeed ³ http://shakebuild.com/ ⁴ https://mail.haskell.org/pipermail/ghc-devs/2015-May/009032.html ⁵ https://wiki.haskell.org/ZuriHac2015 PS: Thanks to davean from the haskell.org admin team for setting up perf.haskell.org. -- Joachim “nomeata” Breitner mail(a)joachim-breitner.de • http://www.joachim-breitner.de/ Jabber: nomeata(a)joachim-breitner.de • GPG-Key: 0xF0FBF51F Debian Developer: nomeata(a)debian.org

1 0

Re: [Haskell-cafe] Static executables in minimal Docker containers
by Greg Weber 17 May '15

17 May '15

Haskell is not that great at producing statically linked libraries independent of the OS. The issue you are running into would likely show up in another non-ubuntu image (or even possibly a different version of an ubuntu image), so you could probably use a Fedora image that has tracing. How are you addressing the linker warning about needing a particular glibc version at runtime? On Mon, Apr 13, 2015 at 3:28 AM, Sharif Olorin <sharif.olorin(a)gmail.com> wrote: > Unfortunately, strace and ltrace aren't available in that Docker image, >> but it's a good idea to see if I can get them running there somehow. >> > > Failing that, you might be able to get useful information of the same kind > by running docker (the server, not the `docker run` command) under perf[0] > and then running your busybox container. It should at least give you an > idea of what it's doing when it explodes. > > Sharif > > [0]: https://perf.wiki.kernel.org/index.php/Tutorial > > -- > You received this message because you are subscribed to the Google Groups > "Commercial Haskell" group. > To unsubscribe from this group and stop receiving emails from it, send an > email to commercialhaskell%2Bunsubscribe(a)googlegroups.com. > To post to this group, send email to commercialhaskell(a)googlegroups.com. > To view this discussion on the web visit > https://groups.google.com/d/msgid/commercialhaskell/86ca2603-37f2-4645-9cd2… > <https://groups.google.com/d/msgid/commercialhaskell/86ca2603-37f2-4645-9cd2…> > . > > For more options, visit https://groups.google.com/d/optout. >

10 15

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 141, Issue 25
by Michael Baikov 17 May '15

17 May '15

> > Suppose the following data type for encoding Boolean expressions: > > data BExpr a = BTrue > | BFalse > | Id String > | Not a > | And a a > | Or a a > | BEq a a > deriving (Functor) > type Expr = Fix BExpr > > It is easy to produce a string representation of an expression or evaluate > it: > > estr :: BExpr String -> String > eval :: BExpr Bool -> Bool > > with the cata function from Data.Functor.Fixedpoint. > > Could you suggest a solution for transforming trees encoded as Exp into > equivalent Expr (e.g Not Not a ~> a)? > cata does not work since it expects a function f a -> a while a > transformation would be f a -> f a. Actually cata works just fine, all you need following transformation which is f a -> a alg :: BExpr Expr -> Expr alg (Not (Fix (Not a))) = a alg x = Fix x

1 0

[ANN] relational-record - relational-algebraic query building DSL
by Kei Hibino 16 May '15

16 May '15

Hello everybody, I am happy to announce relational-record library and its project page. relational-record is domain specific language for type-safe SQL query building, and database access API with compile time schema generators. Code is avaiable on github and hackage. https://github.com/khibino/haskell-relational-record/ http://hackage.haskell.org/package/relational-record/ Tutorial, examples and documentations are available from project page links. http://khibino.github.io/haskell-relational-record/ Supported features are below, * Type safe query building. * Composable query. * Outer join. * Aggregation. * Compile time compile code generation along with RDBMS schema. * Schema support of ProsgreSQL, SQLite3, MySQL, IBM DB2, MicroSoft SQL Server, and Oracle. Any comments, any questions about this library are welcome. -- Kei Hibino ex8k.hibino at gmail.com https://github.com/khibino/

6 12

Call for concurrency bugs!
by Michael Walker 16 May '15

16 May '15

Hi cafe, I've been working on a little library for testing concurrent Haskell programs, and would really like some test cases not constructed by myself to throw it at. If anyone has any examples of buggy concurrency (preferably where it's tricky to provoke the bugs with conventional testing techniques) that I could use: either open bugs, or things which have been fixed but were awkward to do so, that would be really useful. This is leading up to a paper, hopefully, so examples may go into that: anonymously, if preferred. Thank you. -- Michael Walker (http://www.barrucadu.co.uk)

2 1

Deriving Show instance with ADT that has phantom type
by Cody Goodman 16 May '15

16 May '15

Going through the Data Types Ala Carte paper I found this definition: data Expr f = In (f (Expr f)) I tried to use "deriving Show"... data Expr f = In (f (Expr f)) deriving Show I found out that doesn't work with ADT's that have phantom types. I tried StandaloneDeriving too since GHC recommended it: {-# LANGUAGE StandaloneDeriving #-} data Expr f = In (f (Expr f)) deriving Show instance deriving Show (Expr f) Got this error: src/Main.hs:32:1-31: No instance for (Show (f (Expr f))) … arising from a use of ‘showsPrec’ In the second argument of ‘(.)’, namely ‘(showsPrec 11 b1)’ In the second argument of ‘showParen’, namely ‘((.) (showString "In ") (showsPrec 11 b1))’ In the expression: showParen ((a >= 11)) ((.) (showString "In ") (showsPrec 11 b1)) When typechecking the code for ‘showsPrec’ in a standalone derived instance for ‘Show (Expr f)’: To see the code I am typechecking, use -ddump-deriv Compilation failed. Here is the derived instance output from ghc -ddump-simple: Derived instances: instance GHC.Show.Show (Main.Expr f_aq1) where GHC.Show.showsPrec a_azP (Main.In b1_azQ) = GHC.Show.showParen ((a_azP GHC.Classes.>= 11)) ((GHC.Base..) (GHC.Show.showString "In ") (GHC.Show.showsPrec 11 b1_azQ)) GHC.Show.showList = GHC.Show.showList__ (GHC.Show.showsPrec 0) Didn't work. Can this be derived? Will I need to manually make instances?

1 0

cast to specific Typeclass
by Teodor Vlasov 16 May '15

16 May '15

Hello everyone, I'm trying to implement traversal over data structures and found Data.Typeable very useful for that. But it seems to be impossible to cast to specific typeclass, so that we can cast Typeable to something that is Show'able for example. It'd be usefull to have something like: data CanShow = forall a. CanShow a toConcrete :: (Typeable a) => a -> Maybe CanShow Implementing such datatypes for needed classes would allow to do some kind of class casting. Is it possible to implement this somehow? Is it a limitation of the implementation or a principal one? Thanks! Regards, Teodor.

2 1

Transforming ASTs
by anakreon 16 May '15

16 May '15

This might be a duplicated message. The first time I posted it I had not subscribed to haskell cafe. Suppose the following data type for encoding Boolean expressions: data BExpr a = BTrue | BFalse | Id String | Not a | And a a | Or a a | BEq a a deriving (Functor) type Expr = Fix BExpr It is easy to produce a string representation of an expression or evaluate it: estr :: BExpr String -> String eval :: BExpr Bool -> Bool with the cata function from Data.Functor.Fixedpoint. Could you suggest a solution for transforming trees encoded as Exp into equivalent Expr (e.g Not Not a ~> a)? cata does not work since it expects a function f a -> a while a transformation would be f a -> f a.

2 1

Can I specify the a in a phantom type to be limited to a sum type?
by Cody Goodman 16 May '15

16 May '15

How can I create Answers of type Gender, Race, or Age? These should be possible: λ> Answer Male λ> Answer White λ> Answer Black λ> Answer 28 Others such as using a string should not be possible: λ> Answer "a string" -- should throw type error {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE StandaloneDeriving #-} module Tutorial where data Gender = Male | Female deriving (Show) data Race = White | Black deriving (Show) type Age = Int data Answer a where Answer :: Gender -> Answer Gender deriving instance Show (Answer w) -- λ> -- This is pretty useful and accepts Answers with the Gender -- λ> Answer Male -- Answer Male -- λ> :t Answer Male -- Answer Male :: Answer Gender -- λ> -- how do I also accept Race and Age? -- below I try to sort out how to use type families (unsuccessfully) before bed -- type family Answer :: * -- type instance Answer Gender = Answer Gender

4 4

Fwd: Transforming ASTs
by Sergey Vinokurov 16 May '15

16 May '15

Hi anakreon, You should look at paramorphism and histomorphism recursion schemes. Paramorphism has type f (a, Fix f) -> a, and thus allows you to pattern match on the subtree that produced the result. But it's not enough to write simplification of (Not (Not x)) -> x because it'll have to access simplification result that is more than one level deep. But this recursion scheme would be helpful for simpler transformations like (And True x) -> x. As for original optimization of double negation I'd suggest to use histomorphism where you'll have access to all the expression subtrees annotated with intermediate results. E.g. {-# LANGUAGE DeriveFunctor #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE UndecidableInstances #-} data Cofree f a = a :< f (Cofree f a) deriving (Functor) strip :: (Functor f) => Cofree f a -> Fix f strip (_ :< x) = Fix $ fmap strip x newtype Fix f = Fix (f (Fix f)) deriving instance (Show (f (Fix f))) => Show (Fix f) unFix :: Fix f -> f (Fix f) unFix (Fix x) = x histo :: (Functor f) => (f (Cofree f a) -> a) -> Fix f -> a histo alg x = case histo' alg x of y :< _ -> y histo' :: (Functor f) => (f (Cofree f a) -> a) -> Fix f -> Cofree f a histo' alg = (\x -> alg x :< x) . fmap (histo' alg) . unFix simplify :: Fix BExpr -> Fix BExpr simplify = histo alg where alg :: BExpr (Cofree BExpr Expr) -> Expr alg (Not (_ :< (Not (x :< _)))) = x alg x = Fix $ fmap strip x main :: IO () main = do print $ simplify $ Fix (Not (Fix (Not (Fix (Not (Fix (And (Fix BTrue) (Fix BFalse)))))))) For more detailed exposition I'd suggest to look into https://github.com/willtim/recursion-schemes/raw/master/slides-final.pdf Sergey. On Fri, May 15, 2015 at 7:08 PM, anakreon <anakreonmejdi(a)gmail.com> wrote: > This might be a duplicated message. The first time I posted it I had not > subscribed to haskell cafe. > > Suppose the following data type for encoding Boolean expressions: > > data BExpr a = BTrue > | BFalse > | Id String > | Not a > | And a a > | Or a a > | BEq a a > deriving (Functor) > type Expr = Fix BExpr > > It is easy to produce a string representation of an expression or evaluate > it: > > estr :: BExpr String -> String > eval :: BExpr Bool -> Bool > > with the cata function from Data.Functor.Fixedpoint. > > Could you suggest a solution for transforming trees encoded as Exp into > equivalent Expr (e.g Not Not a ~> a)? > cata does not work since it expects a function f a -> a while a > transformation would be f a -> f a. > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >

2 1