ListLike 1.0.2 → 1.1.0

raw patch · 4 files changed

+20/−13 lines, 4 filesdep ~containersPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: containers

API changes (from Hackage documentation)

- Data.ListLike.Instances: instance (Ix i) => FoldableLL (Array i e) e

- Data.ListLike.Instances: instance (Ord key) => FoldableLL (Map key val) (key, val)

+ Data.ListLike.Instances: instance Ix i => FoldableLL (Array i e) e

+ Data.ListLike.Instances: instance Ord key => FoldableLL (Map key val) (key, val)

- Data.ListLike: all :: (ListLike full item) => (item -> Bool) -> full -> Bool

+ Data.ListLike: all :: ListLike full item => (item -> Bool) -> full -> Bool

- Data.ListLike: and :: (ListLike full Bool) => full -> Bool

+ Data.ListLike: and :: ListLike full Bool => full -> Bool

- Data.ListLike: any :: (ListLike full item) => (item -> Bool) -> full -> Bool

+ Data.ListLike: any :: ListLike full item => (item -> Bool) -> full -> Bool

- Data.ListLike: append :: (ListLike full item) => full -> full -> full

+ Data.ListLike: append :: ListLike full item => full -> full -> full

- Data.ListLike: appendFile :: (ListLikeIO full item) => FilePath -> full -> IO ()

+ Data.ListLike: appendFile :: ListLikeIO full item => FilePath -> full -> IO ()

- Data.ListLike: break :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike: break :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike: class (ListLike full item) => InfiniteListLike full item | full -> item

+ Data.ListLike: class ListLike full item => InfiniteListLike full item | full -> item

- Data.ListLike: class (ListLike full item) => ListLikeIO full item | full -> item

+ Data.ListLike: class ListLike full item => ListLikeIO full item | full -> item

- Data.ListLike: cons :: (ListLike full item) => item -> full -> full

+ Data.ListLike: cons :: ListLike full item => item -> full -> full

- Data.ListLike: cycle :: (InfiniteListLike full item) => full -> full

+ Data.ListLike: cycle :: InfiniteListLike full item => full -> full

- Data.ListLike: deleteBy :: (ListLike full item) => (item -> item -> Bool) -> item -> full -> full

+ Data.ListLike: deleteBy :: ListLike full item => (item -> item -> Bool) -> item -> full -> full

- Data.ListLike: deleteFirstsBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike: deleteFirstsBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike: drop :: (ListLike full item) => Int -> full -> full

+ Data.ListLike: drop :: ListLike full item => Int -> full -> full

- Data.ListLike: dropWhile :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike: dropWhile :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike: empty :: (ListLike full item) => full

+ Data.ListLike: empty :: ListLike full item => full

- Data.ListLike: filter :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike: filter :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike: find :: (ListLike full item) => (item -> Bool) -> full -> Maybe item

+ Data.ListLike: find :: ListLike full item => (item -> Bool) -> full -> Maybe item

- Data.ListLike: findIndex :: (ListLike full item) => (item -> Bool) -> full -> Maybe Int

+ Data.ListLike: findIndex :: ListLike full item => (item -> Bool) -> full -> Maybe Int

- Data.ListLike: foldl :: (FoldableLL full item) => (a -> item -> a) -> a -> full -> a

+ Data.ListLike: foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

- Data.ListLike: foldl' :: (FoldableLL full item) => (a -> item -> a) -> a -> full -> a

+ Data.ListLike: foldl' :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

- Data.ListLike: foldl1 :: (FoldableLL full item) => (item -> item -> item) -> full -> item

+ Data.ListLike: foldl1 :: FoldableLL full item => (item -> item -> item) -> full -> item

- Data.ListLike: foldr :: (FoldableLL full item) => (item -> b -> b) -> b -> full -> b

+ Data.ListLike: foldr :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

- Data.ListLike: foldr' :: (FoldableLL full item) => (item -> b -> b) -> b -> full -> b

+ Data.ListLike: foldr' :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

- Data.ListLike: foldr1 :: (FoldableLL full item) => (item -> item -> item) -> full -> item

