EdisonCore 1.3.2.1 → 1.3.3

raw patch · 28 files changed

+193/−154 lines, 28 filesdep +faildep ~EdisonAPIdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: fail

Dependency ranges changed: EdisonAPI, base

API changes (from Hackage documentation)

Files

• CHANGES +4/−0
• EdisonCore.cabal +6/−4
• src/Data/Edison/Assoc/AssocList.hs +10/−9
• src/Data/Edison/Assoc/Defaults.hs +3/−1
• src/Data/Edison/Assoc/PatriciaLoMap.hs +9/−8
• src/Data/Edison/Assoc/StandardMap.hs +7/−6
• src/Data/Edison/Assoc/TernaryTrie.hs +12/−10
• src/Data/Edison/Coll/Defaults.hs +5/−4
• src/Data/Edison/Coll/EnumSet.hs +4/−3
• src/Data/Edison/Coll/LazyPairingHeap.hs +4/−3
• src/Data/Edison/Coll/LeftistHeap.hs +4/−3
• src/Data/Edison/Coll/MinHeap.hs +4/−3
• src/Data/Edison/Coll/SkewHeap.hs +4/−3
• src/Data/Edison/Coll/SplayHeap.hs +4/−3
• src/Data/Edison/Coll/StandardSet.hs +4/−3
• src/Data/Edison/Coll/UnbalancedSet.hs +4/−3
• src/Data/Edison/Concrete/FingerTree.hs +3/−2
• src/Data/Edison/Seq/BankersQueue.hs +10/−8
• src/Data/Edison/Seq/BinaryRandList.hs +10/−9
• src/Data/Edison/Seq/BraunSeq.hs +10/−8
• src/Data/Edison/Seq/Defaults.hs +6/−4
• src/Data/Edison/Seq/FingerSeq.hs +14/−13
• src/Data/Edison/Seq/JoinList.hs +8/−7
• src/Data/Edison/Seq/MyersStack.hs +10/−8
• src/Data/Edison/Seq/RandList.hs +10/−8
• src/Data/Edison/Seq/RevSeq.hs +8/−7
• src/Data/Edison/Seq/SimpleQueue.hs +8/−7
• src/Data/Edison/Seq/SizedSeq.hs +8/−7

@@ -1,3 +1,7 @@+Changes in 1.3.3+  * Updates to handle MonadFail changes in GHC 8.x+  * Updates to fix compile issues in GHC 9+ Changes in 1.3.2.1   * Fix compile problems on GHC 7.10 

@@ -1,7 +1,7 @@ Name:           EdisonCore Cabal-Version:  >= 1.10 Build-Type:     Simple-Version:        1.3.2.1+Version:        1.3.3 License:        MIT License-File:   COPYRIGHT Author:         Chris Okasaki@@ -57,13 +57,15 @@      base == 4.*,      mtl,      QuickCheck >= 2.8.2 && < 3,-     EdisonAPI == 1.3.*,+     EdisonAPI >= 1.3.3 && < 1.4,      containers,      array    if impl(ghc < 8.0)-    -- Provide/emulate Data.Semigroups` API for pre-GHC-8-    Build-Depends: semigroups == 0.18.*+    Build-Depends:+      fail,+      -- Provide/emulate Data.Semigroups` API for pre-GHC-8+      semigroups == 0.18.*    Default-Language: Haskell2010   Default-Extensions:

@@ -58,8 +58,9 @@ import qualified Prelude import Data.Monoid import Data.Semigroup as SG-import Control.Monad.Identity+import qualified Control.Monad.Fail as Fail import qualified Data.Edison.Assoc as A+import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S import qualified Data.Edison.Seq.BinaryRandList as RL import Data.Edison.Assoc.Defaults@@ -82,10 +83,10 @@ member        :: Eq k => k -> FM k a -> Bool count         :: Eq k => k -> FM k a -> Int lookup        :: Eq k => k -> FM k a -> a-lookupM       :: (Eq k, Monad rm) => k -> FM k a -> rm a+lookupM       :: (Eq k, Fail.MonadFail rm) => k -> FM k a -> rm a lookupAll     :: (Eq k,S.Sequence seq) => k -> FM k a -> seq a lookupAndDelete    :: Eq k => k -> FM k a -> (a,FM k a)-lookupAndDeleteM   :: (Eq k,Monad rm)   => k -> FM k a -> rm (a,FM k a)+lookupAndDeleteM   :: (Eq k, Fail.MonadFail rm)   => k -> FM k a -> rm (a,FM k a) lookupAndDeleteAll :: (Eq k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a) lookupWithDefault  :: Eq k => a -> k -> FM k a -> a adjust             :: Eq k => (a -> a) -> k -> FM k a -> FM k a@@ -143,11 +144,11 @@                         (k -> a -> a -> a) -> seq (FM k a) -> FM k a intersectionWithKey :: Eq k => (k -> a -> b -> c) -> FM k a -> FM k b -> FM k c -minView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)+minView          :: (Ord k, Fail.MonadFail m) => FM k a -> m (a,FM k a) minElem          :: Ord k => FM k a -> a deleteMin        :: Ord k => FM k a -> FM k a unsafeInsertMin  :: Ord k => k -> a -> FM k a -> FM k a-maxView          :: (Ord k,Monad m) => FM k a -> m (a,FM k a)+maxView          :: (Ord k, Fail.MonadFail m) => FM k a -> m (a,FM k a) maxElem          :: Ord k => FM k a -> a deleteMax        :: Ord k => FM k a -> FM k a unsafeInsertMax  :: Ord k => k -> a -> FM k a -> FM k a@@ -169,9 +170,9 @@ partitionLE_GT   :: Ord k => k -> FM k a -> (FM k a,FM k a) partitionLT_GT   :: Ord k => k -> FM k a -> (FM k a,FM k a) -minViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)+minViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a) minElemWithKey    :: Ord k => FM k a -> (k,a)-maxViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)+maxViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a) maxElemWithKey    :: Ord k => FM k a -> (k,a) foldrWithKey      :: Ord k => (k -> a -> b -> b) -> b -> FM k a -> b foldlWithKey      :: Ord k => (b -> k -> a -> b) -> b -> FM k a -> b@@ -309,7 +310,7 @@ count key (I k _ m) | key == k  = 1                     | otherwise = count key m -lookup key m = runIdentity (lookupM key m)+lookup key m = runFail_ (lookupM key m)  lookupM _ E = fail "AssocList.lookup: lookup failed" lookupM key (I k x m) | key == k  = return x@@ -319,7 +320,7 @@ lookupAll key (I k x m) | key == k  = S.singleton x                         | otherwise = lookupAll key m -lookupAndDelete key m = runIdentity (lookupAndDeleteM key m)+lookupAndDelete key m = runFail_ (lookupAndDeleteM key m)  lookupAndDeleteM _ E = fail "AssocList.lookupAndDeleteM: lookup failed" lookupAndDeleteM key (I k x m)

