-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Classes and data structures complementing the singletons library
--   
--   Please see README.md
@package pringletons
@version 0.4

module Data.Singletons.Class
class EqSing1 f
eqSing1 :: EqSing1 f => Sing a -> f a -> f a -> Bool
class EqSing2 f
eqSing2 :: EqSing2 f => Sing a -> Sing b -> f a b -> f a b -> Bool
class EqSing1 f => OrdSing1 f
compareSing1 :: OrdSing1 f => Sing a -> f a -> f a -> Ordering
class EqSing2 f => OrdSing2 f
compareSing2 :: OrdSing2 f => Sing a -> Sing b -> f a b -> f a b -> Ordering
class ShowSing2 f
showsPrecSing2 :: ShowSing2 f => Int -> Sing a -> Sing b -> f a b -> ShowS
class ReadSing2 f
readPrecSing2 :: ReadSing2 f => Sing a -> Sing b -> ReadPrec (f a b)
class HashableSing1 f
hashWithSaltSing1 :: HashableSing1 f => Sing a -> Int -> f a -> Int
class HashableSing2 f
hashWithSaltSing2 :: HashableSing2 f => Sing a -> Sing b -> Int -> f a b -> Int
class ToJSONSing1 f
toJSONSing1 :: ToJSONSing1 f => Sing a -> f a -> Value
class ToJSONSing2 f
toJSONSing2 :: ToJSONSing2 f => Sing a -> Sing b -> f a b -> Value
class FromJSONSing1 f
parseJSONSing1 :: FromJSONSing1 f => Sing a -> Value -> Parser (f a)
class FromJSONSing2 f
parseJSONSing2 :: FromJSONSing2 f => Sing a -> Sing b -> Value -> Parser (f a b)
class ShowKind k where showsPrecKind i s xs = showsPrec i (fromSing s) xs
showsPrecKind :: ShowKind k => Int -> Sing (x :: k) -> ShowS
showsPrecKind :: (ShowKind k, SingKind k, Show (DemoteRep k)) => Int -> Sing (x :: k) -> ShowS
class ReadKind k where readPrecKind = fmap toSing readPrec
readPrecKind :: ReadKind k => ReadPrec (SomeSing k)
readPrecKind :: (ReadKind k, SingKind k, Read (DemoteRep k)) => ReadPrec (SomeSing k)
class HashableKind k where hashWithSaltKind i s = hashWithSalt i (fromSing s)
hashWithSaltKind :: HashableKind k => Int -> Sing (x :: k) -> Int
hashWithSaltKind :: (HashableKind k, SingKind k, Hashable (DemoteRep k)) => Int -> Sing (x :: k) -> Int
class ToJSONKind k where toJSONKind s = String (pack (showKind s))
toJSONKind :: ToJSONKind k => Sing (x :: k) -> Value
toJSONKind :: (ToJSONKind k, ShowKind k) => Sing (x :: k) -> Value
class FromJSONKind k where parseJSONKind (String t) = let s = unpack t in case readMaybeKind s of { Nothing -> fail ("Could not parse singleton from: " ++ s) Just a -> return a }
parseJSONKind :: FromJSONKind k => Value -> Parser (SomeSing k)
parseJSONKind :: (FromJSONKind k, ReadKind k) => Value -> Parser (SomeSing k)
class ToJSONKeyKind k where toJSONKeyKind s = pack (showKind s)
toJSONKeyKind :: ToJSONKeyKind k => Sing (x :: k) -> Text
toJSONKeyKind :: (ToJSONKeyKind k, ShowKind k) => Sing (x :: k) -> Text
class FromJSONKeyKind k where parseJSONKeyKind t = let s = unpack t in case readMaybeKind s of { Nothing -> fail ("Could not parse key: " ++ s) Just a -> return a }
parseJSONKeyKind :: FromJSONKeyKind k => Text -> Parser (SomeSing k)
parseJSONKeyKind :: (FromJSONKeyKind k, ReadKind k) => Text -> Parser (SomeSing k)
newtype Applied1 (f :: TyFun k Type -> Type) (a :: k)
Applied1 :: Apply f a -> Applied1
[getApplied1] :: Applied1 -> Apply f a
newtype Applied2 (f :: TyFun k (TyFun j Type -> Type) -> Type) (a :: k) (b :: j)
Applied2 :: Apply (Apply f a) b -> Applied2
[getApplied2] :: Applied2 -> Apply (Apply f a) b
newtype Applied3 (f :: TyFun k (TyFun j (TyFun l Type -> Type) -> Type) -> Type) (a :: k) (b :: j) (c :: l)
Applied3 :: Apply (Apply (Apply f a) b) c -> Applied3
[getApplied3] :: Applied3 -> Apply (Apply (Apply f a) b) c
data SomeSingWith1 (k :: Type) (f :: k -> Type)
[SomeSingWith1] :: forall (a :: k) (f :: k -> Type). Sing a -> f a -> SomeSingWith1 k f
data SomeSingWith2 (k :: Type) (j :: Type) (f :: k -> j -> Type)
[SomeSingWith2] :: forall (a :: k) (b :: j) (f :: k -> j -> Type). Sing a -> Sing b -> f a b -> SomeSingWith2 k j f
data SingWith1 k (f :: k -> Type) (a :: k)
[SingWith1] :: Sing a -> f a -> SingWith1 k f a

