- Haskell-Cafe - Haskell.org

ANNOUNCE: Sylvia, a lambda calculus visualizer
by Chris Wong 01 Oct '12

01 Oct '12

Hello all Some of you in the audience may have read Dave Keenan's paper, [To Dissect a Mockingbird][]. A subset of that may have wondered if it was possible to generate those pretty pictures programmatically. For that subset, I can answer to you -- yes, yes you can. [To Dissect a Mockingbird]: http://dkeenan.com/Lambda/ Sylvia is a lambda calculus visualizer. It takes in an expression in the untyped lambda calculus and spits out a pretty picture. This is still in very early alpha, but it renders a fair number of combinators correctly. I plan to add animated reduction (once I figure out how to do it), and eventually develop this into a sandbox game of some sort. I'm hoping to get some comments and ideas on how I can take it from here. Obligatory links ---------------- Hackage: http://hackage.haskell.org/package/sylvia Source: https://github.com/lfairy/sylvia Documentation: https://github.com/lfairy/sylvia/wiki ----------------

5 5

Monads
by Vasili I. Galchin 01 Oct '12

01 Oct '12

Hello, I would an examples of monads that are pure, i.e. no side-effects. Thank you, Vasili

8 10

List indexer
by Alex Stangl 01 Oct '12

01 Oct '12

Hi, I have written a small "wrapper" to speed random-access to a list. The usage scenario I have in mind is a "stream" computation yielding an infinite list, and I want to randomly access elements w/o having to traverse the entire list from the beginning for each access. I suspected something similar must already exist, but nothing I looked at seemed to do the trick. IntMap seems to want a finite input list. Ditto for the various array types, except possibly dynamic array. Attached is the list indexer I came up with, and a small test program (I swap the commented-out lines to switch btw. list & list index tests). I am interested to hear any feedback on this -- whether it duplicates something that already exists, or whether there's a better approach, and comments on the code, etc. Also if somebody can suggest a better name (so as not to overlay the word index too much.) I'll publish it on hackage (or at least github) if people think it's useful. It sped up the program I initally wrote it for enormously. Thanks, Alex

2 2

Compiler jobs
by Tom Hawkins 01 Oct '12

01 Oct '12

Hi, BAE Systems has some open positions for principal level Haskell programmers with compiler experience. Our DARPA project[1] is building a compiler for a new programming language with dynamic information flow control, targeting a custom ISA with hardware enforced information security. On the project, we are partnered with academics from the University of Pennsylvania, Harvard, and Northeastern University. Send a resume If interested. Thanks! -Tom [1] http://www.crash-safe.org/

1 0

ANN: monadLib-3.7.1 on Hackage
by Iavor Diatchki 01 Oct '12

01 Oct '12

Hello, I am pleased to announce the availability of monadLib-3.7.1 on Hackage. MonadLib is a library intended to help programmers to quickly and easily construct various monads. The library has support for a wide range of effects: threading state, read-only variables, collecting output, exception handling, back-tracking computation, and working with explicit continuations. It provides similar functionality to libraries such as MTL, but it has a simpler interface and improved functionality for a number of the transformers. The main change in this version is improved support for working with continuations: now we support invoking the same continuation in contexts that have different types. Happy hacking! -Iavor

1 0

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 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