@@ -15,6 +15,8 @@  import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter) +import qualified Control.Monad.Fail as Fail+ import Data.Edison.Assoc import qualified Data.Edison.Seq as S import qualified Data.Edison.Seq.ListSeq as L@@ -190,7 +192,7 @@      Nothing -> error (instanceName m ++ ".lookupAndDelete: lookup failed")      Just x  -> (x, delete k m) -lookupAndDeleteMDefault :: (Monad rm, AssocX m k) => k -> m a -> rm (a, m a)+lookupAndDeleteMDefault :: (Fail.MonadFail rm, AssocX m k) => k -> m a -> rm (a, m a) lookupAndDeleteMDefault k m =   case lookupM k m of      Nothing -> fail (instanceName m ++ ".lookupAndDelete: lookup failed")

@@ -55,10 +55,11 @@  import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter) import qualified Prelude-import Control.Monad.Identity (runIdentity)+import qualified Control.Monad.Fail as Fail import Data.Monoid import Data.Semigroup as SG import qualified Data.Edison.Assoc as A+import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S import qualified Data.Edison.Seq.ListSeq as L import Data.Edison.Assoc.Defaults@@ -210,9 +211,9 @@ member k (B _ m t0 t1) = if zeroBit k m then member k t0 else member k t1  lookup :: Int -> FM a -> a-lookup k m = runIdentity (lookupM k m)+lookup k m = runFail_ (lookupM k m) -lookupM :: (Monad rm) => Int -> FM a -> rm a+lookupM :: (Fail.MonadFail rm) => Int -> FM a -> rm a lookupM _ E = fail "PatriciaLoMap.lookup: lookup failed" lookupM k (L j x)   | j == k    = return x@@ -233,7 +234,7 @@                            (error "PatriciaLoMap.lookupAndDelete: lookup failed")                            (,) -lookupAndDeleteM :: Monad m => Int -> FM a -> m (a, FM a)+lookupAndDeleteM :: Fail.MonadFail m => Int -> FM a -> m (a, FM a) lookupAndDeleteM       = doLookupAndDelete                            (fail "PatriciaLoMap.lookupAndDelete: lookup failed")                            (\x m -> return (x,m))@@ -583,25 +584,25 @@             GT -> x : merge xs (y:ys)             EQ -> error "PatriciaLoMap: bug in ordListFM_rev" -minView :: Monad m => FM a -> m (a, FM a)+minView :: Fail.MonadFail m => FM a -> m (a, FM a) minView fm =    case ordListFM fm of      [] -> fail $ moduleName++".minView: empty map"      ((k,x):_) -> return (x,delete k fm) -minViewWithKey :: Monad m => FM a -> m ((Int, a), FM a)+minViewWithKey :: Fail.MonadFail m => FM a -> m ((Int, a), FM a) minViewWithKey fm =    case ordListFM fm of      [] -> fail $ moduleName++".minViewWithKey: empty map"      ((k,x):_) -> return ((k,x),delete k fm) -maxView :: Monad m => FM a -> m (a, FM a)+maxView :: Fail.MonadFail m => FM a -> m (a, FM a) maxView fm =   case ordListFM_rev fm of      [] -> fail $ moduleName++".maxView: empty map"      ((k,x):_) -> return (x,delete k fm) -maxViewWithKey :: Monad m => FM a -> m ((Int, a), FM a)+maxViewWithKey :: Fail.MonadFail m => FM a -> m ((Int, a), FM a) maxViewWithKey fm =    case ordListFM_rev fm of      [] -> fail $ moduleName++".maxViewWithKey: empty map"