-- | This is a wrapper for <a>SomeSing</a> that provides common typeclass
--   instances for it. This can be helpful when you want to use
--   <tt>Data.Set</tt> with <a>SomeSing</a>.
newtype ClassySomeSing kproxy
ClassySomeSing :: SomeSing kproxy -> ClassySomeSing kproxy
[getClassySomeSing] :: ClassySomeSing kproxy -> SomeSing kproxy
class EqApplied1 (f :: TyFun k Type -> Type)
eqApplied1 :: EqApplied1 f => proxy f -> Sing a -> Apply f a -> Apply f a -> Bool
class HashableApplied1 (f :: TyFun k Type -> Type)
hashWithSaltApplied1 :: HashableApplied1 f => proxy f -> Sing a -> Int -> Apply f a -> Int
class ToJSONApplied1 (f :: TyFun k Type -> Type)
toJSONApplied1 :: ToJSONApplied1 f => proxy f -> Sing a -> Apply f a -> Value
class FromJSONApplied1 (f :: TyFun k Type -> Type)
parseJSONApplied1 :: FromJSONApplied1 f => proxy f -> Sing a -> Value -> Parser (Apply f a)
showKind :: forall (a :: k). ShowKind k => Sing a -> String
readMaybeKind :: ReadKind kproxy => String -> Maybe (SomeSing kproxy)

-- | Helper function to demote an equality check. It would be nice if this
--   could be added as an <a>Eq</a> instance for <a>SomeSing</a>, but it
--   would required collapsing a lot of the modules in <tt>singletons</tt>
--   to prevent cyclic imports. Or it could be provided as an orphan
--   instance.
eqSome :: SEq kproxy => SomeSing kproxy -> SomeSing kproxy -> Bool

-- | Helper function to demote a comparison
compareSome :: SOrd kproxy => SomeSing kproxy -> SomeSing kproxy -> Ordering
instance forall k (f :: k Data.Singletons.~> *) (a :: k). GHC.Classes.Eq (Data.Singletons.Apply f a) => GHC.Classes.Eq (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). GHC.Classes.Ord (Data.Singletons.Apply f a) => GHC.Classes.Ord (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). GHC.Read.Read (Data.Singletons.Apply f a) => GHC.Read.Read (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). GHC.Show.Show (Data.Singletons.Apply f a) => GHC.Show.Show (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). Data.Hashable.Class.Hashable (Data.Singletons.Apply f a) => Data.Hashable.Class.Hashable (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). Data.Aeson.Types.ToJSON.ToJSON (Data.Singletons.Apply f a) => Data.Aeson.Types.ToJSON.ToJSON (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: k Data.Singletons.~> *) (a :: k). Data.Aeson.Types.FromJSON.FromJSON (Data.Singletons.Apply f a) => Data.Aeson.Types.FromJSON.FromJSON (Data.Singletons.Class.Applied1 f a)
instance forall k (f :: Data.Singletons.TyFun k GHC.Types.Type -> GHC.Types.Type). Data.Singletons.Class.EqApplied1 f => Data.Singletons.Class.EqSing1 (Data.Singletons.Class.Applied1 f)
instance forall k (f :: Data.Singletons.TyFun k GHC.Types.Type -> GHC.Types.Type). Data.Singletons.Class.ToJSONApplied1 f => Data.Singletons.Class.ToJSONSing1 (Data.Singletons.Class.Applied1 f)
instance forall k (f :: Data.Singletons.TyFun k GHC.Types.Type -> GHC.Types.Type). Data.Singletons.Class.FromJSONApplied1 f => Data.Singletons.Class.FromJSONSing1 (Data.Singletons.Class.Applied1 f)
instance forall k (f :: Data.Singletons.TyFun k GHC.Types.Type -> GHC.Types.Type). Data.Singletons.Class.HashableApplied1 f => Data.Singletons.Class.HashableSing1 (Data.Singletons.Class.Applied1 f)
instance forall kproxy (f :: kproxy -> *). (Data.Singletons.Class.EqSing1 f, Data.Singletons.Decide.SDecide kproxy) => GHC.Classes.Eq (Data.Singletons.Class.SomeSingWith1 kproxy f)
instance forall kproxy1 kproxy2 (f :: kproxy1 -> kproxy2 -> *). (Data.Singletons.Class.ShowKind kproxy1, Data.Singletons.Class.ShowKind kproxy2, Data.Singletons.Class.ShowSing2 f) => GHC.Show.Show (Data.Singletons.Class.SomeSingWith2 kproxy1 kproxy2 f)
instance forall k j (f :: k -> j -> *). (Data.Singletons.Class.ReadKind k, Data.Singletons.Class.ReadKind j, Data.Singletons.Class.ReadSing2 f) => GHC.Read.Read (Data.Singletons.Class.SomeSingWith2 k j f)
instance forall kproxy1 kproxy2 (f :: kproxy1 -> kproxy2 -> *). (Data.Singletons.Decide.SDecide kproxy1, Data.Singletons.Decide.SDecide kproxy2, Data.Singletons.Class.EqSing2 f) => GHC.Classes.Eq (Data.Singletons.Class.SomeSingWith2 kproxy1 kproxy2 f)
instance forall kproxy1 kproxy2 (f :: kproxy1 -> kproxy2 -> *). (Data.Singletons.Class.ToJSONKind kproxy1, Data.Singletons.Class.ToJSONKind kproxy2, Data.Singletons.Class.ToJSONSing2 f) => Data.Aeson.Types.ToJSON.ToJSON (Data.Singletons.Class.SomeSingWith2 kproxy1 kproxy2 f)
instance forall k j (f :: k -> j -> *). (Data.Singletons.Class.FromJSONKind k, Data.Singletons.Class.FromJSONKind j, Data.Singletons.Class.FromJSONSing2 f) => Data.Aeson.Types.FromJSON.FromJSON (Data.Singletons.Class.SomeSingWith2 k j f)
instance forall k (f :: k -> *). (Data.Singletons.Class.HashableKind k, Data.Singletons.Class.HashableSing1 f) => Data.Hashable.Class.Hashable (Data.Singletons.Class.SomeSingWith1 k f)
instance Data.Singletons.Prelude.Eq.SEq kproxy => GHC.Classes.Eq (Data.Singletons.Class.ClassySomeSing kproxy)
instance Data.Singletons.Prelude.Ord.SOrd kproxy => GHC.Classes.Ord (Data.Singletons.Class.ClassySomeSing kproxy)


