-- SPDX-FileCopyrightText: 2021 Oxhead Alpha
-- SPDX-License-Identifier: LicenseRef-MIT-OA

{-# LANGUAGE NoImplicitPrelude #-}

-- | This module replaces the monomorphic boolean operators from "Prelude"
-- with a set of polymorphic operators.
module Morley.Prelude.Boolean
  ( Boolean(..)
  , BooleanMonoid(..)
  , ApplicativeBoolean(..)
  , or
  , and
  , or1
  , and1
  , Any(..)
  , All(..)
  , any
  , all
  , any1
  , all1

  -- * Example definitions
  -- $setup
  ) where

import Universum hiding (All(..), Any(..), all, and, any, not, or, (&&), (||))
import Universum qualified

import Data.Coerce (coerce)
import Data.Data (Data)

{- $setup
>>> :{
data Vote = Yay | Nay deriving Show
--
instance Boolean Vote where
  Yay && Yay = Yay
  _ && _ = Nay
  Nay || Nay = Nay
  _ || _ = Yay
  not Yay = Nay
  not Nay = Yay
--
instance BooleanMonoid Vote where
  true = Yay
  false = Nay
:}
-}

{- | Generalized boolean operators.

This is useful for defining things that behave like booleans, e.g. predicates,
or EDSL for predicates.

>>> Yay && Nay
Nay
>>> and1 $ Yay :| replicate 9 Yay
Yay

There are also instances for these types lifted into 'IO' and @(->) a@:

>>> (const Yay) && (const Nay) $ ()
Nay
>>> (const Yay) || (const Nay) $ ()
Yay
-}
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

{- | Generalized 'True' and 'False'.

This is useful to complete the isomorphism between regular and generalized
booleans. It's a separate class because not all boolean-like things form a monoid.

>>> or $ replicate 10 Nay
Nay
-}
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

{- | A generalized version of @All@ monoid wrapper.

>>> All Nay <> All Nay
All {getAll = Nay}
>>> All Yay <> All Nay
All {getAll = Nay}
>>> All Yay <> All Yay
All {getAll = Yay}
-}
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)

{- | A generalized version of @Any@ monoid wrapper.

>>> Any Nay <> Any Nay
Any {getAny = Nay}
>>> Any Yay <> Any Nay
Any {getAny = Yay}
>>> Any Yay <> Any Yay
Any {getAny = Yay}
-}
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

{- | Generalized version of 'Universum.or'.

>>> or $ replicate 10 Nay
Nay
>>> or $ Yay : replicate 10 Nay
Yay
-}
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

{- | Generalized version of 'Universum.and'.

>>> and $ replicate 10 Yay
Yay
>>> and $ Nay : replicate 10 Yay
Nay
-}
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

{- | A version of 'or' that works on 'NonEmpty', thus doesn't require
'BooleanMonoid' instance.

>>> or1 $ Yay :| [Nay]
Yay
-}
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) #-}

{- | A version of 'and' that works on 'NonEmpty', thus doesn't require
'BooleanMonoid' instance.

>>> and1 $ Yay :| [Nay]
Nay
-}
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) #-}

{- | Generalized 'Universum.any'.

>>> any (\x -> if x > 50 then Yay else Nay) [1..100]
Yay
-}
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)

{- | Generalized 'Universum.all'.

>>> all (\x -> if x > 50 then Yay else Nay) [1..100]
Nay
-}
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)

{- | A version of 'any' that works on 'NonEmpty', thus doesn't require
'BooleanMonoid' instance.

>>> any1 (\x -> if x > 50 then Yay else Nay) $ 50 :| replicate 10 0
Nay
-}
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

{- | A version of 'all' that works on 'NonEmpty', thus doesn't require
'BooleanMonoid' instance.

>>> all1 (\x -> if x > 50 then Yay else Nay) $ 100 :| replicate 10 51
Yay
-}
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

-- | A newtype for deriving a 'Boolean' instance for any 'Applicative' type
-- constructor using @DerivingVia@.
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)