+ Data.ListLike: foldr1 :: FoldableLL full item => (item -> item -> item) -> full -> item

- Data.ListLike: fromList :: (ListLike full item) => [item] -> full

+ Data.ListLike: fromList :: ListLike full item => [item] -> full

- Data.ListLike: fromString :: (StringLike s) => String -> s

+ Data.ListLike: fromString :: StringLike s => String -> s

- Data.ListLike: getContents :: (ListLikeIO full item) => IO full

+ Data.ListLike: getContents :: ListLikeIO full item => IO full

- Data.ListLike: getLine :: (ListLikeIO full item) => IO full

+ Data.ListLike: getLine :: ListLikeIO full item => IO full

- Data.ListLike: hGet :: (ListLikeIO full item) => Handle -> Int -> IO full

+ Data.ListLike: hGet :: ListLikeIO full item => Handle -> Int -> IO full

- Data.ListLike: hGetContents :: (ListLikeIO full item) => Handle -> IO full

+ Data.ListLike: hGetContents :: ListLikeIO full item => Handle -> IO full

- Data.ListLike: hGetLine :: (ListLikeIO full item) => Handle -> IO full

+ Data.ListLike: hGetLine :: ListLikeIO full item => Handle -> IO full

- Data.ListLike: hGetNonBlocking :: (ListLikeIO full item) => Handle -> Int -> IO full

+ Data.ListLike: hGetNonBlocking :: ListLikeIO full item => Handle -> Int -> IO full

- Data.ListLike: hPutStr :: (ListLikeIO full item) => Handle -> full -> IO ()

+ Data.ListLike: hPutStr :: ListLikeIO full item => Handle -> full -> IO ()

- Data.ListLike: hPutStrLn :: (ListLikeIO full item) => Handle -> full -> IO ()

+ Data.ListLike: hPutStrLn :: ListLikeIO full item => Handle -> full -> IO ()

- Data.ListLike: head :: (ListLike full item) => full -> item

+ Data.ListLike: head :: ListLike full item => full -> item

- Data.ListLike: index :: (ListLike full item) => full -> Int -> item

+ Data.ListLike: index :: ListLike full item => full -> Int -> item

- Data.ListLike: init :: (ListLike full item) => full -> full

+ Data.ListLike: init :: ListLike full item => full -> full

- Data.ListLike: interact :: (ListLikeIO full item) => (full -> full) -> IO ()

+ Data.ListLike: interact :: ListLikeIO full item => (full -> full) -> IO ()

- Data.ListLike: intersectBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike: intersectBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike: intersperse :: (ListLike full item) => item -> full -> full

+ Data.ListLike: intersperse :: ListLike full item => item -> full -> full

- Data.ListLike: iterate :: (InfiniteListLike full item) => (item -> item) -> item -> full

+ Data.ListLike: iterate :: InfiniteListLike full item => (item -> item) -> item -> full

- Data.ListLike: last :: (ListLike full item) => full -> item

+ Data.ListLike: last :: ListLike full item => full -> item

- Data.ListLike: length :: (ListLike full item) => full -> Int

+ Data.ListLike: length :: ListLike full item => full -> Int

- Data.ListLike: nubBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full

+ Data.ListLike: nubBy :: ListLike full item => (item -> item -> Bool) -> full -> full

- Data.ListLike: null :: (ListLike full item) => full -> Bool

+ Data.ListLike: null :: ListLike full item => full -> Bool

- Data.ListLike: or :: (ListLike full Bool) => full -> Bool

+ Data.ListLike: or :: ListLike full Bool => full -> Bool

- Data.ListLike: partition :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike: partition :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike: putStr :: (ListLikeIO full item) => full -> IO ()

+ Data.ListLike: putStr :: ListLikeIO full item => full -> IO ()

- Data.ListLike: putStrLn :: (ListLikeIO full item) => full -> IO ()

+ Data.ListLike: putStrLn :: ListLikeIO full item => full -> IO ()

- Data.ListLike: readFile :: (ListLikeIO full item) => FilePath -> IO full

+ Data.ListLike: readFile :: ListLikeIO full item => FilePath -> IO full

- Data.ListLike: repeat :: (InfiniteListLike full item) => item -> full

