- Haskell-Cafe - Haskell.org

ANN: pooled-io
by Henning Thielemann 17 Jan '14

17 Jan '14

I uploaded the package pooled-io to Hackage: https://hackage.haskell.org/package/pooled-io It is intended to perform parallelism in the IO monad. I needed it for computations that must write intermediate data to disk. The main task of the package is to make sure that no more than a maximum number of actions is run in parallel. There are three modules: For actions without monadic results, for actions with monadic results and for actions that depend on each others results.

3 2

Re: [Haskell-cafe] Restrict values in type
by Simon Yarde 17 Jan '14

17 Jan '14

If it's not been mentioned, this tutorial regarding Type Families and the kinds of restrictions you mention might provide a few pointers: https://www.fpcomplete.com/school/to-infinity-and-beyond/pick-of-the-week/t… In general, I've found key concepts to hold in mind are 'exclusion of bad programs' mentioned in the paper Fun With Types: http://research.microsoft.com/en-us/um/people/simonpj/papers/assoc-types/fu… I'm sorry if any of this has been mentioned previous. I asked a related question yesterday about the relative merits of creating type restrictions using using newtypes (unions), which I agree seem unwieldy, and using multi-parameter-type-classes (and/or type families) to enable exclusion-of-bad-programms via instances. I'd be interested to follow along and see what you discover. Simon Yarde

1 0

Re: [Haskell-cafe] Restrict values in type
by oleg＠okmij.org 17 Jan '14

17 Jan '14