-- | This is a dependent version of the <tt>Data.Map</tt> module from
--   <tt>containers</tt>.
--   
--   This module was largely copied from the <tt>dependent-map</tt>
--   package.
module Data.Singletons.Map
data SingMap (k :: Type) (f :: k -> Type)
[Tip] :: SingMap k f
[Bin] :: !Int -> !(Sing v) -> !(f v) -> !(SingMap k f) -> !(SingMap k f) -> SingMap k f

-- | <i>O(1)</i>. The empty map.
--   
--   <pre>
--   empty      == fromList []
--   size empty == 0
--   </pre>
empty :: SingMap k f

-- | <i>O(1)</i>. A map with a single element.
--   
--   <pre>
--   singleton 1 'a'        == fromList [(1, 'a')]
--   size (singleton 1 'a') == 1
--   </pre>
singleton :: Sing v -> f v -> SingMap k f

-- | <i>O(1)</i>. Is the map empty?
null :: SingMap k f -> Bool

-- | <i>O(1)</i>. The number of elements in the map.
size :: SingMap k f -> Int

-- | <i>O(log n)</i>. Lookup the value at a key in the map.
--   
--   The function will return the corresponding value as <tt>(<a>Just</a>
--   value)</tt>, or <a>Nothing</a> if the key isn't in the map.
lookup :: forall k f v. (SOrd k, SDecide k) => Sing v -> SingMap k f -> Maybe (f v)
lookupAssoc :: forall k f v. (SOrd k, SDecide k) => SomeSing k -> SingMap k f -> Maybe (SomeSingWith1 k f)
combine :: (SOrd k, SDecide k) => Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
insertMax :: Sing v -> f v -> SingMap k f -> SingMap k f
insertMin :: Sing v -> f v -> SingMap k f -> SingMap k f
merge :: SOrd k => SingMap k f -> SingMap k f -> SingMap k f
glue :: SingMap k f -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Delete and find the minimal element.
--   
--   <pre>
--   deleteFindMin (fromList [(5,"a"), (3,"b"), (10,"c")]) == ((3,"b"), fromList[(5,"a"), (10,"c")])
--   deleteFindMin                                            Error: can not return the minimal element of an empty map
--   </pre>
deleteFindMin :: SingMap k f -> (SomeSingWith1 k f, SingMap k f)

