{-# LANGUAGE NoImplicitPrelude #-}
module Morley.Prelude.Boolean
( Boolean(..)
, BooleanMonoid(..)
, ApplicativeBoolean(..)
, or
, and
, or1
, and1
, Any(..)
, All(..)
, any
, all
, any1
, all1
) where
import Universum hiding (All(..), Any(..), all, and, any, not, or, (&&), (||))
import Universum qualified
import Data.Coerce (coerce)
import Data.Data (Data)
class Boolean a where
(&&) :: a -> a -> a
(||) :: a -> a -> a
infixr 3 &&
infixr 2 ||
not :: a -> a
instance Boolean Bool where
&& :: Bool -> Bool -> Bool
(&&) = Bool -> Bool -> Bool
(Universum.&&)
|| :: Bool -> Bool -> Bool
(||) = Bool -> Bool -> Bool
(Universum.||)
not :: Bool -> Bool
not = Bool -> Bool
Universum.not
class Boolean a => BooleanMonoid a where
false :: a
false = a -> a
forall a. Boolean a => a -> a
not a
forall a. BooleanMonoid a => a
true
true :: a
true = a -> a
forall a. Boolean a => a -> a
not a
forall a. BooleanMonoid a => a
false
{-# MINIMAL true | false #-}
instance BooleanMonoid Bool where
false :: Bool
false = Bool
False
true :: Bool
true = Bool
True
newtype All a = All { forall a. All a -> a
getAll :: a }
deriving stock ((forall x. All a -> Rep (All a) x)
-> (forall x. Rep (All a) x -> All a) -> Generic (All a)
forall x. Rep (All a) x -> All a
forall x. All a -> Rep (All a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (All a) x -> All a
forall a x. All a -> Rep (All a) x
$cfrom :: forall a x. All a -> Rep (All a) x
from :: forall x. All a -> Rep (All a) x
$cto :: forall a x. Rep (All a) x -> All a
to :: forall x. Rep (All a) x -> All a
Generic, Typeable (All a)
Typeable (All a)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> All a -> c (All a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (All a))
-> (All a -> Constr)
-> (All a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (All a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All a)))
-> ((forall b. Data b => b -> b) -> All a -> All a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r)
-> (forall u. (forall d. Data d => d -> u) -> All a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> All a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> All a -> m (All a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> All a -> m (All a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> All a -> m (All a))
-> Data (All a)
All a -> Constr
All a -> DataType
(forall b. Data b => b -> b) -> All a -> All a
forall {a}. Data a => Typeable (All a)
forall a. Data a => All a -> Constr
forall a. Data a => All a -> DataType
forall a. Data a => (forall b. Data b => b -> b) -> All a -> All a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> All a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> All a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (All a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> All a -> c (All a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (All a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All 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) -> All a -> u
forall u. (forall d. Data d => d -> u) -> All a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (All a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> All a -> c (All a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (All a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> All a -> c (All a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> All a -> c (All a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (All a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (All a)
$ctoConstr :: forall a. Data a => All a -> Constr
toConstr :: All a -> Constr
$cdataTypeOf :: forall a. Data a => All a -> DataType
dataTypeOf :: All a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (All a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (All a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (All a))
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> All a -> All a
gmapT :: (forall b. Data b => b -> b) -> All a -> All a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> All a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> All a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> All a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> All a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> All a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> All a -> m (All a)
Data, ReadPrec [All a]
ReadPrec (All a)
Int -> ReadS (All a)
ReadS [All a]
(Int -> ReadS (All a))
-> ReadS [All a]
-> ReadPrec (All a)
-> ReadPrec [All a]
-> Read (All a)
forall a. Read a => ReadPrec [All a]
forall a. Read a => ReadPrec (All a)
forall a. Read a => Int -> ReadS (All a)
forall a. Read a => ReadS [All a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (All a)
readsPrec :: Int -> ReadS (All a)
$creadList :: forall a. Read a => ReadS [All a]
readList :: ReadS [All a]
$creadPrec :: forall a. Read a => ReadPrec (All a)
readPrec :: ReadPrec (All a)
$creadListPrec :: forall a. Read a => ReadPrec [All a]
readListPrec :: ReadPrec [All a]
Read, Int -> All a -> ShowS
[All a] -> ShowS
All a -> String
(Int -> All a -> ShowS)
-> (All a -> String) -> ([All a] -> ShowS) -> Show (All a)
forall a. Show a => Int -> All a -> ShowS
forall a. Show a => [All a] -> ShowS
forall a. Show a => All a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> All a -> ShowS
showsPrec :: Int -> All a -> ShowS
$cshow :: forall a. Show a => All a -> String
show :: All a -> String
$cshowList :: forall a. Show a => [All a] -> ShowS
showList :: [All a] -> ShowS
Show, All a -> All a -> Bool
(All a -> All a -> Bool) -> (All a -> All a -> Bool) -> Eq (All a)
forall a. Eq a => All a -> All a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => All a -> All a -> Bool
== :: All a -> All a -> Bool
$c/= :: forall a. Eq a => All a -> All a -> Bool
/= :: All a -> All a -> Bool
Eq, Eq (All a)
Eq (All a)
-> (All a -> All a -> Ordering)
-> (All a -> All a -> Bool)
-> (All a -> All a -> Bool)
-> (All a -> All a -> Bool)
-> (All a -> All a -> Bool)
-> (All a -> All a -> All a)
-> (All a -> All a -> All a)
-> Ord (All a)
All a -> All a -> Bool
All a -> All a -> Ordering
All a -> All a -> All 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 {a}. Ord a => Eq (All a)
forall a. Ord a => All a -> All a -> Bool
forall a. Ord a => All a -> All a -> Ordering
forall a. Ord a => All a -> All a -> All a
$ccompare :: forall a. Ord a => All a -> All a -> Ordering
compare :: All a -> All a -> Ordering
$c< :: forall a. Ord a => All a -> All a -> Bool
< :: All a -> All a -> Bool
$c<= :: forall a. Ord a => All a -> All a -> Bool
<= :: All a -> All a -> Bool
$c> :: forall a. Ord a => All a -> All a -> Bool
> :: All a -> All a -> Bool
$c>= :: forall a. Ord a => All a -> All a -> Bool
>= :: All a -> All a -> Bool
$cmax :: forall a. Ord a => All a -> All a -> All a
max :: All a -> All a -> All a
$cmin :: forall a. Ord a => All a -> All a -> All a
min :: All a -> All a -> All a
Ord)
deriving newtype (All a
All a -> All a -> Bounded (All a)
forall a. a -> a -> Bounded a
forall a. Bounded a => All a
$cminBound :: forall a. Bounded a => All a
minBound :: All a
$cmaxBound :: forall a. Bounded a => All a
maxBound :: All a
Bounded, Int -> All a
All a -> Int
All a -> [All a]
All a -> All a
All a -> All a -> [All a]
All a -> All a -> All a -> [All a]
(All a -> All a)
-> (All a -> All a)
-> (Int -> All a)
-> (All a -> Int)
-> (All a -> [All a])
-> (All a -> All a -> [All a])
-> (All a -> All a -> [All a])
-> (All a -> All a -> All a -> [All a])
-> Enum (All a)
forall a. Enum a => Int -> All a
forall a. Enum a => All a -> Int
forall a. Enum a => All a -> [All a]
forall a. Enum a => All a -> All a
forall a. Enum a => All a -> All a -> [All a]
forall a. Enum a => All a -> All a -> All a -> [All a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: forall a. Enum a => All a -> All a
succ :: All a -> All a
$cpred :: forall a. Enum a => All a -> All a
pred :: All a -> All a
$ctoEnum :: forall a. Enum a => Int -> All a
toEnum :: Int -> All a
$cfromEnum :: forall a. Enum a => All a -> Int
fromEnum :: All a -> Int
$cenumFrom :: forall a. Enum a => All a -> [All a]
enumFrom :: All a -> [All a]
$cenumFromThen :: forall a. Enum a => All a -> All a -> [All a]
enumFromThen :: All a -> All a -> [All a]
$cenumFromTo :: forall a. Enum a => All a -> All a -> [All a]
enumFromTo :: All a -> All a -> [All a]
$cenumFromThenTo :: forall a. Enum a => All a -> All a -> All a -> [All a]
enumFromThenTo :: All a -> All a -> All a -> [All a]
Enum)
newtype Any a = Any { forall a. Any a -> a
getAny :: a }
deriving stock ((forall x. Any a -> Rep (Any a) x)
-> (forall x. Rep (Any a) x -> Any a) -> Generic (Any a)
forall x. Rep (Any a) x -> Any a
forall x. Any a -> Rep (Any a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Any a) x -> Any a
forall a x. Any a -> Rep (Any a) x
$cfrom :: forall a x. Any a -> Rep (Any a) x
from :: forall x. Any a -> Rep (Any a) x
$cto :: forall a x. Rep (Any a) x -> Any a
to :: forall x. Rep (Any a) x -> Any a
Generic, Typeable (Any a)
Typeable (Any a)
-> (forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Any a -> c (Any a))
-> (forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Any a))
-> (Any a -> Constr)
-> (Any a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Any a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any a)))
-> ((forall b. Data b => b -> b) -> Any a -> Any a)
-> (forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r)
-> (forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Any a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Any a -> u)
-> (forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a))
-> (forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a))
-> Data (Any a)
Any a -> Constr
Any a -> DataType
(forall b. Data b => b -> b) -> Any a -> Any a
forall {a}. Data a => Typeable (Any a)
forall a. Data a => Any a -> Constr
forall a. Data a => Any a -> DataType
forall a. Data a => (forall b. Data b => b -> b) -> Any a -> Any a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Any a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Any a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Any a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Any a -> c (Any a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Any a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any 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) -> Any a -> u
forall u. (forall d. Data d => d -> u) -> Any a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Any a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Any a -> c (Any a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Any a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any a))
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Any a -> c (Any a)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Any a -> c (Any a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Any a)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Any a)
$ctoConstr :: forall a. Data a => Any a -> Constr
toConstr :: Any a -> Constr
$cdataTypeOf :: forall a. Data a => Any a -> DataType
dataTypeOf :: Any a -> DataType
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Any a))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Any a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any a))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Any a))
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Any a -> Any a
gmapT :: (forall b. Data b => b -> b) -> Any a -> Any a
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Any a -> r
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Any a -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Any a -> [u]
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Any a -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Any a -> u
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Any a -> m (Any a)
Data, ReadPrec [Any a]
ReadPrec (Any a)
Int -> ReadS (Any a)
ReadS [Any a]
(Int -> ReadS (Any a))
-> ReadS [Any a]
-> ReadPrec (Any a)
-> ReadPrec [Any a]
-> Read (Any a)
forall a. Read a => ReadPrec [Any a]
forall a. Read a => ReadPrec (Any a)
forall a. Read a => Int -> ReadS (Any a)
forall a. Read a => ReadS [Any a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: forall a. Read a => Int -> ReadS (Any a)
readsPrec :: Int -> ReadS (Any a)
$creadList :: forall a. Read a => ReadS [Any a]
readList :: ReadS [Any a]
$creadPrec :: forall a. Read a => ReadPrec (Any a)
readPrec :: ReadPrec (Any a)
$creadListPrec :: forall a. Read a => ReadPrec [Any a]
readListPrec :: ReadPrec [Any a]
Read, Int -> Any a -> ShowS
[Any a] -> ShowS
Any a -> String
(Int -> Any a -> ShowS)
-> (Any a -> String) -> ([Any a] -> ShowS) -> Show (Any a)
forall a. Show a => Int -> Any a -> ShowS
forall a. Show a => [Any a] -> ShowS
forall a. Show a => Any a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Any a -> ShowS
showsPrec :: Int -> Any a -> ShowS
$cshow :: forall a. Show a => Any a -> String
show :: Any a -> String
$cshowList :: forall a. Show a => [Any a] -> ShowS
showList :: [Any a] -> ShowS
Show, Any a -> Any a -> Bool
(Any a -> Any a -> Bool) -> (Any a -> Any a -> Bool) -> Eq (Any a)
forall a. Eq a => Any a -> Any a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Any a -> Any a -> Bool
== :: Any a -> Any a -> Bool
$c/= :: forall a. Eq a => Any a -> Any a -> Bool
/= :: Any a -> Any a -> Bool
Eq, Eq (Any a)
Eq (Any a)
-> (Any a -> Any a -> Ordering)
-> (Any a -> Any a -> Bool)
-> (Any a -> Any a -> Bool)
-> (Any a -> Any a -> Bool)
-> (Any a -> Any a -> Bool)
-> (Any a -> Any a -> Any a)
-> (Any a -> Any a -> Any a)
-> Ord (Any a)
Any a -> Any a -> Bool
Any a -> Any a -> Ordering
Any a -> Any a -> Any 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 {a}. Ord a => Eq (Any a)
forall a. Ord a => Any a -> Any a -> Bool
forall a. Ord a => Any a -> Any a -> Ordering
forall a. Ord a => Any a -> Any a -> Any a
$ccompare :: forall a. Ord a => Any a -> Any a -> Ordering
compare :: Any a -> Any a -> Ordering
$c< :: forall a. Ord a => Any a -> Any a -> Bool
< :: Any a -> Any a -> Bool
$c<= :: forall a. Ord a => Any a -> Any a -> Bool
<= :: Any a -> Any a -> Bool
$c> :: forall a. Ord a => Any a -> Any a -> Bool
> :: Any a -> Any a -> Bool
$c>= :: forall a. Ord a => Any a -> Any a -> Bool
>= :: Any a -> Any a -> Bool
$cmax :: forall a. Ord a => Any a -> Any a -> Any a
max :: Any a -> Any a -> Any a
$cmin :: forall a. Ord a => Any a -> Any a -> Any a
min :: Any a -> Any a -> Any a
Ord)
deriving newtype (Any a
Any a -> Any a -> Bounded (Any a)
forall a. a -> a -> Bounded a
forall a. Bounded a => Any a
$cminBound :: forall a. Bounded a => Any a
minBound :: Any a
$cmaxBound :: forall a. Bounded a => Any a
maxBound :: Any a
Bounded, Int -> Any a
Any a -> Int
Any a -> [Any a]
Any a -> Any a
Any a -> Any a -> [Any a]
Any a -> Any a -> Any a -> [Any a]
(Any a -> Any a)
-> (Any a -> Any a)
-> (Int -> Any a)
-> (Any a -> Int)
-> (Any a -> [Any a])
-> (Any a -> Any a -> [Any a])
-> (Any a -> Any a -> [Any a])
-> (Any a -> Any a -> Any a -> [Any a])
-> Enum (Any a)
forall a. Enum a => Int -> Any a
forall a. Enum a => Any a -> Int
forall a. Enum a => Any a -> [Any a]
forall a. Enum a => Any a -> Any a
forall a. Enum a => Any a -> Any a -> [Any a]
forall a. Enum a => Any a -> Any a -> Any a -> [Any a]
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: forall a. Enum a => Any a -> Any a
succ :: Any a -> Any a
$cpred :: forall a. Enum a => Any a -> Any a
pred :: Any a -> Any a
$ctoEnum :: forall a. Enum a => Int -> Any a
toEnum :: Int -> Any a
$cfromEnum :: forall a. Enum a => Any a -> Int
fromEnum :: Any a -> Int
$cenumFrom :: forall a. Enum a => Any a -> [Any a]
enumFrom :: Any a -> [Any a]
$cenumFromThen :: forall a. Enum a => Any a -> Any a -> [Any a]
enumFromThen :: Any a -> Any a -> [Any a]
$cenumFromTo :: forall a. Enum a => Any a -> Any a -> [Any a]
enumFromTo :: Any a -> Any a -> [Any a]
$cenumFromThenTo :: forall a. Enum a => Any a -> Any a -> Any a -> [Any a]
enumFromThenTo :: Any a -> Any a -> Any a -> [Any a]
Enum)
instance Boolean a => Semigroup (Any a) where
<> :: Any a -> Any a -> Any a
(<>) = (a -> a -> a) -> Any a -> Any a -> Any a
forall a b. Coercible a b => a -> b
coerce ((a -> a -> a) -> Any a -> Any a -> Any a)
-> (a -> a -> a) -> Any a -> Any a -> Any a
forall a b. (a -> b) -> a -> b
$ forall a. Boolean a => a -> a -> a
(||) @a
instance Boolean a => Semigroup (All a) where
<> :: All a -> All a -> All a
(<>) = (a -> a -> a) -> All a -> All a -> All a
forall a b. Coercible a b => a -> b
coerce ((a -> a -> a) -> All a -> All a -> All a)
-> (a -> a -> a) -> All a -> All a -> All a
forall a b. (a -> b) -> a -> b
$ forall a. Boolean a => a -> a -> a
(&&) @a
instance BooleanMonoid a => Monoid (Any a) where
mempty :: Any a
mempty = a -> Any a
forall a b. Coercible a b => a -> b
coerce (a -> Any a) -> a -> Any a
forall a b. (a -> b) -> a -> b
$ forall a. BooleanMonoid a => a
false @a
instance BooleanMonoid a => Monoid (All a) where
mempty :: All a
mempty = a -> All a
forall a b. Coercible a b => a -> b
coerce (a -> All a) -> a -> All a
forall a b. (a -> b) -> a -> b
$ forall a. BooleanMonoid a => a
true @a
or :: (Container c, BooleanMonoid (Element c)) => c -> Element c
or :: forall c.
(Container c, BooleanMonoid (Element c)) =>
c -> Element c
or = (Element c -> Element c) -> c -> Element c
forall c b.
(Container c, BooleanMonoid b) =>
(Element c -> b) -> c -> b
any Element c -> Element c
forall a. a -> a
id
and :: (Container c, BooleanMonoid (Element c)) => c -> Element c
and :: forall c.
(Container c, BooleanMonoid (Element c)) =>
c -> Element c
and = (Element c -> Element c) -> c -> Element c
forall c b.
(Container c, BooleanMonoid b) =>
(Element c -> b) -> c -> b
all Element c -> Element c
forall a. a -> a
id
or1 :: Boolean a => NonEmpty a -> a
or1 :: forall a. Boolean a => NonEmpty a -> a
or1 = (a -> a -> a) -> NonEmpty a -> a
forall a. (a -> a -> a) -> NonEmpty a -> a
foldr1 a -> a -> a
forall a. Boolean a => a -> a -> a
(||)
{-# ANN or1 ("HLint: ignore Use or" :: Text) #-}
and1 :: Boolean a => NonEmpty a -> a
and1 :: forall a. Boolean a => NonEmpty a -> a
and1 = (a -> a -> a) -> NonEmpty a -> a
forall a. (a -> a -> a) -> NonEmpty a -> a
foldr1 a -> a -> a
forall a. Boolean a => a -> a -> a
(&&)
{-# ANN and1 ("HLint: ignore Use and" :: Text) #-}
any :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b
any :: forall c b.
(Container c, BooleanMonoid b) =>
(Element c -> b) -> c -> b
any Element c -> b
f = Any b -> b
forall a. Any a -> a
getAny (Any b -> b) -> (c -> Any b) -> c -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element c -> Any b) -> c -> Any b
forall m. Monoid m => (Element c -> m) -> c -> m
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap (b -> Any b
forall a. a -> Any a
Any (b -> Any b) -> (Element c -> b) -> Element c -> Any b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element c -> b
f)
all :: (Container c, BooleanMonoid b) => (Element c -> b) -> c -> b
all :: forall c b.
(Container c, BooleanMonoid b) =>
(Element c -> b) -> c -> b
all Element c -> b
f = All b -> b
forall a. All a -> a
getAll (All b -> b) -> (c -> All b) -> c -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Element c -> All b) -> c -> All b
forall m. Monoid m => (Element c -> m) -> c -> m
forall t m. (Container t, Monoid m) => (Element t -> m) -> t -> m
foldMap (b -> All b
forall a. a -> All a
All (b -> All b) -> (Element c -> b) -> Element c -> All b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element c -> b
f)
any1 :: Boolean b => (a -> b) -> NonEmpty a -> b
any1 :: forall b a. Boolean b => (a -> b) -> NonEmpty a -> b
any1 a -> b
f = NonEmpty b -> b
forall a. Boolean a => NonEmpty a -> a
or1 (NonEmpty b -> b) -> (NonEmpty a -> NonEmpty b) -> NonEmpty a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> NonEmpty a -> NonEmpty b
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f
all1 :: Boolean b => (a -> b) -> NonEmpty a -> b
all1 :: forall b a. Boolean b => (a -> b) -> NonEmpty a -> b
all1 a -> b
f = NonEmpty b -> b
forall a. Boolean a => NonEmpty a -> a
and1 (NonEmpty b -> b) -> (NonEmpty a -> NonEmpty b) -> NonEmpty a -> b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b) -> NonEmpty a -> NonEmpty b
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f
newtype ApplicativeBoolean f bool = ApplicativeBoolean (f bool)
deriving newtype ((forall a b.
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b)
-> (forall a b.
a -> ApplicativeBoolean f b -> ApplicativeBoolean f a)
-> Functor (ApplicativeBoolean f)
forall a b. a -> ApplicativeBoolean f b -> ApplicativeBoolean f a
forall a b.
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b
forall (f :: * -> *) a b.
Functor f =>
a -> ApplicativeBoolean f b -> ApplicativeBoolean f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b
fmap :: forall a b.
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> ApplicativeBoolean f b -> ApplicativeBoolean f a
<$ :: forall a b. a -> ApplicativeBoolean f b -> ApplicativeBoolean f a
Functor, Functor (ApplicativeBoolean f)
Functor (ApplicativeBoolean f)
-> (forall a. a -> ApplicativeBoolean f a)
-> (forall a b.
ApplicativeBoolean f (a -> b)
-> ApplicativeBoolean f a -> ApplicativeBoolean f b)
-> (forall a b c.
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c)
-> (forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f b)
-> (forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f a)
-> Applicative (ApplicativeBoolean f)
forall a. a -> ApplicativeBoolean f a
forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f a
forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f b
forall a b.
ApplicativeBoolean f (a -> b)
-> ApplicativeBoolean f a -> ApplicativeBoolean f b
forall a b c.
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
forall {f :: * -> *}.
Applicative f =>
Functor (ApplicativeBoolean f)
forall (f :: * -> *) a.
Applicative f =>
a -> ApplicativeBoolean f a
forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f a
forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f b
forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f (a -> b)
-> ApplicativeBoolean f a -> ApplicativeBoolean f b
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
$cpure :: forall (f :: * -> *) a.
Applicative f =>
a -> ApplicativeBoolean f a
pure :: forall a. a -> ApplicativeBoolean f a
$c<*> :: forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f (a -> b)
-> ApplicativeBoolean f a -> ApplicativeBoolean f b
<*> :: forall a b.
ApplicativeBoolean f (a -> b)
-> ApplicativeBoolean f a -> ApplicativeBoolean f b
$cliftA2 :: forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
liftA2 :: forall a b c.
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
$c*> :: forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f b
*> :: forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f b
$c<* :: forall (f :: * -> *) a b.
Applicative f =>
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f a
<* :: forall a b.
ApplicativeBoolean f a
-> ApplicativeBoolean f b -> ApplicativeBoolean f a
Applicative)
instance (Applicative f, Boolean bool) => Boolean (ApplicativeBoolean f bool) where
&& :: ApplicativeBoolean f bool
-> ApplicativeBoolean f bool -> ApplicativeBoolean f bool
(&&) = (bool -> bool -> bool)
-> ApplicativeBoolean f bool
-> ApplicativeBoolean f bool
-> ApplicativeBoolean f bool
forall a b c.
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 bool -> bool -> bool
forall a. Boolean a => a -> a -> a
(&&)
|| :: ApplicativeBoolean f bool
-> ApplicativeBoolean f bool -> ApplicativeBoolean f bool
(||) = (bool -> bool -> bool)
-> ApplicativeBoolean f bool
-> ApplicativeBoolean f bool
-> ApplicativeBoolean f bool
forall a b c.
(a -> b -> c)
-> ApplicativeBoolean f a
-> ApplicativeBoolean f b
-> ApplicativeBoolean f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 bool -> bool -> bool
forall a. Boolean a => a -> a -> a
(||)
not :: ApplicativeBoolean f bool -> ApplicativeBoolean f bool
not = (bool -> bool)
-> ApplicativeBoolean f bool -> ApplicativeBoolean f bool
forall a b.
(a -> b) -> ApplicativeBoolean f a -> ApplicativeBoolean f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap bool -> bool
forall a. Boolean a => a -> a
not
deriving via (ApplicativeBoolean IO bool) instance Boolean bool => Boolean (IO bool)
deriving via (ApplicativeBoolean ((->) a) bool) instance Boolean bool => Boolean (a -> bool)
instance (Applicative f, BooleanMonoid bool)
=> BooleanMonoid (ApplicativeBoolean f bool) where
true :: ApplicativeBoolean f bool
true = bool -> ApplicativeBoolean f bool
forall a. a -> ApplicativeBoolean f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure bool
forall a. BooleanMonoid a => a
true
false :: ApplicativeBoolean f bool
false = bool -> ApplicativeBoolean f bool
forall a. a -> ApplicativeBoolean f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure bool
forall a. BooleanMonoid a => a
false
deriving via (ApplicativeBoolean IO bool)
instance BooleanMonoid bool => BooleanMonoid (IO bool)
deriving via (ApplicativeBoolean ((->) a) bool)
instance BooleanMonoid bool => BooleanMonoid (a -> bool)