The problem you have posed calls for so-called open unions. Open unions come up all the time, and lots of solutions exists. Alas, they are all a bit ad hoc. At Haskell Symposium I was advocating designing a good solution once and for all. The paper that introduced monad transformers showed one implementation of open unions (of effects). The paper `data types a la carte' showed another (essentially the same, trying to deemphasize its use of overlapping instances). The Extensible effects paper has two more solutions, one with Typeable and one without. You can use OpenUnions from that paper if you install extensible-effects package. Using singletons is yet another, quite heavy-weight solution. I'd like to stress a much simpler solution, which requires no type equality or GADTs or bleeding edge. It is a tagless-final solution. In fact, it has been demonstrated already by Jake McArthur. I elaborate and show the whole code. Your original code defined PenShape as a data structure > data PenShape = Circle Float > | Rectangle Float Float > | ArbitraryPen -- Stuff (not relevant) I will define it as an expression in a very simple domain-specific language of pen shapes. > class CirclePen repr where > circle :: Float -> repr > -- other ways of constructing circles go here > > class RectPen repr where > rectangle :: Float -> Float -> repr > > class ArbitraryPen repr where > arbitrary :: () -> repr -- () stands for irrelevant stuff Here repr is the meaning of a pan shape in a particular interpretation. The same term can be interpreted in many ways (compare: a Haskell code can be loaded into GHCi, compiled with GHC or processed with Haddoc). One interpretation of pen shapes is to print them out nicely: data S = S{unS :: String} instance CirclePen S where circle x = S $ "circle pen of radius " ++ show x instance RectPen S where rectangle x y = S $ "rect pen " ++ show (x,y) instance ArbitraryPen S where arbitrary () = S $ "arbitrary pen" There probably will be other representations: defined only for specific sets of pens (rather than all of them), see below for an example. You ask how can you pattern-match on pen shapes. The answer is that in taggless-final style, you don't pattern-match. You interpret. Quite often the code becomes clearer. Enclosed is the complete code. For (far) more explanation of tagless-final, please see the first part of http://okmij.org/ftp/tagless-final/course/lecture.pdf {-# LANGUAGE RankNTypes #-} module Im where data Image = Image [Stroke] -- As a data structure {- data PenShape = Circle Float | Rectangle Float Float | ArbitraryPen -- Stuff (not relevant) -} -- As a term in a simple language of shapes class CirclePen repr where circle :: Float -> repr -- other ways of constructing circles go here class RectPen repr where rectangle :: Float -> Float -> repr class ArbitraryPen repr where arbitrary :: () -> repr -- () stands for irrelevant stuff -- Let's define a few interpretations of pens -- the Show interpretation, to print them -- All pens support this interpretation data S = S{unS :: String} instance CirclePen S where circle x = S $ "circle pen of radius " ++ show x instance RectPen S where rectangle x y = S $ "rect pen " ++ show (x,y) instance ArbitraryPen S where arbitrary () = S $ "arbitrary pen" -- Another interpretation: finite-dim pens. Only CirclePen and RectPen -- support it data FiniteDim = FiniteDim{unFD:: Float} instance CirclePen FiniteDim where circle x = FiniteDim x instance RectPen FiniteDim where rectangle x y = FiniteDim $ max x y {- data Stroke = Line Point Point PenShape | Arc Point Point Point PenShape | Spot Point PenShape -} type Point = (Float,Float) p0 = (0,0) p1 = (1,1) data Stroke = Line Point Point (forall repr. (CirclePen repr, RectPen repr) => repr) | Arc Point Point (forall repr. (CirclePen repr) => repr) | Spot Point (forall repr. (CirclePen repr, RectPen repr, ArbitraryPen repr) => repr) -- Let's make a an image im1 = Image [ Line p0 p1 (circle 10), Line p0 p1 (rectangle 1 2), -- The following will be a type error, as expected -- Arc p0 p1 (rectangle 1 2), Arc p0 p1 (circle 3), Spot p0 (rectangle 1 2), Spot p0 (arbitrary ()) ] -- If we add -- Line p0 p1 (arbitrary ()) -- we get a type error with an informative message {- Could not deduce (ArbitraryPen repr) arising from a use of `arbitrary' from the context (CirclePen repr, RectPen repr) bound by a type expected by the context: (CirclePen repr, RectPen repr) => repr -} -- Let's print the list of strokes show_strokes :: Image -> [String] show_strokes (Image l) = map f l where f (Line p1 p2 pensh) = unwords ["Line", show (p1,p2), unS pensh] f (Arc p1 p2 pensh) = unwords ["Arc", show (p1,p2), unS pensh] f (Spot p1 pensh) = unwords ["Spot", show p1, unS pensh] tshow = show_strokes im1 {- ["Line ((0.0,0.0),(1.0,1.0)) circle pen of radius 10.0", "Line ((0.0,0.0),(1.0,1.0)) rect pen (1.0,2.0)", "Arc ((0.0,0.0),(1.0,1.0)) circle pen of radius 3.0", "Spot (0.0,0.0) rect pen (1.0,2.0)","Spot (0.0,0.0) arbitrary pen"] -}

3 5

Can't install yesod-platform due to vector package
by Sukit Tretriluxana 16 Jan '14

16 Jan '14

Hi all, I'm trying to install Yesod as suggested by this page. http://www.yesodweb.com/page/quickstart with the following command cabal update cabal install yesod-platform yesod-bin --max-backjumps=-1 --reorder-goals But I constantly get the following error. ... 136 warnings and 6 errors generated. Failed to install vector-0.10.9.1 cabal: Error: some packages failed to install: aeson-0.6.2.1 depends on vector-0.10.9.1 which failed to install. ... The error appears to be from the fact that cabal cannot install vector package. Any suggestion to fix the problem. I'm on Maverick, Xcode5, Haskell Platform 2013.2.0.0 64bit Thanks, Ed

3 3

flip1 through flip9, useful?
by Christian Marie 16 Jan '14

16 Jan '14

I have defined a bunch of functions like this: -- | Move the fourth argument to the first place rotate4 :: (a -> b -> c -> d -> e) -> (d -> a -> b -> c -> e) -- | Reverse four arguments flip4 :: (a -> b -> c -> d -> e) -> (d -> c -> b -> a -> e) I decided to upload this as a library to hackage, as I personally find it useful, especially for writing FFI bindings. It seems like I can't be the first to write a library like this though, am I missing something obvious? Is this useful or stupid? Does it exist already? Full definition here: https://github.com/christian-marie/flippers/blob/master/src/Control/Flipper…