+ Data.ListLike: repeat :: InfiniteListLike full item => item -> full

- Data.ListLike: replicate :: (ListLike full item) => Int -> item -> full

+ Data.ListLike: replicate :: ListLike full item => Int -> item -> full

- Data.ListLike: reverse :: (ListLike full item) => full -> full

+ Data.ListLike: reverse :: ListLike full item => full -> full

- Data.ListLike: rigidConcatMap :: (ListLike full item) => (item -> full) -> full -> full

+ Data.ListLike: rigidConcatMap :: ListLike full item => (item -> full) -> full -> full

- Data.ListLike: rigidMap :: (ListLike full item) => (item -> item) -> full -> full

+ Data.ListLike: rigidMap :: ListLike full item => (item -> item) -> full -> full

- Data.ListLike: singleton :: (ListLike full item) => item -> full

+ Data.ListLike: singleton :: ListLike full item => item -> full

- Data.ListLike: snoc :: (ListLike full item) => full -> item -> full

+ Data.ListLike: snoc :: ListLike full item => full -> item -> full

- Data.ListLike: span :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike: span :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike: splitAt :: (ListLike full item) => Int -> full -> (full, full)

+ Data.ListLike: splitAt :: ListLike full item => Int -> full -> (full, full)

- Data.ListLike: tail :: (ListLike full item) => full -> full

+ Data.ListLike: tail :: ListLike full item => full -> full

- Data.ListLike: take :: (ListLike full item) => Int -> full -> full

+ Data.ListLike: take :: ListLike full item => Int -> full -> full

- Data.ListLike: takeWhile :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike: takeWhile :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike: toList :: (ListLike full item) => full -> [item]

+ Data.ListLike: toList :: ListLike full item => full -> [item]

- Data.ListLike: toString :: (StringLike s) => s -> String

+ Data.ListLike: toString :: StringLike s => s -> String

- Data.ListLike: unionBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike: unionBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike: writeFile :: (ListLikeIO full item) => FilePath -> full -> IO ()

+ Data.ListLike: writeFile :: ListLikeIO full item => FilePath -> full -> IO ()

- Data.ListLike.Base: all :: (ListLike full item) => (item -> Bool) -> full -> Bool

+ Data.ListLike.Base: all :: ListLike full item => (item -> Bool) -> full -> Bool

- Data.ListLike.Base: any :: (ListLike full item) => (item -> Bool) -> full -> Bool

+ Data.ListLike.Base: any :: ListLike full item => (item -> Bool) -> full -> Bool

- Data.ListLike.Base: append :: (ListLike full item) => full -> full -> full

+ Data.ListLike.Base: append :: ListLike full item => full -> full -> full

- Data.ListLike.Base: break :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike.Base: break :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike.Base: class (ListLike full item) => InfiniteListLike full item | full -> item

+ Data.ListLike.Base: class ListLike full item => InfiniteListLike full item | full -> item

- Data.ListLike.Base: cons :: (ListLike full item) => item -> full -> full

+ Data.ListLike.Base: cons :: ListLike full item => item -> full -> full

- Data.ListLike.Base: cycle :: (InfiniteListLike full item) => full -> full

+ Data.ListLike.Base: cycle :: InfiniteListLike full item => full -> full

- Data.ListLike.Base: deleteBy :: (ListLike full item) => (item -> item -> Bool) -> item -> full -> full

+ Data.ListLike.Base: deleteBy :: ListLike full item => (item -> item -> Bool) -> item -> full -> full

- Data.ListLike.Base: deleteFirstsBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike.Base: deleteFirstsBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike.Base: drop :: (ListLike full item) => Int -> full -> full

+ Data.ListLike.Base: drop :: ListLike full item => Int -> full -> full

- Data.ListLike.Base: dropWhile :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike.Base: dropWhile :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike.Base: empty :: (ListLike full item) => full

+ Data.ListLike.Base: empty :: ListLike full item => full

- Data.ListLike.Base: filter :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike.Base: filter :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike.Base: find :: (ListLike full item) => (item -> Bool) -> full -> Maybe item