@@ -51,6 +51,7 @@  import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter) import qualified Prelude+import qualified Control.Monad.Fail as Fail import qualified Data.Edison.Assoc as A import qualified Data.Edison.Seq as S import qualified Data.Edison.Seq.ListSeq as L@@ -81,10 +82,10 @@ count             :: Ord k => k -> FM k a -> Int lookup            :: Ord k => k -> FM k a -> a lookupAll         :: (Ord k,S.Sequence seq) => k -> FM k a -> seq a-lookupM           :: (Ord k,Monad m) => k -> FM k a -> m a+lookupM           :: (Ord k, Fail.MonadFail m) => k -> FM k a -> m a lookupWithDefault :: Ord k => a -> k -> FM k a -> a lookupAndDelete   :: Ord k => k -> FM k a -> (a, FM k a)-lookupAndDeleteM  :: (Ord k,Monad m) => k -> FM k a -> m (a, FM k a)+lookupAndDeleteM  :: (Ord k, Fail.MonadFail m) => k -> FM k a -> m (a, FM k a) lookupAndDeleteAll :: (Ord k,S.Sequence seq) => k -> FM k a -> (seq a,FM k a) adjust            :: Ord k => (a->a) -> k -> FM k a -> FM k a adjustAll         :: Ord k => (a->a) -> k -> FM k a -> FM k a@@ -103,11 +104,11 @@ partition         :: Ord k => (a -> Bool) -> FM k a -> (FM k a,FM k a) elements          :: (Ord k,S.Sequence seq) => FM k a -> seq a -minView           :: (Ord k,Monad m) => FM k a -> m (a, FM k a)+minView           :: (Ord k, Fail.MonadFail m) => FM k a -> m (a, FM k a) minElem           :: Ord k => FM k a -> a deleteMin         :: Ord k => FM k a -> FM k a unsafeInsertMin   :: Ord k => k -> a -> FM k a -> FM k a-maxView           :: (Ord k,Monad m) => FM k a -> m (a, FM k a)+maxView           :: (Ord k, Fail.MonadFail m) => FM k a -> m (a, FM k a) maxElem           :: Ord k => FM k a -> a deleteMax         :: Ord k => FM k a -> FM k a unsafeInsertMax   :: Ord k => k -> a -> FM k a -> FM k a@@ -165,9 +166,9 @@ filterWithKey     :: Ord k => (k -> a -> Bool) -> FM k a -> FM k a partitionWithKey  :: Ord k => (k -> a -> Bool) -> FM k a -> (FM k a,FM k a) -minViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)+minViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a) minElemWithKey    :: Ord k => FM k a -> (k,a)-maxViewWithKey    :: (Ord k,Monad m) => FM k a -> m ((k, a), FM k a)+maxViewWithKey    :: (Ord k, Fail.MonadFail m) => FM k a -> m ((k, a), FM k a) maxElemWithKey    :: Ord k => FM k a -> (k,a) foldrWithKey      :: (k -> a -> b -> b) -> b -> FM k a -> b foldlWithKey      :: (b -> k -> a -> b) -> b -> FM k a -> b

@@ -55,8 +55,10 @@ import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter) import qualified Prelude import qualified Data.Edison.Assoc as A+import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S import qualified Data.List as L+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Monoid import Data.Semigroup as SG@@ -83,10 +85,10 @@ member        :: Ord k => [k] -> FM k a -> Bool count         :: Ord k => [k] -> FM k a -> Int lookup        :: Ord k => [k] -> FM k a -> a-lookupM       :: (Ord k, Monad rm) => [k] -> FM k a -> rm a+lookupM       :: (Ord k, Fail.MonadFail rm) => [k] -> FM k a -> rm a lookupAll     :: (Ord k,S.Sequence seq) => [k] -> FM k a -> seq a lookupAndDelete    :: Ord k => [k] -> FM k a -> (a, FM k a)-lookupAndDeleteM   :: (Ord k, Monad rm) => [k] -> FM k a -> rm (a, FM k a)+lookupAndDeleteM   :: (Ord k, Fail.MonadFail rm) => [k] -> FM k a -> rm (a, FM k a) lookupAndDeleteAll :: (Ord k, S.Sequence seq) => [k] -> FM k a -> (seq a,FM k a) lookupWithDefault  :: Ord k => a -> [k] -> FM k a -> a adjust        :: Ord k => (a -> a) -> [k] -> FM k a -> FM k a@@ -527,7 +529,7 @@  count = countUsingMember -lookup m k = runIdentity (lookupM m k)+lookup m k = runFail_ (lookupM m k)  lookupM [] (FM Nothing _)   = fail "TernaryTrie.lookup: lookup failed"@@ -854,18 +856,18 @@  -- OrdAssocX -minViewFMB :: Monad m => FMB k a -> (FMB k a -> FM k a) -> m (a, FM k a)+minViewFMB :: Fail.MonadFail m => FMB k a -> (FMB k a -> FM k a) -> m (a, FM k a) minViewFMB E _ = fail $ moduleName++".minView: empty map" minViewFMB (I i k (Just v) E m r)        f = return (v, f (I i k Nothing E m r)) minViewFMB (I _ _ Nothing  E (FMB' E) _) _ = error $ moduleName++".minView: bug!" minViewFMB (I _ k Nothing  E (FMB' m) r) f = minViewFMB m (\m' -> f (mkVBalancedFMB k Nothing E (FMB' m') r)) minViewFMB (I _ k mv l m r)              f = minViewFMB l (\l' -> f (mkVBalancedFMB k mv l' m r)) -minView :: Monad m => FM k a -> m (a,FM k a)+minView :: Fail.MonadFail m => FM k a -> m (a,FM k a) minView (FM (Just v) fmb) = return (v, FM Nothing fmb) minView (FM Nothing fmb)  = minViewFMB fmb (FM Nothing) -minViewWithKeyFMB :: Monad m => FMB k a -> ([k] -> [k]) -> (FMB k a -> FM k a) -> m (([k],a),FM k a)+minViewWithKeyFMB :: Fail.MonadFail m => FMB k a -> ([k] -> [k]) -> (FMB k a -> FM k a) -> m (([k],a),FM k a) minViewWithKeyFMB E _ _ = fail $ moduleName++".minView: empty map" minViewWithKeyFMB (I i k (Just v) E m r)        kf f = return ((kf [k],v),f (I i k Nothing E m r)) minViewWithKeyFMB (I _ _ Nothing  E (FMB' E) _) _ _ = error $ moduleName++".minViewWithKey: bug!"@@ -874,7 +876,7 @@ minViewWithKeyFMB (I _ k mv l m r)              kf f = minViewWithKeyFMB l kf                                                         (\l' -> f (mkVBalancedFMB k mv l' m r)) -minViewWithKey :: Monad m => FM k a -> m (([k],a),FM k a)+minViewWithKey :: Fail.MonadFail m => FM k a -> m (([k],a),FM k a) minViewWithKey (FM (Just v) fmb) = return (([],v),FM Nothing fmb) minViewWithKey (FM Nothing fmb)  = minViewWithKeyFMB fmb id (FM Nothing) @@ -906,7 +908,7 @@ unsafeInsertMin :: Ord k => [k] -> a -> FM k a -> FM k a unsafeInsertMin = insert -maxViewFMB :: Monad m => FMB k a -> (FMB k a -> FM k a) -> m (a, FM k a)+maxViewFMB :: Fail.MonadFail m => FMB k a -> (FMB k a -> FM k a) -> m (a, FM k a) maxViewFMB (I _ _ (Just v) l (FMB' E) E) f = return (v, f l) --maxViewFMB (I i k (Just v) l (FMB' E) E) f = return (v, f (I i k Nothing l (FMB' E) E)) maxViewFMB (I _ _ Nothing  _ (FMB' E) E) _ = error $ moduleName++".maxView: bug!"@@ -914,7 +916,7 @@ maxViewFMB (I _ k mv l m r)              f = maxViewFMB r (\r' -> f (mkVBalancedFMB k mv l m r')) maxViewFMB E                             _ = error $ moduleName++".maxView: bug!" -maxView :: Monad m => FM k a -> m (a, FM k a)+maxView :: Fail.MonadFail m => FM k a -> m (a, FM k a) maxView (FM Nothing E)  = fail $ moduleName++".maxView: empty map" maxView (FM (Just v) E) = return (v,FM Nothing E) maxView (FM mv fmb)     = maxViewFMB fmb (FM mv)@@ -930,7 +932,7 @@ maxViewWithKeyFMB E                             _ _ = error $ moduleName++".maxViewWithKey: bug!"  -maxViewWithKey :: Monad m => FM k a -> m (([k],a), FM k a)+maxViewWithKey :: Fail.MonadFail m => FM k a -> m (([k],a), FM k a) maxViewWithKey (FM Nothing E)  = fail $ moduleName++".maxViewWithKey: empty map" maxViewWithKey (FM (Just v) E) = return (([],v),FM Nothing E) maxViewWithKey (FM mv fmb)     = maxViewWithKeyFMB fmb id (FM mv)

