September 2012 - Haskell-Cafe

One of the new buzz phrases is "Event-Sourcing"; is Haskell suitable for this?
by KC 30 Sep '12

30 Sep '12

http://martinfowler.com/eaaDev/EventSourcing.html http://martinfowler.com/articles/lmax.html -- -- Regards, KC

6 6

Re: [Haskell-cafe] Call for discussion: OverloadedLists extension
by George Giorgidze 29 Sep '12

29 Sep '12

Hi Michael, Here at the University of Tübingen, I am co-supervising (together with Jeroen Weijers) a student project implementing the OverloadedLists extension for GHC. Achim Krause is the student who is working on the project. We took into consideration earlier discussions on this topic [1,2] before embarking on the project. Achim has worked on two approaches. The first approach is very simple, both from the user's and the extension implementor's perspective (it follows the implementation of OverloadedStrings closely) and typechecks and desugars lists like [] ; [x,y,z] ; ['a' .. 'z'] ; as fromList [] ; fromList [x,y,z] ; fromList ['a' .. 'z'] ; where fromList is whatever is in scope with that name. That said, we do provide the FromList type class that can be used to overload fromList. In the following I give the definition of the class, as well as, example instances: class FromList l where type Item l fromList :: [Item l] -> l instance FromList [a] where type Item [a] = a fromList = id instance (Ord a) => FromList (Set a) where type Item (Set a) = a fromList = Set.fromList instance (Ord k) => FromList (Map k v) where type Item (Map k v) = (k,v) fromList = Map.fromList instance FromList (IntMap v) where type Item (IntMap v) = (Int,v) fromList = IntMap.fromList instance FromList Text where type Item Text = Char fromList = Text.pack This approach has already been implemented by Achim as patch against GHC head. This approach is very simple, but can be inefficient as it may result into unnecessary construction of lists at runtime. This can be a serious issue when constructing large structures from arithmetic sequences (e.g., from the [ .. ] notation) or when using non-literal expressions (e.g., variables) inside the square brackets. Our second approach to OverloadedLists is to avoid the construction of lists altogether. By typechecking and desugaring lists like [] ; [x,y,z] ; ['a' .. 'z'] ; as mempty ; singleton x `mappend` singleton y `mappend` singleton z ; genericEnumFromTo 'a' 'z' ; We provide the Singleton and GenericEnum type classes for overloading singleton and genericEnum(..) functions. In the following, I give the definitions of the classes, as well as, example instances: -- Singleton class class Singleton l where type SingletonItem l singleton :: SingletonItem l -> l -- Singleton instances instance Singleton [a] where type SingletonItem [a] = a singleton a = [a] instance (Ord a) => Singleton (Set a) where type SingletonItem (Set a) = a singleton = Set.singleton instance (Ord k) => Singleton (Map k v) where type SingletonItem (Map k v) = (k,v) singleton (k,v) = Map.singleton k v instance Singleton (IntMap v) where type SingletonItem (IntMap v) = (Int,v) singleton (k,v) = IntMap.singleton k v instance Singleton Text where type SingletonItem Text = Char singleton = Text.singleton -- GenericEnum class class GenericEnum l where type EnumItem l genericEnumFrom :: EnumItem l -> l genericEnumFromThen :: EnumItem l -> EnumItem l -> l genericEnumFromTo :: EnumItem l -> EnumItem l -> l genericEnumFromThenTo :: EnumItem l -> EnumItem l -> EnumItem l -> l -- GenericEnum instances instance (Enum a) => GenericEnum [a] where type EnumItem [a] = a genericEnumFrom = enumFrom genericEnumFromThen = enumFromThen genericEnumFromTo = enumFromTo genericEnumFromThenTo = enumFromThenTo instance (Ord a,Enum a) => GenericEnum (Set a) where type EnumItem (Set a) = a genericEnumFrom a = Set.fromList (enumFrom a) genericEnumFromThen a b = Set.fromList (enumFromThen a b) genericEnumFromTo a b = Set.fromList (enumFromTo a b) genericEnumFromThenTo a b c = Set.fromList (enumFromThenTo a b c) instance (Ord k,Enum (k,v)) => GenericEnum (Map k v) where type EnumItem (Map k v) = (k,v) genericEnumFrom a = Map.fromList (enumFrom a) genericEnumFromThen a b = Map.fromList (enumFromThen a b) genericEnumFromTo a b = Map.fromList (enumFromTo a b) genericEnumFromThenTo a b c = Map.fromList (enumFromThenTo a b c) instance (Enum (Int,v)) => GenericEnum (IntMap v) where type EnumItem (IntMap v) = (Int,v) genericEnumFrom a = IntMap.fromList (enumFrom a) genericEnumFromThen a b = IntMap.fromList (enumFromThen a b) genericEnumFromTo a b = IntMap.fromList (enumFromTo a b) genericEnumFromThenTo a b c = IntMap.fromList (enumFromThenTo a b c) instance GenericEnum Text where type EnumItem Text = Char genericEnumFrom a = Text.pack (enumFrom a) genericEnumFromThen a b = Text.pack (enumFromThen a b) genericEnumFromTo a b = Text.pack (enumFromTo a b) genericEnumFromThenTo a b c = Text.pack (enumFromThenTo a b c) Note that the GenericEnum instances can be implemented more efficiently, but for now I give simple definitions that go through lists. Our second approach avoids the construction of intermediate lists at runtime and directly constructs the target data structure for which the list notation is used. We will release GHC patches for both approaches, meanwhile the feedback from the community on the approaches that we took would be very much appreciated. Which one those would you prefer? or would you suggest a different one. Note that we intend to make fromList in the first approach and singleton, genericEnum(..), mempty and mapped rebindable. This means that the definitions of the type classes that overload this functions can be easily changed. Having said that, altering the changes that Achim already made to the GHC source code (including typechecking and desugaring rules) will be more work and we hope that one of the approaches that we took will be acceptable for the community. Cheers, George [1] http://www.mail-archive.com/glasgow-haskell-users@haskell.org/msg20447.html [2] http://www.mail-archive.com/glasgow-haskell-users@haskell.org/msg20518.html