+ Data.ListLike.Base: find :: ListLike full item => (item -> Bool) -> full -> Maybe item

- Data.ListLike.Base: findIndex :: (ListLike full item) => (item -> Bool) -> full -> Maybe Int

+ Data.ListLike.Base: findIndex :: ListLike full item => (item -> Bool) -> full -> Maybe Int

- Data.ListLike.Base: fromList :: (ListLike full item) => [item] -> full

+ Data.ListLike.Base: fromList :: ListLike full item => [item] -> full

- Data.ListLike.Base: head :: (ListLike full item) => full -> item

+ Data.ListLike.Base: head :: ListLike full item => full -> item

- Data.ListLike.Base: index :: (ListLike full item) => full -> Int -> item

+ Data.ListLike.Base: index :: ListLike full item => full -> Int -> item

- Data.ListLike.Base: init :: (ListLike full item) => full -> full

+ Data.ListLike.Base: init :: ListLike full item => full -> full

- Data.ListLike.Base: intersectBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike.Base: intersectBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike.Base: intersperse :: (ListLike full item) => item -> full -> full

+ Data.ListLike.Base: intersperse :: ListLike full item => item -> full -> full

- Data.ListLike.Base: iterate :: (InfiniteListLike full item) => (item -> item) -> item -> full

+ Data.ListLike.Base: iterate :: InfiniteListLike full item => (item -> item) -> item -> full

- Data.ListLike.Base: last :: (ListLike full item) => full -> item

+ Data.ListLike.Base: last :: ListLike full item => full -> item

- Data.ListLike.Base: length :: (ListLike full item) => full -> Int

+ Data.ListLike.Base: length :: ListLike full item => full -> Int

- Data.ListLike.Base: nubBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full

+ Data.ListLike.Base: nubBy :: ListLike full item => (item -> item -> Bool) -> full -> full

- Data.ListLike.Base: null :: (ListLike full item) => full -> Bool

+ Data.ListLike.Base: null :: ListLike full item => full -> Bool

- Data.ListLike.Base: partition :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike.Base: partition :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike.Base: repeat :: (InfiniteListLike full item) => item -> full

+ Data.ListLike.Base: repeat :: InfiniteListLike full item => item -> full

- Data.ListLike.Base: replicate :: (ListLike full item) => Int -> item -> full

+ Data.ListLike.Base: replicate :: ListLike full item => Int -> item -> full

- Data.ListLike.Base: reverse :: (ListLike full item) => full -> full

+ Data.ListLike.Base: reverse :: ListLike full item => full -> full

- Data.ListLike.Base: rigidConcatMap :: (ListLike full item) => (item -> full) -> full -> full

+ Data.ListLike.Base: rigidConcatMap :: ListLike full item => (item -> full) -> full -> full

- Data.ListLike.Base: rigidMap :: (ListLike full item) => (item -> item) -> full -> full

+ Data.ListLike.Base: rigidMap :: ListLike full item => (item -> item) -> full -> full

- Data.ListLike.Base: singleton :: (ListLike full item) => item -> full

+ Data.ListLike.Base: singleton :: ListLike full item => item -> full

- Data.ListLike.Base: snoc :: (ListLike full item) => full -> item -> full

+ Data.ListLike.Base: snoc :: ListLike full item => full -> item -> full

- Data.ListLike.Base: span :: (ListLike full item) => (item -> Bool) -> full -> (full, full)

+ Data.ListLike.Base: span :: ListLike full item => (item -> Bool) -> full -> (full, full)

- Data.ListLike.Base: splitAt :: (ListLike full item) => Int -> full -> (full, full)

+ Data.ListLike.Base: splitAt :: ListLike full item => Int -> full -> (full, full)

- Data.ListLike.Base: tail :: (ListLike full item) => full -> full

+ Data.ListLike.Base: tail :: ListLike full item => full -> full

- Data.ListLike.Base: take :: (ListLike full item) => Int -> full -> full

+ Data.ListLike.Base: take :: ListLike full item => Int -> full -> full

- Data.ListLike.Base: takeWhile :: (ListLike full item) => (item -> Bool) -> full -> full