@@ -14,8 +14,9 @@ module Data.Edison.Coll.Defaults where  import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter)-import Control.Monad.Identity+import qualified Control.Monad.Fail as Fail +import Data.Edison.Prelude ( runFail_ ) import Data.Edison.Coll import qualified Data.Edison.Seq as S import qualified Data.Edison.Seq.ListSeq as L@@ -81,7 +82,7 @@         disj _ _ = True  intersectWitnessUsingToOrdList ::-        (OrdColl c a, Monad m) => c -> c -> m (a,a)+        (OrdColl c a, Fail.MonadFail m) => c -> c -> m (a,a) intersectWitnessUsingToOrdList as bs = witness (toOrdList as) (toOrdList bs)   where witness a@(x:xs) b@(y:ys) =           case compare x y of@@ -92,7 +93,7 @@         witness _ _ = fail $ instanceName as ++ ".intersect: failed"  lookupUsingLookupM :: Coll c a => a -> c -> a-lookupUsingLookupM x ys = runIdentity (lookupM x ys)+lookupUsingLookupM x ys = runFail_ (lookupM x ys)  lookupUsingLookupAll :: Coll c a => a -> c -> a lookupUsingLookupAll x ys =@@ -100,7 +101,7 @@     (y:_) -> y     [] -> error $ instanceName ys ++ ".lookup: lookup failed" -lookupMUsingLookupAll :: (Coll c a, Monad m) => a -> c -> m a+lookupMUsingLookupAll :: (Coll c a, Fail.MonadFail m) => a -> c -> m a lookupMUsingLookupAll x ys =   case lookupAll x ys of     (y:_) -> return y

@@ -157,6 +157,7 @@  import qualified Prelude import Prelude hiding (filter,foldl,foldr,null,map,lookup,foldl1,foldr1)+import qualified Control.Monad.Fail as Fail import qualified Data.Bits as Bits import Data.Bits hiding (complement) import Data.Word@@ -251,7 +252,7 @@ lookup :: (Eq a, Enum a) => a -> Set a -> a lookup = lookupUsingLookupAll -lookupM :: (Eq a, Enum a, Monad m) => a -> Set a -> m a+lookupM :: (Eq a, Enum a, Fail.MonadFail m) => a -> Set a -> m a lookupM x s    | member x s = return x    | otherwise  = fail (moduleName++".lookupM: lookup failed")@@ -340,12 +341,12 @@    | w == 0    = empty    | otherwise = Set $ clearBit w $ msb w -minView :: (Enum a, Monad m) => Set a -> m (a, Set a)+minView :: (Enum a, Fail.MonadFail m) => Set a -> m (a, Set a) minView (Set w)    | w == 0    = fail (moduleName++".minView: empty set")    | otherwise = let i = lsb w in return (toEnum i,Set $ clearBit w i) -maxView :: (Enum a, Monad m) => Set a -> m (a, Set a)+maxView :: (Enum a, Fail.MonadFail m) => Set a -> m (a, Set a) maxView (Set w)    | w == 0    = fail (moduleName++".maxView: empty set")    | otherwise = let i = msb w in return (toEnum i, Set $ clearBit w i)

@@ -49,6 +49,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  moduleName :: String@@ -359,7 +360,7 @@             EQ -> S.lcons x $ look i $ look xs rest             GT -> rest -minView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+minView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) minView E = fail "LazyPairingHeap.minView: empty heap" minView (H1 x xs) = return (x,xs) minView (H2 x h xs) = return (x,union h xs)@@ -369,7 +370,7 @@ minElem (H1 x _) = x minElem (H2 x _ _) = x -maxView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+maxView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) maxView E = fail "LazyPairingHeap.maxView: empty heap" maxView xs = return (y,xs')   where (xs', y) = maxView' xs@@ -474,7 +475,7 @@ lookup :: Ord a => a -> Heap a -> a lookup = lookupUsingLookupAll -lookupM :: (Ord a, Monad m) => a -> Heap a -> m a+lookupM :: (Ord a, Fail.MonadFail m) => a -> Heap a -> m a lookupM = lookupMUsingLookupAll  lookupWithDefault :: Ord a => a -> a -> Heap a -> a