-- | <i>O(log n)</i>. Delete and find the maximal element.
--   
--   <pre>
--   deleteFindMax (fromList [(5,"a"), (3,"b"), (10,"c")]) == ((10,"c"), fromList [(3,"b"), (5,"a")])
--   deleteFindMax empty                                      Error: can not return the maximal element of an empty map
--   </pre>
deleteFindMax :: SingMap k f -> (SomeSingWith1 k f, SingMap k f)
delta :: Int
ratio :: Int
balance :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
rotateL :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
rotateR :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
singleL :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
singleR :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
doubleL :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
doubleR :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
bin :: Sing v -> f v -> SingMap k f -> SingMap k f -> SingMap k f
trim :: SOrd k => (SomeSing k -> Ordering) -> (SomeSing k -> Ordering) -> SingMap k f -> SingMap k f
trimLookupLo :: (SOrd k, SDecide k) => SomeSing k -> (SomeSing k -> Ordering) -> SingMap k f -> (Maybe (SomeSingWith1 k f), SingMap k f)
filterGt :: (SOrd k, SDecide k) => (SomeSing k -> Ordering) -> SingMap k f -> SingMap k f
filterLt :: (SOrd k, SDecide k) => (SomeSing k -> Ordering) -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Find the value at a key. Calls <a>error</a> when the
--   element can not be found.
--   
--   <pre>
--   fromList [(5,'a'), (3,'b')] ! 1    Error: element not in the map
--   fromList [(5,'a'), (3,'b')] ! 5 == 'a'
--   </pre>
(!) :: (SOrd k, SDecide k) => SingMap k f -> Sing v -> f v
infixl 9 !

-- | Same as <a>difference</a>.
(\\) :: (SOrd k, SDecide k) => SingMap k f -> SingMap k f -> SingMap k f
infixl 9 \\

-- | <i>O(log n)</i>. Is the key a member of the map? See also
--   <a>notMember</a>.
member :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> Bool

-- | <i>O(log n)</i>. Is the key not a member of the map? See also
--   <a>member</a>.
notMember :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> Bool

-- | <i>O(log n)</i>. Find the value at a key. Calls <a>error</a> when the
--   element can not be found. Consider using <a>lookup</a> when elements
--   may not be present.
find :: (SOrd k, SDecide k) => Sing v -> SingMap k f -> f v

-- | <i>O(log n)</i>. The expression <tt>(<a>findWithDefault</a> def k
--   map)</tt> returns the value at key <tt>k</tt> or returns default value
--   <tt>def</tt> when the key is not in the map.
findWithDefault :: (SOrd k, SDecide k) => f v -> Sing v -> SingMap k f -> f v

-- | <i>O(log n)</i>. Insert a new key and value in the map. If the key is
--   already present in the map, the associated value is replaced with the
--   supplied value. <a>insert</a> is equivalent to <tt><a>insertWith</a>
--   <a>const</a></tt>.
insert :: forall k f v. (SOrd k, SDecide k) => Sing v -> f v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Insert with a function, combining new value and old
--   value. <tt><a>insertWith</a> f key value mp</tt> will insert the entry
--   <tt>key :=&gt; value</tt> into <tt>mp</tt> if key does not exist in
--   the map. If the key does exist, the function will insert the entry
--   <tt>key :=&gt; f new_value old_value</tt>.
insertWith :: (SOrd k, SDecide k) => (f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> SingMap k f

-- | Same as <a>insertWith</a>, but the combining function is applied
--   strictly. This is often the most desirable behavior.
insertWith' :: (SOrd k, SDecide k) => (f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Insert with a function, combining key, new value and
--   old value. <tt><a>insertWithKey</a> f key value mp</tt> will insert
--   the entry <tt>key :=&gt; value</tt> into <tt>mp</tt> if key does not
--   exist in the map. If the key does exist, the function will insert the
--   entry <tt>key :=&gt; f key new_value old_value</tt>. Note that the key
--   passed to f is the same key passed to <a>insertWithKey</a>.
insertWithKey :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> SingMap k f

-- | Same as <a>insertWithKey</a>, but the combining function is applied
--   strictly.
insertWithKey' :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Combines insert operation with old value retrieval.
--   The expression (<tt><a>insertLookupWithKey</a> f k x map</tt>) is a
--   pair where the first element is equal to (<tt><a>lookup</a> k
--   map</tt>) and the second element equal to (<tt><a>insertWithKey</a> f
--   k x map</tt>).
insertLookupWithKey :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> (Maybe (f v), SingMap k f)

-- | <i>O(log n)</i>. A strict version of <a>insertLookupWithKey</a>.
insertLookupWithKey' :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> f v -> f v) -> Sing v -> f v -> SingMap k f -> (Maybe (f v), SingMap k f)

-- | <i>O(log n)</i>. Delete a key and its value from the map. When the key
--   is not a member of the map, the original map is returned.
delete :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Update a value at a specific key with the result of
--   the provided function. When the key is not a member of the map, the
--   original map is returned.
adjust :: (SOrd k, SDecide k) => (f v -> f v) -> Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Adjust a value at a specific key. When the key is not
--   a member of the map, the original map is returned.
adjustWithKey :: (SOrd k, SDecide k) => (Sing v -> f v -> f v) -> Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. The expression (<tt><a>update</a> f k map</tt>)
--   updates the value <tt>x</tt> at <tt>k</tt> (if it is in the map). If
--   (<tt>f x</tt>) is <a>Nothing</a>, the element is deleted. If it is
--   (<tt><a>Just</a> y</tt>), the key <tt>k</tt> is bound to the new value
--   <tt>y</tt>.
update :: (SOrd k, SDecide k) => (f v -> Maybe (f v)) -> Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. The expression (<tt><a>updateWithKey</a> f k
--   map</tt>) updates the value <tt>x</tt> at <tt>k</tt> (if it is in the
--   map). If (<tt>f k x</tt>) is <a>Nothing</a>, the element is deleted.
--   If it is (<tt><a>Just</a> y</tt>), the key <tt>k</tt> is bound to the
--   new value <tt>y</tt>.
updateWithKey :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> Maybe (f v)) -> Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Lookup and update. See also <a>updateWithKey</a>. The
--   function returns changed value, if it is updated. Returns the original
--   key value if the map entry is deleted.
updateLookupWithKey :: forall k f v. (SOrd k, SDecide k) => (Sing v -> f v -> Maybe (f v)) -> Sing v -> SingMap k f -> (Maybe (f v), SingMap k f)