+ Data.ListLike.Base: takeWhile :: ListLike full item => (item -> Bool) -> full -> full

- Data.ListLike.Base: toList :: (ListLike full item) => full -> [item]

+ Data.ListLike.Base: toList :: ListLike full item => full -> [item]

- Data.ListLike.Base: unionBy :: (ListLike full item) => (item -> item -> Bool) -> full -> full -> full

+ Data.ListLike.Base: unionBy :: ListLike full item => (item -> item -> Bool) -> full -> full -> full

- Data.ListLike.FoldableLL: foldl :: (FoldableLL full item) => (a -> item -> a) -> a -> full -> a

+ Data.ListLike.FoldableLL: foldl :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

- Data.ListLike.FoldableLL: foldl' :: (FoldableLL full item) => (a -> item -> a) -> a -> full -> a

+ Data.ListLike.FoldableLL: foldl' :: FoldableLL full item => (a -> item -> a) -> a -> full -> a

- Data.ListLike.FoldableLL: foldl1 :: (FoldableLL full item) => (item -> item -> item) -> full -> item

+ Data.ListLike.FoldableLL: foldl1 :: FoldableLL full item => (item -> item -> item) -> full -> item

- Data.ListLike.FoldableLL: foldr :: (FoldableLL full item) => (item -> b -> b) -> b -> full -> b

+ Data.ListLike.FoldableLL: foldr :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

- Data.ListLike.FoldableLL: foldr' :: (FoldableLL full item) => (item -> b -> b) -> b -> full -> b

+ Data.ListLike.FoldableLL: foldr' :: FoldableLL full item => (item -> b -> b) -> b -> full -> b

- Data.ListLike.FoldableLL: foldr1 :: (FoldableLL full item) => (item -> item -> item) -> full -> item

+ Data.ListLike.FoldableLL: foldr1 :: FoldableLL full item => (item -> item -> item) -> full -> item

- Data.ListLike.IO: appendFile :: (ListLikeIO full item) => FilePath -> full -> IO ()

+ Data.ListLike.IO: appendFile :: ListLikeIO full item => FilePath -> full -> IO ()

- Data.ListLike.IO: class (ListLike full item) => ListLikeIO full item | full -> item

+ Data.ListLike.IO: class ListLike full item => ListLikeIO full item | full -> item

- Data.ListLike.IO: getContents :: (ListLikeIO full item) => IO full

+ Data.ListLike.IO: getContents :: ListLikeIO full item => IO full

- Data.ListLike.IO: getLine :: (ListLikeIO full item) => IO full

+ Data.ListLike.IO: getLine :: ListLikeIO full item => IO full

- Data.ListLike.IO: hGet :: (ListLikeIO full item) => Handle -> Int -> IO full

+ Data.ListLike.IO: hGet :: ListLikeIO full item => Handle -> Int -> IO full

- Data.ListLike.IO: hGetContents :: (ListLikeIO full item) => Handle -> IO full

+ Data.ListLike.IO: hGetContents :: ListLikeIO full item => Handle -> IO full

- Data.ListLike.IO: hGetLine :: (ListLikeIO full item) => Handle -> IO full

+ Data.ListLike.IO: hGetLine :: ListLikeIO full item => Handle -> IO full

- Data.ListLike.IO: hGetNonBlocking :: (ListLikeIO full item) => Handle -> Int -> IO full

+ Data.ListLike.IO: hGetNonBlocking :: ListLikeIO full item => Handle -> Int -> IO full

- Data.ListLike.IO: hPutStr :: (ListLikeIO full item) => Handle -> full -> IO ()

+ Data.ListLike.IO: hPutStr :: ListLikeIO full item => Handle -> full -> IO ()

- Data.ListLike.IO: hPutStrLn :: (ListLikeIO full item) => Handle -> full -> IO ()

+ Data.ListLike.IO: hPutStrLn :: ListLikeIO full item => Handle -> full -> IO ()

- Data.ListLike.IO: interact :: (ListLikeIO full item) => (full -> full) -> IO ()

+ Data.ListLike.IO: interact :: ListLikeIO full item => (full -> full) -> IO ()

