-- |
-- Module      : Control.Applicative.ListF
-- Copyright   : (c) Justin Le 2019
-- License     : BSD3
--
-- Maintainer  : justin@jle.im
-- Stability   : experimental
-- Portability : non-portable
--
-- This module provides functor combinators that are wrappers over lists or
-- maybes of @f a@s, especially for their
-- 'Data.HFunctor.Interpret.Interpret' instances.
--
-- Each one transforms a functor into some product of itself.  For example,
-- @'NonEmptyF' f@ represents @f ':*:' f@, or @f :*: f :*: f@, or @f :*:
-- f :*: f :*: f@, etc.
module Control.Applicative.ListF (
  -- * 'ListF'
    ListF(..), mapListF
  -- * 'NonEmptyF'
  , NonEmptyF(.., ProdNonEmpty, nonEmptyProd), mapNonEmptyF
  , toListF, fromListF
  -- * 'MaybeF'
  , MaybeF(..), mapMaybeF
  , listToMaybeF, maybeToListF
  -- * 'MapF'
  , MapF(..)
  , NEMapF(..)
  ) where

import           Control.Applicative
import           Control.Natural
import           Data.Coerce
import           Data.Data
import           Data.Deriving
import           Data.Foldable
import           Data.Functor.Bind
import           Data.Functor.Classes
import           Data.Functor.Contravariant
import           Data.Functor.Contravariant.Conclude
import           Data.Functor.Contravariant.Decide
import           Data.Functor.Contravariant.Divise
import           Data.Functor.Contravariant.Divisible
import           Data.Functor.Invariant
import           Data.Functor.Plus
import           Data.List.NonEmpty                   (NonEmpty(..))
import           Data.Maybe
import           Data.Pointed
import           Data.Semigroup.Foldable
import           Data.Semigroup.Traversable
import           GHC.Generics
import qualified Data.Map                             as M
import qualified Data.Map.NonEmpty                    as NEM

