November 2009 - Haskell-Cafe

Some thoughts about Hackage
by Vasyl Pasternak 15 Nov '09

15 Nov '09

Hi, Yesterday Max complained about documentation for many Haskell modules. But I found another similar problem with Hackage. Before coding some Haskell program I try to find most appropriate libraries, which help me to do task more efficiently. But the problem, that there are to many libraries with similar functionality (for example - networking, web servers etc.). And to find the best solution is not so obvious. My idea is to improve Hackage to help everyone with package selecting. I propose the following: - add download counter for each package, it could show how popular the package is - allow registered users set the quality mark of the package (from 1 to 5) and show the average mark of each packet - add counter which shows how many packages depend on this package (direct/indirect) - create an aggregate package rank (a function on previous three values), similar to Google's PageRank, i. e. rank of the package is proportional to the package mark and weighted rank of dependent packages - allow comments on the package page, so anyone could tell its opinion or other useful info for this package. All messages should be delivered to the maintainer. This is useful, because it could speedup the feedback on the packages, and also could form large knowledge base on each package. Now everyone, who wants to read more about some package should use Google to extract info from HaskellWiki, Haskell-Cafe or hundreds of blog posts from different authors. What do you think ? Best regards, Vasyl Pasternak

6 5

I'm also missing examples of library function and Hackage usage. Haskell Wiki?
by Casey Hawthorne 15 Nov '09

15 Nov '09

I'm also missing examples of library function and Hackage usage. Where does one put up code on the Haskell Wiki? :) -- Regards, Casey

1 0

Type-indexed expressions with fixpoint
by oleg＠okmij.org 14 Nov '09

14 Nov '09