@@ -47,6 +47,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  moduleName :: String@@ -173,7 +174,7 @@   where tol E rest = rest         tol (L _ x a b) rest = S.lcons x (tol b (tol a rest)) -lookupM :: (Ord a, Monad m) => a -> Heap a -> m a+lookupM :: (Ord a, Fail.MonadFail m) => a -> Heap a -> m a lookupM _ E = fail "LeftistHeap.lookupM: XXX" lookupM x (L _ y a b) =   case compare x y of@@ -299,7 +300,7 @@                       (b', hs'') = collect b hs'                   in (node x a' b', hs'') -minView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+minView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) minView E = fail "LeftistHeap.minView: empty collection" minView (L _ x a b) = return (x, union a b) @@ -307,7 +308,7 @@ minElem E = error "LeftistHeap.minElem: empty collection" minElem (L _ x _ _) = x -maxView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+maxView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) maxView E = fail "LeftistHeap.maxView: empty collection" maxView (L _ x E _) = return (x, E) maxView (L _ x a E) = return (y, L 1 x a' E)

@@ -46,6 +46,7 @@ import Data.Monoid import qualified Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  data Min h a = E | M a h  deriving (Eq)@@ -75,7 +76,7 @@  toSeq     :: (C.Coll h a,S.Sequence s) => Min h a -> s a lookup    :: (C.Coll h a,Ord a) => a -> Min h a -> a-lookupM   :: (C.Coll h a,Ord a,Monad m) => a -> Min h a -> m a+lookupM   :: (C.Coll h a, Ord a, Fail.MonadFail m) => a -> Min h a -> m a lookupAll :: (C.Coll h a,Ord a,S.Sequence s) => a -> Min h a -> s a lookupWithDefault :: (C.Coll h a,Ord a) => a -> a -> Min h a -> a fold      :: (C.Coll h a) => (a -> b -> b) -> b -> Min h a -> b@@ -100,9 +101,9 @@ partitionLE_GT :: (C.OrdColl h a,Ord a) => a -> Min h a -> (Min h a, Min h a) partitionLT_GT :: (C.OrdColl h a,Ord a) => a -> Min h a -> (Min h a, Min h a) -minView :: (C.OrdColl h a,Ord a,Monad m) => Min h a -> m (a, Min h a)+minView :: (C.OrdColl h a, Ord a, Fail.MonadFail m) => Min h a -> m (a, Min h a) minElem :: (C.OrdColl h a,Ord a) => Min h a -> a-maxView :: (C.OrdColl h a,Ord a,Monad m) => Min h a -> m (a, Min h a)+maxView :: (C.OrdColl h a, Ord a, Fail.MonadFail m) => Min h a -> m (a, Min h a) maxElem :: (C.OrdColl h a,Ord a) => Min h a -> a foldr :: (C.OrdColl h a,Ord a) => (a -> b -> b) -> b -> Min h a -> b foldl :: (C.OrdColl h a,Ord a) => (b -> a -> b) -> b -> Min h a -> b

@@ -47,6 +47,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail  import Test.QuickCheck @@ -142,7 +143,7 @@   where tol E rest = rest         tol (T x a b) rest = S.lcons x (tol b (tol a rest)) -lookupM :: (Ord a, Monad m) => a -> Heap a -> m a+lookupM :: (Ord a, Fail.MonadFail m) => a -> Heap a -> m a lookupM _ E = fail "SkewHeap.lookupM: XXX" lookupM x (T y a b) =   case compare x y of@@ -267,7 +268,7 @@                       (b', hs'') = collect b hs'                   in (T x a' b', hs'') -minView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+minView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) minView E = fail "SkewHeap.minView: empty heap" minView (T x a b) = return (x, union a b) @@ -275,7 +276,7 @@ minElem E = error "SkewHeap.minElem: empty collection" minElem (T x _ _) = x -maxView :: (Ord a, Monad m) => Heap a -> m (a, Heap a)+maxView :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) maxView E = fail "SkewHeap.maxView: empty heap" maxView (T x E E) = return (x, E) maxView (T x a E) = return (y, T x a' E)

@@ -50,6 +50,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  moduleName :: String@@ -93,7 +94,7 @@  toSeq     :: (Ord a, S.Sequence s) => Heap a -> s a lookup    :: Ord a => a -> Heap a -> a-lookupM   :: (Ord a,Monad m) => a -> Heap a -> m a+lookupM   :: (Ord a, Fail.MonadFail m) => a -> Heap a -> m a lookupAll :: (Ord a,S.Sequence s) => a -> Heap a -> s a lookupWithDefault :: Ord a => a -> a -> Heap a -> a fold      :: Ord a => (a -> b -> b) -> b -> Heap a -> b@@ -118,9 +119,9 @@ partitionLE_GT   :: Ord a => a -> Heap a -> (Heap a, Heap a) partitionLT_GT   :: Ord a => a -> Heap a -> (Heap a, Heap a) -minView  :: (Ord a,Monad m) => Heap a -> m (a, Heap a)+minView  :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) minElem  :: Ord a => Heap a -> a-maxView  :: (Ord a,Monad m) => Heap a -> m (a, Heap a)+maxView  :: (Ord a, Fail.MonadFail m) => Heap a -> m (a, Heap a) maxElem  :: Ord a => Heap a -> a foldr    :: Ord a => (a -> b -> b) -> b -> Heap a -> b foldl    :: Ord a => (b -> a -> b) -> b -> Heap a -> b