10 11

ANN: castle 0.1.0.0
by Eric Rochester 16 Jan '14

16 Jan '14

I'd like to announce the first release of castle ( http://hackage.haskell.org/package/castle and https://github.com/erochest/castle) From the README: > I really like having sandboxes baked into cabal-install<http://hackage.haskell.org/package/cabal-install>(see Cabal > Sandboxes <http://coldwa.st/e/blog/2013-08-20-Cabal-sandbox.html> for > more information). > > I got tired of waiting for big packages like Yesod<http://www.yesodweb.com/>and > Lens <http://hackage.haskell.org/package/lens> to compile in project > after project that used them. However, I still didn't want to install them > in the user database. I wanted to maintain *some* sandboxing among a > group of projects that all share a common set of packages, but I wanted to > be able to switch from them or upgrade them easily. > > That's the itch I was trying to scratch with castle. > > It allows you to share one Cabal sandbox between multiple projects. This > keeps the package versions for all of these projects in line. It also means > that you don't have to constantly be re-installing everything, but you > still get the ability to blow away a set of packages without borking your > whole system. > This tool is still pretty rough around the edges, but I've been using it some, and it's to the point that more feedback would be helpful. Let me know what bugs and rough patches you find. Thanks, Eric

4 9

mdo with multiple values
by Joachim Breitner 16 Jan '14

16 Jan '14

Dear List, a little puzzle. Given a monad M with a MonadFix instance, and these two functions: act1 :: T -> M () act2 :: a -> M T I morally want to write this function: foo :: [a] -> M () foo = mdo mapM_ act1 xs xs <- mapM act2 return () Unfortunately, that will not work: mapM_ will force xs before any of it can be generated. But morally it should be possible, as the lists passed to mapM_ and mapM have the same, already known list. So here is my solution (which is a bit more general, because I happen to need some that in one place): mapFstMapSnd :: MonadFix m => [(a -> m (), m a)] -> m () mapFstMapSnd xs = const () `liftM` go xs (return []) where go [] cont = cont go ((f,s):xs) cont = mdo f v (v:vs) <- go xs $ do vs <- cont v <- s return (v:vs) return vs Using that, I can write foo = mapFstSnd . map (x -> (act1, act2 x)) Are there better solutions? Simpler ones? Or possibly ones that do not require a partial pattern? Hmm, and thinking while writing lets me come up with data FunSplit m where FunSplit :: forall m a . (a -> m ()) -> m a -> FunSplit m mapFstMapSnd :: forall m. MonadFix m => [FunSplit m] -> m () mapFstMapSnd xs = const () `liftM` go xs (return ()) where go :: [FunSplit m] -> m b -> m b go [] cont = cont go (FunSplit f s:xs) cont = mdo f v (v,vs) <- go xs $ do vs <- cont v <- s return (v,vs) return vs foo :: [SPut] -> SPut foo = mapFstMapSnd . map go where go x = FunSplit act1 (act2 x) Any suggestions for improvement? Thanks, Joachim -- Joachim Breitner e-Mail: mail(a)joachim-breitner.de Homepage: http://www.joachim-breitner.de Jabber-ID: nomeata(a)joachim-breitner.de

3 4

Error management in Happstack
by Corentin Dupont 16 Jan '14

16 Jan '14

Hi Jeremy, all, In Happstack when I throw an error, I obtain a blank page with "server error: my message". How can I decorate this page? I'd like to have it look like the other pages of my website, and a "back to login" link, for example. Thanks! Corentin

2 2

Restrict values in type
by Luke Clifton 16 Jan '14

16 Jan '14