-- | <i>O(log n)</i>. The expression (<tt><a>alter</a> f k map</tt>) alters
--   the value <tt>x</tt> at <tt>k</tt>, or absence thereof. <a>alter</a>
--   can be used to insert, delete, or update a value in a <a>Map</a>. In
--   short : <tt><a>lookup</a> k (<a>alter</a> f k m) = f (<a>lookup</a> k
--   m)</tt>.
alter :: forall k f v. (SOrd k, SDecide k) => (Maybe (f v) -> Maybe (f v)) -> Sing v -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Return the <i>index</i> of a key. The index is a
--   number from <i>0</i> up to, but not including, the <a>size</a> of the
--   map. Calls <a>error</a> when the key is not a <a>member</a> of the
--   map.
findIndex :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> Int

-- | <i>O(log n)</i>. Lookup the <i>index</i> of a key. The index is a
--   number from <i>0</i> up to, but not including, the <a>size</a> of the
--   map.
lookupIndex :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> Maybe Int

-- | <i>O(log n)</i>. Retrieve an element by <i>index</i>. Calls
--   <a>error</a> when an invalid index is used.
elemAt :: Int -> SingMap k f -> SomeSingWith1 k f

-- | <i>O(log n)</i>. Update the element at <i>index</i>. Calls
--   <a>error</a> when an invalid index is used.
updateAt :: (forall v. Sing v -> f v -> Maybe (f v)) -> Int -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Delete the element at <i>index</i>. Defined as
--   (<tt><a>deleteAt</a> i map = <a>updateAt</a> (k x -&gt;
--   <a>Nothing</a>) i map</tt>).
deleteAt :: Int -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. The minimal key of the map. Calls <a>error</a> is the
--   map is empty.
findMin :: SingMap k f -> SomeSingWith1 k f

-- | <i>O(log n)</i>. The maximal key of the map. Calls <a>error</a> is the
--   map is empty.
findMax :: SingMap k f -> SomeSingWith1 k f

-- | <i>O(log n)</i>. Delete the minimal key. Returns an empty map if the
--   map is empty.
deleteMin :: SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Delete the maximal key. Returns an empty map if the
--   map is empty.
deleteMax :: SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Update the value at the minimal key.
updateMinWithKey :: (forall v. Sing v -> f v -> Maybe (f v)) -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Update the value at the maximal key.
updateMaxWithKey :: (forall v. Sing v -> f v -> Maybe (f v)) -> SingMap k f -> SingMap k f

-- | <i>O(log n)</i>. Retrieves the minimal (key :=&gt; value) entry of the
--   map, and the map stripped of that element, or <a>Nothing</a> if passed
--   an empty map.
minViewWithKey :: SingMap k f -> Maybe (SomeSingWith1 k f, SingMap k f)

-- | <i>O(log n)</i>. Retrieves the maximal (key :=&gt; value) entry of the
--   map, and the map stripped of that element, or <a>Nothing</a> if passed
--   an empty map.
maxViewWithKey :: SingMap k f -> Maybe (SomeSingWith1 k f, SingMap k f)

-- | The union of a list of maps: (<tt><a>unions</a> == <a>foldl</a>
--   <a>union</a> <a>empty</a></tt>).
unions :: (SOrd k, SDecide k) => [SingMap k f] -> SingMap k f

-- | The union of a list of maps, with a combining operation:
--   (<tt><a>unionsWithKey</a> f == <a>foldl</a> (<a>unionWithKey</a> f)
--   <a>empty</a></tt>).
unionsWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> f v -> f v) -> [SingMap k f] -> SingMap k f

-- | <i>O(n+m)</i>. The expression (<tt><a>union</a> t1 t2</tt>) takes the
--   left-biased union of <tt>t1</tt> and <tt>t2</tt>. It prefers
--   <tt>t1</tt> when duplicate keys are encountered, i.e.
--   (<tt><a>union</a> == <tt>unionWith</tt> <a>const</a></tt>). The
--   implementation uses the efficient <i>hedge-union</i> algorithm.
--   Hedge-union is more efficient on (bigset `<a>union</a>` smallset).
union :: (SOrd k, SDecide k) => SingMap k f -> SingMap k f -> SingMap k f
hedgeUnionL :: (SOrd k, SDecide k) => (SomeSing k -> Ordering) -> (SomeSing k -> Ordering) -> SingMap k f -> SingMap k f -> SingMap k f