@@ -43,6 +43,7 @@  import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter) import qualified Prelude+import qualified Control.Monad.Fail as Fail import qualified Data.List  import qualified Data.Edison.Coll as C@@ -73,7 +74,7 @@  toSeq      :: (Ord a,S.Sequence seq) => Set a -> seq a lookup     :: Ord a => a -> Set a -> a-lookupM    :: (Ord a,Monad m) => a -> Set a -> m a+lookupM    :: (Ord a, Monad m, Fail.MonadFail m) => a -> Set a -> m a lookupAll  :: (Ord a,S.Sequence seq) => a -> Set a -> seq a lookupWithDefault :: Ord a => a -> a -> Set a  -> a fold       :: (a -> b -> b) -> b -> Set a -> b@@ -98,9 +99,9 @@ partitionLE_GT   :: Ord a => a -> Set a -> (Set a, Set a) partitionLT_GT   :: Ord a => a -> Set a -> (Set a, Set a) -minView       :: (Ord a,Monad m) => Set a -> m (a, Set a)+minView       :: (Ord a, Monad m, Fail.MonadFail m) => Set a -> m (a, Set a) minElem       :: Set a -> a-maxView       :: (Ord a,Monad m) => Set a -> m (a, Set a)+maxView       :: (Ord a, Monad m, Fail.MonadFail m) => Set a -> m (a, Set a) maxElem       :: Set a -> a foldr         :: (a -> b -> b) -> b -> Set a -> b foldl         :: (b -> a -> b) -> b -> Set a -> b

@@ -43,6 +43,7 @@  import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter) import qualified Prelude+import qualified Control.Monad.Fail as Fail import qualified Data.Edison.Coll as C import qualified Data.Edison.Seq as S import Data.Edison.Coll.Defaults@@ -70,7 +71,7 @@  toSeq      :: (Ord a,S.Sequence seq) => Set a -> seq a lookup     :: Ord a => a -> Set a -> a-lookupM    :: (Ord a,Monad m) => a -> Set a -> m a+lookupM    :: (Ord a, Fail.MonadFail m) => a -> Set a -> m a lookupAll  :: (Ord a,S.Sequence seq) => a -> Set a -> seq a lookupWithDefault :: Ord a => a -> a -> Set a -> a fold       :: (a -> b -> b) -> b -> Set a -> b@@ -95,9 +96,9 @@ partitionLE_GT   :: Ord a => a -> Set a -> (Set a, Set a) partitionLT_GT   :: Ord a => a -> Set a -> (Set a, Set a) -minView       :: (Monad m) => Set a -> m (a, Set a)+minView       :: (Fail.MonadFail m) => Set a -> m (a, Set a) minElem       :: Set a -> a-maxView       :: (Monad m) => Set a -> m (a, Set a)+maxView       :: (Fail.MonadFail m) => Set a -> m (a, Set a) maxElem       :: Set a -> a foldr         :: (a -> b -> b) -> b -> Set a -> b foldl         :: (b -> a -> b) -> b -> Set a -> b

@@ -81,6 +81,7 @@ import Data.Edison.Prelude  import Control.Monad (liftM2, liftM3, liftM4)+import qualified Control.Monad.Fail as Fail   infixr 5 `lcons`@@ -334,7 +335,7 @@ null _ = False  -- | /O(1)/. Analyse the left end of a sequence.-lview :: (Measured v a, Monad m) => FingerTree v a -> m (a,FingerTree v a)+lview :: (Measured v a, Fail.MonadFail m) => FingerTree v a -> m (a,FingerTree v a) lview Empty                 =  fail "FingerTree.lview: empty tree" lview (Single x)            =  return (x, Empty) lview (Deep _ (One x) m sf) =  return . (,) x $@@ -357,7 +358,7 @@ ltailDigit _ = error "FingerTree.ltailDigit: bug!"  -- | /O(1)/. Analyse the right end of a sequence.-rview :: (Measured v a, Monad m) => FingerTree v a -> m (a, FingerTree v a)+rview :: (Measured v a, Fail.MonadFail m) => FingerTree v a -> m (a, FingerTree v a) rview Empty                  = fail "FingerTree.rview: empty tree" rview (Single x)             = return (x, Empty) rview (Deep _ pr m (One x))  = return . (,) x $

@@ -51,11 +51,13 @@  import qualified Control.Applicative as App +import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S ( Sequence(..) ) import Data.Edison.Seq.Defaults import qualified Data.Edison.Seq.ListSeq as L import Data.Monoid import Data.Semigroup as SG+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Test.QuickCheck @@ -66,16 +68,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -106,7 +108,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -263,7 +265,7 @@  -- reduce1: given sizes could do more effective job of dividing evenly! -lookup idx q = runIdentity (lookupM idx q)+lookup idx q = runFail_ (lookupM idx q)  lookupM idx (Q i xs ys j)   | idx < i   = L.lookupM idx xs

@@ -55,14 +55,15 @@                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)  import qualified Control.Applicative as App-import Control.Monad.Identity import Data.Maybe +import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S ( Sequence(..) ) import Data.Edison.Seq.Defaults import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  -- signatures for exported functions@@ -72,16 +73,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -112,7 +113,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -267,7 +268,7 @@         inb (Even ps) i = inb ps (half i)         inb (Odd _ ps) i = (i == 0) || inb ps (half (i-1)) -lookup i xs = runIdentity (lookupM i xs)+lookup i xs = runFail_ (lookupM i xs)  lookupM i xs     | i < 0     = fail "BinaryRandList.lookup: bad subscript"