- Data.ListLike.IO: putStr :: (ListLikeIO full item) => full -> IO ()

+ Data.ListLike.IO: putStr :: ListLikeIO full item => full -> IO ()

- Data.ListLike.IO: putStrLn :: (ListLikeIO full item) => full -> IO ()

+ Data.ListLike.IO: putStrLn :: ListLikeIO full item => full -> IO ()

- Data.ListLike.IO: readFile :: (ListLikeIO full item) => FilePath -> IO full

+ Data.ListLike.IO: readFile :: ListLikeIO full item => FilePath -> IO full

- Data.ListLike.IO: writeFile :: (ListLikeIO full item) => FilePath -> full -> IO ()

+ Data.ListLike.IO: writeFile :: ListLikeIO full item => FilePath -> full -> IO ()

- Data.ListLike.String: fromString :: (StringLike s) => String -> s

+ Data.ListLike.String: fromString :: StringLike s => String -> s

- Data.ListLike.String: toString :: (StringLike s) => s -> String

+ Data.ListLike.String: toString :: StringLike s => s -> String

- Data.ListLike.Utils: and :: (ListLike full Bool) => full -> Bool

+ Data.ListLike.Utils: and :: ListLike full Bool => full -> Bool

- Data.ListLike.Utils: list :: (ListLike full a) => b -> (a -> full -> b) -> full -> b

+ Data.ListLike.Utils: list :: ListLike full a => b -> (a -> full -> b) -> full -> b

- Data.ListLike.Utils: or :: (ListLike full Bool) => full -> Bool

+ Data.ListLike.Utils: or :: ListLike full Bool => full -> Bool

Files

ListLike.cabal +9/−9
README +10/−0
src/Data/ListLike/Instances.hs +1/−1
testsrc/runtests.hs +0/−3

ListLike.cabal view

@@ -1,14 +1,14 @@ Name: ListLike-Version: 1.0.2+Version: 1.1.0 License: LGPL-Maintainer: John W. Lato <jwlato@gmail.com>+Maintainer: John Goerzen <jgoerzen@complete.org> Author: John Goerzen Copyright: Copyright (c) 2007-2008 John Goerzen license-file: COPYRIGHT-extra-source-files: COPYING+extra-source-files: COPYING, README Category: Generics Build-Type: Simple-homepage: http://github.com/JohnLato/listlike+homepage: http://software.complete.org/listlike synopsis: Generic support for list-like structures Description: Generic support for list-like structures in Haskell.  .@@ -30,11 +30,11 @@         Data.ListLike.String,         Data.ListLike.Utils -- Other-Modules: Data.ConfigFile.Lexer-Build-Depends: base           >= 3 && < 5-              ,mtl            >= 1.1.0 && < 1.2-              ,containers     >= 0.3 && < 0.4-              ,bytestring     >= 0.9.1 && < 0.10-              ,array          >= 0.3 && < 0.4+Build-Depends: base       >= 3     && < 5+              ,mtl        >= 1.1.0 && < 1.2+              ,containers >= 0.3   && < 0.5+              ,bytestring >= 0.9.1 && < 0.10+              ,array      >= 0.3   && < 0.4  Executable: runtests Buildable: False

+ README view

@@ -0,0 +1,10 @@+The ListLike package provides typeclasses and instances to allow+polymorphism over many common datatypes.++The package can be built/installed with Cabal.  If you have cabal-install,+simply run "cabal install ListLike" to install the package.  Without+cabal-install, execute the following commands:++$ runghc Setup.hs configure+$ runghc Setup.hs build+$ runghc Setup.hs install

src/Data/ListLike/Instances.hs view

@@ -304,7 +304,7 @@ -- Map  instance (Ord key) => FoldableLL (Map.Map key val) (key, val) where-    foldr f start m = Map.foldWithKey func start m+    foldr f start m = Map.foldrWithKey func start m             where func k v accum = f (k, v) accum     foldl f start m = L.foldl f start (Map.toList m)

testsrc/runtests.hs view

@@ -1,6 +1,3 @@-{-# LANGUAGE ScopedTypeVariables #-}-- {- Copyright (C) 2007 John Goerzen <jgoerzen@complete.org>