7 8

If I want to make a pure Haskell eigenvalue, etc. package without calling to LAPACK, etc ...
by KC 29 Sep '12

29 Sep '12

What are some good basis (pun intended) to start from? e.g. REPA? or ....? -- -- Regards, KC

1 0

ANNOUNCE: bindings-gobject-0.4
by Yuras Shumovich 29 Sep '12

29 Sep '12

Hello, I uploaded new release of bindings-gobject, low level binding to gobject library: http://hackage.haskell.org/package/bindings-gobject-0.4 (I maintain it now) Now it exposes internals of GObject and GObjectClass, so it is possible to create custom GObject subclasses from haskell land. Source repository contains basic example: https://github.com/Yuras/bindings-gobject/blob/master/examples/custom-objec… The use case I'm personally is interested in is implementing custom SourceCompletionProvider for gtksourceview2. I hope it will be useful for other applications. Right now we don't (afaik) have low level bindings to gtk and gtksourceview. But once we will have them, it will be possible to create custom controls in haskell and even expose them to C (C++, python, etc) land. Thanks, Yuras

1 0

Class constraints with "free" type variables and fundeps
by Francesco Mazzoli 29 Sep '12

29 Sep '12

I would expect this to work, maybe with some additional notation (a la ScopedTypeVariables) {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE MultiParamTypeClasses #-} class Foo a b | a -> b class Foo a b => Bar a where foo :: a -> b -> c The type family equivalent works as expected: {-# LANGUAGE TypeFamilies #-} class Foo a where type T a :: * class Bar a where foo :: a -> T a -> c I can't use type families because the `Foo' I'm using is in an external library. Is there any way to achieve what I want without adding `b' to `Bar'? -- Francesco * Often in error, never in doubt

3 5

Discovery of unnecessary build-depends
by Jason Whittle 29 Sep '12

29 Sep '12

Is there a tool available that will tell me if the cabal file for my library or application has any unnecessary build-depends? I have a habit of developing new modules within an application and then moving them out to separate libraries. For instance, I might move module Foo out of my application and into a new or existing library package. If Foo was the only module in my application to explicitly import any modules from the Bar package, I would like to know that I can now remove the dependency on Bar from my application's build-depends in the cabal file. My strategy right now would be to search my whole application for other imports of any of the modules from the Bar package, or just remove Bar from build-depends and check if the application still compiles. Neither solution is particularly scalable or satisfying. Cheers, Jason Whittle

2 1

Re: [Haskell-cafe] Class constraints with "free" type variables and fundeps
by Francesco Mazzoli 29 Sep '12

29 Sep '12

CCing the list back. At Fri, 28 Sep 2012 13:30:52 -0700, Alexander Solla wrote: > What is the problem, exactly? It looks to me like UndecidableInstances and > ScopedTypeVariables (on foo, or its arguments) would be enough. I'm not sure what you mean. I don't see the need for UndecidableInstances, and there is no way I can see to bring the `b' into scope in the type sig for foo, ScopedTypeVariables or not - unless I'm missing something. > Also note that as stated, foo's type "is a bottom" (more specifically, is a > function onto bottom, since c is free in the class, and so foo must be > parametrically polymorphic in its return type, and so is devoid of "real" > Haskell values). Hopefully that is just an artefact of the translation to > Foo's and Bar's. Yeah the type for `foo' is irrelevant, I just needed to put something there. -- Francesco * Often in error, never in doubt

2 6

ticketimer - haskell project on Gruender-Garage contest!
by Anton Kholomiov 28 Sep '12

28 Sep '12

I'd like to announce ticketimer.com -- it's a website that is not done yet. With ticketimer you can choose films for your local cinema. People can buy tickets in advance and promote the films they like. Do we need to eat this blockbuster stuff all the time? See how to vote for a change on http://www.indiegogo.com/ticketimer?a=1301421 We are going to use Yesod as a main weapon. Anton

1 0

GHC 6.13 and GHC 7.6 in parallel on Linux
by spacestation＠venussociety.org 28 Sep '12

28 Sep '12

Hello to everyone, First of all sorry if my question posted to this list is maybe OFF TOPIC. Myself is using Haskell from time to time on WIN XP and OpenSuse system. So far without a problem using RWH book as reference and 6.12 version with a lot of modules installed via cabal. Also a Hugs install from source on my OpenSuse system only caused minor problems.setting a symlink solved the minor problem. But what surprised me totally was that Hugs/Cabal and (or ) GHC are using shared libraries and Hugs install interfered with cabal/ghc. I thought that both systems are totally independent from each other.Hugs a Haskell code interpreter GHV a Haskell code compiler. But now my question : How is it possible to run 2 different versions of GHC on the same computer ( OS , in my case OpenSuse 6.1x and hopefully 7.6 ) Any search for "running GHC versions in parallel only returned results for the DPH extensions wiki but not how to run two GHC versions on the same OS. http://www.haskell.org/haskellwiki/GHC/Data_Parallel_Haskell http://www.haskell.org/haskellwiki/Parallel So any feedback welcome Rgds Gottfried

4 4

An easy way to represent and modify graphs?
by Takayuki Muranushi 28 Sep '12

28 Sep '12

tl;dr: I would like to apply genetic algorithm to directed acyclic graphs that represents arithmetic operations. Thank you for hosts, speakers and all participants in ICFP2012. I had chance to make a lot of questions (c.f. [prize.jpg]) and receive lots of stimulating ideas. I have been working on automated parallel code generation and automated tuning for hydrodynamics http://iopscience.iop.org/1749-4699/5/1/015003 ; one of my next target is model acquisition in robotics: http://creativemachines.cornell.edu/sites/default/files/moriguchi11.pdf ; both deal with computations represented in forms of directed acyclic graphs c.f. [graph-1.png] [graph-2.png]. We would like to describe them easily in Haskell, but also to mutate (add random changes) and crossover (create a new graph by mixing other two graphs.) In my previous work, I used Monad to generate graphs and used the Functional Graph Library to explicitly modify the graphs. Now I have learned that there are more elegant methods to describe the computations with sharing. But are those method also enables easy editing of the graphs? That's my question. In [data-reify.hs] I tried Observed Sharing by Gill09. Apparently, sharing is lost once we try to modify the graph. $ runhaskell data-reify.hs let [(1,GraphMul 2 2),(2,GraphAdd 3 3),(3,GraphMul 4 5),(5,GraphVar "X"),(4,GraphVal 40)] in 1 let [(1,GraphMul 2 9),(9,GraphAdd 10 13),(13,GraphMul 14 15),(15,GraphVar "X"),...,(5,GraphVar "X"),(4,GraphVal 42)] in 1 In [GenericMain.hs] I tried PHOAS by Oliveria & Cook 2012. $ runhaskell GenericMain.hs Mu ( a => Fork "Add"(Fork "Sub"(b) (Empty)) (c) b => Fork "Mul"(c) (c) c => Fork "40"(Empty) (Empty) d => Fork "X"(Empty) (Empty) ) Mu ( a => Fork "Add"(Fork "Sub"(b) (Empty)) (c) b => Fork "Mul"(c) (c) c => Fork "42"(Empty) (Empty) d => Fork "X"(Empty) (Empty) ) This time, I can modify a node without loosing the sharing. How about edges? Can you write operations such as "Choose one of the edges that point to (c) and make it point to (d)" ? Is there any good methods to describe and modify structures that has sharing (if it helps, I don't need loops.)? Or, after all is the best way explicit manipulation of the graph structure? Both information are helpful to me. Thanks in advance, -- Takayuki MURANUSHI The Hakubi Center for Advanced Research, Kyoto University http://www.hakubi.kyoto-u.ac.jp/02_mem/h22/muranushi.html

2 3