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

Symbols

  • compareUsingToOrdList See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
      coarbitrary E = variant 0
      coarbitrary (H1 x a) = variant 1 . coarbitrary x . coarbitrary a
      coarbitrary (H2 x a b) =
          variant 2 . coarbitrary x . coarbitrary a . coarbitrary b
    
    instance (Ord a) => Semigroup (Heap a) where
        (<>) = union
    
    instance (Ord a) => Monoid (Heap a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a) => Ord (Heap a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    instance (Ord a, CoArbitrary a) => CoArbitrary (Heap a) where
      coarbitrary E = variant 0
      coarbitrary (L _ x a b) =
          variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
    
    instance (Ord a) => Semigroup (Heap a) where
        (<>) = union
    
    instance (Ord a) => Monoid (Heap a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a) => Ord (Heap a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
                                           else fromPrim xs)
    
    instance (C.OrdColl h a,CoArbitrary h,CoArbitrary a) => CoArbitrary (Min h a) where
      coarbitrary E = variant 0
      coarbitrary (M x xs) = variant 1 . coarbitrary x . coarbitrary xs
    
    instance (C.OrdColl h a) => SG.Semigroup (Min h a) where
        (<>) = union
    instance (C.OrdColl h a) => Monoid (Min h a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Eq h, C.OrdColl h a) => Ord (Min h a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    instance (Ord a, CoArbitrary a) => CoArbitrary (Heap a) where
      coarbitrary E = variant 0
      coarbitrary (T x a b) =
          variant 1 . coarbitrary x . coarbitrary a . coarbitrary b
    
    instance (Ord a) => Semigroup (Heap a) where
        (<>) = union
    
    instance (Ord a) => Monoid (Heap a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a) => Ord (Heap a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
    instance (Ord a,CoArbitrary a) => CoArbitrary (Heap a) where
      coarbitrary E = variant 0
      coarbitrary (T a x b) =
        variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
    
    instance (Ord a) => Semigroup (Heap a) where
        (<>) = union
    instance (Ord a) => Monoid (Heap a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a) => Ord (Heap a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
      arbitrary = do (w::Int) <- arbitrary
                     return (Set (fromIntegral w))
    
    instance (Eq a, Enum a, CoArbitrary a) => CoArbitrary (Set a) where
      coarbitrary (Set w) = coarbitrary (fromIntegral w :: Int)
    
    instance (Eq a, Enum a) => Semigroup (Set a) where
        (<>) = union
    instance (Eq a, Enum a) => Monoid (Set a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a, Enum a) => Ord (Set a) where
        compare = compareUsingToOrdList
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    instance (Ord a, CoArbitrary a) => CoArbitrary (Set a) where
      coarbitrary E = variant 0
      coarbitrary (T a x b) =
        variant 1 . coarbitrary a . coarbitrary x . coarbitrary b
    
    instance (Ord a) => Semigroup (Set a) where
      (<>) = union
    
    instance (Ord a) => Monoid (Set a) where
        mempty  = empty
        mappend = (SG.<>)
        mconcat = unionSeq
    
    instance (Ord a) => Ord (Set a) where
        compare = compareUsingToOrdList
    

    countUsingMember See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    empty              = DS.empty
    singleton          = DS.singleton
    fromSeq            = fromSeqUsingFoldr
    insert             = DS.insert
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    
    toSeq              = toSeqUsingFold
    lookup el set      = DS.findMin (DS.intersection set (DS.singleton el))
    lookupM            = lookupMUsingLookupAll
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    -- | /O(1)/. Is this the empty set?
    null :: Set a -> Bool
    null (Set 0) = True
    null _       = False
    
    -- | /O(1)/. The number of elements in the set.
    size :: Set a -> Int
    size (Set w) = countBits w
    
    -- | /O(1)/. Is the element in the set?
    member :: (Eq a, Enum a) => a -> Set a -> Bool
    member x (Set w) = testBit w $ fromEnum x
    
    count :: (Eq a, Enum a) => a -> Set a -> Int
    count = countUsingMember
    
    lookup :: (Eq a, Enum a) => a -> Set a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Eq a, Enum a, Monad m) => a -> Set a -> m a
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    

    deleteMaxUsingMaxView See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingFoldr
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Ord a, Monad m) => a -> Heap a -> m a
    

    deleteSeqUsingDelete See 7 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    strictWith f h@(L _ x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
    unionSeq = unionSeqUsingReduce
    
    delete _ E = E
    delete x m@(M y ys)
      | x > y     = M y (C.delete x ys)
      | x == y    = fromPrim ys
      | otherwise = m
    
    deleteAll _ E = E
    deleteAll x m@(M y ys)
      | x > y     = M y (C.deleteAll x ys)
      | x == y    = fromPrim (C.deleteAll x ys)
      | otherwise = m
    
    deleteSeq = deleteSeqUsingDelete
    
    null E = True
    null (M _ _) = False
    
    size E = 0
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    strictWith f h@(T x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
    unsafeMapMonotonic f (T a x b) =
      T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict h@E = h
    strict h@(T l _ r) = strict l `seq` strict r `seq` h
    
    strictWith _ h@E = h
    strictWith f h@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use defaults
    
    fromSeq = fromSeqUsingFoldr
    insertSeq = insertSeqUsingFoldr
    unionSeq = unionSeqUsingReduce
    deleteSeq = deleteSeqUsingDelete
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    -- instance declarations
    
    instance Ord a => C.CollX (Heap a) a where
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    type Set = DS.Set
    
    structuralInvariant :: Ord a => Set a -> Bool
    structuralInvariant = DS.valid
    
    empty              = DS.empty
    singleton          = DS.singleton
    fromSeq            = fromSeqUsingFoldr
    insert             = DS.insert
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    -- given the preconditions, we can just ignore the combining function
    insertWith :: (Eq a, Enum a) => (a -> a -> a) -> a -> Set a -> Set a
    insertWith _ x (Set w) =
        Set $ setBit w $ check "insertWith" $ fromEnum x
    
    -- | /O(1)/. Delete an element from a set.
    delete :: (Eq a, Enum a) => a -> Set a -> Set a
    delete x (Set w) =
        Set $ clearBit w $ fromEnum x
    
    deleteAll :: (Eq a, Enum a) => a -> Set a -> Set a
    deleteAll = delete
    
    deleteSeq :: (Eq a, Enum a, S.Sequence s) => s a -> Set a -> Set a
    deleteSeq = deleteSeqUsingDelete
    
    {--------------------------------------------------------------------
      Subset
    --------------------------------------------------------------------}
    -- | /O(1)/. Is this a proper subset? (ie. a subset but not equal).
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    

    differenceUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    

    disjointUsingToOrdList No usage example found for this symbol :( Collapse [-]
    filterUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    

    fromSeqUsingFoldr See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    strict :: Heap a -> Heap a
    strict h@E = h
    strict h@(H1 _ xs) = strict xs `seq` h
    strict h@(H2 _ h' xs) = strict h' `seq` strict xs `seq` h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(H1 x xs) = f x `seq` strictWith f xs `seq` h
    strictWith f h@(H2 x h' xs) = f x `seq` strictWith f h' `seq` strictWith f xs `seq` h
    
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingFoldr
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
            tos (T a x b) rest = tos a (S.lcons x (tos b rest))
    
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
      T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict h@E = h
    strict h@(T l _ r) = strict l `seq` strict r `seq` h
    
    strictWith _ h@E = h
    strictWith f h@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use defaults
    
    fromSeq = fromSeqUsingFoldr
    insertSeq = insertSeqUsingFoldr
    unionSeq = unionSeqUsingReduce
    deleteSeq = deleteSeqUsingDelete
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    unionWith    :: Ord a => (a -> a -> a) -> Set a -> Set a -> Set a
    unionSeqWith :: (Ord a,S.Sequence seq) => (a -> a -> a) -> seq (Set a) -> Set a
    intersectionWith :: Ord a => (a -> a -> a) -> Set a -> Set a -> Set a
    unsafeMapMonotonic :: Ord a => (a -> a) -> Set a -> Set a
    
    moduleName = "Data.Edison.Coll.StandardSet"
    
    type Set = DS.Set
    
    structuralInvariant :: Ord a => Set a -> Bool
    structuralInvariant = DS.valid
    
    empty              = DS.empty
    singleton          = DS.singleton
    fromSeq            = fromSeqUsingFoldr
    insert             = DS.insert
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    

    fromSeqUsingUnionSeq See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
      L i (f x) (unsafeMapMonotonic f a) (unsafeMapMonotonic f b)
    
    
    -- all fields are already fully strict!
    strict :: Heap a -> Heap a
    strict h = h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(L _ x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
      T (f x) (unsafeMapMonotonic f a) (unsafeMapMonotonic f b)
    
    
    strict :: Heap a -> Heap a
    strict h@E = h
    strict h@(T _ l r) = strict l `seq` strict r `seq` h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(T x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    foldl1' f (T a x b) = foldl' f ((f $! (foldl1' f a)) x) b
    
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
        T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    

    fromSeqWithUsingInsertWith See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    foldr1' f   set     = L.foldr1' f   (DS.toAscList set)
    foldl   f x set     = L.foldl   f x (DS.toAscList set)
    foldl'  f x set     = L.foldl'  f x (DS.toAscList set)
    foldl1  f   set     = L.foldl1  f   (DS.toAscList set)
    foldl1' f   set     = L.foldl1' f   (DS.toAscList set)
    
    toOrdSeq           = S.fromList . DS.toAscList
    
    intersection       = DS.intersection
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
                            Nothing -> DS.insert x set
                            Just x' -> DS.insert (f x x') set
    insertSeqWith      = insertSeqWithUsingInsertWith
    unionl             = DS.union
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    insertSeq = insertSeqUsingUnion
    
    -- given the preconditions, we can just ignore the combining function
    insertSeqWith :: (Eq a, Enum a, S.Sequence s) => (a -> a -> a) -> s a -> Set a -> Set a
    insertSeqWith _ = insertSeq
    
    toSeq :: (Eq a, Enum a, S.Sequence s) => Set a -> s a
    toSeq (Set w) = foldrBits f S.empty w
      where f i z = S.lcons (toEnum i) z
    
    toOrdSeq :: (Ord a, Enum a, S.Sequence s) => Set a -> s a
    toOrdSeq = toSeq
    
    fromSeqWith :: (Eq a, Enum a, S.Sequence s) => (a -> a -> a) -> s a -> Set a
    fromSeqWith = fromSeqWithUsingInsertWith
    
    
    {--------------------------------------------------------------------
      Split
    --------------------------------------------------------------------}
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    

    insertSeqUsingFoldr See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    strict h@(H2 _ h' xs) = strict h' `seq` strict xs `seq` h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(H1 x xs) = f x `seq` strictWith f xs `seq` h
    strictWith f h@(H2 x h' xs) = f x `seq` strictWith f h' `seq` strictWith f xs `seq` h
    
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingFoldr
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
      T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict h@E = h
    strict h@(T l _ r) = strict l `seq` strict r `seq` h
    
    strictWith _ h@E = h
    strictWith f h@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use defaults
    
    fromSeq = fromSeqUsingFoldr
    insertSeq = insertSeqUsingFoldr
    unionSeq = unionSeqUsingReduce
    deleteSeq = deleteSeqUsingDelete
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    -- instance declarations
    

    insertSeqUsingUnion See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    -- all fields are already fully strict!
    strict :: Heap a -> Heap a
    strict h = h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(L _ x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    strict :: Heap a -> Heap a
    strict h@E = h
    strict h@(T _ l r) = strict l `seq` strict r `seq` h
    
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(T x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    intersectionWith :: Ord a => (a -> a -> a) -> Set a -> Set a -> Set a
    unsafeMapMonotonic :: Ord a => (a -> a) -> Set a -> Set a
    
    moduleName = "Data.Edison.Coll.StandardSet"
    
    type Set = DS.Set
    
    structuralInvariant :: Ord a => Set a -> Bool
    structuralInvariant = DS.valid
    
    empty              = DS.empty
    singleton          = DS.singleton
    fromSeq            = fromSeqUsingFoldr
    insert             = DS.insert
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
        mininum = lsb w
        folder z i = f z (toEnum i)
    
    {--------------------------------------------------------------------
      Lists
    --------------------------------------------------------------------}
    fromSeq :: (Eq a, Enum a, S.Sequence s) => s a -> Set a
    fromSeq xs = Set $ S.fold' f 0 xs
      where f x z = setBit z $ check "fromSeq" $ fromEnum x
    
    fromOrdSeq :: (Ord a, Enum a, S.Sequence s) => s a -> Set a
    fromOrdSeq = fromSeq
    
    insertSeq :: (Eq a, Enum a, S.Sequence s) => s a -> Set a -> Set a
    insertSeq = insertSeqUsingUnion
    
    -- given the preconditions, we can just ignore the combining function
    insertSeqWith :: (Eq a, Enum a, S.Sequence s) => (a -> a -> a) -> s a -> Set a -> Set a
    insertSeqWith _ = insertSeq
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
        T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    

    insertSeqWithUsingInsertWith See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    foldl1' f   set     = L.foldl1' f   (DS.toAscList set)
    
    toOrdSeq           = S.fromList . DS.toAscList
    
    intersection       = DS.intersection
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
                            Nothing -> DS.insert x set
                            Just x' -> DS.insert (f x x') set
    insertSeqWith      = insertSeqWithUsingInsertWith
    unionl             = DS.union
    unionr             = flip DS.union
    unionWith          = unionWithUsingOrdLists
    unionSeqWith       = unionSeqWithUsingReducer
    intersectionWith   = intersectionWithUsingOrdLists
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    

    insertUsingInsertWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
        T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    

    intersectWitnessUsingToOrdList No usage example found for this symbol :( Collapse [-]
    intersectionUsingIntersectionWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    

    intersectionWithUsingOrdLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
                            Nothing -> DS.insert x set
                            Just x' -> DS.insert (f x x') set
    insertSeqWith      = insertSeqWithUsingInsertWith
    unionl             = DS.union
    unionr             = flip DS.union
    unionWith          = unionWithUsingOrdLists
    unionSeqWith       = unionSeqWithUsingReducer
    intersectionWith   = intersectionWithUsingOrdLists
    unsafeMapMonotonic = DS.mapMonotonic
    
    
    
    instance Ord a => C.CollX (Set a) a where
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    
    -- instance declarations
    
    instance Ord a => C.CollX (Set a) a where
      {singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    lookupAllUsingLookupM See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    member x (Set w) = testBit w $ fromEnum x
    
    count :: (Eq a, Enum a) => a -> Set a -> Int
    count = countUsingMember
    
    lookup :: (Eq a, Enum a) => a -> Set a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Eq a, Enum a, Monad m) => a -> Set a -> m a
    lookupM x s
       | member x s = return x
       | otherwise  = fail (moduleName++".lookupM: lookup failed")
    
    lookupAll  :: (Eq a, Enum a, S.Sequence s) => a -> Set a -> s a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: (Eq a, Enum a) => a -> a -> Set a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    {--------------------------------------------------------------------
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    

    lookupMUsingLookupAll See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Ord a, Monad m) => a -> Heap a -> m a
    lookupM = lookupMUsingLookupAll
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupAll
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    
    toSeq              = toSeqUsingFold
    lookup el set      = DS.findMin (DS.intersection set (DS.singleton el))
    lookupM            = lookupMUsingLookupAll
    lookupAll el set   = toSeqUsingFold (DS.intersection set (DS.singleton el))
    lookupWithDefault  = lookupWithDefaultUsingLookupAll
    fold               = DS.fold
    fold' f x xs       = L.foldl' (flip f) x (DS.toList xs)
    fold1 f set        = let (x,s) = DS.deleteFindMin set in DS.fold f x s
    

    lookupUsingLookupAll See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Ord a, Monad m) => a -> Heap a -> m a
    lookupM = lookupMUsingLookupAll
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    null _       = False
    
    -- | /O(1)/. The number of elements in the set.
    size :: Set a -> Int
    size (Set w) = countBits w
    
    -- | /O(1)/. Is the element in the set?
    member :: (Eq a, Enum a) => a -> Set a -> Bool
    member x (Set w) = testBit w $ fromEnum x
    
    count :: (Eq a, Enum a) => a -> Set a -> Int
    count = countUsingMember
    
    lookup :: (Eq a, Enum a) => a -> Set a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Eq a, Enum a, Monad m) => a -> Set a -> m a
    lookupM x s
       | member x s = return x
       | otherwise  = fail (moduleName++".lookupM: lookup failed")
    

    lookupUsingLookupM See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    

    lookupWithDefaultUsingLookupAll See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Ord a, Monad m) => a -> Heap a -> m a
    lookupM = lookupMUsingLookupAll
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupAll
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    
    -- instance declarations
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    
    toSeq              = toSeqUsingFold
    lookup el set      = DS.findMin (DS.intersection set (DS.singleton el))
    lookupM            = lookupMUsingLookupAll
    lookupAll el set   = toSeqUsingFold (DS.intersection set (DS.singleton el))
    lookupWithDefault  = lookupWithDefaultUsingLookupAll
    fold               = DS.fold
    fold' f x xs       = L.foldl' (flip f) x (DS.toList xs)
    fold1 f set        = let (x,s) = DS.deleteFindMin set in DS.fold f x s
    fold1' f xs        = L.foldl1' (flip f) (DS.toList xs)
    filter             = DS.filter
    

    lookupWithDefaultUsingLookupM See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    count = countUsingMember
    
    lookup :: (Eq a, Enum a) => a -> Set a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Eq a, Enum a, Monad m) => a -> Set a -> m a
    lookupM x s
       | member x s = return x
       | otherwise  = fail (moduleName++".lookupM: lookup failed")
    
    lookupAll  :: (Eq a, Enum a, S.Sequence s) => a -> Set a -> s a
    lookupAll = lookupAllUsingLookupM
    
    lookupWithDefault :: (Eq a, Enum a) => a -> a -> Set a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    {--------------------------------------------------------------------
      Construction
    --------------------------------------------------------------------}
    -- | /O(1)/. The empty set.
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    

    memberUsingFold No usage example found for this symbol :( Collapse [-]
    partitionUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    

    properSubsetOnOrdLists No usage example found for this symbol :( Collapse [-]
    properSubsetUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    

    readsPrecUsingFromList See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    instance Ord a => C.OrdColl (Heap a) a where
      {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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord a, Arbitrary a) => Arbitrary (Heap a) where
      arbitrary = sized (\n -> arbTree n)
        where arbTree 0 = return E
              arbTree n =
    

    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    instance Ord a => C.OrdColl (Heap a) a where
      {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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    
    instance (Ord a, Arbitrary a) => Arbitrary (Heap a) where
      arbitrary = sized (\n -> arbTree n)
        where arbTree 0 = return E
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    instance Ord a => C.OrdColl (Heap a) a where
      {minView = minView; minElem = minElem; maxView = maxView;
       maxElem = maxElem; foldr = foldr; foldr' = foldr';
       foldl = foldl; foldl' = foldl'; foldr1 = foldr1; foldr1' = foldr1';
       foldl1  = foldl1; foldl1' = fold1'; toOrdSeq = toOrdSeq;
       unsafeMapMonotonic = unsafeMapMonotonic}
    
    instance Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    
    instance (Ord a, Arbitrary a) => Arbitrary (Heap a) where
      arbitrary = sized (\n -> arbTree n)
        where arbTree 0 = return E
    

    Found in Data.Edison.Coll.SplayHeap 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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord a,Arbitrary a) => Arbitrary (Heap a) where
      arbitrary = do xs <- arbitrary
                     return (C.fromList xs)
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    instance (Eq a, Enum a) => C.Set (Set a) a where
      {fromSeqWith = fromSeqWith; insertWith = insertWith;
       insertSeqWith = insertSeqWith; unionl = unionl; unionr = unionr;
       unionWith = unionWith; unionSeqWith = unionSeqWith;
       intersectionWith = intersectionWith}
    
    instance (Ord a, Enum a) => C.OrdSetX (Set a) a
    instance (Ord a, Enum a) => C.OrdSet (Set a) a
    
    instance (Eq a, Enum a, Show a) => Show (Set a) where
       showsPrec = showsPrecUsingToList
    
    instance (Eq a, Enum a, Read a) => Read (Set a) where
       readsPrec = readsPrecUsingFromList
    
    instance (Eq a, Enum a, Arbitrary a) => Arbitrary (Set a) where
      arbitrary = do (w::Int) <- arbitrary
                     return (Set (fromIntegral w))
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
       intersectionWith = intersectionWith}
    
    instance Ord a => C.OrdSetX (Set a) a
    
    instance Ord a => C.OrdSet (Set a) a
    
    
    instance Ord a => Eq (Set a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Set a) where
       showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Set a) where
       readsPrec = readsPrecUsingFromList
    
    
    instance (Ord a, Arbitrary a) => Arbitrary (Set a) where
      arbitrary = do (xs::[a]) <- arbitrary
                     return (Prelude.foldr insert empty xs)
    

    showsPrecUsingToList See 6 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; strictWith = strictWith}
    
    instance Ord a => C.OrdColl (Heap a) a where
      {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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord a, Arbitrary a) => Arbitrary (Heap a) where
    

    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; strictWith = strictWith}
    
    instance Ord a => C.OrdColl (Heap a) a where
      {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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
       fold = fold; fold' = fold'; fold1 = fold1; fold1' = fold1';
       filter = filter; partition = partition; strictWith = strictWith}
    
    instance Ord a => C.OrdColl (Heap a) a where
      {minView = minView; minElem = minElem; maxView = maxView;
       maxElem = maxElem; foldr = foldr; foldr' = foldr';
       foldl = foldl; foldl' = foldl'; foldr1 = foldr1; foldr1' = foldr1';
       foldl1  = foldl1; foldl1' = fold1'; toOrdSeq = toOrdSeq;
       unsafeMapMonotonic = unsafeMapMonotonic}
    
    instance Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
       filter = filter; partition = partition}
    
    instance Ord a => C.OrdColl (Heap a) a where
      {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 Ord a => Eq (Heap a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Heap a) where
      showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Heap a) where
      readsPrec = readsPrecUsingFromList
    
    instance (Ord a,Arbitrary a) => Arbitrary (Heap a) where
    

    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
       foldl = foldl; foldl' = foldl'; foldr1 = foldr1; foldr1' = foldr1';
       foldl1 = foldl1; foldl1' = foldl1'; toOrdSeq = toOrdSeq;
       unsafeMapMonotonic = unsafeMapMonotonic}
    
    instance (Eq a, Enum a) => C.Set (Set a) a where
      {fromSeqWith = fromSeqWith; insertWith = insertWith;
       insertSeqWith = insertSeqWith; unionl = unionl; unionr = unionr;
       unionWith = unionWith; unionSeqWith = unionSeqWith;
       intersectionWith = intersectionWith}
    
    instance (Ord a, Enum a) => C.OrdSetX (Set a) a
    instance (Ord a, Enum a) => C.OrdSet (Set a) a
    
    instance (Eq a, Enum a, Show a) => Show (Set a) where
       showsPrec = showsPrecUsingToList
    
    instance (Eq a, Enum a, Read a) => Read (Set a) where
       readsPrec = readsPrecUsingFromList
    
    instance (Eq a, Enum a, Arbitrary a) => Arbitrary (Set a) where
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
      {fromSeqWith = fromSeqWith; insertWith = insertWith;
       insertSeqWith = insertSeqWith; unionl = unionl; unionr = unionr;
       unionWith = unionWith; unionSeqWith = unionSeqWith;
       intersectionWith = intersectionWith}
    
    instance Ord a => C.OrdSetX (Set a) a
    
    instance Ord a => C.OrdSet (Set a) a
    
    
    instance Ord a => Eq (Set a) where
      xs == ys = C.toOrdList xs == C.toOrdList ys
    
    instance (Ord a, Show a) => Show (Set a) where
       showsPrec = showsPrecUsingToList
    
    instance (Ord a, Read a) => Read (Set a) where
       readsPrec = readsPrecUsingFromList
    

    subsetOnOrdLists No usage example found for this symbol :( Collapse [-]
    subsetUsingOrdLists See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    

    symmetricDifferenceUsingDifference See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    foldr   f x set     = L.foldr   f x (DS.toAscList set)
    foldr'  f x set     = L.foldr'  f x (DS.toAscList set)
    foldr1  f   set     = L.foldr1  f   (DS.toAscList set)
    foldr1' f   set     = L.foldr1' f   (DS.toAscList set)
    foldl   f x set     = L.foldl   f x (DS.toAscList set)
    foldl'  f x set     = L.foldl'  f x (DS.toAscList set)
    foldl1  f   set     = L.foldl1  f   (DS.toAscList set)
    foldl1' f   set     = L.foldl1' f   (DS.toAscList set)
    
    toOrdSeq           = S.fromList . DS.toAscList
    
    intersection       = DS.intersection
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    

    toOrdSeqUsingFoldr See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupAll
    
    lookupM :: (Ord a, Monad m) => a -> Heap a -> m a
    lookupM = lookupMUsingLookupAll
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupAll
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    
    -- instance declarations
    
    instance Ord a => C.CollX (Heap a) a where
      {singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    
    
    -- instance declarations
    
    instance Ord a => C.CollX (Heap a) a where
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    
    -- instance declarations
    
    instance Ord a => C.CollX (Heap a) a where
      {singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    

    toSeqUsingFold See 3 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    
    toSeq              = toSeqUsingFold
    lookup el set      = DS.findMin (DS.intersection set (DS.singleton el))
    lookupM            = lookupMUsingLookupAll
    lookupAll el set   = toSeqUsingFold (DS.intersection set (DS.singleton el))
    lookupWithDefault  = lookupWithDefaultUsingLookupAll
    fold               = DS.fold
    fold' f x xs       = L.foldl' (flip f) x (DS.toList xs)
    fold1 f set        = let (x,s) = DS.deleteFindMin set in DS.fold f x s
    fold1' f xs        = L.foldl1' (flip f) (DS.toList xs)
    

    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    fromSeq            = fromSeqUsingFoldr
    insert             = DS.insert
    insertSeq          = insertSeqUsingUnion
    union              = DS.union
    unionSeq se        = DS.unions $ S.toList se
    delete             = DS.delete
    deleteAll          = DS.delete -- by set property
    deleteSeq          = deleteSeqUsingDelete
    null               = DS.null
    size               = DS.size
    member             = DS.member
    count              = countUsingMember
    strict xs          = DS.fold (flip const) () xs `seq` xs
    
    toSeq              = toSeqUsingFold
    lookup el set      = DS.findMin (DS.intersection set (DS.singleton el))
    lookupM            = lookupMUsingLookupAll
    lookupAll el set   = toSeqUsingFold (DS.intersection set (DS.singleton el))
    lookupWithDefault  = lookupWithDefaultUsingLookupAll
    fold               = DS.fold
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    

    unionSeqUsingFoldl See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    strictWith _ h@E = h
    strictWith f h@(H1 x xs) = f x `seq` strictWith f xs `seq` h
    strictWith f h@(H2 x h' xs) = f x `seq` strictWith f h' `seq` strictWith f xs `seq` h
    
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingFoldr
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    

    unionSeqUsingFoldl' See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.EnumSet from the package EdisonCore
    partitionLT_GE x s = (filterLT x s,filterGE x s)
    
    partitionLE_GT :: (Ord a, Enum a) => a -> Set a -> (Set a, Set a)
    partitionLE_GT x s = (filterLE x s,filterGT x s)
    
    partitionLT_GT :: (Ord a, Enum a) => a -> Set a -> (Set a, Set a)
    partitionLT_GT x s = (filterLT x s,filterGT x s)
    
    
    {--------------------------------------------------------------------
      Union.
    --------------------------------------------------------------------}
    -- | The union of a list of sets: (@'unions' == 'foldl' 'union' 'empty'@).
    unionSeq :: (Eq a, Enum a, S.Sequence s) => s (Set a) -> Set a
    unionSeq = unionSeqUsingFoldl'
    
    -- | /O(1)/. The union of two sets.
    union :: Set a -> Set a -> Set a
    union (Set x) (Set y) = Set $ x .|. y
    

    unionSeqUsingReduce See 5 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(L _ x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    

    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
    insertSeq xs (M y ys) =
        case C.minView xs_ys of
          Nothing -> M y C.empty
          Just (x, rest)
              | x < y     -> M x (C.insert y rest)
              | otherwise -> M y xs_ys
      where xs_ys = C.insertSeq xs ys
    
    union E ys = ys
    union xs E = xs
    union (M x xs) (M y ys)
      | x <= y    = M x (C.union xs (C.unsafeInsertMin y ys))
      | otherwise = M y (C.union (C.unsafeInsertMin x xs) ys)
    
    unionSeq = unionSeqUsingReduce
    
    delete _ E = E
    delete x m@(M y ys)
      | x > y     = M y (C.delete x ys)
      | x == y    = fromPrim ys
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    strictWith :: (a -> b) -> Heap a -> Heap a
    strictWith _ h@E = h
    strictWith f h@(T x l r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingUnionSeq
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingUnion
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
    unsafeMapMonotonic _ E = E
    unsafeMapMonotonic f (T a x b) =
      T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict h@E = h
    strict h@(T l _ r) = strict l `seq` strict r `seq` h
    
    strictWith _ h@E = h
    strictWith f h@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use defaults
    
    fromSeq = fromSeqUsingFoldr
    insertSeq = insertSeqUsingFoldr
    unionSeq = unionSeqUsingReduce
    deleteSeq = deleteSeqUsingDelete
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    -- instance declarations
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
        T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    
    toSeq = toSeqUsingFold
    

    unionSeqWithUsingReducer See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    intersection       = DS.intersection
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
                            Nothing -> DS.insert x set
                            Just x' -> DS.insert (f x x') set
    insertSeqWith      = insertSeqWithUsingInsertWith
    unionl             = DS.union
    unionr             = flip DS.union
    unionWith          = unionWithUsingOrdLists
    unionSeqWith       = unionSeqWithUsingReducer
    intersectionWith   = intersectionWithUsingOrdLists
    unsafeMapMonotonic = DS.mapMonotonic
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    
    -- instance declarations
    
    instance Ord a => C.CollX (Set a) a where
    

    unionUsingUnionWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    unsafeMapMonotonic f (T a x b) =
        T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict s@E = s
    strict s@(T l _ r) = strict l `seq` strict r `seq` s
    
    strictWith _ s@E = s
    strictWith f s@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` s
    
    -- the remaining functions all use default definitions
    
    fromSeq = fromSeqUsingUnionSeq
    insert = insertUsingInsertWith
    insertSeq = insertSeqUsingUnion
    union = unionUsingUnionWith
    unionSeq = unionSeqUsingReduce
    deleteAll = delete
    deleteSeq = deleteSeqUsingDelete
    count = countUsingMember
    

    unionWithUsingOrdLists See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.StandardSet from the package EdisonCore
    intersection       = DS.intersection
    difference         = DS.difference
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset       = DS.isProperSubsetOf
    subset             = DS.isSubsetOf
    
    fromSeqWith        = fromSeqWithUsingInsertWith
    insertWith f x set = case lookupM x set of
                            Nothing -> DS.insert x set
                            Just x' -> DS.insert (f x x') set
    insertSeqWith      = insertSeqWithUsingInsertWith
    unionl             = DS.union
    unionr             = flip DS.union
    unionWith          = unionWithUsingOrdLists
    unionSeqWith       = unionSeqWithUsingReducer
    intersectionWith   = intersectionWithUsingOrdLists
    unsafeMapMonotonic = DS.mapMonotonic
    

    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    
    -- instance declarations
    

    unionlUsingUnionWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    lookup = lookupUsingLookupM
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    

    unionrUsingUnionWith See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.UnbalancedSet from the package EdisonCore
    lookupAll = lookupAllUsingLookupM
    lookupWithDefault = lookupWithDefaultUsingLookupM
    filter = filterUsingOrdLists
    partition = partitionUsingOrdLists
    toOrdSeq = toOrdSeqUsingFoldr
    
    intersection = intersectionUsingIntersectionWith
    difference = differenceUsingOrdLists
    symmetricDifference = symmetricDifferenceUsingDifference
    properSubset = properSubsetUsingOrdLists
    subset = subsetUsingOrdLists
    fromSeqWith = fromSeqWithUsingInsertWith
    insertSeqWith = insertSeqWithUsingInsertWith
    unionl = unionlUsingUnionWith
    unionr = unionrUsingUnionWith
    unionWith = unionWithUsingOrdLists
    unionSeqWith = unionSeqWithUsingReducer
    intersectionWith = intersectionWithUsingOrdLists
    
    -- instance declarations
    

    unsafeFromOrdSeqUsingUnsafeInsertMin See 4 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LazyPairingHeap from the package EdisonCore
    -- the remaining functions all use default definitions
    
    fromSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    fromSeq = fromSeqUsingFoldr
    
    insertSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    insertSeq = insertSeqUsingFoldr
    
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingFoldl
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    deleteMax :: Ord a => Heap a -> Heap a
    deleteMax = deleteMaxUsingMaxView
    
    lookup :: Ord a => a -> Heap a -> a
    

    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    toOrdSeq = toOrdSeqUsingFoldr
    
    -- instance declarations
    

    Found in Data.Edison.Coll.SplayHeap from the package EdisonCore
      T (unsafeMapMonotonic f a) (f x) (unsafeMapMonotonic f b)
    
    strict h@E = h
    strict h@(T l _ r) = strict l `seq` strict r `seq` h
    
    strictWith _ h@E = h
    strictWith f h@(T l x r) = f x `seq` strictWith f l `seq` strictWith f r `seq` h
    
    -- the remaining functions all use defaults
    
    fromSeq = fromSeqUsingFoldr
    insertSeq = insertSeqUsingFoldr
    unionSeq = unionSeqUsingReduce
    deleteSeq = deleteSeqUsingDelete
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    -- instance declarations
    
    instance Ord a => C.CollX (Heap a) a where
      {singleton = singleton; fromSeq = fromSeq; insert = insert;
    

    unsafeInsertMaxUsingUnsafeAppend See 2 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.LeftistHeap from the package EdisonCore
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    

    Found in Data.Edison.Coll.SkewHeap from the package EdisonCore
    unionSeq :: (Ord a,S.Sequence seq) => seq (Heap a) -> Heap a
    unionSeq = unionSeqUsingReduce
    
    deleteSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a -> Heap a
    deleteSeq = deleteSeqUsingDelete
    
    lookup :: Ord a => a -> Heap a -> a
    lookup = lookupUsingLookupM
    
    lookupWithDefault :: Ord a => a -> a -> Heap a -> a
    lookupWithDefault = lookupWithDefaultUsingLookupM
    
    unsafeInsertMax :: Ord a => a -> Heap a -> Heap a
    unsafeInsertMax = unsafeInsertMaxUsingUnsafeAppend
    
    unsafeFromOrdSeq :: (Ord a,S.Sequence seq) => seq a -> Heap a
    unsafeFromOrdSeq = unsafeFromOrdSeqUsingUnsafeInsertMin
    
    toOrdSeq :: (Ord a,S.Sequence seq) => Heap a -> seq a
    

    unsafeMapMonotonicUsingFoldr See 1 Occurences [+] Collapse [-]
    Found in Data.Edison.Coll.MinHeap from the package EdisonCore
    foldr1' _ E = error "MinHeap.foldr1': empty heap"
    foldr1' f (M x xs)
      | C.null xs = x
      | otherwise = f x $! (C.foldr1' f xs)
    
    foldl1 _ E = error "MinHeap.foldl1: empty heap"
    foldl1 f (M x xs) = C.foldl f x xs
    
    foldl1' _ E = error "MinHeap.foldl1': empty heap"
    foldl1' f (M x xs) = C.foldl' f x xs
    
    toOrdSeq E = S.empty
    toOrdSeq (M x xs) = S.lcons x (C.toOrdSeq xs)
    
    unsafeMapMonotonic = unsafeMapMonotonicUsingFoldr
    
    strict h@E = h
    strict h@(M _ xs) = C.strict xs `seq` h
    
    strictWith _ h@E = h