Data.Functor.Misc

This module provides types and functions with no particular theme, but which are relevant to the use of Functor-based datastructures like DMap.

Const2

data Const2 :: * -> x -> x -> * where

Const2 stores a value of a given type k and ensures that a particular type v is always given for the last type parameter

Constructors

Const2 :: k -> Const2 k v v

Instances

Ord k2 => GCompare (Const2 k2 v :: k1 -> Type)

Defined in Data.Functor.Misc

Methods

gcompare :: Const2 k2 v a -> Const2 k2 v b -> GOrdering a b

Eq k2 => GEq (Const2 k2 v :: k1 -> Type)

Defined in Data.Functor.Misc

Methods

geq :: Const2 k2 v a -> Const2 k2 v b -> Maybe (a := b)

Show k2 => GShow (Const2 k2 v :: k1 -> Type)

Defined in Data.Functor.Misc

Methods

gshowsPrec :: Int -> Const2 k2 v a -> ShowS

(Show k2, Show (f v)) => ShowTag (Const2 k2 v :: k1 -> Type) (f :: k1 -> Type)

Defined in Data.Functor.Misc

Methods

showTaggedPrec :: Const2 k2 v a -> Int -> f a -> ShowS

Eq k => Eq (Const2 k v v')

Defined in Data.Functor.Misc

Methods

(==) :: Const2 k v v' -> Const2 k v v' -> Bool

(/=) :: Const2 k v v' -> Const2 k v v' -> Bool

Ord k => Ord (Const2 k v v')

Defined in Data.Functor.Misc

Methods

compare :: Const2 k v v' -> Const2 k v v' -> Ordering

(<) :: Const2 k v v' -> Const2 k v v' -> Bool

(<=) :: Const2 k v v' -> Const2 k v v' -> Bool

(>) :: Const2 k v v' -> Const2 k v v' -> Bool

(>=) :: Const2 k v v' -> Const2 k v v' -> Bool

max :: Const2 k v v' -> Const2 k v v' -> Const2 k v v'

min :: Const2 k v v' -> Const2 k v v' -> Const2 k v v'

Read k => Read (Const2 k v v)

Defined in Data.Functor.Misc

Methods

readsPrec :: Int -> ReadS (Const2 k v v)

readList :: ReadS [Const2 k v v]

readPrec :: ReadPrec (Const2 k v v)

readListPrec :: ReadPrec [Const2 k v v]

Show k => Show (Const2 k v v')

Defined in Data.Functor.Misc

Methods

showsPrec :: Int -> Const2 k v v' -> ShowS

show :: Const2 k v v' -> String

showList :: [Const2 k v v'] -> ShowS

unConst2 :: Const2 k v v' -> k

Extract the value from a Const2

dmapToMap :: DMap (Const2 k v) Identity -> Map k v

Convert a DMap to a regular Map

dmapToIntMap :: DMap (Const2 Key v) Identity -> IntMap v

Convert a DMap to an IntMap

dmapToMapWith :: (f v -> v') -> DMap (Const2 k v) f -> Map k v'

Convert a DMap to a regular Map, applying the given function to remove the wrapping Functor

mapToDMap :: Map k v -> DMap (Const2 k v) Identity

Convert a regular Map to a DMap

weakenDMapWith :: (forall a. v a -> v') -> DMap k v -> Map (Some k) v'

Convert a DMap to a regular Map by forgetting the types associated with the keys, using a function to remove the wrapping Functor

WrapArg

data WrapArg :: (k -> *) -> (k -> *) -> * -> * where

WrapArg can be used to tag a value in one functor with a type representing another functor. This was primarily used with dependent-map < 0.2, in which the value type was not wrapped in a separate functor.

Constructors

WrapArg :: f a -> WrapArg g f (g a)

Instances

GCompare f => GCompare (WrapArg g f :: Type -> Type)

Defined in Data.Functor.Misc

Methods

gcompare :: WrapArg g f a -> WrapArg g f b -> GOrdering a b

GEq f => GEq (WrapArg g f :: Type -> Type)

Defined in Data.Functor.Misc

Methods

geq :: WrapArg g f a -> WrapArg g f b -> Maybe (a := b)

Eq (f a) => Eq (WrapArg g f (g' a))

Defined in Data.Functor.Misc

Methods

(==) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

(/=) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

Ord (f a) => Ord (WrapArg g f (g' a))

Defined in Data.Functor.Misc

Methods

compare :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Ordering

(<) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

(<=) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

(>) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

(>=) :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> Bool

max :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> WrapArg g f (g' a)

min :: WrapArg g f (g' a) -> WrapArg g f (g' a) -> WrapArg g f (g' a)

Read (f a) => Read (WrapArg g f (g a))

Defined in Data.Functor.Misc

Methods

readsPrec :: Int -> ReadS (WrapArg g f (g a))

readList :: ReadS [WrapArg g f (g a)]

readPrec :: ReadPrec (WrapArg g f (g a))

readListPrec :: ReadPrec [WrapArg g f (g a)]

Show (f a) => Show (WrapArg g f (g' a))

Defined in Data.Functor.Misc

Methods

showsPrec :: Int -> WrapArg g f (g' a) -> ShowS

show :: WrapArg g f (g' a) -> String

showList :: [WrapArg g f (g' a)] -> ShowS

Convenience functions for DMap

mapWithFunctorToDMap :: Map k (f v) -> DMap (Const2 k v) f

Convert a regular Map, where the values are already wrapped in a functor, to a DMap

intMapWithFunctorToDMap :: IntMap (f v) -> DMap (Const2 Key v) f

Convert a regular IntMap, where the values are already wrapped in a functor, to a DMap

mapKeyValuePairsMonotonic :: (DSum k v -> DSum k' v') -> DMap k v -> DMap k' v'

Map over all key/value pairs in a DMap, potentially altering the key as well as the value. The provided function MUST preserve the ordering of the keys, or the resulting DMap will be malformed.

combineDMapsWithKey :: forall f g h i. GCompare f => (forall a. f a -> These (g a) (h a) -> i a) -> DMap f g -> DMap f h -> DMap f i

Union two DMaps of different types, yielding another type. Each key that is present in either input map will be present in the output.

data EitherTag l r a where

Tag type for Either to use it as a DSum.

Constructors

LeftTag :: EitherTag l r l

RightTag :: EitherTag l r r

Instances

GCompare (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

gcompare :: EitherTag l r a -> EitherTag l r b -> GOrdering a b

GEq (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

geq :: EitherTag l r a -> EitherTag l r b -> Maybe (a := b)

GShow (EitherTag l r :: k -> Type)

Defined in Data.Functor.Misc

Methods

gshowsPrec :: Int -> EitherTag l r a -> ShowS

(Show l, Show r) => ShowTag (EitherTag l r :: Type -> Type) Identity

Defined in Data.Functor.Misc

Methods

showTaggedPrec :: EitherTag l r a -> Int -> Identity a -> ShowS

Eq (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

(==) :: EitherTag l r a -> EitherTag l r a -> Bool

(/=) :: EitherTag l r a -> EitherTag l r a -> Bool

Ord (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

compare :: EitherTag l r a -> EitherTag l r a -> Ordering

(<) :: EitherTag l r a -> EitherTag l r a -> Bool

(<=) :: EitherTag l r a -> EitherTag l r a -> Bool

(>) :: EitherTag l r a -> EitherTag l r a -> Bool

(>=) :: EitherTag l r a -> EitherTag l r a -> Bool

max :: EitherTag l r a -> EitherTag l r a -> EitherTag l r a

min :: EitherTag l r a -> EitherTag l r a -> EitherTag l r a

Show (EitherTag l r a)

Defined in Data.Functor.Misc

Methods

showsPrec :: Int -> EitherTag l r a -> ShowS

show :: EitherTag l r a -> String

showList :: [EitherTag l r a] -> ShowS

dmapToThese :: DMap (EitherTag a b) Identity -> Maybe (These a b)

Extract the values of a DMap of EitherTags.

eitherToDSum :: Either a b -> DSum (EitherTag a b) Identity

Convert Either to a DSum. Inverse of dsumToEither.

dsumToEither :: DSum (EitherTag a b) Identity -> Either a b

Convert DSum to Either. Inverse of eitherToDSum.

Deprecated functions

sequenceDmap :: Applicative t => DMap f t -> t (DMap f Identity)

Deprecated: Use 'Data.Dependent.Map.traverseWithKey (_ -> fmap Identity)' instead

Run the actions contained in the DMap

wrapDMap :: (forall a. a -> f a) -> DMap k Identity -> DMap k f

Deprecated: Use 'Data.Dependent.Map.map (f . runIdentity)' instead

Replace the Identity functor for a DMap's values with a different functor

rewrapDMap :: (forall (a :: *). f a -> g a) -> DMap k f -> DMap k g

Deprecated: Use map instead

Replace one functor for a DMap's values with a different functor

unwrapDMap :: (forall a. f a -> a) -> DMap k f -> DMap k Identity

Deprecated: Use 'Data.Dependent.Map.map (Identity . f)' instead

Replace one functor for a DMap's values with the Identity functor

unwrapDMapMaybe :: GCompare k => (forall a. f a -> Maybe a) -> DMap k f -> DMap k Identity

Deprecated: Use 'Data.Dependent.Map.mapMaybeWithKey (_ a -> fmap Identity $ f a)' instead

Like unwrapDMap, but possibly delete some values from the DMap

extractFunctorDMap :: DMap (Const2 k (f v)) Identity -> DMap (Const2 k v) f

Deprecated: Use 'mapKeyValuePairsMonotonic ((Const2 k :=> Identity v) -> Const2 k :=> v)' instead

Eliminate the Identity functor in a DMap and replace it with the underlying functor

newtype ComposeMaybe f a

We can't use Compose Maybe instead of ComposeMaybe, because that would make the f parameter have a nominal type role. We need f to be representational so that we can use safe coerce.

Constructors

ComposeMaybe

Fields

• getComposeMaybe :: Maybe (f a)

Instances

Functor f => Functor (ComposeMaybe f)

Defined in Data.Functor.Misc

Methods

fmap :: (a -> b) -> ComposeMaybe f a -> ComposeMaybe f b

(<$) :: a -> ComposeMaybe f b -> ComposeMaybe f a

Eq (f a) => Eq (ComposeMaybe f a)

Defined in Data.Functor.Misc

Methods

(==) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

(/=) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

Ord (f a) => Ord (ComposeMaybe f a)

Defined in Data.Functor.Misc

Methods

compare :: ComposeMaybe f a -> ComposeMaybe f a -> Ordering

(<) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

(<=) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

(>) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

(>=) :: ComposeMaybe f a -> ComposeMaybe f a -> Bool

max :: ComposeMaybe f a -> ComposeMaybe f a -> ComposeMaybe f a

min :: ComposeMaybe f a -> ComposeMaybe f a -> ComposeMaybe f a

Show (f a) => Show (ComposeMaybe f a)

Defined in Data.Functor.Misc

Methods

showsPrec :: Int -> ComposeMaybe f a -> ShowS

show :: ComposeMaybe f a -> String

showList :: [ComposeMaybe f a] -> ShowS