-- | A list of @f a@s.  Can be used to describe a product of many different
-- values of type @f a@.
--
-- This is the Free 'Plus'.
--
-- Incidentally, if used with a 'Contravariant' @f@, this is instead the
-- free 'Divisible'.
newtype ListF f a = ListF { ListF f a -> [f a]
runListF :: [f a] }
  deriving (Int -> ListF f a -> ShowS
[ListF f a] -> ShowS
ListF f a -> String
(Int -> ListF f a -> ShowS)
-> (ListF f a -> String)
-> ([ListF f a] -> ShowS)
-> Show (ListF f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> ListF f a -> ShowS
forall k (f :: k -> *) (a :: k). Show (f a) => [ListF f a] -> ShowS
forall k (f :: k -> *) (a :: k). Show (f a) => ListF f a -> String
showList :: [ListF f a] -> ShowS
$cshowList :: forall k (f :: k -> *) (a :: k). Show (f a) => [ListF f a] -> ShowS
show :: ListF f a -> String
$cshow :: forall k (f :: k -> *) (a :: k). Show (f a) => ListF f a -> String
showsPrec :: Int -> ListF f a -> ShowS
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> ListF f a -> ShowS
Show, ReadPrec [ListF f a]
ReadPrec (ListF f a)
Int -> ReadS (ListF f a)
ReadS [ListF f a]
(Int -> ReadS (ListF f a))
-> ReadS [ListF f a]
-> ReadPrec (ListF f a)
-> ReadPrec [ListF f a]
-> Read (ListF f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec [ListF f a]
forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec (ListF f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (ListF f a)
forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [ListF f a]
readListPrec :: ReadPrec [ListF f a]
$creadListPrec :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec [ListF f a]
readPrec :: ReadPrec (ListF f a)
$creadPrec :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadPrec (ListF f a)
readList :: ReadS [ListF f a]
$creadList :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [ListF f a]
readsPrec :: Int -> ReadS (ListF f a)
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (ListF f a)
Read, ListF f a -> ListF f a -> Bool
(ListF f a -> ListF f a -> Bool)
-> (ListF f a -> ListF f a -> Bool) -> Eq (ListF f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
ListF f a -> ListF f a -> Bool
/= :: ListF f a -> ListF f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
ListF f a -> ListF f a -> Bool
== :: ListF f a -> ListF f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
ListF f a -> ListF f a -> Bool
Eq, Eq (ListF f a)
Eq (ListF f a) =>
(ListF f a -> ListF f a -> Ordering)
-> (ListF f a -> ListF f a -> Bool)
-> (ListF f a -> ListF f a -> Bool)
-> (ListF f a -> ListF f a -> Bool)
-> (ListF f a -> ListF f a -> Bool)
-> (ListF f a -> ListF f a -> ListF f a)
-> (ListF f a -> ListF f a -> ListF f a)
-> Ord (ListF f a)
ListF f a -> ListF f a -> Bool
ListF f a -> ListF f a -> Ordering
ListF f a -> ListF f a -> ListF f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (ListF f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> ListF f a
min :: ListF f a -> ListF f a -> ListF f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> ListF f a
max :: ListF f a -> ListF f a -> ListF f a
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> ListF f a
>= :: ListF f a -> ListF f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Bool
> :: ListF f a -> ListF f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Bool
<= :: ListF f a -> ListF f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Bool
< :: ListF f a -> ListF f a -> Bool
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Bool
compare :: ListF f a -> ListF f a -> Ordering
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
ListF f a -> ListF f a -> Ordering
$cp1Ord :: forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (ListF f a)
Ord, a -> ListF f b -> ListF f a
(a -> b) -> ListF f a -> ListF f b
(forall a b. (a -> b) -> ListF f a -> ListF f b)
-> (forall a b. a -> ListF f b -> ListF f a) -> Functor (ListF f)
forall a b. a -> ListF f b -> ListF f a
forall a b. (a -> b) -> ListF f a -> ListF f b
forall (f :: * -> *) a b. Functor f => a -> ListF f b -> ListF f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ListF f a -> ListF f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ListF f b -> ListF f a
$c<$ :: forall (f :: * -> *) a b. Functor f => a -> ListF f b -> ListF f a
fmap :: (a -> b) -> ListF f a -> ListF f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ListF f a -> ListF f b
Functor, ListF f a -> Bool
(a -> m) -> ListF f a -> m
(a -> b -> b) -> b -> ListF f a -> b
(forall m. Monoid m => ListF f m -> m)
-> (forall m a. Monoid m => (a -> m) -> ListF f a -> m)
-> (forall m a. Monoid m => (a -> m) -> ListF f a -> m)
-> (forall a b. (a -> b -> b) -> b -> ListF f a -> b)
-> (forall a b. (a -> b -> b) -> b -> ListF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> ListF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> ListF f a -> b)
-> (forall a. (a -> a -> a) -> ListF f a -> a)
-> (forall a. (a -> a -> a) -> ListF f a -> a)
-> (forall a. ListF f a -> [a])
-> (forall a. ListF f a -> Bool)
-> (forall a. ListF f a -> Int)
-> (forall a. Eq a => a -> ListF f a -> Bool)
-> (forall a. Ord a => ListF f a -> a)
-> (forall a. Ord a => ListF f a -> a)
-> (forall a. Num a => ListF f a -> a)
-> (forall a. Num a => ListF f a -> a)
-> Foldable (ListF f)
forall a. Eq a => a -> ListF f a -> Bool
forall a. Num a => ListF f a -> a
forall a. Ord a => ListF f a -> a
forall m. Monoid m => ListF f m -> m
forall a. ListF f a -> Bool
forall a. ListF f a -> Int
forall a. ListF f a -> [a]
forall a. (a -> a -> a) -> ListF f a -> a
forall m a. Monoid m => (a -> m) -> ListF f a -> m
forall b a. (b -> a -> b) -> b -> ListF f a -> b
forall a b. (a -> b -> b) -> b -> ListF f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> ListF f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => ListF f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => ListF f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => ListF f m -> m
forall (f :: * -> *) a. Foldable f => ListF f a -> Bool
forall (f :: * -> *) a. Foldable f => ListF f a -> Int
forall (f :: * -> *) a. Foldable f => ListF f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> ListF f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ListF f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ListF f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ListF f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: ListF f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => ListF f a -> a
sum :: ListF f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => ListF f a -> a
minimum :: ListF f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => ListF f a -> a
maximum :: ListF f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => ListF f a -> a
elem :: a -> ListF f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> ListF f a -> Bool
length :: ListF f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => ListF f a -> Int
null :: ListF f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => ListF f a -> Bool
toList :: ListF f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => ListF f a -> [a]
foldl1 :: (a -> a -> a) -> ListF f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> ListF f a -> a
foldr1 :: (a -> a -> a) -> ListF f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> ListF f a -> a
foldl' :: (b -> a -> b) -> b -> ListF f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ListF f a -> b
foldl :: (b -> a -> b) -> b -> ListF f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> ListF f a -> b
foldr' :: (a -> b -> b) -> b -> ListF f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ListF f a -> b
foldr :: (a -> b -> b) -> b -> ListF f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> ListF f a -> b
foldMap' :: (a -> m) -> ListF f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ListF f a -> m
foldMap :: (a -> m) -> ListF f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> ListF f a -> m
fold :: ListF f m -> m
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => ListF f m -> m
Foldable, Functor (ListF f)
Foldable (ListF f)
(Functor (ListF f), Foldable (ListF f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> ListF f a -> f (ListF f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ListF f (f a) -> f (ListF f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ListF f a -> m (ListF f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ListF f (m a) -> m (ListF f a))
-> Traversable (ListF f)
(a -> f b) -> ListF f a -> f (ListF f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *). Traversable f => Functor (ListF f)
forall (f :: * -> *). Traversable f => Foldable (ListF f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
ListF f (m a) -> m (ListF f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
ListF f (f a) -> f (ListF f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> ListF f a -> m (ListF f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> ListF f a -> f (ListF f b)
forall (m :: * -> *) a. Monad m => ListF f (m a) -> m (ListF f a)
forall (f :: * -> *) a.
Applicative f =>
ListF f (f a) -> f (ListF f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ListF f a -> m (ListF f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ListF f a -> f (ListF f b)
sequence :: ListF f (m a) -> m (ListF f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
ListF f (m a) -> m (ListF f a)
mapM :: (a -> m b) -> ListF f a -> m (ListF f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> ListF f a -> m (ListF f b)
sequenceA :: ListF f (f a) -> f (ListF f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
ListF f (f a) -> f (ListF f a)
traverse :: (a -> f b) -> ListF f a -> f (ListF f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> ListF f a -> f (ListF f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (ListF f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (ListF f)
Traversable, Typeable, (forall x. ListF f a -> Rep (ListF f a) x)
-> (forall x. Rep (ListF f a) x -> ListF f a)
-> Generic (ListF f a)
forall x. Rep (ListF f a) x -> ListF f a
forall x. ListF f a -> Rep (ListF f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x. Rep (ListF f a) x -> ListF f a
forall k (f :: k -> *) (a :: k) x. ListF f a -> Rep (ListF f a) x
$cto :: forall k (f :: k -> *) (a :: k) x. Rep (ListF f a) x -> ListF f a
$cfrom :: forall k (f :: k -> *) (a :: k) x. ListF f a -> Rep (ListF f a) x
Generic, Typeable (ListF f a)
DataType
Constr
Typeable (ListF f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ListF f a -> c (ListF f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (ListF f a))
-> (ListF f a -> Constr)
-> (ListF f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (ListF f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (ListF f a)))
-> ((forall b. Data b => b -> b) -> ListF f a -> ListF f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ListF f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ListF f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> ListF f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ListF f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a))
-> Data (ListF f a)
ListF f a -> DataType
ListF f a -> Constr
(forall b. Data b => b -> b) -> ListF f a -> ListF f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListF f a -> c (ListF f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListF f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ListF f a -> u
forall u. (forall d. Data d => d -> u) -> ListF f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (ListF f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
ListF f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
ListF f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> ListF f a -> ListF f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> ListF f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> ListF f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListF f a -> c (ListF f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ListF f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListF f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListF f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListF f a -> c (ListF f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (ListF f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListF f a))
$cListF :: Constr
$tListF :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
gmapMp :: (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
gmapM :: (forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> ListF f a -> m (ListF f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> ListF f a -> u
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> ListF f a -> u
gmapQ :: (forall d. Data d => d -> u) -> ListF f a -> [u]
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> ListF f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ListF f a -> r
gmapT :: (forall b. Data b => b -> b) -> ListF f a -> ListF f a
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> ListF f a -> ListF f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListF f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (ListF f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (ListF f a))
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (ListF f a))
dataTypeOf :: ListF f a -> DataType
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
ListF f a -> DataType
toConstr :: ListF f a -> Constr
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
ListF f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListF f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (ListF f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListF f a -> c (ListF f a)
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ListF f a -> c (ListF f a)
$cp1Data :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (ListF f a)
Data)

deriveShow1 ''ListF
deriveRead1 ''ListF
deriveEq1 ''ListF
deriveOrd1 ''ListF

instance Apply f => Apply (ListF f) where
    ListF fs :: [f (a -> b)]
fs <.> :: ListF f (a -> b) -> ListF f a -> ListF f b
<.> ListF xs :: [f a]
xs = [f b] -> ListF f b
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f b] -> ListF f b) -> [f b] -> ListF f b
forall a b. (a -> b) -> a -> b
$ (f (a -> b) -> f a -> f b) -> [f (a -> b)] -> [f a] -> [f b]
forall (f :: * -> *) a b c.
Apply f =>
(a -> b -> c) -> f a -> f b -> f c
liftF2 f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Apply f => f (a -> b) -> f a -> f b
(<.>) [f (a -> b)]
fs [f a]
xs
instance Applicative f => Applicative (ListF f) where
    pure :: a -> ListF f a
pure  = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a] -> ListF f a) -> (a -> [f a]) -> a -> ListF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f a -> [f a] -> [f a]
forall a. a -> [a] -> [a]
:[]) (f a -> [f a]) -> (a -> f a) -> a -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    ListF fs :: [f (a -> b)]
fs <*> :: ListF f (a -> b) -> ListF f a -> ListF f b
<*> ListF xs :: [f a]
xs = [f b] -> ListF f b
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f b] -> ListF f b) -> [f b] -> ListF f b
forall a b. (a -> b) -> a -> b
$ (f (a -> b) -> f a -> f b) -> [f (a -> b)] -> [f a] -> [f b]
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>) [f (a -> b)]
fs [f a]
xs

instance Functor f => Alt (ListF f) where
    <!> :: ListF f a -> ListF f a -> ListF f a
(<!>) = ListF f a -> ListF f a -> ListF f a
forall a. Semigroup a => a -> a -> a
(<>)

instance Functor f => Plus (ListF f) where
    zero :: ListF f a
zero = ListF f a
forall a. Monoid a => a
mempty

instance Applicative f => Alternative (ListF f) where
    empty :: ListF f a
empty = ListF f a
forall (f :: * -> *) a. Plus f => f a
zero
    <|> :: ListF f a -> ListF f a -> ListF f a
(<|>) = ListF f a -> ListF f a -> ListF f a
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
(<!>)

instance Semigroup (ListF f a) where
    ListF xs :: [f a]
xs <> :: ListF f a -> ListF f a -> ListF f a
<> ListF ys :: [f a]
ys = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a]
xs [f a] -> [f a] -> [f a]
forall a. [a] -> [a] -> [a]
++ [f a]
ys)

instance Monoid (ListF f a) where
    mempty :: ListF f a
mempty = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF []

instance Pointed f => Pointed (ListF f) where
    point :: a -> ListF f a
point = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a] -> ListF f a) -> (a -> [f a]) -> a -> ListF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f a -> [f a] -> [f a]
forall a. a -> [a] -> [a]
: []) (f a -> [f a]) -> (a -> f a) -> a -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (p :: * -> *) a. Pointed p => a -> p a
point

-- | @since 0.3.0.0
instance Contravariant f => Contravariant (ListF f) where
    contramap :: (a -> b) -> ListF f b -> ListF f a
contramap f :: a -> b
f (ListF xs :: [f b]
xs) = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF (((f b -> f a) -> [f b] -> [f a]
forall a b. (a -> b) -> [a] -> [b]
map ((f b -> f a) -> [f b] -> [f a])
-> ((a -> b) -> f b -> f a) -> (a -> b) -> [f b] -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) a -> b
f [f b]
xs)

-- | @since 0.3.0.0
instance Invariant f => Invariant (ListF f) where
    invmap :: (a -> b) -> (b -> a) -> ListF f a -> ListF f b
invmap f :: a -> b
f g :: b -> a
g (ListF xs :: [f a]
xs) = [f b] -> ListF f b
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ((f a -> f b) -> [f a] -> [f b]
forall a b. (a -> b) -> [a] -> [b]
map ((a -> b) -> (b -> a) -> f a -> f b
forall (f :: * -> *) a b.
Invariant f =>
(a -> b) -> (b -> a) -> f a -> f b
invmap a -> b
f b -> a
g) [f a]
xs)

-- | @since 0.3.0.0
instance Contravariant f => Divise (ListF f) where
    divise :: (a -> (b, c)) -> ListF f b -> ListF f c -> ListF f a
divise f :: a -> (b, c)
f (ListF xs :: [f b]
xs) (ListF ys :: [f c]
ys) = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a] -> ListF f a) -> [f a] -> ListF f a
forall a b. (a -> b) -> a -> b
$
         ((f b -> f a) -> [f b] -> [f a]
forall a b. (a -> b) -> [a] -> [b]
map ((f b -> f a) -> [f b] -> [f a])
-> ((a -> b) -> f b -> f a) -> (a -> b) -> [f b] -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> b
forall a b. (a, b) -> a
fst ((b, c) -> b) -> (a -> (b, c)) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) [f b]
xs
      [f a] -> [f a] -> [f a]
forall a. Semigroup a => a -> a -> a
<> ((f c -> f a) -> [f c] -> [f a]
forall a b. (a -> b) -> [a] -> [b]
map ((f c -> f a) -> [f c] -> [f a])
-> ((a -> c) -> f c -> f a) -> (a -> c) -> [f c] -> [f a]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> c) -> f c -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> c
forall a b. (a, b) -> b
snd ((b, c) -> c) -> (a -> (b, c)) -> a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) [f c]
ys

-- | @since 0.3.0.0
instance Contravariant f => Divisible (ListF f) where
    divide :: (a -> (b, c)) -> ListF f b -> ListF f c -> ListF f a
divide  = (a -> (b, c)) -> ListF f b -> ListF f c -> ListF f a
forall (f :: * -> *) a b c.
Divise f =>
(a -> (b, c)) -> f b -> f c -> f a
divise
    conquer :: ListF f a
conquer = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF []

-- | @since 0.3.0.0
instance Decide f => Decide (ListF f) where
    decide :: (a -> Either b c) -> ListF f b -> ListF f c -> ListF f a
decide f :: a -> Either b c
f (ListF xs :: [f b]
xs) (ListF ys :: [f c]
ys) = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a] -> ListF f a) -> [f a] -> ListF f a
forall a b. (a -> b) -> a -> b
$
        (f b -> f c -> f a) -> [f b] -> [f c] -> [f a]
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((a -> Either b c) -> f b -> f c -> f a
forall (f :: * -> *) a b c.
Decide f =>
(a -> Either b c) -> f b -> f c -> f a
decide a -> Either b c
f) [f b]
xs [f c]
ys

-- | @since 0.3.0.0
instance Conclude f => Conclude (ListF f) where
    conclude :: (a -> Void) -> ListF f a
conclude f :: a -> Void
f = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF [(a -> Void) -> f a
forall (f :: * -> *) a. Conclude f => (a -> Void) -> f a
conclude a -> Void
f]

-- | @since 0.3.0.0
instance Decidable f => Decidable (ListF f) where
    lose :: (a -> Void) -> ListF f a
lose f :: a -> Void
f = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF [(a -> Void) -> f a
forall (f :: * -> *) a. Decidable f => (a -> Void) -> f a
lose a -> Void
f]
    choose :: (a -> Either b c) -> ListF f b -> ListF f c -> ListF f a
choose f :: a -> Either b c
f (ListF xs :: [f b]
xs) (ListF ys :: [f c]
ys) = [f a] -> ListF f a
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF ([f a] -> ListF f a) -> [f a] -> ListF f a
forall a b. (a -> b) -> a -> b
$
        (f b -> f c -> f a) -> [f b] -> [f c] -> [f a]
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((a -> Either b c) -> f b -> f c -> f a
forall (f :: * -> *) a b c.
Decidable f =>
(a -> Either b c) -> f b -> f c -> f a
choose a -> Either b c
f) [f b]
xs [f c]
ys

-- | Map a function over the inside of a 'ListF'.
mapListF
    :: ([f a] -> [g b])
    -> ListF f a
    -> ListF g b
mapListF :: ([f a] -> [g b]) -> ListF f a -> ListF g b
mapListF = ([f a] -> [g b]) -> ListF f a -> ListF g b
forall a b. Coercible a b => a -> b
coerce

-- | A non-empty list of @f a@s.  Can be used to describe a product between
-- many different possible values of type @f a@.
--
-- Essentially:
--
-- @
-- 'NonEmptyF' f
--     ~ f                          -- one f
--   ':+:' (f ':*:' f)              -- two f's
--   :+: (f :*: f :*: f)            -- three f's
--   :+: (f :*: f :*: f :*: f)      -- four f's
--   :+: ...                        -- etc.
-- @
--
-- This is the Free 'Plus' on any 'Functor' @f@.
--
-- Incidentally, if used with a 'Contravariant' @f@, this is instead the
-- free 'Divise'.
newtype NonEmptyF f a = NonEmptyF { NonEmptyF f a -> NonEmpty (f a)
runNonEmptyF :: NonEmpty (f a) }
  deriving (Int -> NonEmptyF f a -> ShowS
[NonEmptyF f a] -> ShowS
NonEmptyF f a -> String
(Int -> NonEmptyF f a -> ShowS)
-> (NonEmptyF f a -> String)
-> ([NonEmptyF f a] -> ShowS)
-> Show (NonEmptyF f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> NonEmptyF f a -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
[NonEmptyF f a] -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
NonEmptyF f a -> String
showList :: [NonEmptyF f a] -> ShowS
$cshowList :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
[NonEmptyF f a] -> ShowS
show :: NonEmptyF f a -> String
$cshow :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
NonEmptyF f a -> String
showsPrec :: Int -> NonEmptyF f a -> ShowS
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> NonEmptyF f a -> ShowS
Show, ReadPrec [NonEmptyF f a]
ReadPrec (NonEmptyF f a)
Int -> ReadS (NonEmptyF f a)
ReadS [NonEmptyF f a]
(Int -> ReadS (NonEmptyF f a))
-> ReadS [NonEmptyF f a]
-> ReadPrec (NonEmptyF f a)
-> ReadPrec [NonEmptyF f a]
-> Read (NonEmptyF f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [NonEmptyF f a]
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (NonEmptyF f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (NonEmptyF f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [NonEmptyF f a]
readListPrec :: ReadPrec [NonEmptyF f a]
$creadListPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [NonEmptyF f a]
readPrec :: ReadPrec (NonEmptyF f a)
$creadPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (NonEmptyF f a)
readList :: ReadS [NonEmptyF f a]
$creadList :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadS [NonEmptyF f a]
readsPrec :: Int -> ReadS (NonEmptyF f a)
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (NonEmptyF f a)
Read, NonEmptyF f a -> NonEmptyF f a -> Bool
(NonEmptyF f a -> NonEmptyF f a -> Bool)
-> (NonEmptyF f a -> NonEmptyF f a -> Bool) -> Eq (NonEmptyF f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
/= :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
== :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
Eq, Eq (NonEmptyF f a)
Eq (NonEmptyF f a) =>
(NonEmptyF f a -> NonEmptyF f a -> Ordering)
-> (NonEmptyF f a -> NonEmptyF f a -> Bool)
-> (NonEmptyF f a -> NonEmptyF f a -> Bool)
-> (NonEmptyF f a -> NonEmptyF f a -> Bool)
-> (NonEmptyF f a -> NonEmptyF f a -> Bool)
-> (NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a)
-> (NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a)
-> Ord (NonEmptyF f a)
NonEmptyF f a -> NonEmptyF f a -> Bool
NonEmptyF f a -> NonEmptyF f a -> Ordering
NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (NonEmptyF f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
min :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
max :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
>= :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
> :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
<= :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
< :: NonEmptyF f a -> NonEmptyF f a -> Bool
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Bool
compare :: NonEmptyF f a -> NonEmptyF f a -> Ordering
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
NonEmptyF f a -> NonEmptyF f a -> Ordering
$cp1Ord :: forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (NonEmptyF f a)
Ord, a -> NonEmptyF f b -> NonEmptyF f a
(a -> b) -> NonEmptyF f a -> NonEmptyF f b
(forall a b. (a -> b) -> NonEmptyF f a -> NonEmptyF f b)
-> (forall a b. a -> NonEmptyF f b -> NonEmptyF f a)
-> Functor (NonEmptyF f)
forall a b. a -> NonEmptyF f b -> NonEmptyF f a
forall a b. (a -> b) -> NonEmptyF f a -> NonEmptyF f b
forall (f :: * -> *) a b.
Functor f =>
a -> NonEmptyF f b -> NonEmptyF f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> NonEmptyF f a -> NonEmptyF f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> NonEmptyF f b -> NonEmptyF f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> NonEmptyF f b -> NonEmptyF f a
fmap :: (a -> b) -> NonEmptyF f a -> NonEmptyF f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> NonEmptyF f a -> NonEmptyF f b
Functor, NonEmptyF f a -> Bool
(a -> m) -> NonEmptyF f a -> m
(a -> b -> b) -> b -> NonEmptyF f a -> b
(forall m. Monoid m => NonEmptyF f m -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmptyF f a -> m)
-> (forall m a. Monoid m => (a -> m) -> NonEmptyF f a -> m)
-> (forall a b. (a -> b -> b) -> b -> NonEmptyF f a -> b)
-> (forall a b. (a -> b -> b) -> b -> NonEmptyF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmptyF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> NonEmptyF f a -> b)
-> (forall a. (a -> a -> a) -> NonEmptyF f a -> a)
-> (forall a. (a -> a -> a) -> NonEmptyF f a -> a)
-> (forall a. NonEmptyF f a -> [a])
-> (forall a. NonEmptyF f a -> Bool)
-> (forall a. NonEmptyF f a -> Int)
-> (forall a. Eq a => a -> NonEmptyF f a -> Bool)
-> (forall a. Ord a => NonEmptyF f a -> a)
-> (forall a. Ord a => NonEmptyF f a -> a)
-> (forall a. Num a => NonEmptyF f a -> a)
-> (forall a. Num a => NonEmptyF f a -> a)
-> Foldable (NonEmptyF f)
forall a. Eq a => a -> NonEmptyF f a -> Bool
forall a. Num a => NonEmptyF f a -> a
forall a. Ord a => NonEmptyF f a -> a
forall m. Monoid m => NonEmptyF f m -> m
forall a. NonEmptyF f a -> Bool
forall a. NonEmptyF f a -> Int
forall a. NonEmptyF f a -> [a]
forall a. (a -> a -> a) -> NonEmptyF f a -> a
forall m a. Monoid m => (a -> m) -> NonEmptyF f a -> m
forall b a. (b -> a -> b) -> b -> NonEmptyF f a -> b
forall a b. (a -> b -> b) -> b -> NonEmptyF f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> NonEmptyF f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => NonEmptyF f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => NonEmptyF f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
NonEmptyF f m -> m
forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> Bool
forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> Int
forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NonEmptyF f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NonEmptyF f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NonEmptyF f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NonEmptyF f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: NonEmptyF f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => NonEmptyF f a -> a
sum :: NonEmptyF f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => NonEmptyF f a -> a
minimum :: NonEmptyF f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => NonEmptyF f a -> a
maximum :: NonEmptyF f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => NonEmptyF f a -> a
elem :: a -> NonEmptyF f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> NonEmptyF f a -> Bool
length :: NonEmptyF f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> Int
null :: NonEmptyF f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> Bool
toList :: NonEmptyF f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => NonEmptyF f a -> [a]
foldl1 :: (a -> a -> a) -> NonEmptyF f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NonEmptyF f a -> a
foldr1 :: (a -> a -> a) -> NonEmptyF f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NonEmptyF f a -> a
foldl' :: (b -> a -> b) -> b -> NonEmptyF f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NonEmptyF f a -> b
foldl :: (b -> a -> b) -> b -> NonEmptyF f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NonEmptyF f a -> b
foldr' :: (a -> b -> b) -> b -> NonEmptyF f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NonEmptyF f a -> b
foldr :: (a -> b -> b) -> b -> NonEmptyF f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NonEmptyF f a -> b
foldMap' :: (a -> m) -> NonEmptyF f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NonEmptyF f a -> m
foldMap :: (a -> m) -> NonEmptyF f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NonEmptyF f a -> m
fold :: NonEmptyF f m -> m
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
NonEmptyF f m -> m
Foldable, Functor (NonEmptyF f)
Foldable (NonEmptyF f)
(Functor (NonEmptyF f), Foldable (NonEmptyF f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NonEmptyF f (f a) -> f (NonEmptyF f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NonEmptyF f (m a) -> m (NonEmptyF f a))
-> Traversable (NonEmptyF f)
(a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *). Traversable f => Functor (NonEmptyF f)
forall (f :: * -> *). Traversable f => Foldable (NonEmptyF f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
NonEmptyF f (m a) -> m (NonEmptyF f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
NonEmptyF f (f a) -> f (NonEmptyF f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b)
forall (m :: * -> *) a.
Monad m =>
NonEmptyF f (m a) -> m (NonEmptyF f a)
forall (f :: * -> *) a.
Applicative f =>
NonEmptyF f (f a) -> f (NonEmptyF f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b)
sequence :: NonEmptyF f (m a) -> m (NonEmptyF f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
NonEmptyF f (m a) -> m (NonEmptyF f a)
mapM :: (a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> NonEmptyF f a -> m (NonEmptyF f b)
sequenceA :: NonEmptyF f (f a) -> f (NonEmptyF f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
NonEmptyF f (f a) -> f (NonEmptyF f a)
traverse :: (a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> NonEmptyF f a -> f (NonEmptyF f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (NonEmptyF f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (NonEmptyF f)
Traversable, Typeable, (forall x. NonEmptyF f a -> Rep (NonEmptyF f a) x)
-> (forall x. Rep (NonEmptyF f a) x -> NonEmptyF f a)
-> Generic (NonEmptyF f a)
forall x. Rep (NonEmptyF f a) x -> NonEmptyF f a
forall x. NonEmptyF f a -> Rep (NonEmptyF f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x.
Rep (NonEmptyF f a) x -> NonEmptyF f a
forall k (f :: k -> *) (a :: k) x.
NonEmptyF f a -> Rep (NonEmptyF f a) x
$cto :: forall k (f :: k -> *) (a :: k) x.
Rep (NonEmptyF f a) x -> NonEmptyF f a
$cfrom :: forall k (f :: k -> *) (a :: k) x.
NonEmptyF f a -> Rep (NonEmptyF f a) x
Generic, Typeable (NonEmptyF f a)
DataType
Constr
Typeable (NonEmptyF f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a))
-> (NonEmptyF f a -> Constr)
-> (NonEmptyF f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NonEmptyF f a)))
-> ((forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NonEmptyF f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> NonEmptyF f a -> m (NonEmptyF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NonEmptyF f a -> m (NonEmptyF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> NonEmptyF f a -> m (NonEmptyF f a))
-> Data (NonEmptyF f a)
NonEmptyF f a -> DataType
NonEmptyF f a -> Constr
(forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u
forall u. (forall d. Data d => d -> u) -> NonEmptyF f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (NonEmptyF f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
NonEmptyF f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
NonEmptyF f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> NonEmptyF f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptyF f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptyF f a))
$cNonEmptyF :: Constr
$tNonEmptyF :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
gmapMp :: (forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
gmapM :: (forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d)
-> NonEmptyF f a -> m (NonEmptyF f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> NonEmptyF f a -> u
gmapQ :: (forall d. Data d => d -> u) -> NonEmptyF f a -> [u]
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> NonEmptyF f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NonEmptyF f a -> r
gmapT :: (forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> NonEmptyF f a -> NonEmptyF f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptyF f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NonEmptyF f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a))
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NonEmptyF f a))
dataTypeOf :: NonEmptyF f a -> DataType
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
NonEmptyF f a -> DataType
toConstr :: NonEmptyF f a -> Constr
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
NonEmptyF f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NonEmptyF f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NonEmptyF f a -> c (NonEmptyF f a)
$cp1Data :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (NonEmptyF f a)
Data)

deriveShow1 ''NonEmptyF
deriveRead1 ''NonEmptyF
deriveEq1 ''NonEmptyF
deriveOrd1 ''NonEmptyF

instance Applicative f => Applicative (NonEmptyF f) where
    pure :: a -> NonEmptyF f a
pure  = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f a) -> NonEmptyF f a)
-> (a -> NonEmpty (f a)) -> a -> NonEmptyF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f a -> [f a] -> NonEmpty (f a)
forall a. a -> [a] -> NonEmpty a
:| []) (f a -> NonEmpty (f a)) -> (a -> f a) -> a -> NonEmpty (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    NonEmptyF fs :: NonEmpty (f (a -> b))
fs <*> :: NonEmptyF f (a -> b) -> NonEmptyF f a -> NonEmptyF f b
<*> NonEmptyF xs :: NonEmpty (f a)
xs = NonEmpty (f b) -> NonEmptyF f b
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f b) -> NonEmptyF f b)
-> NonEmpty (f b) -> NonEmptyF f b
forall a b. (a -> b) -> a -> b
$ (f (a -> b) -> f a -> f b)
-> NonEmpty (f (a -> b)) -> NonEmpty (f a) -> NonEmpty (f b)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>) NonEmpty (f (a -> b))
fs NonEmpty (f a)
xs

instance Functor f => Alt (NonEmptyF f) where
    <!> :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
(<!>) = NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
forall a. Semigroup a => a -> a -> a
(<>)

-- | @since 0.3.0.0
instance Contravariant f => Contravariant (NonEmptyF f) where
    contramap :: (a -> b) -> NonEmptyF f b -> NonEmptyF f a
contramap f :: a -> b
f (NonEmptyF xs :: NonEmpty (f b)
xs) = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF ((f b -> f a) -> NonEmpty (f b) -> NonEmpty (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap a -> b
f) NonEmpty (f b)
xs)
-- | @since 0.3.0.0
instance Invariant f => Invariant (NonEmptyF f) where
    invmap :: (a -> b) -> (b -> a) -> NonEmptyF f a -> NonEmptyF f b
invmap f :: a -> b
f g :: b -> a
g (NonEmptyF xs :: NonEmpty (f a)
xs) = NonEmpty (f b) -> NonEmptyF f b
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF ((f a -> f b) -> NonEmpty (f a) -> NonEmpty (f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> (b -> a) -> f a -> f b
forall (f :: * -> *) a b.
Invariant f =>
(a -> b) -> (b -> a) -> f a -> f b
invmap a -> b
f b -> a
g) NonEmpty (f a)
xs)
-- | @since 0.3.0.0
instance Contravariant f => Divise (NonEmptyF f) where
    divise :: (a -> (b, c)) -> NonEmptyF f b -> NonEmptyF f c -> NonEmptyF f a
divise f :: a -> (b, c)
f (NonEmptyF xs :: NonEmpty (f b)
xs) (NonEmptyF ys :: NonEmpty (f c)
ys) = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f a) -> NonEmptyF f a)
-> NonEmpty (f a) -> NonEmptyF f a
forall a b. (a -> b) -> a -> b
$
         ((f b -> f a) -> NonEmpty (f b) -> NonEmpty (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f b -> f a) -> NonEmpty (f b) -> NonEmpty (f a))
-> ((a -> b) -> f b -> f a)
-> (a -> b)
-> NonEmpty (f b)
-> NonEmpty (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> b
forall a b. (a, b) -> a
fst ((b, c) -> b) -> (a -> (b, c)) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) NonEmpty (f b)
xs
      NonEmpty (f a) -> NonEmpty (f a) -> NonEmpty (f a)
forall a. Semigroup a => a -> a -> a
<> ((f c -> f a) -> NonEmpty (f c) -> NonEmpty (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f c -> f a) -> NonEmpty (f c) -> NonEmpty (f a))
-> ((a -> c) -> f c -> f a)
-> (a -> c)
-> NonEmpty (f c)
-> NonEmpty (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> c) -> f c -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> c
forall a b. (a, b) -> b
snd ((b, c) -> c) -> (a -> (b, c)) -> a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) NonEmpty (f c)
ys
-- | @since 0.3.0.0
instance Decide f => Decide (NonEmptyF f) where
    decide :: (a -> Either b c)
-> NonEmptyF f b -> NonEmptyF f c -> NonEmptyF f a
decide f :: a -> Either b c
f (NonEmptyF xs :: NonEmpty (f b)
xs) (NonEmptyF ys :: NonEmpty (f c)
ys) = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f a) -> NonEmptyF f a)
-> NonEmpty (f a) -> NonEmptyF f a
forall a b. (a -> b) -> a -> b
$
      (a -> Either b c) -> f b -> f c -> f a
forall (f :: * -> *) a b c.
Decide f =>
(a -> Either b c) -> f b -> f c -> f a
decide a -> Either b c
f (f b -> f c -> f a) -> NonEmpty (f b) -> NonEmpty (f c -> f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (f b)
xs NonEmpty (f c -> f a) -> NonEmpty (f c) -> NonEmpty (f a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> NonEmpty (f c)
ys

instance Semigroup (NonEmptyF f a) where
    NonEmptyF xs :: NonEmpty (f a)
xs <> :: NonEmptyF f a -> NonEmptyF f a -> NonEmptyF f a
<> NonEmptyF ys :: NonEmpty (f a)
ys = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f a)
xs NonEmpty (f a) -> NonEmpty (f a) -> NonEmpty (f a)
forall a. Semigroup a => a -> a -> a
<> NonEmpty (f a)
ys)

instance Pointed f => Pointed (NonEmptyF f) where
    point :: a -> NonEmptyF f a
point = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (NonEmpty (f a) -> NonEmptyF f a)
-> (a -> NonEmpty (f a)) -> a -> NonEmptyF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f a -> [f a] -> NonEmpty (f a)
forall a. a -> [a] -> NonEmpty a
:| []) (f a -> NonEmpty (f a)) -> (a -> f a) -> a -> NonEmpty (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (p :: * -> *) a. Pointed p => a -> p a
point

-- | Map a function over the inside of a 'NonEmptyF'.
mapNonEmptyF
    :: (NonEmpty (f a) -> NonEmpty (g b))
    -> NonEmptyF f a
    -> NonEmptyF g b
mapNonEmptyF :: (NonEmpty (f a) -> NonEmpty (g b))
-> NonEmptyF f a -> NonEmptyF g b
mapNonEmptyF = (NonEmpty (f a) -> NonEmpty (g b))
-> NonEmptyF f a -> NonEmptyF g b
forall a b. Coercible a b => a -> b
coerce

-- | Convert a 'NonEmptyF' into a 'ListF' with at least one item.
toListF :: NonEmptyF f ~> ListF f
toListF :: NonEmptyF f x -> ListF f x
toListF (NonEmptyF xs :: NonEmpty (f x)
xs) = [f x] -> ListF f x
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF (NonEmpty (f x) -> [f x]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty (f x)
xs)

-- | Convert a 'ListF' either a 'NonEmptyF', or a 'Proxy' in the case that
-- the list was empty.
fromListF :: ListF f ~> (Proxy :+: NonEmptyF f)
fromListF :: ListF f x -> (:+:) Proxy (NonEmptyF f) x
fromListF (ListF xs :: [f x]
xs) = case [f x]
xs of
    []   -> Proxy x -> (:+:) Proxy (NonEmptyF f) x
forall k (f :: k -> *) (g :: k -> *) (p :: k). f p -> (:+:) f g p
L1 Proxy x
forall k (t :: k). Proxy t
Proxy
    y :: f x
y:ys :: [f x]
ys -> NonEmptyF f x -> (:+:) Proxy (NonEmptyF f) x
forall k (f :: k -> *) (g :: k -> *) (p :: k). g p -> (:+:) f g p
R1 (NonEmptyF f x -> (:+:) Proxy (NonEmptyF f) x)
-> NonEmptyF f x -> (:+:) Proxy (NonEmptyF f) x
forall a b. (a -> b) -> a -> b
$ NonEmpty (f x) -> NonEmptyF f x
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (f x
y f x -> [f x] -> NonEmpty (f x)
forall a. a -> [a] -> NonEmpty a
:| [f x]
ys)

-- | Treat a @'NonEmptyF' f@ as a product between an @f@ and a @'ListF' f@.
--
-- 'nonEmptyProd' is the record accessor.
pattern ProdNonEmpty :: (f :*: ListF f) a -> NonEmptyF f a
pattern $bProdNonEmpty :: (:*:) f (ListF f) a -> NonEmptyF f a
$mProdNonEmpty :: forall r k (f :: k -> *) (a :: k).
NonEmptyF f a -> ((:*:) f (ListF f) a -> r) -> (Void# -> r) -> r
ProdNonEmpty { NonEmptyF f a -> (:*:) f (ListF f) a
nonEmptyProd
                     }
            <- ((\case NonEmptyF (x :| xs) -> x :*: ListF xs) -> nonEmptyProd)
  where
    ProdNonEmpty (x :: f a
x :*: ListF xs :: [f a]
xs) = NonEmpty (f a) -> NonEmptyF f a
forall k (f :: k -> *) (a :: k). NonEmpty (f a) -> NonEmptyF f a
NonEmptyF (f a
x f a -> [f a] -> NonEmpty (f a)
forall a. a -> [a] -> NonEmpty a
:| [f a]
xs)
{-# COMPLETE ProdNonEmpty #-}

-- | A maybe @f a@.
--
-- Can be useful for describing a "an @f a@ that may or may not be there".
--
-- This is the free structure for a "fail"-like typeclass that would only
-- have @zero :: f a@.
newtype MaybeF f a = MaybeF { MaybeF f a -> Maybe (f a)
runMaybeF :: Maybe (f a) }
  deriving (Int -> MaybeF f a -> ShowS
[MaybeF f a] -> ShowS
MaybeF f a -> String
(Int -> MaybeF f a -> ShowS)
-> (MaybeF f a -> String)
-> ([MaybeF f a] -> ShowS)
-> Show (MaybeF f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> MaybeF f a -> ShowS
forall k (f :: k -> *) (a :: k).
Show (f a) =>
[MaybeF f a] -> ShowS
forall k (f :: k -> *) (a :: k). Show (f a) => MaybeF f a -> String
showList :: [MaybeF f a] -> ShowS
$cshowList :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
[MaybeF f a] -> ShowS
show :: MaybeF f a -> String
$cshow :: forall k (f :: k -> *) (a :: k). Show (f a) => MaybeF f a -> String
showsPrec :: Int -> MaybeF f a -> ShowS
$cshowsPrec :: forall k (f :: k -> *) (a :: k).
Show (f a) =>
Int -> MaybeF f a -> ShowS
Show, ReadPrec [MaybeF f a]
ReadPrec (MaybeF f a)
Int -> ReadS (MaybeF f a)
ReadS [MaybeF f a]
(Int -> ReadS (MaybeF f a))
-> ReadS [MaybeF f a]
-> ReadPrec (MaybeF f a)
-> ReadPrec [MaybeF f a]
-> Read (MaybeF f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [MaybeF f a]
forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (MaybeF f a)
forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (MaybeF f a)
forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [MaybeF f a]
readListPrec :: ReadPrec [MaybeF f a]
$creadListPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec [MaybeF f a]
readPrec :: ReadPrec (MaybeF f a)
$creadPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
ReadPrec (MaybeF f a)
readList :: ReadS [MaybeF f a]
$creadList :: forall k (f :: k -> *) (a :: k). Read (f a) => ReadS [MaybeF f a]
readsPrec :: Int -> ReadS (MaybeF f a)
$creadsPrec :: forall k (f :: k -> *) (a :: k).
Read (f a) =>
Int -> ReadS (MaybeF f a)
Read, MaybeF f a -> MaybeF f a -> Bool
(MaybeF f a -> MaybeF f a -> Bool)
-> (MaybeF f a -> MaybeF f a -> Bool) -> Eq (MaybeF f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k (f :: k -> *) (a :: k).
Eq (f a) =>
MaybeF f a -> MaybeF f a -> Bool
/= :: MaybeF f a -> MaybeF f a -> Bool
$c/= :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
MaybeF f a -> MaybeF f a -> Bool
== :: MaybeF f a -> MaybeF f a -> Bool
$c== :: forall k (f :: k -> *) (a :: k).
Eq (f a) =>
MaybeF f a -> MaybeF f a -> Bool
Eq, Eq (MaybeF f a)
Eq (MaybeF f a) =>
(MaybeF f a -> MaybeF f a -> Ordering)
-> (MaybeF f a -> MaybeF f a -> Bool)
-> (MaybeF f a -> MaybeF f a -> Bool)
-> (MaybeF f a -> MaybeF f a -> Bool)
-> (MaybeF f a -> MaybeF f a -> Bool)
-> (MaybeF f a -> MaybeF f a -> MaybeF f a)
-> (MaybeF f a -> MaybeF f a -> MaybeF f a)
-> Ord (MaybeF f a)
MaybeF f a -> MaybeF f a -> Bool
MaybeF f a -> MaybeF f a -> Ordering
MaybeF f a -> MaybeF f a -> MaybeF f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (MaybeF f a)
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Bool
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Ordering
forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> MaybeF f a
min :: MaybeF f a -> MaybeF f a -> MaybeF f a
$cmin :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> MaybeF f a
max :: MaybeF f a -> MaybeF f a -> MaybeF f a
$cmax :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> MaybeF f a
>= :: MaybeF f a -> MaybeF f a -> Bool
$c>= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Bool
> :: MaybeF f a -> MaybeF f a -> Bool
$c> :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Bool
<= :: MaybeF f a -> MaybeF f a -> Bool
$c<= :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Bool
< :: MaybeF f a -> MaybeF f a -> Bool
$c< :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Bool
compare :: MaybeF f a -> MaybeF f a -> Ordering
$ccompare :: forall k (f :: k -> *) (a :: k).
Ord (f a) =>
MaybeF f a -> MaybeF f a -> Ordering
$cp1Ord :: forall k (f :: k -> *) (a :: k). Ord (f a) => Eq (MaybeF f a)
Ord, a -> MaybeF f b -> MaybeF f a
(a -> b) -> MaybeF f a -> MaybeF f b
(forall a b. (a -> b) -> MaybeF f a -> MaybeF f b)
-> (forall a b. a -> MaybeF f b -> MaybeF f a)
-> Functor (MaybeF f)
forall a b. a -> MaybeF f b -> MaybeF f a
forall a b. (a -> b) -> MaybeF f a -> MaybeF f b
forall (f :: * -> *) a b.
Functor f =>
a -> MaybeF f b -> MaybeF f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> MaybeF f a -> MaybeF f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MaybeF f b -> MaybeF f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> MaybeF f b -> MaybeF f a
fmap :: (a -> b) -> MaybeF f a -> MaybeF f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> MaybeF f a -> MaybeF f b
Functor, MaybeF f a -> Bool
(a -> m) -> MaybeF f a -> m
(a -> b -> b) -> b -> MaybeF f a -> b
(forall m. Monoid m => MaybeF f m -> m)
-> (forall m a. Monoid m => (a -> m) -> MaybeF f a -> m)
-> (forall m a. Monoid m => (a -> m) -> MaybeF f a -> m)
-> (forall a b. (a -> b -> b) -> b -> MaybeF f a -> b)
-> (forall a b. (a -> b -> b) -> b -> MaybeF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> MaybeF f a -> b)
-> (forall b a. (b -> a -> b) -> b -> MaybeF f a -> b)
-> (forall a. (a -> a -> a) -> MaybeF f a -> a)
-> (forall a. (a -> a -> a) -> MaybeF f a -> a)
-> (forall a. MaybeF f a -> [a])
-> (forall a. MaybeF f a -> Bool)
-> (forall a. MaybeF f a -> Int)
-> (forall a. Eq a => a -> MaybeF f a -> Bool)
-> (forall a. Ord a => MaybeF f a -> a)
-> (forall a. Ord a => MaybeF f a -> a)
-> (forall a. Num a => MaybeF f a -> a)
-> (forall a. Num a => MaybeF f a -> a)
-> Foldable (MaybeF f)
forall a. Eq a => a -> MaybeF f a -> Bool
forall a. Num a => MaybeF f a -> a
forall a. Ord a => MaybeF f a -> a
forall m. Monoid m => MaybeF f m -> m
forall a. MaybeF f a -> Bool
forall a. MaybeF f a -> Int
forall a. MaybeF f a -> [a]
forall a. (a -> a -> a) -> MaybeF f a -> a
forall m a. Monoid m => (a -> m) -> MaybeF f a -> m
forall b a. (b -> a -> b) -> b -> MaybeF f a -> b
forall a b. (a -> b -> b) -> b -> MaybeF f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> MaybeF f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => MaybeF f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => MaybeF f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => MaybeF f m -> m
forall (f :: * -> *) a. Foldable f => MaybeF f a -> Bool
forall (f :: * -> *) a. Foldable f => MaybeF f a -> Int
forall (f :: * -> *) a. Foldable f => MaybeF f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MaybeF f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MaybeF f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MaybeF f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MaybeF f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: MaybeF f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => MaybeF f a -> a
sum :: MaybeF f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => MaybeF f a -> a
minimum :: MaybeF f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => MaybeF f a -> a
maximum :: MaybeF f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => MaybeF f a -> a
elem :: a -> MaybeF f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> MaybeF f a -> Bool
length :: MaybeF f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => MaybeF f a -> Int
null :: MaybeF f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => MaybeF f a -> Bool
toList :: MaybeF f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => MaybeF f a -> [a]
foldl1 :: (a -> a -> a) -> MaybeF f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MaybeF f a -> a
foldr1 :: (a -> a -> a) -> MaybeF f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MaybeF f a -> a
foldl' :: (b -> a -> b) -> b -> MaybeF f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MaybeF f a -> b
foldl :: (b -> a -> b) -> b -> MaybeF f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MaybeF f a -> b
foldr' :: (a -> b -> b) -> b -> MaybeF f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MaybeF f a -> b
foldr :: (a -> b -> b) -> b -> MaybeF f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MaybeF f a -> b
foldMap' :: (a -> m) -> MaybeF f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MaybeF f a -> m
foldMap :: (a -> m) -> MaybeF f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MaybeF f a -> m
fold :: MaybeF f m -> m
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => MaybeF f m -> m
Foldable, Functor (MaybeF f)
Foldable (MaybeF f)
(Functor (MaybeF f), Foldable (MaybeF f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> MaybeF f a -> f (MaybeF f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MaybeF f (f a) -> f (MaybeF f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MaybeF f a -> m (MaybeF f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MaybeF f (m a) -> m (MaybeF f a))
-> Traversable (MaybeF f)
(a -> f b) -> MaybeF f a -> f (MaybeF f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *). Traversable f => Functor (MaybeF f)
forall (f :: * -> *). Traversable f => Foldable (MaybeF f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
MaybeF f (m a) -> m (MaybeF f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
MaybeF f (f a) -> f (MaybeF f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> MaybeF f a -> m (MaybeF f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> MaybeF f a -> f (MaybeF f b)
forall (m :: * -> *) a. Monad m => MaybeF f (m a) -> m (MaybeF f a)
forall (f :: * -> *) a.
Applicative f =>
MaybeF f (f a) -> f (MaybeF f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MaybeF f a -> m (MaybeF f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MaybeF f a -> f (MaybeF f b)
sequence :: MaybeF f (m a) -> m (MaybeF f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
MaybeF f (m a) -> m (MaybeF f a)
mapM :: (a -> m b) -> MaybeF f a -> m (MaybeF f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> MaybeF f a -> m (MaybeF f b)
sequenceA :: MaybeF f (f a) -> f (MaybeF f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
MaybeF f (f a) -> f (MaybeF f a)
traverse :: (a -> f b) -> MaybeF f a -> f (MaybeF f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> MaybeF f a -> f (MaybeF f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (MaybeF f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (MaybeF f)
Traversable, Typeable, (forall x. MaybeF f a -> Rep (MaybeF f a) x)
-> (forall x. Rep (MaybeF f a) x -> MaybeF f a)
-> Generic (MaybeF f a)
forall x. Rep (MaybeF f a) x -> MaybeF f a
forall x. MaybeF f a -> Rep (MaybeF f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k (f :: k -> *) (a :: k) x. Rep (MaybeF f a) x -> MaybeF f a
forall k (f :: k -> *) (a :: k) x. MaybeF f a -> Rep (MaybeF f a) x
$cto :: forall k (f :: k -> *) (a :: k) x. Rep (MaybeF f a) x -> MaybeF f a
$cfrom :: forall k (f :: k -> *) (a :: k) x. MaybeF f a -> Rep (MaybeF f a) x
Generic, Typeable (MaybeF f a)
DataType
Constr
Typeable (MaybeF f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MaybeF f a))
-> (MaybeF f a -> Constr)
-> (MaybeF f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MaybeF f a)))
-> ((forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> MaybeF f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a))
-> Data (MaybeF f a)
MaybeF f a -> DataType
MaybeF f a -> Constr
(forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybeF f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u
forall u. (forall d. Data d => d -> u) -> MaybeF f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (MaybeF f a)
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
MaybeF f a -> DataType
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
MaybeF f a -> Constr
forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u
forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> MaybeF f a -> [u]
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybeF f a)
forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)
forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a))
forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybeF f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybeF f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybeF f a))
$cMaybeF :: Constr
$tMaybeF :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
$cgmapMo :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
gmapMp :: (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
$cgmapMp :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), MonadPlus m) =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
gmapM :: (forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
$cgmapM :: forall k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Monad m) =>
(forall d. Data d => d -> m d) -> MaybeF f a -> m (MaybeF f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u
$cgmapQi :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Int -> (forall d. Data d => d -> u) -> MaybeF f a -> u
gmapQ :: (forall d. Data d => d -> u) -> MaybeF f a -> [u]
$cgmapQ :: forall k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d. Data d => d -> u) -> MaybeF f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
$cgmapQr :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
$cgmapQl :: forall k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MaybeF f a -> r
gmapT :: (forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a
$cgmapT :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b. Data b => b -> b) -> MaybeF f a -> MaybeF f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybeF f a))
$cdataCast2 :: forall k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MaybeF f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a))
$cdataCast1 :: forall k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a), Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MaybeF f a))
dataTypeOf :: MaybeF f a -> DataType
$cdataTypeOf :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
MaybeF f a -> DataType
toConstr :: MaybeF f a -> Constr
$ctoConstr :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
MaybeF f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybeF f a)
$cgunfold :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MaybeF f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)
$cgfoldl :: forall k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MaybeF f a -> c (MaybeF f a)
$cp1Data :: forall k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data (f a)) =>
Typeable (MaybeF f a)
Data)

deriveShow1 ''MaybeF
deriveRead1 ''MaybeF
deriveEq1 ''MaybeF
deriveOrd1 ''MaybeF

instance Applicative f => Applicative (MaybeF f) where
    pure :: a -> MaybeF f a
pure = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a)
-> (a -> Maybe (f a)) -> a -> MaybeF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Maybe (f a)
forall a. a -> Maybe a
Just (f a -> Maybe (f a)) -> (a -> f a) -> a -> Maybe (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
    MaybeF f :: Maybe (f (a -> b))
f <*> :: MaybeF f (a -> b) -> MaybeF f a -> MaybeF f b
<*> MaybeF x :: Maybe (f a)
x = Maybe (f b) -> MaybeF f b
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f b) -> MaybeF f b) -> Maybe (f b) -> MaybeF f b
forall a b. (a -> b) -> a -> b
$ (f (a -> b) -> f a -> f b)
-> Maybe (f (a -> b)) -> Maybe (f a) -> Maybe (f b)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
(<*>) Maybe (f (a -> b))
f Maybe (f a)
x

instance Functor f => Alt (MaybeF f) where
    <!> :: MaybeF f a -> MaybeF f a -> MaybeF f a
(<!>) = MaybeF f a -> MaybeF f a -> MaybeF f a
forall a. Semigroup a => a -> a -> a
(<>)

instance Functor f => Plus (MaybeF f) where
    zero :: MaybeF f a
zero = MaybeF f a
forall a. Monoid a => a
mempty

instance Applicative f => Alternative (MaybeF f) where
    empty :: MaybeF f a
empty = MaybeF f a
forall (f :: * -> *) a. Plus f => f a
zero
    <|> :: MaybeF f a -> MaybeF f a -> MaybeF f a
(<|>) = MaybeF f a -> MaybeF f a -> MaybeF f a
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
(<!>)

-- | @since 0.3.3.0
instance Contravariant f => Contravariant (MaybeF f) where
    contramap :: (a -> b) -> MaybeF f b -> MaybeF f a
contramap f :: a -> b
f (MaybeF x :: Maybe (f b)
x) = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a) -> Maybe (f a) -> MaybeF f a
forall a b. (a -> b) -> a -> b
$ ((f b -> f a) -> Maybe (f b) -> Maybe (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f b -> f a) -> Maybe (f b) -> Maybe (f a))
-> ((a -> b) -> f b -> f a)
-> (a -> b)
-> Maybe (f b)
-> Maybe (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) a -> b
f Maybe (f b)
x

-- | @since 0.3.3.0
instance Invariant f => Invariant (MaybeF f) where
    invmap :: (a -> b) -> (b -> a) -> MaybeF f a -> MaybeF f b
invmap f :: a -> b
f g :: b -> a
g (MaybeF x :: Maybe (f a)
x) = Maybe (f b) -> MaybeF f b
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f b) -> MaybeF f b) -> Maybe (f b) -> MaybeF f b
forall a b. (a -> b) -> a -> b
$ (f a -> f b) -> Maybe (f a) -> Maybe (f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((a -> b) -> (b -> a) -> f a -> f b
forall (f :: * -> *) a b.
Invariant f =>
(a -> b) -> (b -> a) -> f a -> f b
invmap a -> b
f b -> a
g) Maybe (f a)
x

-- | @since 0.3.3.0
instance Contravariant f => Divise (MaybeF f) where
    divise :: (a -> (b, c)) -> MaybeF f b -> MaybeF f c -> MaybeF f a
divise f :: a -> (b, c)
f (MaybeF x :: Maybe (f b)
x) (MaybeF y :: Maybe (f c)
y) = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a) -> Maybe (f a) -> MaybeF f a
forall a b. (a -> b) -> a -> b
$
          ((f b -> f a) -> Maybe (f b) -> Maybe (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f b -> f a) -> Maybe (f b) -> Maybe (f a))
-> ((a -> b) -> f b -> f a)
-> (a -> b)
-> Maybe (f b)
-> Maybe (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> f b -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> b
forall a b. (a, b) -> a
fst ((b, c) -> b) -> (a -> (b, c)) -> a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) Maybe (f b)
x
      Maybe (f a) -> Maybe (f a) -> Maybe (f a)
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((f c -> f a) -> Maybe (f c) -> Maybe (f a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((f c -> f a) -> Maybe (f c) -> Maybe (f a))
-> ((a -> c) -> f c -> f a)
-> (a -> c)
-> Maybe (f c)
-> Maybe (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> c) -> f c -> f a
forall (f :: * -> *) a b. Contravariant f => (a -> b) -> f b -> f a
contramap) ((b, c) -> c
forall a b. (a, b) -> b
snd ((b, c) -> c) -> (a -> (b, c)) -> a -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> (b, c)
f) Maybe (f c)
y

-- | @since 0.3.3.0
instance Contravariant f => Divisible (MaybeF f) where
    divide :: (a -> (b, c)) -> MaybeF f b -> MaybeF f c -> MaybeF f a
divide  = (a -> (b, c)) -> MaybeF f b -> MaybeF f c -> MaybeF f a
forall (f :: * -> *) a b c.
Divise f =>
(a -> (b, c)) -> f b -> f c -> f a
divise
    conquer :: MaybeF f a
conquer = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF Maybe (f a)
forall a. Maybe a
Nothing

-- | @since 0.3.3.0
instance Decide f => Decide (MaybeF f) where
    decide :: (a -> Either b c) -> MaybeF f b -> MaybeF f c -> MaybeF f a
decide f :: a -> Either b c
f (MaybeF x :: Maybe (f b)
x) (MaybeF y :: Maybe (f c)
y) = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a) -> Maybe (f a) -> MaybeF f a
forall a b. (a -> b) -> a -> b
$
        (f b -> f c -> f a) -> Maybe (f b) -> Maybe (f c) -> Maybe (f a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((a -> Either b c) -> f b -> f c -> f a
forall (f :: * -> *) a b c.
Decide f =>
(a -> Either b c) -> f b -> f c -> f a
decide a -> Either b c
f) Maybe (f b)
x Maybe (f c)
y

-- | @since 0.3.3.0
instance Conclude f => Conclude (MaybeF f) where
    conclude :: (a -> Void) -> MaybeF f a
conclude f :: a -> Void
f = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (f a -> Maybe (f a)
forall a. a -> Maybe a
Just ((a -> Void) -> f a
forall (f :: * -> *) a. Conclude f => (a -> Void) -> f a
conclude a -> Void
f))

-- | @since 0.3.3.0
instance Decidable f => Decidable (MaybeF f) where
    choose :: (a -> Either b c) -> MaybeF f b -> MaybeF f c -> MaybeF f a
choose f :: a -> Either b c
f (MaybeF x :: Maybe (f b)
x) (MaybeF y :: Maybe (f c)
y) = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a) -> Maybe (f a) -> MaybeF f a
forall a b. (a -> b) -> a -> b
$
        (f b -> f c -> f a) -> Maybe (f b) -> Maybe (f c) -> Maybe (f a)
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 ((a -> Either b c) -> f b -> f c -> f a
forall (f :: * -> *) a b c.
Decidable f =>
(a -> Either b c) -> f b -> f c -> f a
choose a -> Either b c
f) Maybe (f b)
x Maybe (f c)
y
    lose :: (a -> Void) -> MaybeF f a
lose f :: a -> Void
f = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (f a -> Maybe (f a)
forall a. a -> Maybe a
Just ((a -> Void) -> f a
forall (f :: * -> *) a. Decidable f => (a -> Void) -> f a
lose a -> Void
f))

-- | Picks the first 'Just'.
instance Semigroup (MaybeF f a) where
    MaybeF xs :: Maybe (f a)
xs <> :: MaybeF f a -> MaybeF f a -> MaybeF f a
<> MaybeF ys :: Maybe (f a)
ys = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a)
xs Maybe (f a) -> Maybe (f a) -> Maybe (f a)
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
<!> Maybe (f a)
ys)

instance Monoid (MaybeF f a) where
    mempty :: MaybeF f a
mempty = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF Maybe (f a)
forall a. Maybe a
Nothing

instance Pointed f => Pointed (MaybeF f) where
    point :: a -> MaybeF f a
point = Maybe (f a) -> MaybeF f a
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF (Maybe (f a) -> MaybeF f a)
-> (a -> Maybe (f a)) -> a -> MaybeF f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. f a -> Maybe (f a)
forall a. a -> Maybe a
Just (f a -> Maybe (f a)) -> (a -> f a) -> a -> Maybe (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (p :: * -> *) a. Pointed p => a -> p a
point

-- | Map a function over the inside of a 'MaybeF'.
mapMaybeF
    :: (Maybe (f a) -> Maybe (g b))
    -> MaybeF f a
    -> MaybeF g b
mapMaybeF :: (Maybe (f a) -> Maybe (g b)) -> MaybeF f a -> MaybeF g b
mapMaybeF = (Maybe (f a) -> Maybe (g b)) -> MaybeF f a -> MaybeF g b
forall a b. Coercible a b => a -> b
coerce

-- | Convert a 'MaybeF' into a 'ListF' with zero or one items.
maybeToListF :: MaybeF f ~> ListF f
maybeToListF :: MaybeF f x -> ListF f x
maybeToListF (MaybeF x :: Maybe (f x)
x) = [f x] -> ListF f x
forall k (f :: k -> *) (a :: k). [f a] -> ListF f a
ListF (Maybe (f x) -> [f x]
forall a. Maybe a -> [a]
maybeToList Maybe (f x)
x)

-- | Convert a 'ListF' into a 'MaybeF' containing the first @f a@ in the
-- list, if it exists.
listToMaybeF :: ListF f ~> MaybeF f
listToMaybeF :: ListF f x -> MaybeF f x
listToMaybeF (ListF xs :: [f x]
xs) = Maybe (f x) -> MaybeF f x
forall k (f :: k -> *) (a :: k). Maybe (f a) -> MaybeF f a
MaybeF ([f x] -> Maybe (f x)
forall a. [a] -> Maybe a
listToMaybe [f x]
xs)

-- | A map of @f a@s, indexed by keys of type @k@.  It can be useful for
-- represeting a product of many different values of type @f a@, each "at"
-- a different @k@ location.
--
-- Can be considered a combination of 'Control.Comonad.Trans.Env.EnvT' and
-- 'ListF', in a way --- a @'MapF' k f a@ is like a @'ListF'
-- ('Control.Comonad.Trans.Env.EnvT' k f) a@ with unique (and ordered)
-- keys.
--
-- One use case might be to extend a schema with many "options", indexed by
-- some string.
--
-- For example, if you had a command line argument parser for a single
-- command
--
-- @
-- data Command a
-- @
--
-- Then you can represent a command line argument parser for /multiple/
-- named commands with
--
-- @
-- type Commands = 'MapF' 'String' Command
-- @
--
-- See 'NEMapF' for a non-empty variant, if you want to enforce that your
-- bag has at least one @f a@.
newtype MapF k f a = MapF { MapF k f a -> Map k (f a)
runMapF :: M.Map k (f a) }
  deriving (Int -> MapF k f a -> ShowS
[MapF k f a] -> ShowS
MapF k f a -> String
(Int -> MapF k f a -> ShowS)
-> (MapF k f a -> String)
-> ([MapF k f a] -> ShowS)
-> Show (MapF k f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
Int -> MapF k f a -> ShowS
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
[MapF k f a] -> ShowS
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
MapF k f a -> String
showList :: [MapF k f a] -> ShowS
$cshowList :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
[MapF k f a] -> ShowS
show :: MapF k f a -> String
$cshow :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
MapF k f a -> String
showsPrec :: Int -> MapF k f a -> ShowS
$cshowsPrec :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
Int -> MapF k f a -> ShowS
Show, ReadPrec [MapF k f a]
ReadPrec (MapF k f a)
Int -> ReadS (MapF k f a)
ReadS [MapF k f a]
(Int -> ReadS (MapF k f a))
-> ReadS [MapF k f a]
-> ReadPrec (MapF k f a)
-> ReadPrec [MapF k f a]
-> Read (MapF k f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec [MapF k f a]
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec (MapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
Int -> ReadS (MapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadS [MapF k f a]
readListPrec :: ReadPrec [MapF k f a]
$creadListPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec [MapF k f a]
readPrec :: ReadPrec (MapF k f a)
$creadPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec (MapF k f a)
readList :: ReadS [MapF k f a]
$creadList :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadS [MapF k f a]
readsPrec :: Int -> ReadS (MapF k f a)
$creadsPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
Int -> ReadS (MapF k f a)
Read, MapF k f a -> MapF k f a -> Bool
(MapF k f a -> MapF k f a -> Bool)
-> (MapF k f a -> MapF k f a -> Bool) -> Eq (MapF k f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
MapF k f a -> MapF k f a -> Bool
/= :: MapF k f a -> MapF k f a -> Bool
$c/= :: forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
MapF k f a -> MapF k f a -> Bool
== :: MapF k f a -> MapF k f a -> Bool
$c== :: forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
MapF k f a -> MapF k f a -> Bool
Eq, Eq (MapF k f a)
Eq (MapF k f a) =>
(MapF k f a -> MapF k f a -> Ordering)
-> (MapF k f a -> MapF k f a -> Bool)
-> (MapF k f a -> MapF k f a -> Bool)
-> (MapF k f a -> MapF k f a -> Bool)
-> (MapF k f a -> MapF k f a -> Bool)
-> (MapF k f a -> MapF k f a -> MapF k f a)
-> (MapF k f a -> MapF k f a -> MapF k f a)
-> Ord (MapF k f a)
MapF k f a -> MapF k f a -> Bool
MapF k f a -> MapF k f a -> Ordering
MapF k f a -> MapF k f a -> MapF k f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
Eq (MapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Bool
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Ordering
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> MapF k f a
min :: MapF k f a -> MapF k f a -> MapF k f a
$cmin :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> MapF k f a
max :: MapF k f a -> MapF k f a -> MapF k f a
$cmax :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> MapF k f a
>= :: MapF k f a -> MapF k f a -> Bool
$c>= :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Bool
> :: MapF k f a -> MapF k f a -> Bool
$c> :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Bool
<= :: MapF k f a -> MapF k f a -> Bool
$c<= :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Bool
< :: MapF k f a -> MapF k f a -> Bool
$c< :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Bool
compare :: MapF k f a -> MapF k f a -> Ordering
$ccompare :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
MapF k f a -> MapF k f a -> Ordering
$cp1Ord :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
Eq (MapF k f a)
Ord, a -> MapF k f b -> MapF k f a
(a -> b) -> MapF k f a -> MapF k f b
(forall a b. (a -> b) -> MapF k f a -> MapF k f b)
-> (forall a b. a -> MapF k f b -> MapF k f a)
-> Functor (MapF k f)
forall a b. a -> MapF k f b -> MapF k f a
forall a b. (a -> b) -> MapF k f a -> MapF k f b
forall k (f :: * -> *) a b.
Functor f =>
a -> MapF k f b -> MapF k f a
forall k (f :: * -> *) a b.
Functor f =>
(a -> b) -> MapF k f a -> MapF k f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> MapF k f b -> MapF k f a
$c<$ :: forall k (f :: * -> *) a b.
Functor f =>
a -> MapF k f b -> MapF k f a
fmap :: (a -> b) -> MapF k f a -> MapF k f b
$cfmap :: forall k (f :: * -> *) a b.
Functor f =>
(a -> b) -> MapF k f a -> MapF k f b
Functor, MapF k f a -> Bool
(a -> m) -> MapF k f a -> m
(a -> b -> b) -> b -> MapF k f a -> b
(forall m. Monoid m => MapF k f m -> m)
-> (forall m a. Monoid m => (a -> m) -> MapF k f a -> m)
-> (forall m a. Monoid m => (a -> m) -> MapF k f a -> m)
-> (forall a b. (a -> b -> b) -> b -> MapF k f a -> b)
-> (forall a b. (a -> b -> b) -> b -> MapF k f a -> b)
-> (forall b a. (b -> a -> b) -> b -> MapF k f a -> b)
-> (forall b a. (b -> a -> b) -> b -> MapF k f a -> b)
-> (forall a. (a -> a -> a) -> MapF k f a -> a)
-> (forall a. (a -> a -> a) -> MapF k f a -> a)
-> (forall a. MapF k f a -> [a])
-> (forall a. MapF k f a -> Bool)
-> (forall a. MapF k f a -> Int)
-> (forall a. Eq a => a -> MapF k f a -> Bool)
-> (forall a. Ord a => MapF k f a -> a)
-> (forall a. Ord a => MapF k f a -> a)
-> (forall a. Num a => MapF k f a -> a)
-> (forall a. Num a => MapF k f a -> a)
-> Foldable (MapF k f)
forall a. Eq a => a -> MapF k f a -> Bool
forall a. Num a => MapF k f a -> a
forall a. Ord a => MapF k f a -> a
forall m. Monoid m => MapF k f m -> m
forall a. MapF k f a -> Bool
forall a. MapF k f a -> Int
forall a. MapF k f a -> [a]
forall a. (a -> a -> a) -> MapF k f a -> a
forall m a. Monoid m => (a -> m) -> MapF k f a -> m
forall b a. (b -> a -> b) -> b -> MapF k f a -> b
forall a b. (a -> b -> b) -> b -> MapF k f a -> b
forall k (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> MapF k f a -> Bool
forall k (f :: * -> *) a. (Foldable f, Num a) => MapF k f a -> a
forall k (f :: * -> *) a. (Foldable f, Ord a) => MapF k f a -> a
forall k (f :: * -> *) m. (Foldable f, Monoid m) => MapF k f m -> m
forall k (f :: * -> *) a. Foldable f => MapF k f a -> Bool
forall k (f :: * -> *) a. Foldable f => MapF k f a -> Int
forall k (f :: * -> *) a. Foldable f => MapF k f a -> [a]
forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MapF k f a -> a
forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MapF k f a -> m
forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MapF k f a -> b
forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MapF k f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: MapF k f a -> a
$cproduct :: forall k (f :: * -> *) a. (Foldable f, Num a) => MapF k f a -> a
sum :: MapF k f a -> a
$csum :: forall k (f :: * -> *) a. (Foldable f, Num a) => MapF k f a -> a
minimum :: MapF k f a -> a
$cminimum :: forall k (f :: * -> *) a. (Foldable f, Ord a) => MapF k f a -> a
maximum :: MapF k f a -> a
$cmaximum :: forall k (f :: * -> *) a. (Foldable f, Ord a) => MapF k f a -> a
elem :: a -> MapF k f a -> Bool
$celem :: forall k (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> MapF k f a -> Bool
length :: MapF k f a -> Int
$clength :: forall k (f :: * -> *) a. Foldable f => MapF k f a -> Int
null :: MapF k f a -> Bool
$cnull :: forall k (f :: * -> *) a. Foldable f => MapF k f a -> Bool
toList :: MapF k f a -> [a]
$ctoList :: forall k (f :: * -> *) a. Foldable f => MapF k f a -> [a]
foldl1 :: (a -> a -> a) -> MapF k f a -> a
$cfoldl1 :: forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MapF k f a -> a
foldr1 :: (a -> a -> a) -> MapF k f a -> a
$cfoldr1 :: forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> MapF k f a -> a
foldl' :: (b -> a -> b) -> b -> MapF k f a -> b
$cfoldl' :: forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MapF k f a -> b
foldl :: (b -> a -> b) -> b -> MapF k f a -> b
$cfoldl :: forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> MapF k f a -> b
foldr' :: (a -> b -> b) -> b -> MapF k f a -> b
$cfoldr' :: forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MapF k f a -> b
foldr :: (a -> b -> b) -> b -> MapF k f a -> b
$cfoldr :: forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> MapF k f a -> b
foldMap' :: (a -> m) -> MapF k f a -> m
$cfoldMap' :: forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MapF k f a -> m
foldMap :: (a -> m) -> MapF k f a -> m
$cfoldMap :: forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> MapF k f a -> m
fold :: MapF k f m -> m
$cfold :: forall k (f :: * -> *) m. (Foldable f, Monoid m) => MapF k f m -> m
Foldable, Functor (MapF k f)
Foldable (MapF k f)
(Functor (MapF k f), Foldable (MapF k f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> MapF k f a -> f (MapF k f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    MapF k f (f a) -> f (MapF k f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> MapF k f a -> m (MapF k f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    MapF k f (m a) -> m (MapF k f a))
-> Traversable (MapF k f)
(a -> f b) -> MapF k f a -> f (MapF k f b)
forall k (f :: * -> *). Traversable f => Functor (MapF k f)
forall k (f :: * -> *). Traversable f => Foldable (MapF k f)
forall k (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
MapF k f (m a) -> m (MapF k f a)
forall k (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
MapF k f (f a) -> f (MapF k f a)
forall k (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> MapF k f a -> m (MapF k f b)
forall k (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> MapF k f a -> f (MapF k f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => MapF k f (m a) -> m (MapF k f a)
forall (f :: * -> *) a.
Applicative f =>
MapF k f (f a) -> f (MapF k f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> MapF k f a -> m (MapF k f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> MapF k f a -> f (MapF k f b)
sequence :: MapF k f (m a) -> m (MapF k f a)
$csequence :: forall k (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
MapF k f (m a) -> m (MapF k f a)
mapM :: (a -> m b) -> MapF k f a -> m (MapF k f b)
$cmapM :: forall k (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> MapF k f a -> m (MapF k f b)
sequenceA :: MapF k f (f a) -> f (MapF k f a)
$csequenceA :: forall k (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
MapF k f (f a) -> f (MapF k f a)
traverse :: (a -> f b) -> MapF k f a -> f (MapF k f b)
$ctraverse :: forall k (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> MapF k f a -> f (MapF k f b)
$cp2Traversable :: forall k (f :: * -> *). Traversable f => Foldable (MapF k f)
$cp1Traversable :: forall k (f :: * -> *). Traversable f => Functor (MapF k f)
Traversable, Typeable, (forall x. MapF k f a -> Rep (MapF k f a) x)
-> (forall x. Rep (MapF k f a) x -> MapF k f a)
-> Generic (MapF k f a)
forall x. Rep (MapF k f a) x -> MapF k f a
forall x. MapF k f a -> Rep (MapF k f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k k (f :: k -> *) (a :: k) x.
Rep (MapF k f a) x -> MapF k f a
forall k k (f :: k -> *) (a :: k) x.
MapF k f a -> Rep (MapF k f a) x
$cto :: forall k k (f :: k -> *) (a :: k) x.
Rep (MapF k f a) x -> MapF k f a
$cfrom :: forall k k (f :: k -> *) (a :: k) x.
MapF k f a -> Rep (MapF k f a) x
Generic, Typeable (MapF k f a)
DataType
Constr
Typeable (MapF k f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (MapF k f a))
-> (MapF k f a -> Constr)
-> (MapF k f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (MapF k f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (MapF k f a)))
-> ((forall b. Data b => b -> b) -> MapF k f a -> MapF k f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MapF k f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MapF k f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> MapF k f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> MapF k f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a))
-> Data (MapF k f a)
MapF k f a -> DataType
MapF k f a -> Constr
(forall b. Data b => b -> b) -> MapF k f a -> MapF k f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapF k f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> MapF k f a -> u
forall u. (forall d. Data d => d -> u) -> MapF k f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Typeable (MapF k f a)
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
MapF k f a -> DataType
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
MapF k f a -> Constr
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b. Data b => b -> b) -> MapF k f a -> MapF k f a
forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Int -> (forall d. Data d => d -> u) -> MapF k f a -> u
forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d. Data d => d -> u) -> MapF k f a -> [u]
forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Monad m) =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapF k f a)
forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)
forall k k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MapF k f a))
forall k k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapF k f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapF k f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (MapF k f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapF k f a))
$cMapF :: Constr
$tMapF :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
$cgmapMo :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
gmapMp :: (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
$cgmapMp :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
gmapM :: (forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
$cgmapM :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Monad m) =>
(forall d. Data d => d -> m d) -> MapF k f a -> m (MapF k f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> MapF k f a -> u
$cgmapQi :: forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Int -> (forall d. Data d => d -> u) -> MapF k f a -> u
gmapQ :: (forall d. Data d => d -> u) -> MapF k f a -> [u]
$cgmapQ :: forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d. Data d => d -> u) -> MapF k f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
$cgmapQr :: forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
$cgmapQl :: forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MapF k f a -> r
gmapT :: (forall b. Data b => b -> b) -> MapF k f a -> MapF k f a
$cgmapT :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b. Data b => b -> b) -> MapF k f a -> MapF k f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapF k f a))
$cdataCast2 :: forall k k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (MapF k f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (MapF k f a))
$cdataCast1 :: forall k k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (MapF k f a))
dataTypeOf :: MapF k f a -> DataType
$cdataTypeOf :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
MapF k f a -> DataType
toConstr :: MapF k f a -> Constr
$ctoConstr :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
MapF k f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapF k f a)
$cgunfold :: forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (MapF k f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)
$cgfoldl :: forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MapF k f a -> c (MapF k f a)
$cp1Data :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Typeable (MapF k f a)
Data)

deriveShow1 ''MapF
deriveEq1 ''MapF
deriveOrd1 ''MapF

instance (Ord k, Read k, Read1 f) => Read1 (MapF k f) where
    liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MapF k f a)
liftReadsPrec = $(makeLiftReadsPrec ''MapF)

-- | A union, combining matching keys with '<!>'.
instance (Ord k, Alt f) => Semigroup (MapF k f a) where
    MapF xs :: Map k (f a)
xs <> :: MapF k f a -> MapF k f a -> MapF k f a
<> MapF ys :: Map k (f a)
ys = Map k (f a) -> MapF k f a
forall k k (f :: k -> *) (a :: k). Map k (f a) -> MapF k f a
MapF (Map k (f a) -> MapF k f a) -> Map k (f a) -> MapF k f a
forall a b. (a -> b) -> a -> b
$ (f a -> f a -> f a) -> Map k (f a) -> Map k (f a) -> Map k (f a)
forall k a. Ord k => (a -> a -> a) -> Map k a -> Map k a -> Map k a
M.unionWith f a -> f a -> f a
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
(<!>) Map k (f a)
xs Map k (f a)
ys

instance (Ord k, Alt f) => Monoid (MapF k f a) where
    mempty :: MapF k f a
mempty = Map k (f a) -> MapF k f a
forall k k (f :: k -> *) (a :: k). Map k (f a) -> MapF k f a
MapF Map k (f a)
forall k a. Map k a
M.empty

-- | Left-biased union
instance (Functor f, Ord k) => Alt (MapF k f) where
    MapF xs :: Map k (f a)
xs <!> :: MapF k f a -> MapF k f a -> MapF k f a
<!> MapF ys :: Map k (f a)
ys = Map k (f a) -> MapF k f a
forall k k (f :: k -> *) (a :: k). Map k (f a) -> MapF k f a
MapF (Map k (f a) -> MapF k f a) -> Map k (f a) -> MapF k f a
forall a b. (a -> b) -> a -> b
$ Map k (f a) -> Map k (f a) -> Map k (f a)
forall k a. Ord k => Map k a -> Map k a -> Map k a
M.union Map k (f a)
xs Map k (f a)
ys

instance (Functor f, Ord k) => Plus (MapF k f) where
    zero :: MapF k f a
zero = Map k (f a) -> MapF k f a
forall k k (f :: k -> *) (a :: k). Map k (f a) -> MapF k f a
MapF Map k (f a)
forall k a. Map k a
M.empty

instance (Monoid k, Pointed f) => Pointed (MapF k f) where
    point :: a -> MapF k f a
point = Map k (f a) -> MapF k f a
forall k k (f :: k -> *) (a :: k). Map k (f a) -> MapF k f a
MapF (Map k (f a) -> MapF k f a)
-> (a -> Map k (f a)) -> a -> MapF k f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> f a -> Map k (f a)
forall k a. k -> a -> Map k a
M.singleton k
forall a. Monoid a => a
mempty (f a -> Map k (f a)) -> (a -> f a) -> a -> Map k (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (p :: * -> *) a. Pointed p => a -> p a
point

-- | A non-empty map of @f a@s, indexed by keys of type @k@.  It can be
-- useful for represeting a product of many different values of type @f a@,
-- each "at" a different @k@ location, where you need to have at least one
-- @f a@ at all times.
--
-- Can be considered a combination of 'Control.Comonad.Trans.Env.EnvT' and
-- 'NonEmptyF', in a way --- an @'NEMapF' k f a@ is like a @'NonEmptyF'
-- ('Control.Comonad.Trans.Env.EnvT' k f) a@ with unique (and ordered)
-- keys.
--
-- See 'MapF' for some use cases.
newtype NEMapF k f a = NEMapF { NEMapF k f a -> NEMap k (f a)
runNEMapF :: NEM.NEMap k (f a) }
  deriving (Int -> NEMapF k f a -> ShowS
[NEMapF k f a] -> ShowS
NEMapF k f a -> String
(Int -> NEMapF k f a -> ShowS)
-> (NEMapF k f a -> String)
-> ([NEMapF k f a] -> ShowS)
-> Show (NEMapF k f a)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
Int -> NEMapF k f a -> ShowS
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
[NEMapF k f a] -> ShowS
forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
NEMapF k f a -> String
showList :: [NEMapF k f a] -> ShowS
$cshowList :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
[NEMapF k f a] -> ShowS
show :: NEMapF k f a -> String
$cshow :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
NEMapF k f a -> String
showsPrec :: Int -> NEMapF k f a -> ShowS
$cshowsPrec :: forall k k (f :: k -> *) (a :: k).
(Show k, Show (f a)) =>
Int -> NEMapF k f a -> ShowS
Show, ReadPrec [NEMapF k f a]
ReadPrec (NEMapF k f a)
Int -> ReadS (NEMapF k f a)
ReadS [NEMapF k f a]
(Int -> ReadS (NEMapF k f a))
-> ReadS [NEMapF k f a]
-> ReadPrec (NEMapF k f a)
-> ReadPrec [NEMapF k f a]
-> Read (NEMapF k f a)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec [NEMapF k f a]
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec (NEMapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
Int -> ReadS (NEMapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadS [NEMapF k f a]
readListPrec :: ReadPrec [NEMapF k f a]
$creadListPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec [NEMapF k f a]
readPrec :: ReadPrec (NEMapF k f a)
$creadPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadPrec (NEMapF k f a)
readList :: ReadS [NEMapF k f a]
$creadList :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
ReadS [NEMapF k f a]
readsPrec :: Int -> ReadS (NEMapF k f a)
$creadsPrec :: forall k k (f :: k -> *) (a :: k).
(Ord k, Read k, Read (f a)) =>
Int -> ReadS (NEMapF k f a)
Read, NEMapF k f a -> NEMapF k f a -> Bool
(NEMapF k f a -> NEMapF k f a -> Bool)
-> (NEMapF k f a -> NEMapF k f a -> Bool) -> Eq (NEMapF k f a)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
/= :: NEMapF k f a -> NEMapF k f a -> Bool
$c/= :: forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
== :: NEMapF k f a -> NEMapF k f a -> Bool
$c== :: forall k k (f :: k -> *) (a :: k).
(Eq k, Eq (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
Eq, Eq (NEMapF k f a)
Eq (NEMapF k f a) =>
(NEMapF k f a -> NEMapF k f a -> Ordering)
-> (NEMapF k f a -> NEMapF k f a -> Bool)
-> (NEMapF k f a -> NEMapF k f a -> Bool)
-> (NEMapF k f a -> NEMapF k f a -> Bool)
-> (NEMapF k f a -> NEMapF k f a -> Bool)
-> (NEMapF k f a -> NEMapF k f a -> NEMapF k f a)
-> (NEMapF k f a -> NEMapF k f a -> NEMapF k f a)
-> Ord (NEMapF k f a)
NEMapF k f a -> NEMapF k f a -> Bool
NEMapF k f a -> NEMapF k f a -> Ordering
NEMapF k f a -> NEMapF k f a -> NEMapF k f a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
Eq (NEMapF k f a)
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Ordering
forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> NEMapF k f a
min :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a
$cmin :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> NEMapF k f a
max :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a
$cmax :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> NEMapF k f a
>= :: NEMapF k f a -> NEMapF k f a -> Bool
$c>= :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
> :: NEMapF k f a -> NEMapF k f a -> Bool
$c> :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
<= :: NEMapF k f a -> NEMapF k f a -> Bool
$c<= :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
< :: NEMapF k f a -> NEMapF k f a -> Bool
$c< :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Bool
compare :: NEMapF k f a -> NEMapF k f a -> Ordering
$ccompare :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
NEMapF k f a -> NEMapF k f a -> Ordering
$cp1Ord :: forall k k (f :: k -> *) (a :: k).
(Ord k, Ord (f a)) =>
Eq (NEMapF k f a)
Ord, a -> NEMapF k f b -> NEMapF k f a
(a -> b) -> NEMapF k f a -> NEMapF k f b
(forall a b. (a -> b) -> NEMapF k f a -> NEMapF k f b)
-> (forall a b. a -> NEMapF k f b -> NEMapF k f a)
-> Functor (NEMapF k f)
forall a b. a -> NEMapF k f b -> NEMapF k f a
forall a b. (a -> b) -> NEMapF k f a -> NEMapF k f b
forall k (f :: * -> *) a b.
Functor f =>
a -> NEMapF k f b -> NEMapF k f a
forall k (f :: * -> *) a b.
Functor f =>
(a -> b) -> NEMapF k f a -> NEMapF k f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> NEMapF k f b -> NEMapF k f a
$c<$ :: forall k (f :: * -> *) a b.
Functor f =>
a -> NEMapF k f b -> NEMapF k f a
fmap :: (a -> b) -> NEMapF k f a -> NEMapF k f b
$cfmap :: forall k (f :: * -> *) a b.
Functor f =>
(a -> b) -> NEMapF k f a -> NEMapF k f b
Functor, NEMapF k f a -> Bool
(a -> m) -> NEMapF k f a -> m
(a -> b -> b) -> b -> NEMapF k f a -> b
(forall m. Monoid m => NEMapF k f m -> m)
-> (forall m a. Monoid m => (a -> m) -> NEMapF k f a -> m)
-> (forall m a. Monoid m => (a -> m) -> NEMapF k f a -> m)
-> (forall a b. (a -> b -> b) -> b -> NEMapF k f a -> b)
-> (forall a b. (a -> b -> b) -> b -> NEMapF k f a -> b)
-> (forall b a. (b -> a -> b) -> b -> NEMapF k f a -> b)
-> (forall b a. (b -> a -> b) -> b -> NEMapF k f a -> b)
-> (forall a. (a -> a -> a) -> NEMapF k f a -> a)
-> (forall a. (a -> a -> a) -> NEMapF k f a -> a)
-> (forall a. NEMapF k f a -> [a])
-> (forall a. NEMapF k f a -> Bool)
-> (forall a. NEMapF k f a -> Int)
-> (forall a. Eq a => a -> NEMapF k f a -> Bool)
-> (forall a. Ord a => NEMapF k f a -> a)
-> (forall a. Ord a => NEMapF k f a -> a)
-> (forall a. Num a => NEMapF k f a -> a)
-> (forall a. Num a => NEMapF k f a -> a)
-> Foldable (NEMapF k f)
forall a. Eq a => a -> NEMapF k f a -> Bool
forall a. Num a => NEMapF k f a -> a
forall a. Ord a => NEMapF k f a -> a
forall m. Monoid m => NEMapF k f m -> m
forall a. NEMapF k f a -> Bool
forall a. NEMapF k f a -> Int
forall a. NEMapF k f a -> [a]
forall a. (a -> a -> a) -> NEMapF k f a -> a
forall m a. Monoid m => (a -> m) -> NEMapF k f a -> m
forall b a. (b -> a -> b) -> b -> NEMapF k f a -> b
forall a b. (a -> b -> b) -> b -> NEMapF k f a -> b
forall k (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> NEMapF k f a -> Bool
forall k (f :: * -> *) a. (Foldable f, Num a) => NEMapF k f a -> a
forall k (f :: * -> *) a. (Foldable f, Ord a) => NEMapF k f a -> a
forall k (f :: * -> *) m.
(Foldable f, Monoid m) =>
NEMapF k f m -> m
forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> Bool
forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> Int
forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> [a]
forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NEMapF k f a -> a
forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NEMapF k f a -> m
forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NEMapF k f a -> b
forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NEMapF k f a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: NEMapF k f a -> a
$cproduct :: forall k (f :: * -> *) a. (Foldable f, Num a) => NEMapF k f a -> a
sum :: NEMapF k f a -> a
$csum :: forall k (f :: * -> *) a. (Foldable f, Num a) => NEMapF k f a -> a
minimum :: NEMapF k f a -> a
$cminimum :: forall k (f :: * -> *) a. (Foldable f, Ord a) => NEMapF k f a -> a
maximum :: NEMapF k f a -> a
$cmaximum :: forall k (f :: * -> *) a. (Foldable f, Ord a) => NEMapF k f a -> a
elem :: a -> NEMapF k f a -> Bool
$celem :: forall k (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> NEMapF k f a -> Bool
length :: NEMapF k f a -> Int
$clength :: forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> Int
null :: NEMapF k f a -> Bool
$cnull :: forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> Bool
toList :: NEMapF k f a -> [a]
$ctoList :: forall k (f :: * -> *) a. Foldable f => NEMapF k f a -> [a]
foldl1 :: (a -> a -> a) -> NEMapF k f a -> a
$cfoldl1 :: forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NEMapF k f a -> a
foldr1 :: (a -> a -> a) -> NEMapF k f a -> a
$cfoldr1 :: forall k (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> NEMapF k f a -> a
foldl' :: (b -> a -> b) -> b -> NEMapF k f a -> b
$cfoldl' :: forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NEMapF k f a -> b
foldl :: (b -> a -> b) -> b -> NEMapF k f a -> b
$cfoldl :: forall k (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> NEMapF k f a -> b
foldr' :: (a -> b -> b) -> b -> NEMapF k f a -> b
$cfoldr' :: forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NEMapF k f a -> b
foldr :: (a -> b -> b) -> b -> NEMapF k f a -> b
$cfoldr :: forall k (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> NEMapF k f a -> b
foldMap' :: (a -> m) -> NEMapF k f a -> m
$cfoldMap' :: forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NEMapF k f a -> m
foldMap :: (a -> m) -> NEMapF k f a -> m
$cfoldMap :: forall k (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> NEMapF k f a -> m
fold :: NEMapF k f m -> m
$cfold :: forall k (f :: * -> *) m.
(Foldable f, Monoid m) =>
NEMapF k f m -> m
Foldable, Functor (NEMapF k f)
Foldable (NEMapF k f)
(Functor (NEMapF k f), Foldable (NEMapF k f)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> NEMapF k f a -> f (NEMapF k f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    NEMapF k f (f a) -> f (NEMapF k f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> NEMapF k f a -> m (NEMapF k f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    NEMapF k f (m a) -> m (NEMapF k f a))
-> Traversable (NEMapF k f)
(a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
forall k (f :: * -> *). Traversable f => Functor (NEMapF k f)
forall k (f :: * -> *). Traversable f => Foldable (NEMapF k f)
forall k (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
NEMapF k f (m a) -> m (NEMapF k f a)
forall k (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
NEMapF k f (f a) -> f (NEMapF k f a)
forall k (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> NEMapF k f a -> m (NEMapF k f b)
forall k (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
NEMapF k f (m a) -> m (NEMapF k f a)
forall (f :: * -> *) a.
Applicative f =>
NEMapF k f (f a) -> f (NEMapF k f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> NEMapF k f a -> m (NEMapF k f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
sequence :: NEMapF k f (m a) -> m (NEMapF k f a)
$csequence :: forall k (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
NEMapF k f (m a) -> m (NEMapF k f a)
mapM :: (a -> m b) -> NEMapF k f a -> m (NEMapF k f b)
$cmapM :: forall k (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> NEMapF k f a -> m (NEMapF k f b)
sequenceA :: NEMapF k f (f a) -> f (NEMapF k f a)
$csequenceA :: forall k (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
NEMapF k f (f a) -> f (NEMapF k f a)
traverse :: (a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
$ctraverse :: forall k (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
$cp2Traversable :: forall k (f :: * -> *). Traversable f => Foldable (NEMapF k f)
$cp1Traversable :: forall k (f :: * -> *). Traversable f => Functor (NEMapF k f)
Traversable, Typeable, (forall x. NEMapF k f a -> Rep (NEMapF k f a) x)
-> (forall x. Rep (NEMapF k f a) x -> NEMapF k f a)
-> Generic (NEMapF k f a)
forall x. Rep (NEMapF k f a) x -> NEMapF k f a
forall x. NEMapF k f a -> Rep (NEMapF k f a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall k k (f :: k -> *) (a :: k) x.
Rep (NEMapF k f a) x -> NEMapF k f a
forall k k (f :: k -> *) (a :: k) x.
NEMapF k f a -> Rep (NEMapF k f a) x
$cto :: forall k k (f :: k -> *) (a :: k) x.
Rep (NEMapF k f a) x -> NEMapF k f a
$cfrom :: forall k k (f :: k -> *) (a :: k) x.
NEMapF k f a -> Rep (NEMapF k f a) x
Generic, Typeable (NEMapF k f a)
DataType
Constr
Typeable (NEMapF k f a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (NEMapF k f a))
-> (NEMapF k f a -> Constr)
-> (NEMapF k f a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (NEMapF k f a)))
-> ((forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r)
-> (forall u. (forall d. Data d => d -> u) -> NEMapF k f a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a))
-> Data (NEMapF k f a)
NEMapF k f a -> DataType
NEMapF k f a -> Constr
(forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u
forall u. (forall d. Data d => d -> u) -> NEMapF k f a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Typeable (NEMapF k f a)
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
NEMapF k f a -> DataType
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
NEMapF k f a -> Constr
forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a
forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u
forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d. Data d => d -> u) -> NEMapF k f a -> [u]
forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Monad m) =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)
forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)
forall k k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a))
forall k k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NEMapF k f a))
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NEMapF k f a))
$cNEMapF :: Constr
$tNEMapF :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
$cgmapMo :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
gmapMp :: (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
$cgmapMp :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 MonadPlus m) =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
gmapM :: (forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
$cgmapM :: forall k k (f :: k -> *) (a :: k) (m :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Monad m) =>
(forall d. Data d => d -> m d) -> NEMapF k f a -> m (NEMapF k f a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u
$cgmapQi :: forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Int -> (forall d. Data d => d -> u) -> NEMapF k f a -> u
gmapQ :: (forall d. Data d => d -> u) -> NEMapF k f a -> [u]
$cgmapQ :: forall k k (f :: k -> *) (a :: k) u.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d. Data d => d -> u) -> NEMapF k f a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
$cgmapQr :: forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
$cgmapQl :: forall k k (f :: k -> *) (a :: k) r r'.
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NEMapF k f a -> r
gmapT :: (forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a
$cgmapT :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b. Data b => b -> b) -> NEMapF k f a -> NEMapF k f a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NEMapF k f a))
$cdataCast2 :: forall k k (f :: k -> *) (a :: k) (t :: * -> * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (NEMapF k f a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a))
$cdataCast1 :: forall k k (f :: k -> *) (a :: k) (t :: * -> *) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k,
 Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (NEMapF k f a))
dataTypeOf :: NEMapF k f a -> DataType
$cdataTypeOf :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
NEMapF k f a -> DataType
toConstr :: NEMapF k f a -> Constr
$ctoConstr :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
NEMapF k f a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)
$cgunfold :: forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (NEMapF k f a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)
$cgfoldl :: forall k k (f :: k -> *) (a :: k) (c :: * -> *).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NEMapF k f a -> c (NEMapF k f a)
$cp1Data :: forall k k (f :: k -> *) (a :: k).
(Typeable a, Typeable f, Typeable k, Data k, Data (f a), Ord k) =>
Typeable (NEMapF k f a)
Data)

deriveShow1 ''NEMapF
deriveEq1 ''NEMapF
deriveOrd1 ''NEMapF

instance (Ord k, Read k, Read1 f) => Read1 (NEMapF k f) where
    liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (NEMapF k f a)
liftReadsPrec = $(makeLiftReadsPrec ''NEMapF)

instance Foldable1 f => Foldable1 (NEMapF k f) where
    fold1 :: NEMapF k f m -> m
fold1      = (f m -> m) -> NEMap k (f m) -> m
forall (t :: * -> *) m a.
(Foldable1 t, Semigroup m) =>
(a -> m) -> t a -> m
foldMap1 f m -> m
forall (t :: * -> *) m. (Foldable1 t, Semigroup m) => t m -> m
fold1 (NEMap k (f m) -> m)
-> (NEMapF k f m -> NEMap k (f m)) -> NEMapF k f m -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMapF k f m -> NEMap k (f m)
forall k k (f :: k -> *) (a :: k). NEMapF k f a -> NEMap k (f a)
runNEMapF
    foldMap1 :: (a -> m) -> NEMapF k f a -> m
foldMap1 f :: a -> m
f = ((f a -> m) -> NEMap k (f a) -> m
forall (t :: * -> *) m a.
(Foldable1 t, Semigroup m) =>
(a -> m) -> t a -> m
foldMap1 ((f a -> m) -> NEMap k (f a) -> m)
-> ((a -> m) -> f a -> m) -> (a -> m) -> NEMap k (f a) -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> m) -> f a -> m
forall (t :: * -> *) m a.
(Foldable1 t, Semigroup m) =>
(a -> m) -> t a -> m
foldMap1) a -> m
f (NEMap k (f a) -> m)
-> (NEMapF k f a -> NEMap k (f a)) -> NEMapF k f a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMapF k f a -> NEMap k (f a)
forall k k (f :: k -> *) (a :: k). NEMapF k f a -> NEMap k (f a)
runNEMapF
    toNonEmpty :: NEMapF k f a -> NonEmpty a
toNonEmpty = (f a -> NonEmpty a) -> NEMap k (f a) -> NonEmpty a
forall (t :: * -> *) m a.
(Foldable1 t, Semigroup m) =>
(a -> m) -> t a -> m
foldMap1 f a -> NonEmpty a
forall (t :: * -> *) a. Foldable1 t => t a -> NonEmpty a
toNonEmpty (NEMap k (f a) -> NonEmpty a)
-> (NEMapF k f a -> NEMap k (f a)) -> NEMapF k f a -> NonEmpty a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMapF k f a -> NEMap k (f a)
forall k k (f :: k -> *) (a :: k). NEMapF k f a -> NEMap k (f a)
runNEMapF

instance Traversable1 f => Traversable1 (NEMapF k f) where
    traverse1 :: (a -> f b) -> NEMapF k f a -> f (NEMapF k f b)
traverse1 f :: a -> f b
f = (NEMap k (f b) -> NEMapF k f b)
-> f (NEMap k (f b)) -> f (NEMapF k f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NEMap k (f b) -> NEMapF k f b
forall k k (f :: k -> *) (a :: k). NEMap k (f a) -> NEMapF k f a
NEMapF (f (NEMap k (f b)) -> f (NEMapF k f b))
-> (NEMapF k f a -> f (NEMap k (f b)))
-> NEMapF k f a
-> f (NEMapF k f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((f a -> f (f b)) -> NEMap k (f a) -> f (NEMap k (f b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
traverse1 ((f a -> f (f b)) -> NEMap k (f a) -> f (NEMap k (f b)))
-> ((a -> f b) -> f a -> f (f b))
-> (a -> f b)
-> NEMap k (f a)
-> f (NEMap k (f b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> f a -> f (f b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
traverse1) a -> f b
f (NEMap k (f a) -> f (NEMap k (f b)))
-> (NEMapF k f a -> NEMap k (f a))
-> NEMapF k f a
-> f (NEMap k (f b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMapF k f a -> NEMap k (f a)
forall k k (f :: k -> *) (a :: k). NEMapF k f a -> NEMap k (f a)
runNEMapF
    sequence1 :: NEMapF k f (f b) -> f (NEMapF k f b)
sequence1   = (NEMap k (f b) -> NEMapF k f b)
-> f (NEMap k (f b)) -> f (NEMapF k f b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap NEMap k (f b) -> NEMapF k f b
forall k k (f :: k -> *) (a :: k). NEMap k (f a) -> NEMapF k f a
NEMapF (f (NEMap k (f b)) -> f (NEMapF k f b))
-> (NEMapF k f (f b) -> f (NEMap k (f b)))
-> NEMapF k f (f b)
-> f (NEMapF k f b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f (f b) -> f (f b)) -> NEMap k (f (f b)) -> f (NEMap k (f b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable1 t, Apply f) =>
(a -> f b) -> t a -> f (t b)
traverse1 f (f b) -> f (f b)
forall (t :: * -> *) (f :: * -> *) b.
(Traversable1 t, Apply f) =>
t (f b) -> f (t b)
sequence1 (NEMap k (f (f b)) -> f (NEMap k (f b)))
-> (NEMapF k f (f b) -> NEMap k (f (f b)))
-> NEMapF k f (f b)
-> f (NEMap k (f b))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NEMapF k f (f b) -> NEMap k (f (f b))
forall k k (f :: k -> *) (a :: k). NEMapF k f a -> NEMap k (f a)
runNEMapF

-- | A union, combining matching keys with '<!>'.
instance (Ord k, Alt f) => Semigroup (NEMapF k f a) where
    NEMapF xs :: NEMap k (f a)
xs <> :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a
<> NEMapF ys :: NEMap k (f a)
ys = NEMap k (f a) -> NEMapF k f a
forall k k (f :: k -> *) (a :: k). NEMap k (f a) -> NEMapF k f a
NEMapF (NEMap k (f a) -> NEMapF k f a) -> NEMap k (f a) -> NEMapF k f a
forall a b. (a -> b) -> a -> b
$ (f a -> f a -> f a)
-> NEMap k (f a) -> NEMap k (f a) -> NEMap k (f a)
forall k a.
Ord k =>
(a -> a -> a) -> NEMap k a -> NEMap k a -> NEMap k a
NEM.unionWith f a -> f a -> f a
forall (f :: * -> *) a. Alt f => f a -> f a -> f a
(<!>) NEMap k (f a)
xs NEMap k (f a)
ys

-- | Left-biased union
instance (Functor f, Ord k) => Alt (NEMapF k f) where
    NEMapF xs :: NEMap k (f a)
xs <!> :: NEMapF k f a -> NEMapF k f a -> NEMapF k f a
<!> NEMapF ys :: NEMap k (f a)
ys = NEMap k (f a) -> NEMapF k f a
forall k k (f :: k -> *) (a :: k). NEMap k (f a) -> NEMapF k f a
NEMapF (NEMap k (f a) -> NEMapF k f a) -> NEMap k (f a) -> NEMapF k f a
forall a b. (a -> b) -> a -> b
$ NEMap k (f a) -> NEMap k (f a) -> NEMap k (f a)
forall k a. Ord k => NEMap k a -> NEMap k a -> NEMap k a
NEM.union NEMap k (f a)
xs NEMap k (f a)
ys

instance (Monoid k, Pointed f) => Pointed (NEMapF k f) where
    point :: a -> NEMapF k f a
point = NEMap k (f a) -> NEMapF k f a
forall k k (f :: k -> *) (a :: k). NEMap k (f a) -> NEMapF k f a
NEMapF (NEMap k (f a) -> NEMapF k f a)
-> (a -> NEMap k (f a)) -> a -> NEMapF k f a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> f a -> NEMap k (f a)
forall k a. k -> a -> NEMap k a
NEM.singleton k
forall a. Monoid a => a
mempty (f a -> NEMap k (f a)) -> (a -> f a) -> a -> NEMap k (f a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> f a
forall (p :: * -> *) a. Pointed p => a -> p a
point