January 2017 - Haskell-Cafe

Re: [Haskell-cafe] Question about STRef
by Johannes Waldmann 26 Jan '17

26 Jan '17

Thanks for pointing out this (Knuth's) nice test case. I should use this as an exam question ... Allocation and run-time can be reduced by replacing return (x3' + x4') with let x = (x3' + x4') in x `seq` return x And, modifySTRef' *does* help. I *do* notice a regression (for the seq-ed and primed version) ghc-8.0.2 : 2.6 GB alloc, 2.3 sec ghc-6.10.4: 2.0 GB alloc, 1.7 sec (measured on X5365 @ 3.00GHz ) Numbers are for total allocation, residency is small (it runs with +RTS -H10k -A10k but then the number of GCs goes up) - J.

2 2

Bug-free, leak-free, battle-tested library for broadcast channels?
by Saurabh Nanda 25 Jan '17

25 Jan '17

(cross-posted from Reddit because I'm not sure of the audience overlap between haskell-cafe & reddit) I want to broadcast some instrumentation data from deep within my Haskell app. This data will have listeners in some environments (say, debug), but not others (say, production). Which library should I be using? A little searching threw two possible candidates: * http://hackage.haskell.org/package/split-channel * https://hackage.haskell.org/package/broadcast-chan But, I'm not sure if these are battle-tested. Any help would be appreciated. -- Saurabh.

6 12

Early feedback on a GHC proposal
by Chris Smith 25 Jan '17

25 Jan '17

Anyone want to offer some early feedback on a GHC proposal I'm working on? It's called OverloadedApplication. Current version at https://github.com/cdsmith/ghc-proposals/blob/overloadedapplication/proposa… I am proposing something a bit more ambitious than what I need, because the proposal as written seems more likely to be broadly useful. The bit that I actually need is about desugaring of infix operators in the presence of RebindableSyntax. I'd love to get early thoughts from anyone who has a solid use case for the rest of the proposal. It feels like a thing that *ought* to be useful, but I'm drawing blanks at the moment.

4 3

Re: [Haskell-cafe] A proof that the list monad is not a free monad
by David Feuer 25 Jan '17

25 Jan '17

The ConstraintKinds extension just lets you deal with kinds involving constraints. Turn it on, import the Constraint kind from somewhere (I know it's exported from GHC.Exts and also from Data.Constraint in the constraints package; I don't know if it has a nice home in base). Then you can write things like class C f a where p :: f a => proxy f -> a -> Int etc. On Jan 23, 2017 4:19 PM, "Olaf Klinke" <olf(a)aatal-apotheke.de> wrote: On a mostly unrelated note, Dan Doel elaborated [1] that the list monad is not the monad of free monoids either, even though mathematically the free monoid over x is the set of words of finite length with alphabet x. Briefly, the reason is that Haskell types are domains, not sets. Below is a proof that the free monad is not the free algebra. One approximant to free algebraic structures is to look at the free F-algebra for a functor F. This approach does not take into account any equations between the algebraic operations. {-# LANGUAGE Rank2Types,MultiParamTypeClasses,FlexibleInstances,FlexibleContexts #-} module FreeFAlg where import Control.Applicative import Control.Monad -- F-algebras (sans laws). class Functor f => Alg f a where alg :: f a -> a -- The free F-algebra over x, following Dan Doel's ideas, -- with the universal property baked in. newtype FreeAlg f x = FreeAlg (forall a. Alg f a => (x -> a) -> a) runFree :: Alg f a => FreeAlg f x -> (x -> a) -> a runFree (FreeAlg f) = f universal :: Alg f a => (x -> a) -> FreeAlg f x -> a universal = flip runFree instance Functor f => Alg f (FreeAlg f x) where alg ff = FreeAlg (\f -> alg (fmap (($f).runFree) ff)) instance Functor (FreeAlg f) where fmap h (FreeAlg fx) = FreeAlg (\f -> fx (f.h)) instance Monad (FreeAlg f) where return x = FreeAlg ($x) (FreeAlg fx) >>= k = FreeAlg (\f -> fx (\x -> runFree (k x) f)) instance Applicative (FreeAlg f) where pure = return (<*>) = ap data FreeMonad f x = Pure x | Roll (f (FreeMonad f x)) instance Functor f => Alg f (FreeMonad f x) where alg = Roll -- This looks like the same universal property... universal' :: Alg f a => (x -> a) -> FreeMonad f x -> a universal' f (Pure x) = f x universal' f (Roll ffree) = alg (fmap (universal' f) ffree) freeAlg2freeMonad :: Functor f => FreeAlg f x -> FreeMonad f x freeAlg2freeMonad = universal Pure freeMonad2freeAlg :: Functor f => FreeMonad f x -> FreeAlg f x freeMonad2freeAlg = universal' return The free monad is not the free F-algebra, because uniqueness fails. Consider the constant functor data Point a = Point instance Functor Point where fmap f Point = Point -- universal' f (Pure x) = f x -- universal' f (Roll Point) = alg Point -- but we have another function with the same type as universal': notUnique :: Alg Point a => (x -> a) -> FreeMonad Point x -> a notUnique f = const (alg Point) For classes like Monoid, which have equations between the algebraic operations (such as mappend mempty = id), we'd need the language extension that allows constraints as type parameters. I'd like to write Free Monoid x = Free (forall a. Monid a => (x -> a) -> a) but I am not experienced with the ConstraintKinds extension. Anyone help? Olaf [1] http://comonad.com/reader/2015/free-monoids-in-haskell/ _______________________________________________ Haskell-Cafe mailing list To (un)subscribe, modify options or view archives go to: http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe Only members subscribed via the mailman list are allowed to post.

1 0

GHC 8.0.2 Stackage LTS8 plan
by Luke Murphy 25 Jan '17

25 Jan '17

Hi folks, Please see the following brief write up regarding what the Stackage curator team have planned for a smooth transition to GHC 8.0.2 on LTS builds. http://lwm.github.io/stackage-8.0.2/ Best, Luke

1 0

Re: [Haskell-cafe] Datomic-like db for Haskell?
by Ovidiu Deac 24 Jan '17

24 Jan '17

I'll do some research to evaluate my options. So far I have: Homegrown implementation on top of some DB (Riak/Postgres/Mongo...) https://github.com/agentm/project-m36 https://hackage.haskell.org/package/filestore Thanks for the answers! On Fri, Dec 23, 2016 at 8:07 PM, Ertugrul Söylemez <esz(a)posteo.de> wrote: > >> * Another option is to run an insertion-only relational model on > >> really any database system you want like PostgreSQL. There is > >> nothing about preserving history that needs special handling to be > >> efficient. > > > > I assume that some sort of structural sharing is needed once the > > collections grow above a certain size. Also some support for caching > > would be nice. > > Yeah, sharing could improve disk usage and cache utilisation. I'm not > aware of any DBMS-side sharing features in systems I have used > (PostgreSQL and SQLite mainly). The usual way to get sharing in > relational systems is to normalise the schema. That also allows you to > use domain-specific knowledge to get even better sharing. > > Caching is of course supported, at least by PostgreSQL. It aims to keep > as much of the database in memory as possible (or as you tell it to). >

2 1

PLDI workshop and proposal deadline - Jan 30
by Tobias Grosser 24 Jan '17

24 Jan '17

Reminder! The final deadline for PLDI W&T proposals is coming up on January 30. Please see the PLDI website for more information. http://conf.researchr.org/track/pldi-2017/pldi-2017-workshops-and-tutorials. Tobias Grosser PLDI Publicity Chair

1 0

is it normal for docs to be pending for 24 hours?
by Patrick Pelletier 24 Jan '17

24 Jan '17

This is only my second time uploading a package to Hackage, so I don't yet have a feel for how it's supposed to go. I uploaded normalization-insensitive-2.0.0.1 about 24 hours ago: https://hackage.haskell.org/package/normalization-insensitive-2.0.0.1 Under "Status", it says "Docs pending". (And the module names are all non-clickable.) Is it normal to take this long to build the docs? Is there some way to find out where in the queue my job is? Is this an indication that something has gone wrong? How do I fix it? Thanks, --Patrick

12 35

[ANN] FastPush 0.1.0.0
by William Yager 24 Jan '17

24 Jan '17

In response to a bit of an obscure use case I had, I created this very simple library which gives you a Monad with a single operation, `push :: a -> m ()`. This operation pushes an item onto a stack (represented under the hood by a mutable ST vector). When you run the monad, you get the stack out as a vector. The library is quite fast. It's about 2x faster than C++'s std::vec::push_back compiled without optimizations, and about 40% as fast as std::vec::push_back when compiled with G++ -O2. There's almost certainly some low-hanging optimization fruit for anyone skilled at Haskell optimizing. The library is parametric over choice of mutable vector. You can use Unboxed, Storable, or normal vectors. I've even included a Push Monad Transformer based on Control.Monad.ST.Trans, but that's almost certainly unsafe, per the caveats listed in the Control.Monad.ST.Trans docs. https://hackage.haskell.org/package/FastPush-0.1.0.0 https://github.com/wyager/FastPush/ Cheers, Will

2 3

[ANN] wiringPi-1.0
by Patrick Pelletier 23 Jan '17

23 Jan '17

https://hackage.haskell.org/package/wiringPi-1.0 https://github.com/ppelleti/hs-wiringPi I released wiringPi-0.1.0.0 less than two weeks ago, but already I have a new major version, with a breaking change. wiringPi-0.1.0.0 kept close to the C wiringPi library, which required calling a setup function. There were four different setup functions, and the choice of setup function determined the pin numbering scheme, which would affect all subsequent functions which used pin numbers. This sort of far-reaching global state felt very un-Haskell-like, and antithetical to modularity. So, in wiringPi-1.0, the setup function is called automatically the first time a wiringPi function is used. The wiringPi binding always configures the underlying C library to use the "Broadcom GPIO" pin numbering scheme. However, the Pin type now has three different constructors, to allow a pin to use any of the three pin-numbering schemes. These pin numbers are automatically converted to the "Broadcom GPIO" scheme internally. So now you can use any pin numbering scheme on a case-by-case basis, without having to make a global choice. About wiringPi: This is a Haskell binding to the wiringPi library, which allows you to interface with the GPIO pins on the Raspberry Pi. Unlike some other solutions for using the Raspberry Pi's GPIO pins, wiringPi provides access to more advanced features, such as enabling the internal pull-up or pull-down resistors. --Patrick

1 0