- Haskell-Cafe - Haskell.org

Is inspectable recursion in Arrows possible?
by Alessandro Vermeulen 01 Oct '12

01 Oct '12

Dear all, I am trying to find a way to translate normal recursive notation such as the |fib| function below to an arrow, retaining as much of the structure of the recursive notation as possible. In addition I would like to inspect the arrow. For this I created a datatype containing a constructor for each Arrow{..} class: Fib: > fib 0 = 0 > fib 1 = 1 > fib n = fib (n-2) + fib (n-1) My R datatype, the instances for this datatype consist of the mapping to the appropriate constructor: > data R x y where > -- Category > Id :: R a a > Comp :: R b c -> R a b -> R a c > -- Arrow > Arr :: (a -> b) -> R a b > Split :: R b c -> R b' c' -> R (b,b') (c,c') > Cache :: (a -> a -> Bool) -> R a a > -- ArrowChoice > Choice :: R b c -> R b' c' -> R (Either b b') (Either c c') > -- ArrowLoop > Loop :: R (b, d) (c, d) -> R b c > -- ArrowApply > Apply :: R (R b c, b) c Translating the |fib| function from above first resulted in the following definition. It is not allowed however due to the proc n on the RHS of the declaration for |fibz|. I know that the grammar of the Arrow Notation prevents this, but what is the underlying reason for this? > fib' :: (ArrowChoice r, ArrowLoop r) => r Int Int > fib' = proc x -> do > rec fibz <- proc n -> case n of > 0 -> returnA -< 0 > 1 -> returnA -< 1 > n' -> do l <- fibz -< (n'-2) > r <- fibz -< (n'-1) > returnA -< (l+r) > fibz -<< x Rewriting the function above to use a let statement compiles. However, here my second problem arises. I want to be able to inspect the recursion where it happens. However, in this case |fibz| is an infinite tree. I would like to capture the recursion into fibz, I hoped the rec would help me with that in combination with |loop| but maybe I am wrong? > fib'' :: (ArrowChoice r, ArrowLoop r, ArrowApply r) => r Int Int > fib'' = proc x -> do > let fibz = proc n -> case n of > 0 -> returnA -< 0 > 1 -> returnA -< 1 > n' -> do l <- fibz -< (n'-2) > r <- fibz -< (n'-1) > returnA -< (l+r) > fibz -<< x Basically, is it possible to observe this kind of recursion? (Perhaps even within the boundaries of Arrow Notation) I could perhaps add another constructor like fix. Any thoughts on this? Cheers, Alessandro Vermeulen

1 0

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

01 Oct '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 30 Sep '12

30 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 30 Sep '12

30 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