@@ -72,6 +72,7 @@                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)  import qualified Control.Applicative as App+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Maybe import Data.Monoid@@ -79,6 +80,7 @@ import Test.QuickCheck  +import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S ( Sequence(..) ) import Data.Edison.Seq.Defaults import qualified Data.Edison.Seq.ListSeq as L@@ -91,16 +93,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -131,7 +133,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -344,7 +346,7 @@           | i == 0    = True           | otherwise = inb b (half i - 1) -lookup i xs = runIdentity (lookupM i xs)+lookup i xs = runFail_ (lookupM i xs)  lookupM i xs   | i < 0     = fail "BraunSeq.lookupM: bad subscript"

@@ -17,9 +17,11 @@                        filter,takeWhile,dropWhile,lookup,take,drop,splitAt,                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null) +import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Char (isSpace) +import Data.Edison.Prelude ( runFail_ ) import Data.Edison.Seq import qualified Data.Edison.Seq.ListSeq as L @@ -33,7 +35,7 @@ appendUsingFoldr s t | null t = s                             | otherwise = foldr lcons t s -rviewDefault :: (Monad m, Sequence s) => s a -> m (a, s a)+rviewDefault :: (Fail.MonadFail m, Sequence s) => s a -> m (a, s a) rviewDefault xs   | null xs   = fail $ instanceName xs ++ ".rview: empty sequence"   | otherwise = return (rhead xs, rtail xs)@@ -49,7 +51,7 @@             Nothing      -> empty             Just (y, ys) -> lcons x (rt y ys) -rtailMUsingLview :: (Monad m,Sequence s) => s a -> m (s a)+rtailMUsingLview :: (Fail.MonadFail m, Sequence s) => s a -> m (s a) rtailMUsingLview xs =     case lview xs of       Nothing      -> fail $ instanceName xs ++ ".rtailM: empty sequence"@@ -200,7 +202,7 @@ inBoundsUsingSize i s = i >= 0 && i < size s  lookupUsingLookupM :: Sequence s => Int -> s a -> a-lookupUsingLookupM i s = runIdentity (lookupM i s)+lookupUsingLookupM i s = runFail_ (lookupM i s)  lookupUsingDrop :: Sequence s => Int -> s a -> a lookupUsingDrop i s@@ -220,7 +222,7 @@   | otherwise = lhead s'   where s' = drop i s -lookupMUsingDrop :: (Monad m, Sequence s) => Int -> s a -> m a+lookupMUsingDrop :: (Fail.MonadFail m, Sequence s) => Int -> s a -> m a lookupMUsingDrop i s   -- XXX better error message!   | i < 0 || null s' = fail $ instanceName s

@@ -37,16 +37,17 @@                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)  import qualified Control.Applicative as App-import Data.Edison.Prelude (measure, Measured())+import Data.Edison.Prelude (measure, Measured(), runFail_) import qualified Data.Edison.Seq as S import Data.Edison.Seq.Defaults+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Monoid import Data.Semigroup as SG import Test.QuickCheck  #ifdef __GLASGOW_HASKELL__-import GHC.Base (unsafeCoerce#)+import GHC.Exts (unsafeCoerce#) #endif  @@ -87,16 +88,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -127,7 +128,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -206,10 +207,10 @@ ltailM xs = lview xs >>= return . snd rheadM xs = rview xs >>= return . fst rtailM xs = rview xs >>= return . snd-lhead = runIdentity . lheadM-ltail = runIdentity . ltailM-rhead = runIdentity . rheadM-rtail = runIdentity . rtailM+lhead = runFail_ . lheadM+ltail = runFail_ . ltailM+rhead = runFail_ . rheadM+rtail = runFail_ . rtailM  fold     = foldr fold'    = foldr'

@@ -57,6 +57,7 @@  import Data.Edison.Seq.Defaults import Control.Monad+import qualified Control.Monad.Fail as Fail import Data.Monoid import Data.Semigroup as SG import Test.QuickCheck@@ -68,16 +69,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -108,7 +109,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a

@@ -49,8 +49,10 @@                        zip,zip3,zipWith,zipWith3,unzip,unzip3,null)  import qualified Control.Applicative as App+import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S ( Sequence(..) ) import Data.Edison.Seq.Defaults+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Monoid import Data.Semigroup as SG@@ -63,16 +65,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -103,7 +105,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -246,7 +248,7 @@           | i < j     = (i >= 0)           | otherwise = inb xs' (i - j) -lookup i xs = runIdentity (lookupM i xs)+lookup i xs = runFail_ (lookupM i xs)  lookupM i xs = look xs i   where look E _ = fail "MyersStack.lookup: bad subscript"

@@ -55,8 +55,10 @@  import qualified Control.Applicative as App +import Data.Edison.Prelude ( runFail_ ) import qualified Data.Edison.Seq as S( Sequence(..) ) import Data.Edison.Seq.Defaults+import qualified Control.Monad.Fail as Fail import Control.Monad.Identity import Data.Monoid import Data.Semigroup as SG@@ -69,16 +71,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -109,7 +111,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a@@ -269,7 +271,7 @@           | i < j     = (i >= 0)           | otherwise = inb xs (i - j) -lookup i xs = runIdentity (lookupM i xs)+lookup i xs = runFail_ (lookupM i xs)  lookupM i xs = look xs i   where look E _ = fail "RandList.lookup bad subscript"

