Data.Edison.Seq.Defaults: exported symbols usage examples

Symbols

  • adjustUsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    adjustUsingSplitAt See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    appendUsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
        | j == 1    = (C j (f x) as as, C j (g x) bs bs, C j (h x) cs cs)
        | otherwise = (C j (f x) as (jump as), C j (g x) bs (jump bs),
                       C j (h x) cs (jump cs))
      where (as,bs,cs) = unzipWith3 f g h xs
    
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictTree t@(L _) = t
    strictTree t@(T _ l r) = strictTree l `seq` strictTree r `seq` t
    
    strictWith _ s@E = s
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    

    concatMapUsingFoldr See 10 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
             in (Q idx xs' [] 0, makeQ (i - idx) xs'' ys j)
      else let idx' = idx - i in
        if idx' >= j then (q, empty)
        else let (ys', ys'') = L.splitAt (j - idx') ys
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
            check (B _ E E)   E           = Just 2
            check (B _ l1 l2) (B _ r1 r2) = do
               x <- check l1 l2
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    -- invariants:
    --   * 'E' is never a child of 'A'
    
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    

    Found in Data.Edison.Seq.RevSeq from the package EdisonCore
    rtail (N m xs) = N (m-1) (S.ltail xs)
    
    rtailM (N (-1) _) = fail "RevSeq.rtailM: empty sequence"
    rtailM (N m xs) = return (N (m-1) (S.ltail xs))
    
    null (N m _) = m == -1
    size (N m _) = m+1
    concat (N _ xss) = fromSeq (S.concat (S.map toSeq xss))
    reverse (N m xs) = N m (S.reverse xs)
    reverseOnto (N m xs) (N n ys) = N (m+n+1) (S.append ys (S.reverse xs))
    fromList = fromSeq . S.fromList . L.reverse
    toList (N _ xs) = S.foldl (flip (:)) [] xs
    map f (N m xs) = N m (S.map f xs)
    
    concatMap = concatMapUsingFoldr -- only function that uses a default
    
    fold f e (N _ xs) = S.fold f e xs
    fold' f e (N _ xs) = S.fold' f e xs
    fold1 f (N _ xs) = S.fold1 f xs
    fold1' f (N _ xs) = S.fold1' f xs
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    filter p (Q xs ys) = makeQ (L.filter p xs) (L.filter p ys)
    
    partition p (Q xs ys)
      = (makeQ xsT ysT, makeQ xsF ysF)
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    

    Found in Data.Edison.Seq.SizedSeq from the package EdisonCore
    rtail (N n xs) = N (n-1) (S.rtail xs)
    
    rtailM (N 0 _) = fail "SizedSeq.rtailM: empty sequence"
    rtailM (N n xs) = return (N (n-1) (S.rtail xs))
    
    null (N n _) = n == 0
    size (N n _) = n
    concat (N _ xss) = fromSeq (S.concat (S.map toSeq xss))
    reverse (N n xs) = N n (S.reverse xs)
    reverseOnto (N m xs) (N n ys) = N (m+n) (S.reverseOnto xs ys)
    fromList = fromSeq . S.fromList
    toList (N _ xs) = S.toList xs
    map f (N n xs) = N n (S.map f xs)
    
    concatMap = concatMapUsingFoldr -- only function that uses a default
    
    fold  f e (N _ xs) = S.fold f e xs
    fold' f e (N _ xs) = S.fold' f e xs
    fold1 f  (N _ xs) = S.fold1 f xs
    fold1' f (N _ xs) = S.fold1' f xs
    

    concatUsingFoldr See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
        else let (xs',xs'') = L.splitAt idx xs
             in (Q idx xs' [] 0, makeQ (i - idx) xs'' ys j)
      else let idx' = idx - i in
        if idx' >= j then (q, empty)
        else let (ys', ys'') = L.splitAt (j - idx') ys
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strictWith _ l@E = l
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
      where check :: Seq a -> Seq a -> Maybe Int
            check E           E           = Just 1
            check (B _ E E)   E           = Just 2
            check (B _ l1 l2) (B _ r1 r2) = do
               x <- check l1 l2
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(L x) = f x `seq` s
    strictWith f s@(A l _) = strictWith f l `seq` strictWith f l `seq` s
    
    -- invariants:
    --   * 'E' is never a child of 'A'
    
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
        | otherwise = (C j (f x) as (jump as), C j (g x) bs (jump bs),
                       C j (h x) cs (jump cs))
      where (as,bs,cs) = unzipWith3 f g h xs
    
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    filter p (Q xs ys) = makeQ (L.filter p xs) (L.filter p ys)
    
    partition p (Q xs ys)
      = (makeQ xsT ysT, makeQ xsF ysF)
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    copyUsingLists See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    

    defaultCompare See 10 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 =
        (size q1 == size q2) && (toList q1 == toList q2)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys =
        (size xs == size ys) && (toList xs == toList ys)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
      x <*> y = do
         x' <- x
         y' <- y
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.RevSeq from the package EdisonCore
         return (x' y')
    
    instance S.Sequence s => Monad (Rev s) where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance S.Sequence s => MonadPlus (Rev s) where
      mplus = append
      mzero = empty
    
    instance Eq (s a) => Eq (Rev s a) where
      (N m xs) == (N n ys) = (m == n) && (xs == ys)
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Rev s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Rev s a) where
      showsPrec i xs rest
         | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
         | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 = toList q1 == toList q2
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
    

    Found in Data.Edison.Seq.SizedSeq from the package EdisonCore
      xs >>= k = concatMap k xs
    
    instance S.Sequence s => MonadPlus (Sized s) where
      mplus = append
      mzero = empty
    
    
    instance Eq (s a) => Eq (Sized s a) where
      (N m xs) == (N n ys) = (m == n) && (xs == ys)
      -- this is probably identical to the code that would be
      -- generated by "deriving (Eq)", but I wanted to be *sure*
      -- that the sizes were compared before the inner sequences
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Sized s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Sized s a) where
      showsPrec i xs rest
        | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
        | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    

    dropMatch No usage example found for this symbol :( Collapse [-]
    dropUsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    dropUsingLtail See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    

    dropWhileUsingLview See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    
    -- instances
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    

    filterUsingFoldr See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    filterUsingLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    filterUsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    fold1'UsingFold' See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    revfoldr' f e (x:xs) = e `seq` revfoldr' f (f x e) xs
    
    -- local fn on lists
    revfoldl :: (t -> t1 -> t) -> t -> [t1] -> t
    revfoldl _ e [] = e
    revfoldl f e (x:xs) = f (revfoldl f e xs) x
    
    revfoldl' :: (b -> t -> b) -> b -> [t] -> b
    revfoldl' _ e [] = e
    revfoldl' f e (x:xs) = (\z -> f z x) $! (revfoldl f e xs)
    
    fold  f e (Q _ xs ys _) = L.foldr f (L.foldr f e ys) xs
    fold' f e (Q _ xs ys _) = (L.foldl' (flip f) $! (L.foldl' (flip f) e ys)) xs
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr  f e (Q _ xs ys _) = L.foldr  f (revfoldr  f e ys) xs
    foldr' f e (Q _ xs ys _) = L.foldr' f (revfoldr' f e ys) xs
    foldl  f e (Q _ xs ys _) = revfoldl  f (L.foldl  f e xs) ys
    foldl' f e (Q _ xs ys _) = revfoldl' f (L.foldl' f e xs) ys
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    null E = True
    null _ = False
    
    size E = 0
    size (Even ps) = 2 * size ps
    size (Odd _ ps) = 1 + 2 * size ps
    
    map _ E = E
    map f (Even ps)  = Even (map (\(x,y) -> (f x,f y)) ps)
    map f (Odd x ps) = Odd (f x) (map (\(y,z) -> (f y,f z)) ps)
    
    fold   = foldr
    fold'  = foldr'
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (Even ps)  = foldr (\(x,y) e -> f x (f y e)) e ps
    foldr f e (Odd x ps) = f x (foldr (\(x,y) e -> f x (f y e)) e ps)
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reverse xs = xs -- L x or E
    
    toList xs = tol xs []
      where tol E rest = rest
            tol (L x) rest = x:rest
            tol (A xs ys) rest = tol xs (tol ys rest)
    
    map _ E = E
    map f (L x) = L (f x)
    map f (A xs ys) = A (map f xs) (map f ys)
    
    fold   = foldr
    fold'  = foldr'
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (L x) = f x e
    foldr f e (A xs ys) = foldr f (foldr f e ys) xs
    foldr' _ e E = e
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
            go (C j _ _ xs') = j + size xs'
    
    reverseOnto E ys = ys
    reverseOnto (C _ x xs _) ys = reverseOnto xs (lcons x ys)
    
    map _ E = E
    map f (C j x xs _')
        | j == 1    = C j (f x) ys ys
        | otherwise = C j (f x) ys (jump ys)
      where ys = map f xs
    
    fold  = foldr
    fold' f = foldl' (flip f)
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (C _ x xs _) = f x (foldr f e xs)
    
    foldr' _ e E = e
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    reverseOnto E ys = ys
    reverseOnto (C _ t xs) ys = reverseOnto xs (revTree t ys)
      where revTree (L x) ys = lcons x ys
            revTree (T x s t) ys = revTree t (revTree s (lcons x ys))
    
    map _ E = E
    map f (C j t xs) = C j (mapTree f t) (map f xs)
      where mapTree f (L x) = L (f x)
            mapTree f (T x s t) = T (f x) (mapTree f s) (mapTree f t)
    
    fold  = foldr
    fold' f = foldl' (flip f)
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (C _ t xs) = foldTree t (foldr f e xs)
      where foldTree (L x) e = f x e
            foldTree (T x s t) e = f x (foldTree s (foldTree t e))
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    revfoldr' f e (x:xs) = e `seq` revfoldr' f (f x e) xs
    
    -- local fn on lists
    revfoldl :: (t -> t1 -> t) -> t -> [t1] -> t
    revfoldl _ e [] = e
    revfoldl f e (x:xs) = f (revfoldl f e xs) x
    
    revfoldl' :: (a -> t -> a) -> a -> [t] -> a
    revfoldl' _ e [] = e
    revfoldl' f e (x:xs) = e `seq` f (revfoldl' f e xs) x
    
    fold   f e (Q xs ys) = L.foldr f (L.foldr f e ys) xs
    fold'  f e (Q xs ys) = L.foldl' (flip f) (L.foldl' (flip f) e ys) xs
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr  f e (Q xs ys) = L.foldr  f (revfoldr  f e ys) xs
    foldr' f e (Q xs ys) = L.foldr' f (revfoldr' f e ys) xs
    
    foldl  f e (Q xs ys) = revfoldl  f (L.foldl  f e xs) ys
    

    fold1UsingFold See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    revfoldr' _ e [] = e
    revfoldr' f e (x:xs) = e `seq` revfoldr' f (f x e) xs
    
    -- local fn on lists
    revfoldl :: (t -> t1 -> t) -> t -> [t1] -> t
    revfoldl _ e [] = e
    revfoldl f e (x:xs) = f (revfoldl f e xs) x
    
    revfoldl' :: (b -> t -> b) -> b -> [t] -> b
    revfoldl' _ e [] = e
    revfoldl' f e (x:xs) = (\z -> f z x) $! (revfoldl f e xs)
    
    fold  f e (Q _ xs ys _) = L.foldr f (L.foldr f e ys) xs
    fold' f e (Q _ xs ys _) = (L.foldl' (flip f) $! (L.foldl' (flip f) e ys)) xs
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr  f e (Q _ xs ys _) = L.foldr  f (revfoldr  f e ys) xs
    foldr' f e (Q _ xs ys _) = L.foldr' f (revfoldr' f e ys) xs
    foldl  f e (Q _ xs ys _) = revfoldl  f (L.foldl  f e xs) ys
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    null E = True
    null _ = False
    
    size E = 0
    size (Even ps) = 2 * size ps
    size (Odd _ ps) = 1 + 2 * size ps
    
    map _ E = E
    map f (Even ps)  = Even (map (\(x,y) -> (f x,f y)) ps)
    map f (Odd x ps) = Odd (f x) (map (\(y,z) -> (f y,f z)) ps)
    
    fold   = foldr
    fold'  = foldr'
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (Even ps)  = foldr (\(x,y) e -> f x (f y e)) e ps
    foldr f e (Odd x ps) = f x (foldr (\(x,y) e -> f x (f y e)) e ps)
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reverse (A xs ys) = A (reverse ys) (reverse xs)
    reverse xs = xs -- L x or E
    
    toList xs = tol xs []
      where tol E rest = rest
            tol (L x) rest = x:rest
            tol (A xs ys) rest = tol xs (tol ys rest)
    
    map _ E = E
    map f (L x) = L (f x)
    map f (A xs ys) = A (map f xs) (map f ys)
    
    fold   = foldr
    fold'  = foldr'
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (L x) = f x e
    foldr f e (A xs ys) = foldr f (foldr f e ys) xs
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
      where go E = (0::Int)
            go (C j _ _ xs') = j + size xs'
    
    reverseOnto E ys = ys
    reverseOnto (C _ x xs _) ys = reverseOnto xs (lcons x ys)
    
    map _ E = E
    map f (C j x xs _')
        | j == 1    = C j (f x) ys ys
        | otherwise = C j (f x) ys (jump ys)
      where ys = map f xs
    
    fold  = foldr
    fold' f = foldl' (flip f)
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (C _ x xs _) = f x (foldr f e xs)
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
            sz (C j _ xs) = j + sz xs
    
    reverseOnto E ys = ys
    reverseOnto (C _ t xs) ys = reverseOnto xs (revTree t ys)
      where revTree (L x) ys = lcons x ys
            revTree (T x s t) ys = revTree t (revTree s (lcons x ys))
    
    map _ E = E
    map f (C j t xs) = C j (mapTree f t) (map f xs)
      where mapTree f (L x) = L (f x)
            mapTree f (T x s t) = T (f x) (mapTree f s) (mapTree f t)
    
    fold  = foldr
    fold' f = foldl' (flip f)
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr _ e E = e
    foldr f e (C _ t xs) = foldTree t (foldr f e xs)
      where foldTree (L x) e = f x e
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    revfoldr' _ e [] = e
    revfoldr' f e (x:xs) = e `seq` revfoldr' f (f x e) xs
    
    -- local fn on lists
    revfoldl :: (t -> t1 -> t) -> t -> [t1] -> t
    revfoldl _ e [] = e
    revfoldl f e (x:xs) = f (revfoldl f e xs) x
    
    revfoldl' :: (a -> t -> a) -> a -> [t] -> a
    revfoldl' _ e [] = e
    revfoldl' f e (x:xs) = e `seq` f (revfoldl' f e xs) x
    
    fold   f e (Q xs ys) = L.foldr f (L.foldr f e ys) xs
    fold'  f e (Q xs ys) = L.foldl' (flip f) (L.foldl' (flip f) e ys) xs
    fold1  = fold1UsingFold
    fold1' = fold1'UsingFold'
    
    foldr  f e (Q xs ys) = L.foldr  f (revfoldr  f e ys) xs
    foldr' f e (Q xs ys) = L.foldr' f (revfoldr' f e ys) xs
    

    foldl'UsingLists See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
               x <- check l1 l2
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    foldl1'UsingFoldl' See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    

    foldl1'UsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    foldl1UsingFoldl See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    foldl1UsingLists See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    

    foldlUsingLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    

    foldlWithIndex'UsingLists See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    

    foldlWithIndexUsingLists See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    

    foldr'UsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    

    foldr1'UsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    

    foldr1'UsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    

    foldr1UsingLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    foldr1UsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    foldrUsingLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
            check (B _ l1 l2) (B _ r1 r2) = do
               x <- check l1 l2
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    

    foldrWithIndex'UsingLists See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    

    foldrWithIndexUsingLists See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    

    fromListUsingCons See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    strictWith f s@(A l _) = strictWith f l `seq` strictWith f l `seq` s
    
    -- invariants:
    --   * 'E' is never a child of 'A'
    
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
      where (as,bs,cs) = unzipWith3 f g h xs
    
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    

    inBoundsUsingDrop See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    

    inBoundsUsingLookupM See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    

    inBoundsUsingSize See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
        | otherwise = Seq xs
    
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
    

    lookupMUsingDrop See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    lookupUsingDrop See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    

    lookupUsingLookupM See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.Defaults from the package EdisonCore
            disj _ _ = True
    
    intersectWitnessUsingToOrdList ::
            (OrdColl c a, Monad 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
                LT -> witness xs b
                EQ -> return (x, y)
                GT -> witness a ys
            -- XXX
            witness _ _ = fail $ instanceName as ++ ".intersect: failed"
    
    lookupUsingLookupM :: Coll c a => a -> c -> a
    lookupUsingLookupM x ys = runIdentity (lookupM x ys)
    
    lookupUsingLookupAll :: Coll c a => a -> c -> a
    lookupUsingLookupAll x ys =
      case lookupAll x ys of
        (y:_) -> y
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
                GT -> disj a ds
            disj _ _ = True
    
    intersectWitnessUsingToOrdList ::
            (OrdColl c a, Monad 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
                LT -> witness xs b
                EQ -> return (x, y)
                GT -> witness a ys
            -- XXX
            witness _ _ = fail $ instanceName as ++ ".intersect: failed"
    
    lookupUsingLookupM :: Coll c a => a -> c -> a
    lookupUsingLookupM x ys = runIdentity (lookupM x ys)
    
    lookupUsingLookupAll :: Coll c a => a -> c -> a
    lookupUsingLookupAll x ys =
      case lookupAll x ys of
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    adjust f i (Seq xs)
        | inBounds i (Seq xs) =
            case FT.splitTree (> (SizeM i)) (SizeM 0) xs of
               FT.Split l x r -> Seq $ FT.append l $ FT.lcons (Elem (f (unElem x))) $ r
    
        | otherwise = Seq xs
    
    take i (Seq xs) = Seq $ FT.takeUntil (> (SizeM i)) xs
    drop i (Seq xs) = Seq $ FT.dropUntil (> (SizeM i)) xs
    splitAt i (Seq xs) = let (a,b) = FT.split (> (SizeM i)) xs in (Seq a, Seq b)
    
    
    inBounds = inBoundsUsingSize
    lookup   = lookupUsingLookupM
    
    foldr1 f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    

    lookupWithDefaultUsingDrop See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    

    lookupWithDefaultUsingLookupM See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    memberUsingLookupM k m
      = case lookupM k m of
            Just _  -> True
            Nothing -> False
    
    countUsingMember :: AssocX m k => k -> m a -> Int
    countUsingMember k m = if member k m then 1 else 0
    
    lookupAllUsingLookupM :: (AssocX m k,S.Sequence seq) => k -> m a -> seq a
    lookupAllUsingLookupM k m = case lookupM k m of
                                  Just x -> S.singleton x
                                  Nothing -> S.empty
    
    lookupWithDefaultUsingLookupM :: AssocX m k => a -> k -> m a -> a
    lookupWithDefaultUsingLookupM d k m = case lookupM k m of
                                            Just x -> x
                                            Nothing -> d
    
    partitionUsingFilter :: AssocX m k => (a -> Bool) -> m a -> (m a,m a)
    partitionUsingFilter f m = (filter f m, filter (not . f) m)
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    memberUsingLookupM :: (AssocX m k) => k -> m a -> Bool
    memberUsingLookupM k m
      = case lookupM k m of
            Just _  -> True
            Nothing -> False
    
    countUsingMember :: AssocX m k => k -> m a -> Int
    countUsingMember k m = if member k m then 1 else 0
    
    lookupAllUsingLookupM :: (AssocX m k,S.Sequence seq) => k -> m a -> seq a
    lookupAllUsingLookupM k m = case lookupM k m of
                                  Just x -> S.singleton x
                                  Nothing -> S.empty
    
    lookupWithDefaultUsingLookupM :: AssocX m k => a -> k -> m a -> a
    lookupWithDefaultUsingLookupM d k m = case lookupM k m of
                                            Just x -> x
                                            Nothing -> d
    
    partitionUsingFilter :: AssocX m k => (a -> Bool) -> m a -> (m a,m a)
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
    lookupMUsingLookupAll :: (Coll c a, Monad m) => a -> c -> m a
    lookupMUsingLookupAll x ys =
      case lookupAll x ys of
        (y:_) -> return y
        []    -> fail $ instanceName ys ++ ".lookupM: lookup failed"
    
    lookupWithDefaultUsingLookupAll :: Coll c a => a -> a -> c -> a
    lookupWithDefaultUsingLookupAll dflt x ys =
      case lookupAll x ys of
        (y:_) -> y
        [] -> dflt
    
    lookupWithDefaultUsingLookupM :: Coll c a => a -> a -> c -> a
    lookupWithDefaultUsingLookupM dflt x ys =
      case lookupM x ys of
        Just y  -> y
        Nothing -> dflt
    
    deleteMaxUsingMaxView :: OrdColl c a => c -> c
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
        [] -> error $ instanceName ys ++ ".lookup: lookup failed"
    
    lookupMUsingLookupAll :: (Coll c a, Monad m) => a -> c -> m a
    lookupMUsingLookupAll x ys =
      case lookupAll x ys of
        (y:_) -> return y
        []    -> fail $ instanceName ys ++ ".lookupM: lookup failed"
    
    lookupWithDefaultUsingLookupAll :: Coll c a => a -> a -> c -> a
    lookupWithDefaultUsingLookupAll dflt x ys =
      case lookupAll x ys of
        (y:_) -> y
        [] -> dflt
    
    lookupWithDefaultUsingLookupM :: Coll c a => a -> a -> c -> a
    lookupWithDefaultUsingLookupM dflt x ys =
      case lookupM x ys of
        Just y  -> y
        Nothing -> dflt
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    mapUsingFoldr No usage example found for this symbol :( Collapse [-]
    mapWithIndexUsingLists See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    

    maybeParens See 9 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
           -- play games with the typechecker so we don't have to use
           -- extensions for scoped type variables
           ~[(x,_)] = result
    
       in result
    
    showsPrecUsingToOrdList :: (Show k,Show a,OrdAssoc m k) => Int -> m a -> ShowS
    showsPrecUsingToOrdList i xs rest
       | i == 0    = concat [    instanceName xs,".unsafeFromOrdSeq ",showsPrec 10 (toOrdList xs) rest]
       | otherwise = concat ["(",instanceName xs,".unsafeFromOrdSeq ",showsPrec 10 (toOrdList xs) (')':rest)]
    
    readsPrecUsingUnsafeFromOrdSeq :: (Read k,Read a,OrdAssoc m k) => Int -> ReadS (m a)
    readsPrecUsingUnsafeFromOrdSeq i xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".unsafeFromOrdSeq") ys
                    >>= readsPrec i
                    >>= \(l,rest) -> return (unsafeFromOrdList l,rest)
    
           -- play games with the typechecker so we don't have to use
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
      case maxViewWithKey fm of
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    readsPrecUsingFromList _ xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".fromSeq") ys
                    >>= readsPrec 10
                    >>= \(l,rest) -> return (fromList l,rest)
    
           -- play games with the typechecker so we don't have to use
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    --   Stability   :  internal (unstable)
    --   Portability :  GHC, Hugs (MPTC and FD)
    --
    --   This module provides default implementations of many of the associative
    --   collection operations.  These function are used to fill in collection
    --   implementations and are not intended to be used directly by end users.
    
    module Data.Edison.Assoc.Defaults where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    
    import Data.Edison.Assoc
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.ListSeq as L
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    
    singletonUsingInsert :: (Assoc m k) => k -> a -> m a
    singletonUsingInsert k v = insert k v empty
    
    fromSeqUsingInsertSeq :: (AssocX m k,S.Sequence seq) => seq (k,a) -> m a
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
                GT -> inter a ys
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    readsPrecUsingFromList _ xs =
        let result = maybeParens p xs
            p ys = tokenMatch ((instanceName x) ++ ".fromSeq") ys
                     >>= readsPrec 10
                     >>= \(l,rest) -> return (fromList l,rest)
    
            -- play games with the typechecker so we don't have to use
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
    --   Portability :  GHC / Hugs (MPTC and FD)
    --
    --   This module provides default implementations of many of the collection methods.  The functions
    --   in this module are used to fill out collection implementations and are not intended to be
    --   used directly by end users.
    
    module Data.Edison.Coll.Defaults where
    
    import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter)
    import Control.Monad.Identity
    
    import Data.Edison.Coll
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.ListSeq as L
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    
    insertSeqUsingUnion :: (CollX c a,S.Sequence seq) => seq a -> c -> c
    insertSeqUsingUnion xs c = union (fromSeq xs) c
    
    insertSeqUsingFoldr :: (CollX c a,S.Sequence seq) => seq a -> c -> c
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
      {minView = minView; minElem = minElem; maxView = maxView;
       maxElem = maxElem; foldr = foldr; foldr' = foldr';
       foldl = foldl; foldl' = foldl'; foldr1 = foldr1;  foldr1' = foldr1';
       foldl1 = foldl1; foldl1' = foldl1'; toOrdSeq = toOrdSeq;
       unsafeMapMonotonic = unsafeMapMonotonic}
    
    -- instance Eq is derived
    
    instance (C.OrdColl h a, Show h) => Show (Min h a) where
       showsPrec i xs rest
         | i == 0    = concat [    moduleName,".fromColl ",showsPrec 10 (toColl xs) rest]
         | otherwise = concat ["(",moduleName,".fromColl ",showsPrec 10 (toColl xs) (')':rest)]
    
    instance (C.OrdColl h a, Read h) => Read (Min h a) where
       readsPrec _ xs = maybeParens p xs
           where p ys = tokenMatch (moduleName++".fromColl") ys
                          >>= readsPrec 10
                          >>= \(coll,rest) -> return (fromColl coll,rest)
    
    instance (C.OrdColl h a,Arbitrary h,Arbitrary a) => Arbitrary (Min h a) where
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
        foldr1,foldr1',foldl1,foldl1',toOrdSeq,
        unsafeMapMonotonic,
    
        -- * Other supported operations
        toColl,fromColl,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter)
    import qualified Data.Edison.Coll as C
    import qualified Data.Edison.Seq as S
    import Data.Edison.Coll.Defaults
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    import Data.Monoid
    import qualified Data.Semigroup as SG
    import Control.Monad
    import Test.QuickCheck
    

    Found in Data.Edison.Seq.RevSeq from the package EdisonCore
      mzero = empty
    
    instance Eq (s a) => Eq (Rev s a) where
      (N m xs) == (N n ys) = (m == n) && (xs == ys)
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Rev s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Rev s a) where
      showsPrec i xs rest
         | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
         | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    
    instance (S.Sequence s, Read (s a)) => Read (Rev s a) where
      readsPrec _ xs = maybeParens p xs
          where p xs = tokenMatch (moduleName++".fromSeq") xs
                         >>= readsPrec 10
                         >>= \(l,rest) -> return (fromSeq l,rest)
    
    instance (S.Sequence s, Arbitrary (s a)) => Arbitrary (Rev s a) where
    

    Found in Data.Edison.Seq.SizedSeq from the package EdisonCore
      (N m xs) == (N n ys) = (m == n) && (xs == ys)
      -- this is probably identical to the code that would be
      -- generated by "deriving (Eq)", but I wanted to be *sure*
      -- that the sizes were compared before the inner sequences
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Sized s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Sized s a) where
      showsPrec i xs rest
        | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
        | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    
    instance (S.Sequence s, Read (s a)) => Read (Sized s a) where
      readsPrec _ xs = maybeParens p xs
          where p xs = tokenMatch (moduleName++".fromSeq") xs
                         >>= readsPrec 10
                         >>= \(l,rest) -> return (fromSeq l, rest)
    
    instance (S.Sequence s, Arbitrary (s a)) => Arbitrary (Sized s a) where
    

    partitionUsingFoldr See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    partitionUsingLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    rconsUsingAppend No usage example found for this symbol :( Collapse [-]
    rconsUsingFoldr See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strict l@E = l
    strict l@(Even l') = strict l' `seq` l
    strict l@(Odd _ l') = strict l' `seq` l
    
    strictWith _ l@E = l
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    unzipWith3 f g h (C j x xs _)
        | j == 1    = (C j (f x) as as, C j (g x) bs bs, C j (h x) cs cs)
        | otherwise = (C j (f x) as (jump as), C j (g x) bs (jump bs),
                       C j (h x) cs (jump cs))
      where (as,bs,cs) = unzipWith3 f g h xs
    
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictTree :: Tree t -> Tree t
    strictTree t@(L _) = t
    strictTree t@(T _ l r) = strictTree l `seq` strictTree r `seq` t
    
    strictWith _ s@E = s
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    

    readSParens No usage example found for this symbol :( Collapse [-]
    readsPrecUsingFromList See 12 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    maxElemWithKeyUsingMaxViewWithKey fm =
      case maxViewWithKey fm of
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    readsPrecUsingFromList _ xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".fromSeq") ys
                    >>= readsPrec 10
                    >>= \(l,rest) -> return (fromList l,rest)
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    maxElemWithKeyUsingMaxViewWithKey :: OrdAssoc m k => m a -> (k,a)
    maxElemWithKeyUsingMaxViewWithKey fm =
      case maxViewWithKey fm of
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    readsPrecUsingFromList _ xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".fromSeq") ys
                    >>= readsPrec 10
                    >>= \(l,rest) -> return (fromList l,rest)
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
                EQ -> c x y : inter xs ys
                GT -> inter a ys
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    readsPrecUsingFromList _ xs =
        let result = maybeParens p xs
            p ys = tokenMatch ((instanceName x) ++ ".fromSeq") ys
                     >>= readsPrec 10
                     >>= \(l,rest) -> return (fromList l,rest)
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
                LT -> inter xs b
                EQ -> c x y : inter xs ys
                GT -> inter a ys
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    readsPrecUsingFromList _ xs =
        let result = maybeParens p xs
            p ys = tokenMatch ((instanceName x) ++ ".fromSeq") ys
                     >>= readsPrec 10
                     >>= \(l,rest) -> return (fromList l,rest)
    

    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 =
        (size q1 == size q2) && (toList q1 == toList q2)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary =
        do xs <- arbitrary
           ys <- arbitrary
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = do xs <- arbitrary
                     return (fromList xs)
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = arbitrary >>= (return . fromList)
    
    instance CoArbitrary a => CoArbitrary (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Elem a) where
       arbitrary   = arbitrary >>= return . Elem
    
    instance CoArbitrary a => CoArbitrary (Elem a) where
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = sized arbTree
        where arbTree 0 = return E
              arbTree 1 = liftM L arbitrary
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys =
        (size xs == size ys) && (toList xs == toList ys)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = do xs <- arbitrary
                     return (fromList xs)
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = do xs <- arbitrary
                     return (fromList xs)
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 = toList q1 == toList q2
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
      arbitrary = do xs <- arbitrary
                     ys <- arbitrary
                     return (if L.null xs then Q ys [] else Q xs ys)
    

    reduce1'UsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    

    reduce1UsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
        else let (ys', ys'') = L.splitAt (j - idx') ys
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    

    reducel'UsingReduce1' See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    

    reducelUsingReduce1 See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
        if idx' >= j then (q, empty)
        else let (ys', ys'') = L.splitAt (j - idx') ys
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
      = (makeQ xsT ysT, makeQ xsF ysF)
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    

    reducer'UsingReduce1' See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    partition p (Q xs ys)
      = (makeQ xsT ysT, makeQ xsF ysF)
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    

    reducerUsingReduce1 See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
      else let idx' = idx - i in
        if idx' >= j then (q, empty)
        else let (ys', ys'') = L.splitAt (j - idx') ys
             in (Q i xs ys'' idx', Q (j - idx') (L.reverse ys') [] 0)
          -- could do splitAt followed by reverse more efficiently...
    
    
    strict l@(Q _ xs ys _) = L.strict xs `seq` L.strict ys `seq` l
    strictWith f l@(Q _ xs ys _) = L.strictWith f xs `seq` L.strictWith f ys `seq` l
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    foldr = foldrUsingLists
    foldr' = foldr'UsingLists
    foldl = foldlUsingLists
    foldl' = foldl'UsingLists
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1: empty sequence"
          Just (x,xs') -> foldr f x xs'
    
    foldr1' f xs =
       case rview xs of
          Nothing      -> error "FingerSeq.foldr1': empty sequence"
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    --   * 'E' is never a child of 'A'
    
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    partition p (Q xs ys)
      = (makeQ xsT ysT, makeQ xsF ysF)
     where
       (xsT,xsF) = L.partition p xs
       (ysT,ysF) = L.partition p ys
    
    strict s@(Q xs ys) = L.strict xs `seq` L.strict ys `seq` s
    strictWith f s@(Q xs ys) = L.strictWith f xs `seq` L.strictWith f ys `seq` s
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    

    reverseOntoUsingFoldl See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    

    reverseOntoUsingReverse See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
            check E           E           = Just 1
            check (B _ E E)   E           = Just 2
            check (B _ l1 l2) (B _ r1 r2) = do
               x <- check l1 l2
               y <- check r1 r2
               if (x == y) || (x == y + 1)
                  then return (x+y+1)
                  else fail "unbalanced tree"
            check _ _ = fail "unbalanced tree"
    
    
    -- the remaining functions all use defaults
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap = concatMapUsingFoldr
    fold = foldrUsingLists
    fold' f = foldl'UsingLists (flip f)
    fold1 = fold1UsingFold
    fold1' = fold1'UsingFold'
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
          Just (x,xs') -> foldr' f x xs'
    
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    strictWith f s@(L x) = f x `seq` s
    strictWith f s@(A l _) = strictWith f l `seq` strictWith f l `seq` s
    
    -- invariants:
    --   * 'E' is never a child of 'A'
    
    structuralInvariant E = True
    structuralInvariant s = check s
      where check E = False
            check (L _) = True
            check (A s1 s2) = check s1 && check s2
    
    
    concat = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    fromList = fromListUsingCons
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    reverseUsingLists No usage example found for this symbol :( Collapse [-]
    reverseUsingReverseOnto See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
                       C j (h x) cs (jump cs))
      where (as,bs,cs) = unzipWith3 f g h xs
    
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    

    rtailMUsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strictWith _ l@E = l
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    

    rtailUsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strict l@(Odd _ l') = strict l' `seq` l
    
    strictWith _ l@E = l
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    

    rviewDefault See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    strict l@(Even l') = strict l' `seq` l
    strict l@(Odd _ l') = strict l' `seq` l
    
    strictWith _ l@E = l
    strictWith f l@(Even l')  = strictWith (\ (x,y) -> f x `seq` f y) l' `seq` l
    strictWith f l@(Odd x _') = f x `seq` strictWith (\ (x,y) -> f x `seq` f y) `seq` l
    
    
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictTree t@(T _ l r) = strictTree l `seq` strictTree r `seq` t
    
    strictWith _ s@E = s
    strictWith f s@(C _ t xs) = strictWithTree f t `seq` strictWith f xs `seq` s
    
    strictWithTree :: (t -> a) -> Tree t -> Tree t
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    

    showsPrecUsingToList See 12 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
      case maxView fm of
         Nothing    -> error $ (instanceName fm)++".deleteMax: empty map"
         Just (_,m) -> m
    
    maxElemWithKeyUsingMaxViewWithKey :: OrdAssoc m k => m a -> (k,a)
    maxElemWithKeyUsingMaxViewWithKey fm =
      case maxViewWithKey fm of
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    readsPrecUsingFromList _ xs =
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    deleteMaxUsingMaxView fm =
      case maxView fm of
         Nothing    -> error $ (instanceName fm)++".deleteMax: empty map"
         Just (_,m) -> m
    
    maxElemWithKeyUsingMaxViewWithKey :: OrdAssoc m k => m a -> (k,a)
    maxElemWithKeyUsingMaxViewWithKey fm =
      case maxViewWithKey fm of
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
    intersectionWithUsingOrdLists :: OrdSet c a => (a -> a -> a) -> c -> c -> c
    intersectionWithUsingOrdLists c as bs = unsafeFromOrdList $ inter (toOrdList as) (toOrdList bs)
      where inter a@(x:xs) b@(y:ys) =
              case compare x y of
                LT -> inter xs b
                EQ -> c x y : inter xs ys
                GT -> inter a ys
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    readsPrecUsingFromList _ xs =
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
    intersectionWithUsingOrdLists :: OrdSet c a => (a -> a -> a) -> c -> c -> c
    intersectionWithUsingOrdLists c as bs = unsafeFromOrdList $ inter (toOrdList as) (toOrdList bs)
      where inter a@(x:xs) b@(y:ys) =
              case compare x y of
                LT -> inter xs b
                EQ -> c x y : inter xs ys
                GT -> inter a ys
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    

    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 =
        (size q1 == size q2) && (toList q1 == toList q2)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    -- instance Eq (Seq a) is derived
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Elem a) where
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys = toList xs == toList ys
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      xs == ys =
        (size xs == size ys) && (toList xs == toList ys)
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
         return (x' y')
    
    instance Monad Seq where
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
      return = singleton
      xs >>= k = concatMap k xs
    
    instance MonadPlus Seq where
      mplus = append
      mzero = empty
    
    instance Eq a => Eq (Seq a) where
      q1 == q2 = toList q1 == toList q2
    
    instance Ord a => Ord (Seq a) where
      compare = defaultCompare
    
    instance Show a => Show (Seq a) where
      showsPrec = showsPrecUsingToList
    
    instance Read a => Read (Seq a) where
      readsPrec = readsPrecUsingFromList
    
    instance Arbitrary a => Arbitrary (Seq a) where
    

    splitAtDefault See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldr1 = foldr1UsingLists
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    

    splitAtUsingLview See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    

    splitWhileUsingLview See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    
    -- instances
    
    instance S.Sequence Seq where
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    

    subseqDefault See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    foldr1' = foldr1'UsingLists
    foldl1 = foldl1UsingLists
    foldl1' = foldl1UsingLists
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldl    = foldlUsingLists
    foldl'   = foldl'UsingLists
    foldl1   = foldl1UsingLists
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    

    takeUsingLists See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- not exported
    mapFst :: (t -> t2) -> (t, t1) -> (t2, t1)
    mapFst f (x,y) = (f x,y)
    mapSnd :: (t1 -> t2) -> (t, t1) -> (t, t2)
    mapSnd f (x,y) = (x,f y)
    
    take n xs = if n <= 0 then E else tak n xs
      where tak :: Int -> Seq a -> Seq a
            tak 0 _ = E
            tak _ E = E
            tak i (Even ps)
              | even i = Even (tak (half i) ps)
            tak i (Odd x ps)
              | odd i = Odd x (tak (half (i-1)) ps)
            tak i xs = takeUsingLists i xs
    
    -- drop is O(log^2 n) instead of O(log n)??
    drop n xs = if n <= 0 then xs else drp n xs
      where drp :: Int -> Seq a -> Seq a
            drp 0 xs = xs
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    

    takeUsingLview See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    

    takeWhileUsingLview See 8 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reducel = reducelUsingReduce1
    reduce1 = reduce1UsingLists
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.BraunSeq from the package EdisonCore
    reducer = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1 = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    
    -- instances
    

    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    foldl1'  = foldl1'UsingLists
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    
    copy        = copyUsingLists
    concat      = concatUsingFoldr
    reverseOnto = reverseOntoUsingReverse
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    

    toListUsingFoldr See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    -- structural invariants are enforced by the type system
    structuralInvariant = const True
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    strict s@E = s
    strict s@(C _ _ xs _) = strict xs `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(C _ x xs _) = f x `seq` strictWith f xs `seq` s
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    strictWithTree f t@(L x) = f x `seq` t
    strictWithTree f t@(T x l r) = f x `seq` strictWithTree f l `seq` strictWithTree f r `seq` t
    
    
    -- the remaining functions all use defaults
    
    rcons = rconsUsingFoldr
    append = appendUsingFoldr
    rview = rviewDefault
    rtail = rtailUsingLview
    rtailM = rtailMUsingLview
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1  = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1  = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    

    tokenMatch See 9 Occurences [+] Collapse [-]
    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
           -- play games with the typechecker so we don't have to use
           -- extensions for scoped type variables
           ~[(x,_)] = result
    
       in result
    
    showsPrecUsingToOrdList :: (Show k,Show a,OrdAssoc m k) => Int -> m a -> ShowS
    showsPrecUsingToOrdList i xs rest
       | i == 0    = concat [    instanceName xs,".unsafeFromOrdSeq ",showsPrec 10 (toOrdList xs) rest]
       | otherwise = concat ["(",instanceName xs,".unsafeFromOrdSeq ",showsPrec 10 (toOrdList xs) (')':rest)]
    
    readsPrecUsingUnsafeFromOrdSeq :: (Read k,Read a,OrdAssoc m k) => Int -> ReadS (m a)
    readsPrecUsingUnsafeFromOrdSeq i xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".unsafeFromOrdSeq") ys
                    >>= readsPrec i
                    >>= \(l,rest) -> return (unsafeFromOrdList l,rest)
    
           -- play games with the typechecker so we don't have to use
           -- extensions for scoped type variables
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
         Nothing    -> error $ (instanceName fm)++".maxElemWithKey: empty map"
         Just (x,_) -> x
    
    toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
    toOrdSeqUsingFoldrWithKey = foldrWithKey (\k x z -> S.lcons (k,x) z) S.empty
    
    showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
    showsPrecUsingToList i xs rest
       | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
       | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
    readsPrecUsingFromList _ xs =
       let result = maybeParens p xs
           p ys = tokenMatch ((instanceName x)++".fromSeq") ys
                    >>= readsPrec 10
                    >>= \(l,rest) -> return (fromList l,rest)
    
           -- play games with the typechecker so we don't have to use
           -- extensions for scoped type variables
    

    Found in Data.Edison.Assoc.Defaults from the package EdisonCore
    --   Stability   :  internal (unstable)
    --   Portability :  GHC, Hugs (MPTC and FD)
    --
    --   This module provides default implementations of many of the associative
    --   collection operations.  These function are used to fill in collection
    --   implementations and are not intended to be used directly by end users.
    
    module Data.Edison.Assoc.Defaults where
    
    import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,filter)
    
    import Data.Edison.Assoc
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.ListSeq as L
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    
    singletonUsingInsert :: (Assoc m k) => k -> a -> m a
    singletonUsingInsert k v = insert k v empty
    
    fromSeqUsingInsertSeq :: (AssocX m k,S.Sequence seq) => seq (k,a) -> m a
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
            inter _ _ = []
    
    
    unsafeMapMonotonicUsingFoldr :: (OrdColl cin a, OrdCollX cout b) => (a -> b) -> (cin -> cout)
    unsafeMapMonotonicUsingFoldr f xs = foldr (unsafeInsertMin . f) empty xs
    
    showsPrecUsingToList :: (Coll c a,Show a) => Int -> c -> ShowS
    showsPrecUsingToList i xs rest
      | i == 0    = concat [    instanceName xs,".fromSeq ",showsPrec 10 (toList xs) rest]
      | otherwise = concat ["(",instanceName xs,".fromSeq ",showsPrec 10 (toList xs) (')':rest)]
    
    readsPrecUsingFromList :: (Coll c a, Read a) => Int -> ReadS c
    readsPrecUsingFromList _ xs =
        let result = maybeParens p xs
            p ys = tokenMatch ((instanceName x) ++ ".fromSeq") ys
                     >>= readsPrec 10
                     >>= \(l,rest) -> return (fromList l,rest)
    
            -- play games with the typechecker so we don't have to use
            -- extensions for scoped type variables
    

    Found in Data.Edison.Coll.Defaults from the package EdisonCore
    --   Portability :  GHC / Hugs (MPTC and FD)
    --
    --   This module provides default implementations of many of the collection methods.  The functions
    --   in this module are used to fill out collection implementations and are not intended to be
    --   used directly by end users.
    
    module Data.Edison.Coll.Defaults where
    
    import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter)
    import Control.Monad.Identity
    
    import Data.Edison.Coll
    import qualified Data.Edison.Seq as S
    import qualified Data.Edison.Seq.ListSeq as L
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    
    insertSeqUsingUnion :: (CollX c a,S.Sequence seq) => seq a -> c -> c
    insertSeqUsingUnion xs c = union (fromSeq xs) c
    
    insertSeqUsingFoldr :: (CollX c a,S.Sequence seq) => seq a -> c -> c
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
       maxElem = maxElem; foldr = foldr; foldr' = foldr';
       foldl = foldl; foldl' = foldl'; foldr1 = foldr1;  foldr1' = foldr1';
       foldl1 = foldl1; foldl1' = foldl1'; toOrdSeq = toOrdSeq;
       unsafeMapMonotonic = unsafeMapMonotonic}
    
    -- instance Eq is derived
    
    instance (C.OrdColl h a, Show h) => Show (Min h a) where
       showsPrec i xs rest
         | i == 0    = concat [    moduleName,".fromColl ",showsPrec 10 (toColl xs) rest]
         | otherwise = concat ["(",moduleName,".fromColl ",showsPrec 10 (toColl xs) (')':rest)]
    
    instance (C.OrdColl h a, Read h) => Read (Min h a) where
       readsPrec _ xs = maybeParens p xs
           where p ys = tokenMatch (moduleName++".fromColl") ys
                          >>= readsPrec 10
                          >>= \(coll,rest) -> return (fromColl coll,rest)
    
    instance (C.OrdColl h a,Arbitrary h,Arbitrary a) => Arbitrary (Min h a) where
      arbitrary = do xs <- arbitrary
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
        foldr1,foldr1',foldl1,foldl1',toOrdSeq,
        unsafeMapMonotonic,
    
        -- * Other supported operations
        toColl,fromColl,
    
        -- * Documentation
        moduleName
    ) where
    
    import Prelude hiding (null,foldr,foldl,foldr1,foldl1,lookup,filter)
    import qualified Data.Edison.Coll as C
    import qualified Data.Edison.Seq as S
    import Data.Edison.Coll.Defaults
    import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)
    import Data.Monoid
    import qualified Data.Semigroup as SG
    import Control.Monad
    import Test.QuickCheck
    

    Found in Data.Edison.Seq.RevSeq from the package EdisonCore
    instance Eq (s a) => Eq (Rev s a) where
      (N m xs) == (N n ys) = (m == n) && (xs == ys)
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Rev s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Rev s a) where
      showsPrec i xs rest
         | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
         | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    
    instance (S.Sequence s, Read (s a)) => Read (Rev s a) where
      readsPrec _ xs = maybeParens p xs
          where p xs = tokenMatch (moduleName++".fromSeq") xs
                         >>= readsPrec 10
                         >>= \(l,rest) -> return (fromSeq l,rest)
    
    instance (S.Sequence s, Arbitrary (s a)) => Arbitrary (Rev s a) where
      arbitrary = do xs <- arbitrary
    

    Found in Data.Edison.Seq.SizedSeq from the package EdisonCore
      -- this is probably identical to the code that would be
      -- generated by "deriving (Eq)", but I wanted to be *sure*
      -- that the sizes were compared before the inner sequences
    
    instance (S.Sequence s, Ord a, Eq (s a)) => Ord (Sized s a) where
      compare = defaultCompare
    
    instance (S.Sequence s, Show (s a)) => Show (Sized s a) where
      showsPrec i xs rest
        | i == 0    = L.concat [    moduleName,".fromSeq ",showsPrec 10 (toSeq xs) rest]
        | otherwise = L.concat ["(",moduleName,".fromSeq ",showsPrec 10 (toSeq xs) (')':rest)]
    
    instance (S.Sequence s, Read (s a)) => Read (Sized s a) where
      readsPrec _ xs = maybeParens p xs
          where p xs = tokenMatch (moduleName++".fromSeq") xs
                         >>= readsPrec 10
                         >>= \(l,rest) -> return (fromSeq l, rest)
    
    instance (S.Sequence s, Arbitrary (s a)) => Arbitrary (Sized s a) where
      arbitrary = do xs <- arbitrary
    

    unzip3UsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    

    unzip3UsingLists See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariants:
    --   * list of complete binary trees in non-decreasing
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariant:
    --   * front empty only if rear also empty
    

    unzipUsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    

    unzipUsingLists See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariants:
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariant:
    

    unzipWith3UsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
    

    unzipWith3UsingLists See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    
    instance S.Sequence Seq where
      {lcons = lcons; rcons = rcons;
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariants:
    --   * list of complete binary trees in non-decreasing
    --     order by size
    --   * first argument to 'C' is the number
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariant:
    --   * front empty only if rear also empty
    
    structuralInvariant (Q x y) = not (L.null x) || L.null y
    

    unzipWithUsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    
    -- instances
    
    instance S.Sequence Seq where
    

    unzipWithUsingLists See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    
    instance S.Sequence Seq where
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- instances
    
    instance S.Sequence Seq where
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariants:
    --   * list of complete binary trees in non-decreasing
    --     order by size
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    
    -- invariant:
    --   * front empty only if rear also empty
    

    updateUsingAdjust See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    concat = concatUsingFoldr
    reverse = reverseUsingReverseOnto
    reverseOnto = reverseOntoUsingFoldl
    fromList = fromListUsingCons
    toList = toListUsingFoldr
    concatMap = concatMapUsingFoldr
    foldr1 = foldr1UsingLview
    foldr1' = foldr1'UsingLview
    foldl1 = foldl1UsingFoldl
    foldl1' = foldl1'UsingFoldl'
    reducer = reducerUsingReduce1
    reducel = reducelUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel' = reducel'UsingReduce1'
    update = updateUsingAdjust
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex = foldrWithIndexUsingLists
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    concat = concatUsingFoldr
    concatMap = concatMapUsingFoldr
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    copy = copyUsingLists
    inBounds = inBoundsUsingLookupM
    lookup = lookupUsingLookupM
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingLookupM
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    

    updateUsingSplitAt See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    concatMap = concatMapUsingFoldr
    
    reducer  = reducerUsingReduce1
    reducer' = reducer'UsingReduce1'
    reducel  = reducelUsingReduce1
    reducel' = reducel'UsingReduce1'
    reduce1  = reduce1UsingLists
    reduce1' = reduce1'UsingLists
    
    inBounds = inBoundsUsingDrop
    lookup = lookupUsingDrop
    lookupM = lookupMUsingDrop
    lookupWithDefault = lookupWithDefaultUsingDrop
    
    update = updateUsingSplitAt
    adjust = adjustUsingSplitAt
    
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    

    zip3UsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    
    -- FIXME what are the structural invariants?
    structuralInvariant = const True
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    

    zip3UsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    

    zipUsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    reducel' = reducel'UsingReduce1'
    reduce1' = reduce1'UsingLists
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldlWithIndex = foldlWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    
    -- FIXME what are the structural invariants?
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    update = updateUsingAdjust
    adjust = adjustUsingLists
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    

    zipUsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    concatMap   = concatMapUsingFoldr
    subseq      = subseqDefault
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    

    zipWith3UsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    
    -- FIXME what are the structural invariants?
    structuralInvariant = const True
    
    -- instances
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    zipWith3UsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    unzipWith3 = unzipWith3UsingFoldr
    

    zipWithUsingLists See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.BankersQueue from the package EdisonCore
    inBounds = inBoundsUsingSize
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    subseq = subseqDefault
    filter = filterUsingLists
    partition = partitionUsingLists
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.BinaryRandList from the package EdisonCore
    foldlWithIndex' = foldlWithIndex'UsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.MyersStack from the package EdisonCore
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    
    -- FIXME what are the structural invariants?
    structuralInvariant = const True
    

    Found in Data.Edison.Seq.RandList from the package EdisonCore
    take = takeUsingLists
    splitAt = splitAtDefault
    filter = filterUsingFoldr
    partition = partitionUsingFoldr
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    -- for zips, could optimize by calculating which one is shorter and
    -- retaining its shape
    
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    Found in Data.Edison.Seq.SimpleQueue from the package EdisonCore
    mapWithIndex = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    take = takeUsingLists
    drop = dropUsingLists
    splitAt = splitAtDefault
    subseq = subseqDefault
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    zip = zipUsingLists
    zip3 = zip3UsingLists
    zipWith = zipWithUsingLists
    zipWith3 = zipWith3UsingLists
    unzip = unzipUsingLists
    unzip3 = unzip3UsingLists
    unzipWith = unzipWithUsingLists
    unzipWith3 = unzipWith3UsingLists
    

    zipWithUsingLview See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Seq.FingerSeq from the package EdisonCore
    filter      = filterUsingLview
    partition   = partitionUsingFoldr
    takeWhile   = takeWhileUsingLview
    dropWhile   = dropWhileUsingLview
    splitWhile  = splitWhileUsingLview
    
    mapWithIndex    = mapWithIndexUsingLists
    foldrWithIndex  = foldrWithIndexUsingLists
    foldrWithIndex' = foldrWithIndex'UsingLists
    foldlWithIndex  = foldlWithIndexUsingLists
    foldlWithIndex' = foldlWithIndex'UsingLists
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr
    

    Found in Data.Edison.Seq.JoinList from the package EdisonCore
    take = takeUsingLview
    drop = dropUsingLtail
    splitAt = splitAtUsingLview
    subseq = subseqDefault
    
    filter = filterUsingLview
    partition = partitionUsingFoldr
    takeWhile = takeWhileUsingLview
    dropWhile = dropWhileUsingLview
    splitWhile = splitWhileUsingLview
    
    zip = zipUsingLview
    zip3 = zip3UsingLview
    zipWith = zipWithUsingLview
    zipWith3 = zipWith3UsingLview
    
    unzip = unzipUsingFoldr
    unzip3 = unzip3UsingFoldr
    unzipWith = unzipWithUsingFoldr