-- | <i>O(n+m)</i>. Union with a combining function. The implementation
--   uses the efficient <i>hedge-union</i> algorithm. Hedge-union is more
--   efficient on (bigset `<a>union</a>` smallset).
unionWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> f v -> f v) -> SingMap k f -> SingMap k f -> SingMap k f
hedgeUnionWithKey :: forall k f. (SOrd k, SDecide k) => (forall v. Sing v -> f v -> f v -> f v) -> (SomeSing k -> Ordering) -> (SomeSing k -> Ordering) -> SingMap k f -> SingMap k f -> SingMap k f

-- | <i>O(n+m)</i>. Difference of two maps. Return elements of the first
--   map not existing in the second map. The implementation uses an
--   efficient <i>hedge</i> algorithm comparable with <i>hedge-union</i>.
difference :: (SOrd k, SDecide k) => SingMap k f -> SingMap k g -> SingMap k f
hedgeDiff :: (SOrd k, SDecide k) => (SomeSing k -> Ordering) -> (SomeSing k -> Ordering) -> SingMap k f -> SingMap k g -> SingMap k f

-- | <i>O(n+m)</i>. Difference with a combining function. When two equal
--   keys are encountered, the combining function is applied to the key and
--   both values. If it returns <a>Nothing</a>, the element is discarded
--   (proper set difference). If it returns (<tt><a>Just</a> y</tt>), the
--   element is updated with a new value <tt>y</tt>. The implementation
--   uses an efficient <i>hedge</i> algorithm comparable with
--   <i>hedge-union</i>.
differenceWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> g v -> Maybe (f v)) -> SingMap k f -> SingMap k g -> SingMap k f
hedgeDiffWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> g v -> Maybe (f v)) -> (SomeSing k -> Ordering) -> (SomeSing k -> Ordering) -> SingMap k f -> SingMap k g -> SingMap k f

-- | <i>O(n+m)</i>. Intersection of two maps. Return data in the first map
--   for the keys existing in both maps. (<tt><a>intersection</a> m1 m2 ==
--   <tt>intersectionWith</tt> <a>const</a> m1 m2</tt>).
intersection :: (SOrd k, SDecide k) => SingMap k f -> SingMap k f -> SingMap k f

-- | <i>O(n+m)</i>. Intersection with a combining function. Intersection is
--   more efficient on (bigset `<a>intersection</a>` smallset).
intersectionWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> g v -> h v) -> SingMap k f -> SingMap k g -> SingMap k h

-- | <i>O(n)</i>. Filter all keys/values that satisfy the predicate.
filterWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> Bool) -> SingMap k f -> SingMap k f

-- | <i>O(n)</i>. Partition the map according to a predicate. The first map
--   contains all elements that satisfy the predicate, the second all
--   elements that fail the predicate. See also <a>split</a>.
partitionWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> Bool) -> SingMap k f -> (SingMap k f, SingMap k f)

-- | <i>O(n)</i>. Map keys/values and collect the <a>Just</a> results.
mapMaybeWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> Maybe (g v)) -> SingMap k f -> SingMap k g

-- | <i>O(n)</i>. Map keys/values and separate the <a>Left</a> and
--   <a>Right</a> results.
mapEitherWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> Either (g v) (h v)) -> SingMap k f -> (SingMap k g, SingMap k h)

-- | <i>O(n)</i>. Map a function over all values in the map.
mapWithKey :: (forall v. Sing v -> f v -> g v) -> SingMap k f -> SingMap k g

-- | <i>O(n)</i>. The function <a>mapAccumLWithKey</a> threads an
--   accumulating argument throught the map in ascending order of keys.
mapAccumLWithKey :: (forall v. a -> Sing v -> f v -> (a, g v)) -> a -> SingMap k f -> (a, SingMap k g)

-- | <i>O(n)</i>. The function <a>mapAccumRWithKey</a> threads an
--   accumulating argument through the map in descending order of keys.
mapAccumRWithKey :: (forall v. a -> Sing v -> f v -> (a, g v)) -> a -> SingMap k f -> (a, SingMap k g)