@@ -62,6 +62,7 @@ import qualified Data.Edison.Seq.ListSeq as L import Data.Edison.Seq.Defaults -- only used by concatMap import Control.Monad+import qualified Control.Monad.Fail as Fail import Data.Monoid import Data.Semigroup as SG import Test.QuickCheck@@ -75,16 +76,16 @@ lcons          :: S.Sequence s => a -> Rev s a -> Rev s a rcons          :: S.Sequence s => a -> Rev s a -> Rev s a append         :: S.Sequence s => Rev s a -> Rev s a -> Rev s a-lview          :: (S.Sequence s, Monad m) => Rev s a -> m (a, Rev s a)+lview          :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (a, Rev s a) lhead          :: S.Sequence s => Rev s a -> a-lheadM         :: (S.Sequence s, Monad m) => Rev s a -> m a+lheadM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m a ltail          :: S.Sequence s => Rev s a -> Rev s a-ltailM         :: (S.Sequence s, Monad m) => Rev s a -> m (Rev s a)-rview          :: (S.Sequence s, Monad m) => Rev s a -> m (a, Rev s a)+ltailM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (Rev s a)+rview          :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (a, Rev s a) rhead          :: S.Sequence s => Rev s a -> a-rheadM         :: (S.Sequence s, Monad m) => Rev s a -> m a+rheadM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m a rtail          :: S.Sequence s => Rev s a -> Rev s a-rtailM         :: (S.Sequence s, Monad m) => Rev s a -> m (Rev s a)+rtailM         :: (S.Sequence s, Fail.MonadFail m) => Rev s a -> m (Rev s a) null           :: S.Sequence s => Rev s a -> Bool size           :: S.Sequence s => Rev s a -> Int concat         :: S.Sequence s => Rev s (Rev s a) -> Rev s a@@ -115,7 +116,7 @@ copy           :: S.Sequence s => Int -> a -> Rev s a inBounds       :: S.Sequence s => Int -> Rev s a -> Bool lookup         :: S.Sequence s => Int -> Rev s a -> a-lookupM        :: (S.Sequence s, Monad m) => Int -> Rev s a -> m a+lookupM        :: (S.Sequence s, Fail.MonadFail m) => Int -> Rev s a -> m a lookupWithDefault :: S.Sequence s => a -> Int -> Rev s a -> a update         :: S.Sequence s => Int -> a -> Rev s a -> Rev s a adjust         :: S.Sequence s => (a -> a) -> Int -> Rev s a -> Rev s a

@@ -59,6 +59,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  -- signatures for exported functions@@ -68,16 +69,16 @@ lcons          :: a -> Seq a -> Seq a rcons          :: a -> Seq a -> Seq a append         :: Seq a -> Seq a -> Seq a-lview          :: (Monad m) => Seq a -> m (a, Seq a)+lview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) lhead          :: Seq a -> a-lheadM         :: (Monad m) => Seq a -> m a+lheadM         :: (Fail.MonadFail m) => Seq a -> m a ltail          :: Seq a -> Seq a-ltailM         :: (Monad m) => Seq a -> m (Seq a)-rview          :: (Monad m) => Seq a -> m (a, Seq a)+ltailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a)+rview          :: (Fail.MonadFail m) => Seq a -> m (a, Seq a) rhead          :: Seq a -> a-rheadM         :: (Monad m) => Seq a -> m a+rheadM         :: (Fail.MonadFail m) => Seq a -> m a rtail          :: Seq a -> Seq a-rtailM         :: (Monad m) => Seq a -> m (Seq a)+rtailM         :: (Fail.MonadFail m) => Seq a -> m (Seq a) null           :: Seq a -> Bool size           :: Seq a -> Int concat         :: Seq (Seq a) -> Seq a@@ -108,7 +109,7 @@ copy           :: Int -> a -> Seq a inBounds       :: Int -> Seq a -> Bool lookup         :: Int -> Seq a -> a-lookupM        :: (Monad m) => Int -> Seq a -> m a+lookupM        :: (Fail.MonadFail m) => Int -> Seq a -> m a lookupWithDefault :: a -> Int -> Seq a -> a update         :: Int -> a -> Seq a -> Seq a adjust         :: (a -> a) -> Int -> Seq a -> Seq a

@@ -54,6 +54,7 @@ import Data.Monoid import Data.Semigroup as SG import Control.Monad+import qualified Control.Monad.Fail as Fail import Test.QuickCheck  @@ -65,16 +66,16 @@ lcons          :: S.Sequence s => a -> Sized s a -> Sized s a rcons          :: S.Sequence s => a -> Sized s a -> Sized s a append         :: S.Sequence s => Sized s a -> Sized s a -> Sized s a-lview          :: (S.Sequence s, Monad m) => Sized s a -> m (a, Sized s a)+lview          :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m (a, Sized s a) lhead          :: S.Sequence s => Sized s a -> a-lheadM         :: (S.Sequence s, Monad m) => Sized s a -> m a+lheadM         :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m a ltail          :: S.Sequence s => Sized s a -> Sized s a-ltailM         :: (S.Sequence s, Monad m) => Sized s a -> m (Sized s a)-rview          :: (S.Sequence s, Monad m) => Sized s a -> m (a, Sized s a)+ltailM         :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m (Sized s a)+rview          :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m (a, Sized s a) rhead          :: S.Sequence s => Sized s a -> a-rheadM         :: (S.Sequence s, Monad m) => Sized s a -> m a+rheadM         :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m a rtail          :: S.Sequence s => Sized s a -> Sized s a-rtailM         :: (S.Sequence s, Monad m) => Sized s a -> m (Sized s a)+rtailM         :: (S.Sequence s, Fail.MonadFail m) => Sized s a -> m (Sized s a) null           :: S.Sequence s => Sized s a -> Bool size           :: S.Sequence s => Sized s a -> Int concat         :: S.Sequence s => Sized s (Sized s a) -> Sized s a@@ -105,7 +106,7 @@ copy           :: S.Sequence s => Int -> a -> Sized s a inBounds       :: S.Sequence s => Int -> Sized s a -> Bool lookup         :: S.Sequence s => Int -> Sized s a -> a-lookupM        :: (S.Sequence s, Monad m) => Int -> Sized s a -> m a+lookupM        :: (S.Sequence s, Fail.MonadFail m) => Int -> Sized s a -> m a lookupWithDefault :: S.Sequence s => a -> Int -> Sized s a -> a update         :: S.Sequence s => Int -> a -> Sized s a -> Sized s a adjust         :: S.Sequence s => (a -> a) -> Int -> Sized s a -> Sized s a