Hi, I'm quite new to Haskell, and have been loving exploring it. I've always been a huge fan of languages that let me catch errors at compile time, finding dynamic languages like Python a nightmare to work in. I'm finding with Haskell I can take this compile time checking even further than most static languages and it has gotten me rather excited. So I was wondering if there is a Haskell way of solving my problem. I'm trying to represent an image made up of a list of strokes. Strokes are either lines, arcs or spots, and can be made using different pen shapes. data Image = Image [Stroke] data Stroke = Line Point Point PenShape | Arc Point Point Point PenShape | Spot Point PenShape data PenShape = Circle Float | Rectangle Float Float | ArbitraryPen -- Stuff (not relevant) And this is all great and works. But now I have a problem. I want to extend this such that Arc strokes are only allowed to have the Circle pen shape, and Lines are only allowed to have the Rectangle or Circle pen shapes. What is the best way of enforcing this in the type system. I could make more Strokes like LineCircle, LineRectangle, Arc, PointCircle, PointRectangle, PointArbitrary and get rid of the PenShape type altogether. But this doesn't really feel good to me (and seems like the amount of work I have to do is bigger than it needs to be, especially if I added more basic pen shapes). I thought about making the different PenShapes different types, using typeclasses and making Stroke an algebraic data type, but then my strokes would be of different types, and I wouldn't be able to have a list of strokes. I have been looking at DataKinds and GADTs, but I can't quite figure out if they actually help me here at all. I'm sure there is a way to do this, I'm just not googling properly. What I want to write is... data Image = Image [Stroke] data Stroke = Line Point Point (Circle or Rectangle) | Arc Point Point Point Circle | Spot Point PenShape data PenShape = Circle Float | Rectangle Float Float | ArbitraryPen -- Stuff (not relevant) Regards, Luke

7 14

Postdocs / Research Programmer for Efficient First-Class Automatic Differentiation
by Barak A. Pearlmutter 15 Jan '14

15 Jan '14

Postdocs / Research Programmer for Compositional Learning via Generalized Automatic Differentiation The goal of this project is to make a qualitative improvement in our ability to write sophisticated numeric code, by giving numeric programmers access to _fast_, _robust_, _general_, _accurate_ differentiation operators. To be technical: we are adding exact first-class derivative calculation operators (Automatic Differentiation or AD) to the lambda calculus, and embodying the combination in a production-quality fast system suitable for numeric computing in general, and compositional machine learning methods in particular. Our research prototype compilers generate object code competitive with the fastest current systems, which are based on FORTRAN. And the combined expressive power of first-class AD operators and function programming allows very succinct code for many machine learning algorithms, as well as for some algorithms in computer vision and signal processing. Specific sub-projects include: compiler and numeric programming environment construction; writing, simplifying, and generalising, machine learning and other numeric algorithms; and associated Type Theory/Lambda Calculus/PLT/Real Computation issues. TO THE PROGRAMMING LANGUAGE COMMUNITY, we seek to contribute a way to make numeric software faster, more robust, and easier to write. TO THE MACHINE LEARNING COMMUNITY, in addition to making it easier to write efficient numeric codes, we seek to contribute a system that embodies "compositionality", in that gradient optimisation can be automatically and efficiently performed on systems themselves consisting of many components, even when such components may internally take derivatives or perform optimisation. (Examples of this include, say, optimisation of the rules of a multi-player game to cause the players' actions to satisfy some desiderata, where the players themselves optimise their own strategies using simple models of their opponents which they optimise according to their opponents' observed behaviour.) To this end, we are seeking to fill three positions (postdoctoral or research programmer, or in exceptional cases graduate students) with interest and experience in at least one of: programming language theory, automatic differentiation, machine learning, numerics, mathematical logic. Informal announcement: http://www.bcl.hamilton.ie/~barak/ad-fp-positions.html Formal job postings on http://humanresources.nuim.ie/vacancies.shtml, in particular http://humanresources.nuim.ie/documents/JobSpecPostdoc2_Final.pdf and http://humanresources.nuim.ie/documents/JobSpecProgrammer_Final.pdf Inquiries to: -- Barak A. Pearlmutter <barak(a)cs.nuim.ie> Hamilton Institute & Dept Computer Science NUI Maynooth, Co. Kildare, Ireland

1 0