-- | <i>O(n*log n)</i>. <tt><tt>mapKeysWith</tt> c f s</tt> is the map
--   obtained by applying <tt>f</tt> to each key of <tt>s</tt>.
--   
--   The size of the result may be smaller if <tt>f</tt> maps two or more
--   distinct keys to the same new key. In this case the associated values
--   will be combined using <tt>c</tt>. mapKeysWith :: (SOrd k2, SDecide
--   k2) =&gt; (forall v. Sing v -&gt; f v -&gt; f v -&gt; f v) -&gt;
--   (forall v. Sing v -&gt; Sing v) -&gt; SingMap k1 f -&gt; SingMap k2 f
--   mapKeysWith c f = fromListWithKey c . map fFirst . toList where fFirst
--   (SomeSingWith1 x y) = (SomeSingWith1 (f x) y)
--   
--   <i>O(n)</i>. <tt><tt>mapKeysMonotonic</tt> f s == <tt>mapKeys</tt> f
--   s</tt>, but works only when <tt>f</tt> is strictly monotonic. That is,
--   for any values <tt>x</tt> and <tt>y</tt>, if <tt>x</tt> &lt;
--   <tt>y</tt> then <tt>f x</tt> &lt; <tt>f y</tt>. <i>The precondition is
--   not checked.</i> Semi-formally, we have:
--   
--   <pre>
--   and [x &lt; y ==&gt; f x &lt; f y | x &lt;- ls, y &lt;- ls]
--                       ==&gt; mapKeysMonotonic f s == mapKeys f s
--       where ls = keys s
--   </pre>
--   
--   This means that <tt>f</tt> maps distinct original keys to distinct
--   resulting keys. This function has better performance than
--   <tt>mapKeys</tt>. mapKeysMonotonic :: forall (k1 :: KProxy k) k2 f.
--   (forall (v :: k). Sing v -&gt; Sing v) -&gt; SingMap k1 f -&gt;
--   SingMap k2 f mapKeysMonotonic _ Tip = Tip mapKeysMonotonic f (Bin sz k
--   x l r) = Bin sz (f k) x (mapKeysMonotonic f l) (mapKeysMonotonic f r)
--   
--   <i>O(n)</i>. Fold the keys and values in the map, such that
--   <tt><a>foldWithKey</a> f z == <a>foldr</a> (<a>uncurry</a> f) z .
--   <a>toAscList</a></tt>.
--   
--   This is identical to <a>foldrWithKey</a>, and you should use that one
--   instead of this one. This name is kept for backward compatibility.

-- | <i>Deprecated: Use foldrWithKey instead</i>
foldWithKey :: (forall v. Sing v -> f v -> b -> b) -> b -> SingMap k f -> b

-- | <i>O(n)</i>. Post-order fold. The function will be applied from the
--   lowest value to the highest.
foldrWithKey :: (forall v. Sing v -> f v -> b -> b) -> b -> SingMap k f -> b

-- | <i>O(n)</i>. Pre-order fold. The function will be applied from the
--   highest value to the lowest.
foldlWithKey :: (forall v. b -> Sing v -> f v -> b) -> b -> SingMap k f -> b

-- | <i>O(n)</i>. Return all keys of the map in ascending order.
--   
--   <pre>
--   keys (fromList [(5,"a"), (3,"b")]) == [3,5]
--   keys empty == []
--   </pre>
keys :: SingMap k f -> [SomeSing k]

-- | <i>O(n)</i>. Return all key/value pairs in the map in ascending key
--   order.
assocs :: SingMap k f -> [SomeSingWith1 k f]

-- | <i>O(n*log n)</i>. Build a map from a list of key/value pairs. See
--   also <a>fromAscList</a>. If the list contains more than one value for
--   the same key, the last value for the key is retained.
fromList :: (SOrd k, SDecide k) => [SomeSingWith1 k f] -> SingMap k f

-- | <i>O(n*log n)</i>. Build a map from a list of key/value pairs with a
--   combining function. See also <a>fromAscListWithKey</a>.
fromListWithKey :: (SOrd k, SDecide k) => (forall v. Sing v -> f v -> f v -> f v) -> [SomeSingWith1 k f] -> SingMap k f

-- | <i>O(n)</i>. Convert to a list of key/value pairs.
toList :: SingMap k f -> [SomeSingWith1 k f]

-- | <i>O(n)</i>. Convert to an ascending list.
toAscList :: SingMap k f -> [SomeSingWith1 k f]

-- | <i>O(n)</i>. Convert to a descending list.
toDescList :: SingMap k f -> [SomeSingWith1 k f]

-- | <i>O(n)</i>. Build a map from an ascending list in linear time. <i>The
--   precondition (input list is ascending) is not checked.</i>
fromAscList :: (SEq k, SDecide k) => [SomeSingWith1 k f] -> SingMap k f

-- | <i>O(n)</i>. Build a map from an ascending list in linear time with a
--   combining function for equal keys. <i>The precondition (input list is
--   ascending) is not checked.</i>
fromAscListWithKey :: (SEq k, SDecide k) => (forall v. Sing v -> f v -> f v -> f v) -> [SomeSingWith1 k f] -> SingMap k f

-- | <i>O(n)</i>. Build a map from an ascending list of distinct elements
--   in linear time. <i>The precondition is not checked.</i>
fromDistinctAscList :: [SomeSingWith1 k f] -> SingMap k f