Brent Yorgey wrote: > This email is literate Haskell. I'm struggling to come up with the > right way to add a fixpoint constructor to an expression language > described by a type-indexed GADT (details below). > > but since Haskell doesn't have type-level lambdas, I don't see how > to make that work. John Reynolds showed long ago that any higher-order language can be encoded in first-order. We witness this every day: higher-order language like Haskell is encoded in first-order language (machine code). The trick is just to add a layer of interpretive overhead -- I mean, a layer of interpretation. The closure conversion on type level was shown in http://okmij.org/ftp/Computation/lambda-calc.html#haskell-type-level Here's how a similar technique applies to the problem at hand. There is an alternative solution: encode higher-order functors by means of SKI combinators. Somehow I prefer the pointed solution. The complete code follows. {-# LANGUAGE TypeFamilies, KindSignatures, GADTs, FlexibleInstances #-} data U :: (* -> *) -> * where Unit :: U None Var :: U Id (:+:) :: U f -> U g -> U (Sum f g) (:*:) :: U f -> U g -> U (Prod f g) Mu :: HOFunctor f => f -> U (MU f) data None a = None deriving Show data Id a = Id a deriving Show data Sum f g a = Inl (f a) | Inr (g a) deriving Show data Prod f g a = Prod (f a) (g a) deriving Show newtype MU f a = MU (Res f (MU f) a) type family Res f self :: * -> * type instance Res List self = Sum None (Prod Id self) data List = List -- the code for the HO functor class HOFunctor f where fn :: f -> U g -> U (Res f g) instance HOFunctor List where fn _ self = Unit :+: (Var :*: self) enumShapes :: Int -> U f -> [f ()] enumShapes 0 Unit = [None] enumShapes _ Unit = [] enumShapes 1 Var = [Id ()] enumShapes _ Var = [] enumShapes n (f :+: g) = map Inl (enumShapes n f) ++ map Inr (enumShapes n g) enumShapes n (f :*: g) = [ Prod x y | x <- enumShapes n f, y <- enumShapes n g] enumShapes n self@(Mu f) = map MU $ enumShapes (n-1) (fn f self) test0 = enumShapes 0 (Unit :+: (Var :*: Var)) -- [Inl None] test1 = enumShapes 1 (Unit :+: (Var :*: Var)) -- [Inr (Prod (Id ()) (Id ()))] test2 = enumShapes 1 (Mu List) -- [Inl None] test3 = enumShapes 2 (Mu List) -- [Inr (Prod (Id ()) Inl None)] instance Show (MU List ()) where show (MU x) = show x

3 2

Where is a good place to place code like this, so if I may be so bold, people can learn from it?
by Casey Hawthorne 14 Nov '09

14 Nov '09

Where is a good place to place code like this, so if I may be so bold, people can learn from it? {- Author Modifications: Casey Hawthorne Author Original: Jeff Newbern Maintainer: Casey Hawthorne <caseyh(a)istar.ca> Maintainer?: Jeff Newbern <jnewbern(a)nomaware.com> Time-stamp: Jeff <Tue Aug 19 09:31:32 2003> Time-stamp: Casey <Sat Nov 14 10:10 2009> License: GPL The N-queens puzzle is to place N queens on an N by N chess board so that no queen can attack another one. Compiler Flags: ghc -O2 -fvia-c --make N-Queens.hs Description http://www.haskell.org/all_about_monads/html/stacking.html#example Original Code http://www.haskell.org/all_about_monads/examples/example25.hs -} {- Description Example 25 - Using the StateT monad transformer with the List monad to achieve non-deterministic stateful computations, and the Writer monad to do logging Usage: Compile the code and run it with an argument between 1 and 8. It will print a solution to the N-queens puzzle along with a log of the number of choices it had at each step. The N-queens puzzle is to place N queens on a chess board so that no queen can attack another one. The original version always used an 8x8 board. Try: ./ex25 8 ./ex25 1 ./ex25 7 Added by Casey: - different board sizes -- up to a maximum 26x26 square board - updated imports list -} import IO import System import Monad import Data.Maybe import Data.List import Data.Char (toLower) import Control.Monad.State import Control.Monad.Writer -- describe Chess Units and positions type Rank = Int data File = A | B | C | D | E | F | G | H | I | J | K | L | M | N | O | P | Q | R | S | T | U | V | X | Y | Z deriving (Eq, Show, Ord, Enum) data Position = Pos {file::File, rank::Rank} deriving Eq instance Show Position where show (Pos f r) = (map toLower (show f)) ++ (show r) instance Ord Position where compare p1 p2 = case (rank p1) `compare` (rank p2) of LT -> GT GT -> LT _ -> (file p1) `compare` (file p2) data Kind = Pawn | Knight | Bishop | Rook | Queen | King deriving (Eq, Ord, Enum) instance Show Kind where show Pawn = "P" show Knight = "N" show Bishop = "B" show Rook = "R" show Queen = "Q" show King = "K" data Color = Black | White deriving (Eq, Ord, Enum) instance Show Color where show Black = "b" show White = "w" data Unit = Unit {color::Color, kind::Kind} deriving (Eq, Ord) instance Show Unit where show (Unit c k) = ((show c) ++ (show k)) data Board = Board {size::Int, psns::[(Unit,Position)]} -- newtype Board = Board [(Unit,Position)] -- newtype BoardMax = BoardMax Int instance Show Board where show (Board n ps) = let ordered = (sort . swap) ps ranks = map (showRank ordered) [n,(n-1)..1] board = intersperse (concat (take n (repeat "--+"))) ranks rlabels = intersperse " " (map (\n->(twoSpaces n)++" ") [n,(n-1)..1]) flabels = take (n*3) " a b c d e f g h i j k l m n o p q r s t u v w x y z" twoSpaces n | length (show n) == 2 = show n | otherwise = " " ++ (show n) in unlines $ zipWith (++) rlabels board ++ [flabels] where swap = map (\(a,b)->(b,a)) showRank ps r = let rnk = filter (\(p,_)->(rank p)==r) ps cs = map (showUnit rnk) (take n [A .. Z]) in concat (intersperse "|" cs) showUnit ps f = maybe " " (show . snd) (find (\(p,_)->(file p)==f) ps) data Diagonal = Ascending Position | Descending Position deriving (Eq, Show) -- define the diagonal according to its interesction with rank 1 or size of board) -- or with file a normalize :: Int -> Diagonal -> Diagonal normalize n d@(Ascending psn) | (rank psn) == 1 = d | (file psn) == A = d | otherwise = normalize n (Ascending (Pos (pred (file psn)) ((rank psn)-1))) normalize n d@(Descending psn) | (rank psn) == n = d | (file psn) == A = d | otherwise = normalize n (Descending (Pos (pred (file psn)) ((rank psn)+1))) -- get the diagonals corresponding to a location on the board getDiags :: Int -> Position -> (Diagonal,Diagonal) getDiags n p = (normalize n (Ascending p), normalize n (Descending p)) -- this is the type of our problem description data NQueensProblem = NQP {board::Board, ranks::[Rank], files::[File], asc::[Diagonal], desc::[Diagonal]} -- initial state = empty board, all ranks, files, and diagonals free initialState n = let fileA = map (\r->Pos A r) [1..n] rankMax = map (\f->Pos f n) (take n [A .. Z]) rank1 = map (\f->Pos f 1) (take n [A .. Z]) asc = map Ascending (nub (fileA ++ rank1)) desc = map Descending (nub (fileA ++ rankMax)) in NQP (Board n []) [1..n] (take n [A .. Z]) asc desc -- this is our combined monad type for this problem type NDS a = WriterT [String] (StateT NQueensProblem []) a -- Get the first solution to the problem, by evaluating the solver computation with -- an initial problem state and then returning the first solution in the result list, -- or Nothing if there was no solution. getSolution :: NDS a -> NQueensProblem -> Maybe (a,[String]) getSolution c i = listToMaybe (evalStateT (runWriterT c) i) -- add a Queen to the board in a specific position addQueen :: Position -> NDS () addQueen p = do (Board n b) <- gets board rs <- gets ranks fs <- gets files as <- gets asc ds <- gets desc let b' = (Unit Black Queen, p):b rs' = delete (rank p) rs fs' = delete (file p) fs (a,d) = getDiags n p as' = delete a as ds' = delete d ds tell ["Added Queen at " ++ (show p)] put (NQP (Board n b') rs' fs' as' ds') -- test if a position is in the set of allowed diagonals inDiags :: Int -> Position -> NDS Bool inDiags n p = do let (a,d) = getDiags n p as <- gets asc ds <- gets desc return $ (elem a as) && (elem d ds) -- add a Queen to the board in all allowed positions addQueens :: NDS () addQueens = do rs <- gets ranks fs <- gets files (Board n b) <- gets board allowed <- filterM (inDiags n) [Pos f r | f <- fs, r <- rs] tell [show (length allowed) ++ " possible choices"] msum (map addQueen allowed) -- Start with an empty chess board and add the requested number of queens, -- then get the board and print the solution along with the log main :: IO () main = do args <- getArgs let n = read (args!!0) cmds = replicate n addQueens sol = (`getSolution` (initialState n)) $ do sequence_ cmds gets board case sol of Just (b,l) -> do putStr $ show b -- show the solution putStr $ unlines l -- show the log Nothing -> putStrLn "No solution" -- END OF FILE -- Regards, Casey

3 3

ANN: hesql
by Christoph Bauer 14 Nov '09

14 Nov '09

Hello, sure, your program could use a database with HDBC. But I'll guess (since you love static typing so much) you dislike formulating queries in strings and to check the positions of your ?-placeholders and to convert your values with fromSql/toSql. Maybe you would prefer for your select query a list of tuples instead of a list of lists, because your beloved pattern matching needs always a dummy case. And here [1] is hesql... it's a preprocessor, which rewrites SQL-Queries as haskell functions. You put all your SQL-Queries (for example verifyLogin login' password' = select1' Accountid, Login, RealName, Email from Account where (password is null or password = md5(password')) and Lower(Login) = login' and not Locked; ) in a module (example/Account.hesql) and run $ hesql example/Account.hesql dbname=example which will write example/Account.hs, the real haskell module. It will generate code for a haskell function with the type: verifyLogin :: Stmts -> String -> String -> IO (Maybe (Int, String, String, String)) (Ok, this is not quite correct. Check the README.) And Of course my SQL-Parser is very incomplete. Hesql works only with postgresql, etc, etc. So, please send me patches :-) Don't expect too much. Christoph Bauer [1] on hackageDB

3 2

Collection of sets containing no sets which are a subset of another in the collection
by Mark Wassell 14 Nov '09

14 Nov '09

Hi, I am looking for a data structure that will represent a collection of sets such that no element in the collection is a subset of another set. In other words, inserting an element that is already a subset of another element will return the original collection, and inserting an element that is a superset of any elements will result in a collection with the superset added and the subsets removed. What I have so far is the below but I am wondering if there has been any prior work on this (particularly using Haskell but also conceptual work). Inserting a set that is a subset is easy to handle, inserting a superset and remove subsets of it is a little tricker. Cheers Mark module SetTrie where -- -- A set of sets which does not contain elements which are subsets of any other element. -- ie insert a element which is a proper subset of another set returns the same set of sets -- insert a element which is a proper superset of one or more elements causes those elements to be removed -- (and the first element to be added) -- import Data.Set hiding (toList,singleton,map,insert) import Data.Map hiding (fromList,showTreeWith,toAscList,toList,singleton,map,insert) import qualified Data.Map as M (toList,fromList,lookup,insert) import qualified Data.Set as S (toList,fromList) -- Normally we would have a flag at a node to indicate a subset is there, but we -- don't store subsets. data SetTrie a = Leaf [a] | Node (Map a (SetTrie a)) deriving (Show,Eq) singleton :: Ord a => Set a -> SetTrie a singleton = Leaf . S.toList toList' :: Ord a => SetTrie a -> [[a]] toList' (Leaf xs) = [xs] toList' (Node m) = concatMap (\(x,y) -> map (x:) (toList' y)) $ M.toList m toList :: Ord a => SetTrie a -> [Set a] toList x = map S.fromList $ toList' x insert :: Ord a => SetTrie a -> Set a -> SetTrie a insert t s = insert' t $ toAscList s insert':: Ord a => SetTrie a -> [a] -> SetTrie a insert' (Leaf (y:ys)) (x:xs) = Node (M.fromList [(y,Leaf ys),(x,Leaf xs)]) insert' (Node m) (x:xs) = case M.lookup x m of Nothing -> case xs of [] -> Node $ M.insert x (Leaf xs) m _ -> Node $ M.insert x (Leaf xs) m Just t' -> case xs of [] -> Node m _ -> Node $ M.insert x (insert' t' xs) m -- removeSubsets :: -- terminate (Node m) = Node mTrue m -- terminate (Leaf (x:xs)) = Node True (M.fromList [(x,Leaf xs)]) s1 = fromList [1,2,3,5,2] s2 = fromList [2,3,5] t1 = Node (M.fromList [(1,Leaf [2]),(3,Leaf [5]),(2,Node (M.fromList [(4,Leaf [6])]))]) t2 = insert (singleton (S.fromList [1])) $ S.fromList [1,2,3] t3 = insert t1 $ S.fromList [2,4,7] t4 = insert t2 $ S.fromList [1] t5 = insert t3 $ S.fromList [2,5] t6 = insert t5 $ S.fromList [2,4] -- Now add a superset of everything t7 = insert (singleton (S.fromList [8])) $ S.fromList [1,2,3,4,5,6,7,8,9] Mark

4 3

Writing great documentation
by Max Rabkin 14 Nov '09

14 Nov '09

Haskellers, I have heard many complaints about the average quality on documentation. Therefore, I'd like to encourage you all to read Jacob Kaplan-Moss's series on writing great documentation: http://jacobian.org/writing/great-documentation/. The articles are themselves well-written and contain excellent advice (though I disagree somewhat with the comments on automatically-generated documentation: I find many libraries are excellently haddocumented). Jacob Kaplan-Moss is a developer on the Django project, which is well known for the quality of its documentation. One issue he brings up is having different types of documentation. My impression of many Haskell libraries (my own included) is that, while they may have good reference documentation, they lack tutorials and topic guides. Perhaps we could bring up some examples of Haskell projects with particularly good documentation, as examples to look up to. XMonad has very good overviews and guides for developers, and I like how each user-facing xmonad-contrib module gives a small snippet showing how to use it in ones own config. One area where I think it could be improved (and I plan to do some work on this when I have more free time) is in topical guides on things like "how to write your own layout". --Max

7 7

Lexical Syntax and Unicode
by Manlio Perillo 14 Nov '09

14 Nov '09

Hi. Reading the Haskell 98 Report (section 9.2), I have found a possible problem. The lexical syntax supports Unicode, however this is not true for the newline: newline -> return linefeed | return | linefeed | formfeed The Unicode standard adds two additional characters: U+2028 LINE SEPARATOR U+2029 PARAGRAPH SEPARATOR The Unicode Character Database, also defines two general categories: Zl = Separator, line Zp = Separator, paragraph The Zl category only contains the LINE SEPARATOR character and the Zp category only contains the PARAGRAPH SEPARATOR character. So, IMHO, the lexical syntax should be changed in : newline -> return linefeed | return | linefeed | formfeed | uniLine | uniPara uniLine -> any Unicode character defined as line separator uniPara -> any Unicode character defined as paragraph separator or, alternatively: uniLine -> LINE SEPARATOR uniPara -> PARAGRAPH SEPARATOR Manlio Perillo

1 0

Package Woes
by Daniel Fischer 14 Nov '09

14 Nov '09

Sorry, slightly off-topic. I wanted to install LHC to compare that to GHC and JHC, but alas: dafis@linux-mkk1:~/Haskell/LHC/lhc-0.8> cabal install -fwith-libs -flhc-regress Resolving dependencies... Configuring libffi-0.1... cabal: The pkg-config package libffi is required but it could not be found. cabal: Error: some packages failed to install: lhc-0.8 depends on libffi-0.1 which failed to install. libffi-0.1 failed during the configure step. The exception was: exit: ExitFailure 1 Okay, so I installed libffi, but to no avail, still can't find libffi. The problem is apparently that libffi doesn't come with a .pc file, so pkg-config doesn't know about it. Does anybody know how to fix that? (openSuse 11.1, if that matters)

2 3

Haskell Weekly News: Issue 139 - November 14, 2009
by jfredett＠gmail.com 14 Nov '09

14 Nov '09

--------------------------------------------------------------------------- Haskell Weekly News http://sequence.complete.org/hwn/20091114 Issue 139 - November 14, 2009 --------------------------------------------------------------------------- Welcome to issue 139 of HWN, a newsletter covering developments in the [1]Haskell community. Lots of good discussion this week about everything from Monoids to Memory Leaks, Parsers (for Token Streams) and pushing Haskell onto Medical devices! I could go on some long rant rife with really righteous alliteration or a touch of timely consonance, but instead I'll leave you all, my fellow Haskellers, to read your Haskell Weekly News! Announcements Two Open PhD positions at the Technical University Munich. Axel Simon [2]announced two PhD positions are open in Low-level and High-level analysis, see the post for details. (ED: Apologies for being so late in this announcment, it slipped under my radar! ) Final CFP: WFLP 2010. Deadlines extended: Abstract due Nov 18; Full paper due Nov 25 (LNCS). Pablo Nogueira [3]announced a deadline extension for the WLFP 2010 conference, abstracts are now due November 18, and full papers by the 25th. hesql. Christoph Bauer [4]announced hesql, a preprocessor for writing SQL statements in pure haskell. dbus-core 0.6 and dbus-client 0.2. John Millikin [5]announced the second release of his dbus libraries. Changes include performance improvments, better support for byte arrays, and TCP/IP transport (though this remains untested). simple-observer-0.0.1, a simple implementation of the observer design pattern. Andy Gimblett [6]announced an implementation of the Observer pattern in Haskell ICFP 2010: Call for papers. Wouter Swierstra [7]announced a call for papers for ICFP 2010. Calling all Haskellers in Huntsville, Alabama, or surrounding areas! Jake McArthur [8]announced the formation of a new Haskell User Group in Alabama. (ED: Apparently, Shae is the Johnny Appleseed for the Haskell Community, #haskell, BAHUG, now AHUG... when will it end? ) acme-dont. Gracjan Polak [9]announced the acme-dont package, providing a vital missed feature to our language -- a don't monad. See the post for all the revolutionary details. Discussion Could someone teach me why we use Data.Monoid? Magicloud Magiclouds [10]1fa7 gmane.comp.lang.haskell.cafe/66223 asked why we use monoids so much in Haskell. Least common supertype. Sean Leather [11]posed an interesting question about 'antiunification' -- finding a common supertype of two types which is 'most-constrained'. Long running Haskell program. David Leimbach [12]asked about managing memory leaks in long running programs. Parsec - separating Parsing from Lexing. Fernando Henrique Sanches [13]asked about using Parsec to parse a Token Stream. Help Haskell driving Medical Instruments. Philippos Apolinarius [14]talked about using Haskell to drive medical instruments. Blog noise [15]Haskell news from the [16]blogosphere. Blog posts from people new to the Haskell community are marked with >>>, be sure to welcome them! * Neil Brown: [17]The Observer Pattern using a Broadcast Channel. * Martijn van Steenbergen: [18]GADTs in Haskell 98. * Mikael Vejdemo Johansson (Syzygy-): [19][MATH198] Multiple lectures posted. * Andy Gill: [20]LAMBDA this week â ChalkBoard. * London Haskell Users Group: [21]Functional Programming Exchange. * Neil Brown: [22]The Observer Pattern using a Message-Passing Process. * Luke Plant: [23]Is static type checking a redundant testing mechanism?. * Twan van Laarhoven: [24]Four ways to fold an array. * Martin Sulzmann: [25]Tag-free Combinators for Binding-Time Polymorphic Program Generation. * Luke Palmer: [26]Collision Detection with Enneatrees. * Dan Piponi (sigfpe): [27]Memoizing Polymorphic Functions with High School Algebra and Quantifiers. * Luke Plant: [28]Haskell blog software. Quotes of the Week * c2.com: If you can program anything in HappS you actually already learned Haskell * Cale: Chew new Lasty ST Gum! It lasts until _|_! * danderson: [using unsafeFreeze for an ST action] that sounds like a way to shoot myself in the foot with high efficiency, given my knowledge of haskell. * BONUS: C++ is saner than something? imo C++ is like the guy that goes around shouting "I am napoleon!!!" * kmc:: (): worst monoid ever * DanWeston: Bottom has only one value, not two. Otherwise bottom would have been called buttocks. About the Haskell Weekly News New editions are posted to [29]the Haskell mailing list as well as to [30]the Haskell Sequence and [31]Planet Haskell. [32]RSS is also available, and headlines appear on [33]haskell.org. To help create new editions of this newsletter, please see the information on [34]how to contribute. Send stories to jfredett . at . gmail . dot . com. The darcs repository is available at darcs get [35]http://patch-tag.com/r/jfredett/HWN2/pullrepo HWN2 . References 1. http://haskell.org/ 2. http://www.mail-archive.com/haskell@haskell.org/msg22432.html 3. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66215 4. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66184 5. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66110 6. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66103 7. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66021 8. http://article.gmane.org/gmane.comp.lang.haskell.cafe/66018 9. http://article.gmane.org/gmane.comp.lang.haskell.cafe/65958 10. http://thread.gmane.org/ 11. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/66080 12. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/66056 13. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/66012 14. http://thread.gmane.org/gmane.comp.lang.haskell.cafe/65996 15. http://planet.haskell.org/ 16. http://haskell.org/haskellwiki/Blog_articles 17. http://chplib.wordpress.com/2009/11/12/the-observer-pattern-using-a-broadca… 18. http://martijn.van.steenbergen.nl/journal/2009/11/12/gadts-in-haskell-98/ 19. http://blog.mikael.johanssons.org/archive/2009/11/math198-multiple-lectures… 20. http://www.ittc.ku.edu/csdlblog/?p=16 21. http://www.londonhug.net/2009/11/10/functional-programming-exchange/ 22. http://chplib.wordpress.com/2009/11/10/the-observer-pattern-using-a-message… 23. http://lukeplant.me.uk/blog/posts/is-static-type-checking-a-redundant-testi… 24. http://twan.home.fmf.nl/blog/haskell/four-ways-to-fold.details 25. http://sulzmann.blogspot.com/2009/11/tag-free-combinators-for-binding-time.… 26. http://lukepalmer.wordpress.com/2009/11/08/collision-detection-with-enneatr… 27. http://blog.sigfpe.com/2009/11/memoizing-polymorphic-functions-with.html 28. http://lukeplant.me.uk/blog/posts/haskell-blog-software/ 29. http://www.haskell.org/mailman/listinfo/haskell 30. http://sequence.complete.org/ 31. http://planet.haskell.org/ 32. http://sequence.complete.org/node/feed 33. http://haskell.org/ 34. http://haskell.org/haskellwiki/HWN 35. http://patch-tag.com/r/jfredett/HWN2/pullrepo%20HWN2

1 0