-- | <i>O(log n)</i>. The expression (<tt><a>split</a> k map</tt>) is a
--   pair <tt>(map1,map2)</tt> where the keys in <tt>map1</tt> are smaller
--   than <tt>k</tt> and the keys in <tt>map2</tt> larger than <tt>k</tt>.
--   Any key equal to <tt>k</tt> is found in neither <tt>map1</tt> nor
--   <tt>map2</tt>.
split :: forall k f (v :: k). (SOrd k, SDecide k) => Sing v -> SingMap k f -> (SingMap k f, SingMap k f)

-- | <i>O(log n)</i>. The expression (<tt><a>splitLookup</a> k map</tt>)
--   splits a map just like <a>split</a> but also returns <tt><a>lookup</a>
--   k map</tt>.
splitLookup :: forall k f v. (SOrd k, SDecide k) => Sing v -> SingMap k f -> (SingMap k f, Maybe (f v), SingMap k f)

-- | <i>O(log n)</i>.
splitLookupWithKey :: forall k f v. (SOrd k, SDecide k) => Sing v -> SingMap k f -> (SingMap k f, Maybe (Sing v, f v), SingMap k f)

-- | <i>O(n)</i>. The expression (<tt><a>showTreeWith</a> showelem hang
--   wide map</tt>) shows the tree that implements the map. Elements are
--   shown using the <tt>showElem</tt> function. If <tt>hang</tt> is
--   <a>True</a>, a <i>hanging</i> tree is shown otherwise a rotated tree
--   is shown. If <tt>wide</tt> is <a>True</a>, an extra wide version is
--   shown.
showTreeWith :: (forall v. Sing v -> f v -> String) -> Bool -> Bool -> SingMap k f -> String
showsTree :: (forall v. Sing v -> f v -> String) -> Bool -> [String] -> [String] -> SingMap k f -> ShowS
showsTreeHang :: (forall v. Sing v -> f v -> String) -> Bool -> [String] -> SingMap k f -> ShowS
showWide :: Bool -> [String] -> String -> String
showsBars :: [String] -> ShowS
node :: String
withBar :: [String] -> [String]
withEmpty :: [String] -> [String]

-- | <i>O(n)</i>. Test if the internal map structure is valid.
valid :: (SOrd k, SDecide k) => SingMap k f -> Bool
ordered :: (SOrd k, SDecide k) => SingMap k f -> Bool

-- | Exported only for <a>Debug.QuickCheck</a>
balanced :: SingMap k f -> Bool
validsize :: SingMap k f -> Bool
foldlStrict :: (a -> b -> a) -> a -> [b] -> a
ltSome :: SOrd k => SomeSing k -> SomeSing k -> Bool
gtSome :: SOrd k => SomeSing k -> SomeSing k -> Bool
unifyOnCompareEQ :: forall k (a :: k) (b :: k) x. (SDecide k, Compare a b ~ EQ) => Sing a -> Sing b -> (a ~ b => x) -> x
unifyOnEq :: forall k (a :: k) (b :: k) x. (SDecide k, (a :== b) ~ True) => Sing a -> Sing b -> (a ~ b => x) -> x
fromRec :: (SOrd k, SDecide k) => Rec (SingWith1 k f) rs -> SingMap k f
insertRec :: (SOrd k, SDecide k) => Rec (SingWith1 k f) rs -> SingMap k f -> SingMap k f
instance forall k (f :: k -> *). (Data.Singletons.Prelude.Eq.SEq k, Data.Singletons.Decide.SDecide k, Data.Singletons.Class.EqSing1 f) => GHC.Classes.Eq (Data.Singletons.Map.SingMap k f)
instance forall k (f :: k -> *). (Data.Singletons.Class.HashableKind k, Data.Singletons.Class.HashableSing1 f) => Data.Hashable.Class.Hashable (Data.Singletons.Map.SingMap k f)
instance forall k (f :: k -> *). (Data.Singletons.Class.ToJSONKeyKind k, Data.Singletons.Class.ToJSONSing1 f) => Data.Aeson.Types.ToJSON.ToJSON (Data.Singletons.Map.SingMap k f)
instance forall k (f :: k -> *). (Data.Singletons.Prelude.Ord.SOrd k, Data.Singletons.Decide.SDecide k, Data.Singletons.Class.FromJSONKeyKind k, Data.Singletons.Class.FromJSONSing1 f) => Data.Aeson.Types.FromJSON.FromJSON (Data.Singletons.Map.SingMap k f)

module Data.Case.Enumerate

-- | This will create a pattern match on the first argument that splices in
--   the third argument for each pattern. Example:
--   
--   <pre>
--   data Color = Red | Blue | Green deriving Show
--   myFunc :: Color -&gt; String
--   myFunc c = $(enumerateConstructors 'c ''Color =&lt;&lt; [|show c|])
--   </pre>
--   
--   I should fix this function to actually make it work that way. It
--   actually uses the singletonized data type instead.
enumerateConstructors :: Name -> Name -> Exp -> Q Exp