{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{- |
Module: Data.Bool.Truthy
Description: Values that can be treated as 'Boolean's
Copyright: ⓒ 2022 Anselm Schüler
License: MIT
This module provides the 'Truthy' class for values that can be treated as 'Boolean's,
as well as several newtypes that assign boolean interpretations to existing data.
-}

module Data.Bool.Truthy where

import Data.Bool.Class

-- | Values that can be treated as 'Boolean's
class Boolean (BooleanRep b) => Truthy b where
  -- | The 'Boolean' representation of the value
  type BooleanRep b
  -- | Convert the 'Truthy' value to its 'Boolean' representation
  truthy :: b -> BooleanRep b

instance Truthy Bool where
  type BooleanRep Bool = Bool
  truthy :: Bool -> BooleanRep Bool
truthy = Bool -> BooleanRep Bool
forall a. a -> a
id

instance Truthy b => Truthy (a -> b) where
  type BooleanRep (a -> b) = a -> BooleanRep b
  truthy :: (a -> b) -> BooleanRep (a -> b)
truthy = (b -> BooleanRep b
forall b. Truthy b => b -> BooleanRep b
truthy (b -> BooleanRep b) -> (a -> b) -> a -> BooleanRep b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)

-- | A wrapper for numbers ('Num' instances) that is converted by 'truthy' to 'False' if it is @0@
newtype ZeroFalse n = ZeroFalse { ZeroFalse n -> n
unZeroFalse :: n } deriving (Int -> ZeroFalse n -> ShowS
[ZeroFalse n] -> ShowS
ZeroFalse n -> String
(Int -> ZeroFalse n -> ShowS)
-> (ZeroFalse n -> String)
-> ([ZeroFalse n] -> ShowS)
-> Show (ZeroFalse n)
forall n. Show n => Int -> ZeroFalse n -> ShowS
forall n. Show n => [ZeroFalse n] -> ShowS
forall n. Show n => ZeroFalse n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ZeroFalse n] -> ShowS
$cshowList :: forall n. Show n => [ZeroFalse n] -> ShowS
show :: ZeroFalse n -> String
$cshow :: forall n. Show n => ZeroFalse n -> String
showsPrec :: Int -> ZeroFalse n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> ZeroFalse n -> ShowS
Show, ZeroFalse n -> ZeroFalse n -> Bool
(ZeroFalse n -> ZeroFalse n -> Bool)
-> (ZeroFalse n -> ZeroFalse n -> Bool) -> Eq (ZeroFalse n)
forall n. Eq n => ZeroFalse n -> ZeroFalse n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ZeroFalse n -> ZeroFalse n -> Bool
$c/= :: forall n. Eq n => ZeroFalse n -> ZeroFalse n -> Bool
== :: ZeroFalse n -> ZeroFalse n -> Bool
$c== :: forall n. Eq n => ZeroFalse n -> ZeroFalse n -> Bool
Eq, Eq (ZeroFalse n)
Eq (ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n -> Ordering)
-> (ZeroFalse n -> ZeroFalse n -> Bool)
-> (ZeroFalse n -> ZeroFalse n -> Bool)
-> (ZeroFalse n -> ZeroFalse n -> Bool)
-> (ZeroFalse n -> ZeroFalse n -> Bool)
-> (ZeroFalse n -> ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n -> ZeroFalse n)
-> Ord (ZeroFalse n)
ZeroFalse n -> ZeroFalse n -> Bool
ZeroFalse n -> ZeroFalse n -> Ordering
ZeroFalse n -> ZeroFalse n -> ZeroFalse n
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 n. Ord n => Eq (ZeroFalse n)
forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Bool
forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Ordering
forall n. Ord n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
min :: ZeroFalse n -> ZeroFalse n -> ZeroFalse n
$cmin :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
max :: ZeroFalse n -> ZeroFalse n -> ZeroFalse n
$cmax :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
>= :: ZeroFalse n -> ZeroFalse n -> Bool
$c>= :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Bool
> :: ZeroFalse n -> ZeroFalse n -> Bool
$c> :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Bool
<= :: ZeroFalse n -> ZeroFalse n -> Bool
$c<= :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Bool
< :: ZeroFalse n -> ZeroFalse n -> Bool
$c< :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Bool
compare :: ZeroFalse n -> ZeroFalse n -> Ordering
$ccompare :: forall n. Ord n => ZeroFalse n -> ZeroFalse n -> Ordering
$cp1Ord :: forall n. Ord n => Eq (ZeroFalse n)
Ord, Integer -> ZeroFalse n
ZeroFalse n -> ZeroFalse n
ZeroFalse n -> ZeroFalse n -> ZeroFalse n
(ZeroFalse n -> ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n)
-> (ZeroFalse n -> ZeroFalse n)
-> (Integer -> ZeroFalse n)
-> Num (ZeroFalse n)
forall n. Num n => Integer -> ZeroFalse n
forall n. Num n => ZeroFalse n -> ZeroFalse n
forall n. Num n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> ZeroFalse n
$cfromInteger :: forall n. Num n => Integer -> ZeroFalse n
signum :: ZeroFalse n -> ZeroFalse n
$csignum :: forall n. Num n => ZeroFalse n -> ZeroFalse n
abs :: ZeroFalse n -> ZeroFalse n
$cabs :: forall n. Num n => ZeroFalse n -> ZeroFalse n
negate :: ZeroFalse n -> ZeroFalse n
$cnegate :: forall n. Num n => ZeroFalse n -> ZeroFalse n
* :: ZeroFalse n -> ZeroFalse n -> ZeroFalse n
$c* :: forall n. Num n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
- :: ZeroFalse n -> ZeroFalse n -> ZeroFalse n
$c- :: forall n. Num n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
+ :: ZeroFalse n -> ZeroFalse n -> ZeroFalse n
$c+ :: forall n. Num n => ZeroFalse n -> ZeroFalse n -> ZeroFalse n
Num, a -> ZeroFalse b -> ZeroFalse a
(a -> b) -> ZeroFalse a -> ZeroFalse b
(forall a b. (a -> b) -> ZeroFalse a -> ZeroFalse b)
-> (forall a b. a -> ZeroFalse b -> ZeroFalse a)
-> Functor ZeroFalse
forall a b. a -> ZeroFalse b -> ZeroFalse a
forall a b. (a -> b) -> ZeroFalse a -> ZeroFalse b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ZeroFalse b -> ZeroFalse a
$c<$ :: forall a b. a -> ZeroFalse b -> ZeroFalse a
fmap :: (a -> b) -> ZeroFalse a -> ZeroFalse b
$cfmap :: forall a b. (a -> b) -> ZeroFalse a -> ZeroFalse b
Functor, ZeroFalse a -> Bool
(a -> m) -> ZeroFalse a -> m
(a -> b -> b) -> b -> ZeroFalse a -> b
(forall m. Monoid m => ZeroFalse m -> m)
-> (forall m a. Monoid m => (a -> m) -> ZeroFalse a -> m)
-> (forall m a. Monoid m => (a -> m) -> ZeroFalse a -> m)
-> (forall a b. (a -> b -> b) -> b -> ZeroFalse a -> b)
-> (forall a b. (a -> b -> b) -> b -> ZeroFalse a -> b)
-> (forall b a. (b -> a -> b) -> b -> ZeroFalse a -> b)
-> (forall b a. (b -> a -> b) -> b -> ZeroFalse a -> b)
-> (forall a. (a -> a -> a) -> ZeroFalse a -> a)
-> (forall a. (a -> a -> a) -> ZeroFalse a -> a)
-> (forall a. ZeroFalse a -> [a])
-> (forall a. ZeroFalse a -> Bool)
-> (forall a. ZeroFalse a -> Int)
-> (forall a. Eq a => a -> ZeroFalse a -> Bool)
-> (forall a. Ord a => ZeroFalse a -> a)
-> (forall a. Ord a => ZeroFalse a -> a)
-> (forall a. Num a => ZeroFalse a -> a)
-> (forall a. Num a => ZeroFalse a -> a)
-> Foldable ZeroFalse
forall a. Eq a => a -> ZeroFalse a -> Bool
forall a. Num a => ZeroFalse a -> a
forall a. Ord a => ZeroFalse a -> a
forall m. Monoid m => ZeroFalse m -> m
forall a. ZeroFalse a -> Bool
forall a. ZeroFalse a -> Int
forall a. ZeroFalse a -> [a]
forall a. (a -> a -> a) -> ZeroFalse a -> a
forall m a. Monoid m => (a -> m) -> ZeroFalse a -> m
forall b a. (b -> a -> b) -> b -> ZeroFalse a -> b
forall a b. (a -> b -> b) -> b -> ZeroFalse 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 :: ZeroFalse a -> a
$cproduct :: forall a. Num a => ZeroFalse a -> a
sum :: ZeroFalse a -> a
$csum :: forall a. Num a => ZeroFalse a -> a
minimum :: ZeroFalse a -> a
$cminimum :: forall a. Ord a => ZeroFalse a -> a
maximum :: ZeroFalse a -> a
$cmaximum :: forall a. Ord a => ZeroFalse a -> a
elem :: a -> ZeroFalse a -> Bool
$celem :: forall a. Eq a => a -> ZeroFalse a -> Bool
length :: ZeroFalse a -> Int
$clength :: forall a. ZeroFalse a -> Int
null :: ZeroFalse a -> Bool
$cnull :: forall a. ZeroFalse a -> Bool
toList :: ZeroFalse a -> [a]
$ctoList :: forall a. ZeroFalse a -> [a]
foldl1 :: (a -> a -> a) -> ZeroFalse a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> ZeroFalse a -> a
foldr1 :: (a -> a -> a) -> ZeroFalse a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> ZeroFalse a -> a
foldl' :: (b -> a -> b) -> b -> ZeroFalse a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> ZeroFalse a -> b
foldl :: (b -> a -> b) -> b -> ZeroFalse a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> ZeroFalse a -> b
foldr' :: (a -> b -> b) -> b -> ZeroFalse a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> ZeroFalse a -> b
foldr :: (a -> b -> b) -> b -> ZeroFalse a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> ZeroFalse a -> b
foldMap' :: (a -> m) -> ZeroFalse a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> ZeroFalse a -> m
foldMap :: (a -> m) -> ZeroFalse a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> ZeroFalse a -> m
fold :: ZeroFalse m -> m
$cfold :: forall m. Monoid m => ZeroFalse m -> m
Foldable, Functor ZeroFalse
Foldable ZeroFalse
Functor ZeroFalse
-> Foldable ZeroFalse
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> ZeroFalse a -> f (ZeroFalse b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    ZeroFalse (f a) -> f (ZeroFalse a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> ZeroFalse a -> m (ZeroFalse b))
-> (forall (m :: * -> *) a.
    Monad m =>
    ZeroFalse (m a) -> m (ZeroFalse a))
-> Traversable ZeroFalse
(a -> f b) -> ZeroFalse a -> f (ZeroFalse 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 =>
ZeroFalse (m a) -> m (ZeroFalse a)
forall (f :: * -> *) a.
Applicative f =>
ZeroFalse (f a) -> f (ZeroFalse a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ZeroFalse a -> m (ZeroFalse b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ZeroFalse a -> f (ZeroFalse b)
sequence :: ZeroFalse (m a) -> m (ZeroFalse a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
ZeroFalse (m a) -> m (ZeroFalse a)
mapM :: (a -> m b) -> ZeroFalse a -> m (ZeroFalse b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> ZeroFalse a -> m (ZeroFalse b)
sequenceA :: ZeroFalse (f a) -> f (ZeroFalse a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
ZeroFalse (f a) -> f (ZeroFalse a)
traverse :: (a -> f b) -> ZeroFalse a -> f (ZeroFalse b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> ZeroFalse a -> f (ZeroFalse b)
$cp2Traversable :: Foldable ZeroFalse
$cp1Traversable :: Functor ZeroFalse
Traversable)

instance (Eq n, Num n) => Truthy (ZeroFalse n) where
  type BooleanRep (ZeroFalse n) = Bool
  truthy :: ZeroFalse n -> BooleanRep (ZeroFalse n)
truthy (ZeroFalse n
n) = n
n n -> n -> Bool
forall a. Eq a => a -> a -> Bool
/= n
0

-- | A wrapper for numbers ('Num' instances) that is converted by 'truthy' to 'True' if it is @> 0@
newtype PositiveTrue n = PositiveTrue { PositiveTrue n -> n
unPositiveTrue :: n } deriving (Int -> PositiveTrue n -> ShowS
[PositiveTrue n] -> ShowS
PositiveTrue n -> String
(Int -> PositiveTrue n -> ShowS)
-> (PositiveTrue n -> String)
-> ([PositiveTrue n] -> ShowS)
-> Show (PositiveTrue n)
forall n. Show n => Int -> PositiveTrue n -> ShowS
forall n. Show n => [PositiveTrue n] -> ShowS
forall n. Show n => PositiveTrue n -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PositiveTrue n] -> ShowS
$cshowList :: forall n. Show n => [PositiveTrue n] -> ShowS
show :: PositiveTrue n -> String
$cshow :: forall n. Show n => PositiveTrue n -> String
showsPrec :: Int -> PositiveTrue n -> ShowS
$cshowsPrec :: forall n. Show n => Int -> PositiveTrue n -> ShowS
Show, PositiveTrue n -> PositiveTrue n -> Bool
(PositiveTrue n -> PositiveTrue n -> Bool)
-> (PositiveTrue n -> PositiveTrue n -> Bool)
-> Eq (PositiveTrue n)
forall n. Eq n => PositiveTrue n -> PositiveTrue n -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PositiveTrue n -> PositiveTrue n -> Bool
$c/= :: forall n. Eq n => PositiveTrue n -> PositiveTrue n -> Bool
== :: PositiveTrue n -> PositiveTrue n -> Bool
$c== :: forall n. Eq n => PositiveTrue n -> PositiveTrue n -> Bool
Eq, Eq (PositiveTrue n)
Eq (PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n -> Ordering)
-> (PositiveTrue n -> PositiveTrue n -> Bool)
-> (PositiveTrue n -> PositiveTrue n -> Bool)
-> (PositiveTrue n -> PositiveTrue n -> Bool)
-> (PositiveTrue n -> PositiveTrue n -> Bool)
-> (PositiveTrue n -> PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n -> PositiveTrue n)
-> Ord (PositiveTrue n)
PositiveTrue n -> PositiveTrue n -> Bool
PositiveTrue n -> PositiveTrue n -> Ordering
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
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 n. Ord n => Eq (PositiveTrue n)
forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Bool
forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Ordering
forall n.
Ord n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
min :: PositiveTrue n -> PositiveTrue n -> PositiveTrue n
$cmin :: forall n.
Ord n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
max :: PositiveTrue n -> PositiveTrue n -> PositiveTrue n
$cmax :: forall n.
Ord n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
>= :: PositiveTrue n -> PositiveTrue n -> Bool
$c>= :: forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Bool
> :: PositiveTrue n -> PositiveTrue n -> Bool
$c> :: forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Bool
<= :: PositiveTrue n -> PositiveTrue n -> Bool
$c<= :: forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Bool
< :: PositiveTrue n -> PositiveTrue n -> Bool
$c< :: forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Bool
compare :: PositiveTrue n -> PositiveTrue n -> Ordering
$ccompare :: forall n. Ord n => PositiveTrue n -> PositiveTrue n -> Ordering
$cp1Ord :: forall n. Ord n => Eq (PositiveTrue n)
Ord, Integer -> PositiveTrue n
PositiveTrue n -> PositiveTrue n
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
(PositiveTrue n -> PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n)
-> (PositiveTrue n -> PositiveTrue n)
-> (Integer -> PositiveTrue n)
-> Num (PositiveTrue n)
forall n. Num n => Integer -> PositiveTrue n
forall n. Num n => PositiveTrue n -> PositiveTrue n
forall n.
Num n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
fromInteger :: Integer -> PositiveTrue n
$cfromInteger :: forall n. Num n => Integer -> PositiveTrue n
signum :: PositiveTrue n -> PositiveTrue n
$csignum :: forall n. Num n => PositiveTrue n -> PositiveTrue n
abs :: PositiveTrue n -> PositiveTrue n
$cabs :: forall n. Num n => PositiveTrue n -> PositiveTrue n
negate :: PositiveTrue n -> PositiveTrue n
$cnegate :: forall n. Num n => PositiveTrue n -> PositiveTrue n
* :: PositiveTrue n -> PositiveTrue n -> PositiveTrue n
$c* :: forall n.
Num n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
- :: PositiveTrue n -> PositiveTrue n -> PositiveTrue n
$c- :: forall n.
Num n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
+ :: PositiveTrue n -> PositiveTrue n -> PositiveTrue n
$c+ :: forall n.
Num n =>
PositiveTrue n -> PositiveTrue n -> PositiveTrue n
Num, a -> PositiveTrue b -> PositiveTrue a
(a -> b) -> PositiveTrue a -> PositiveTrue b
(forall a b. (a -> b) -> PositiveTrue a -> PositiveTrue b)
-> (forall a b. a -> PositiveTrue b -> PositiveTrue a)
-> Functor PositiveTrue
forall a b. a -> PositiveTrue b -> PositiveTrue a
forall a b. (a -> b) -> PositiveTrue a -> PositiveTrue b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> PositiveTrue b -> PositiveTrue a
$c<$ :: forall a b. a -> PositiveTrue b -> PositiveTrue a
fmap :: (a -> b) -> PositiveTrue a -> PositiveTrue b
$cfmap :: forall a b. (a -> b) -> PositiveTrue a -> PositiveTrue b
Functor, PositiveTrue a -> Bool
(a -> m) -> PositiveTrue a -> m
(a -> b -> b) -> b -> PositiveTrue a -> b
(forall m. Monoid m => PositiveTrue m -> m)
-> (forall m a. Monoid m => (a -> m) -> PositiveTrue a -> m)
-> (forall m a. Monoid m => (a -> m) -> PositiveTrue a -> m)
-> (forall a b. (a -> b -> b) -> b -> PositiveTrue a -> b)
-> (forall a b. (a -> b -> b) -> b -> PositiveTrue a -> b)
-> (forall b a. (b -> a -> b) -> b -> PositiveTrue a -> b)
-> (forall b a. (b -> a -> b) -> b -> PositiveTrue a -> b)
-> (forall a. (a -> a -> a) -> PositiveTrue a -> a)
-> (forall a. (a -> a -> a) -> PositiveTrue a -> a)
-> (forall a. PositiveTrue a -> [a])
-> (forall a. PositiveTrue a -> Bool)
-> (forall a. PositiveTrue a -> Int)
-> (forall a. Eq a => a -> PositiveTrue a -> Bool)
-> (forall a. Ord a => PositiveTrue a -> a)
-> (forall a. Ord a => PositiveTrue a -> a)
-> (forall a. Num a => PositiveTrue a -> a)
-> (forall a. Num a => PositiveTrue a -> a)
-> Foldable PositiveTrue
forall a. Eq a => a -> PositiveTrue a -> Bool
forall a. Num a => PositiveTrue a -> a
forall a. Ord a => PositiveTrue a -> a
forall m. Monoid m => PositiveTrue m -> m
forall a. PositiveTrue a -> Bool
forall a. PositiveTrue a -> Int
forall a. PositiveTrue a -> [a]
forall a. (a -> a -> a) -> PositiveTrue a -> a
forall m a. Monoid m => (a -> m) -> PositiveTrue a -> m
forall b a. (b -> a -> b) -> b -> PositiveTrue a -> b
forall a b. (a -> b -> b) -> b -> PositiveTrue 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 :: PositiveTrue a -> a
$cproduct :: forall a. Num a => PositiveTrue a -> a
sum :: PositiveTrue a -> a
$csum :: forall a. Num a => PositiveTrue a -> a
minimum :: PositiveTrue a -> a
$cminimum :: forall a. Ord a => PositiveTrue a -> a
maximum :: PositiveTrue a -> a
$cmaximum :: forall a. Ord a => PositiveTrue a -> a
elem :: a -> PositiveTrue a -> Bool
$celem :: forall a. Eq a => a -> PositiveTrue a -> Bool
length :: PositiveTrue a -> Int
$clength :: forall a. PositiveTrue a -> Int
null :: PositiveTrue a -> Bool
$cnull :: forall a. PositiveTrue a -> Bool
toList :: PositiveTrue a -> [a]
$ctoList :: forall a. PositiveTrue a -> [a]
foldl1 :: (a -> a -> a) -> PositiveTrue a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> PositiveTrue a -> a
foldr1 :: (a -> a -> a) -> PositiveTrue a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> PositiveTrue a -> a
foldl' :: (b -> a -> b) -> b -> PositiveTrue a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> PositiveTrue a -> b
foldl :: (b -> a -> b) -> b -> PositiveTrue a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> PositiveTrue a -> b
foldr' :: (a -> b -> b) -> b -> PositiveTrue a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> PositiveTrue a -> b
foldr :: (a -> b -> b) -> b -> PositiveTrue a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> PositiveTrue a -> b
foldMap' :: (a -> m) -> PositiveTrue a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> PositiveTrue a -> m
foldMap :: (a -> m) -> PositiveTrue a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> PositiveTrue a -> m
fold :: PositiveTrue m -> m
$cfold :: forall m. Monoid m => PositiveTrue m -> m
Foldable, Functor PositiveTrue
Foldable PositiveTrue
Functor PositiveTrue
-> Foldable PositiveTrue
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> PositiveTrue a -> f (PositiveTrue b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    PositiveTrue (f a) -> f (PositiveTrue a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> PositiveTrue a -> m (PositiveTrue b))
-> (forall (m :: * -> *) a.
    Monad m =>
    PositiveTrue (m a) -> m (PositiveTrue a))
-> Traversable PositiveTrue
(a -> f b) -> PositiveTrue a -> f (PositiveTrue 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 =>
PositiveTrue (m a) -> m (PositiveTrue a)
forall (f :: * -> *) a.
Applicative f =>
PositiveTrue (f a) -> f (PositiveTrue a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PositiveTrue a -> m (PositiveTrue b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PositiveTrue a -> f (PositiveTrue b)
sequence :: PositiveTrue (m a) -> m (PositiveTrue a)
$csequence :: forall (m :: * -> *) a.
Monad m =>
PositiveTrue (m a) -> m (PositiveTrue a)
mapM :: (a -> m b) -> PositiveTrue a -> m (PositiveTrue b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> PositiveTrue a -> m (PositiveTrue b)
sequenceA :: PositiveTrue (f a) -> f (PositiveTrue a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
PositiveTrue (f a) -> f (PositiveTrue a)
traverse :: (a -> f b) -> PositiveTrue a -> f (PositiveTrue b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PositiveTrue a -> f (PositiveTrue b)
$cp2Traversable :: Foldable PositiveTrue
$cp1Traversable :: Functor PositiveTrue
Traversable)

instance (Ord n, Num n) => Truthy (PositiveTrue n) where
  type BooleanRep (PositiveTrue n) = Bool
  truthy :: PositiveTrue n -> BooleanRep (PositiveTrue n)
truthy (PositiveTrue n
n) = n
n n -> n -> Bool
forall a. Ord a => a -> a -> Bool
> n
0

-- | A wrapper for 'Foldable' data structures that is converted by 'truthy' to 'False' if it is empty
newtype EmptyFalse f x = EmptyFalse { EmptyFalse f x -> f x
unEmptyFalse :: f x } deriving (Int -> EmptyFalse f x -> ShowS
[EmptyFalse f x] -> ShowS
EmptyFalse f x -> String
(Int -> EmptyFalse f x -> ShowS)
-> (EmptyFalse f x -> String)
-> ([EmptyFalse f x] -> ShowS)
-> Show (EmptyFalse f x)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) x.
Show (f x) =>
Int -> EmptyFalse f x -> ShowS
forall (f :: * -> *) x. Show (f x) => [EmptyFalse f x] -> ShowS
forall (f :: * -> *) x. Show (f x) => EmptyFalse f x -> String
showList :: [EmptyFalse f x] -> ShowS
$cshowList :: forall (f :: * -> *) x. Show (f x) => [EmptyFalse f x] -> ShowS
show :: EmptyFalse f x -> String
$cshow :: forall (f :: * -> *) x. Show (f x) => EmptyFalse f x -> String
showsPrec :: Int -> EmptyFalse f x -> ShowS
$cshowsPrec :: forall (f :: * -> *) x.
Show (f x) =>
Int -> EmptyFalse f x -> ShowS
Show, EmptyFalse f x -> EmptyFalse f x -> Bool
(EmptyFalse f x -> EmptyFalse f x -> Bool)
-> (EmptyFalse f x -> EmptyFalse f x -> Bool)
-> Eq (EmptyFalse f x)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) x.
Eq (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
/= :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c/= :: forall (f :: * -> *) x.
Eq (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
== :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c== :: forall (f :: * -> *) x.
Eq (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
Eq, Eq (EmptyFalse f x)
Eq (EmptyFalse f x)
-> (EmptyFalse f x -> EmptyFalse f x -> Ordering)
-> (EmptyFalse f x -> EmptyFalse f x -> Bool)
-> (EmptyFalse f x -> EmptyFalse f x -> Bool)
-> (EmptyFalse f x -> EmptyFalse f x -> Bool)
-> (EmptyFalse f x -> EmptyFalse f x -> Bool)
-> (EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x)
-> (EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x)
-> Ord (EmptyFalse f x)
EmptyFalse f x -> EmptyFalse f x -> Bool
EmptyFalse f x -> EmptyFalse f x -> Ordering
EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
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 (f :: * -> *) x. Ord (f x) => Eq (EmptyFalse f x)
forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Ordering
forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
min :: EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
$cmin :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
max :: EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
$cmax :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> EmptyFalse f x
>= :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c>= :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
> :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c> :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
<= :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c<= :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
< :: EmptyFalse f x -> EmptyFalse f x -> Bool
$c< :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Bool
compare :: EmptyFalse f x -> EmptyFalse f x -> Ordering
$ccompare :: forall (f :: * -> *) x.
Ord (f x) =>
EmptyFalse f x -> EmptyFalse f x -> Ordering
$cp1Ord :: forall (f :: * -> *) x. Ord (f x) => Eq (EmptyFalse f x)
Ord, a -> EmptyFalse f b -> EmptyFalse f a
(a -> b) -> EmptyFalse f a -> EmptyFalse f b
(forall a b. (a -> b) -> EmptyFalse f a -> EmptyFalse f b)
-> (forall a b. a -> EmptyFalse f b -> EmptyFalse f a)
-> Functor (EmptyFalse f)
forall a b. a -> EmptyFalse f b -> EmptyFalse f a
forall a b. (a -> b) -> EmptyFalse f a -> EmptyFalse f b
forall (f :: * -> *) a b.
Functor f =>
a -> EmptyFalse f b -> EmptyFalse f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> EmptyFalse f a -> EmptyFalse f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> EmptyFalse f b -> EmptyFalse f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> EmptyFalse f b -> EmptyFalse f a
fmap :: (a -> b) -> EmptyFalse f a -> EmptyFalse f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> EmptyFalse f a -> EmptyFalse f b
Functor, a -> EmptyFalse f a -> Bool
EmptyFalse f m -> m
EmptyFalse f a -> [a]
EmptyFalse f a -> Bool
EmptyFalse f a -> Int
EmptyFalse f a -> a
EmptyFalse f a -> a
EmptyFalse f a -> a
EmptyFalse f a -> a
(a -> m) -> EmptyFalse f a -> m
(a -> m) -> EmptyFalse f a -> m
(a -> b -> b) -> b -> EmptyFalse f a -> b
(a -> b -> b) -> b -> EmptyFalse f a -> b
(b -> a -> b) -> b -> EmptyFalse f a -> b
(b -> a -> b) -> b -> EmptyFalse f a -> b
(a -> a -> a) -> EmptyFalse f a -> a
(a -> a -> a) -> EmptyFalse f a -> a
(forall m. Monoid m => EmptyFalse f m -> m)
-> (forall m a. Monoid m => (a -> m) -> EmptyFalse f a -> m)
-> (forall m a. Monoid m => (a -> m) -> EmptyFalse f a -> m)
-> (forall a b. (a -> b -> b) -> b -> EmptyFalse f a -> b)
-> (forall a b. (a -> b -> b) -> b -> EmptyFalse f a -> b)
-> (forall b a. (b -> a -> b) -> b -> EmptyFalse f a -> b)
-> (forall b a. (b -> a -> b) -> b -> EmptyFalse f a -> b)
-> (forall a. (a -> a -> a) -> EmptyFalse f a -> a)
-> (forall a. (a -> a -> a) -> EmptyFalse f a -> a)
-> (forall a. EmptyFalse f a -> [a])
-> (forall a. EmptyFalse f a -> Bool)
-> (forall a. EmptyFalse f a -> Int)
-> (forall a. Eq a => a -> EmptyFalse f a -> Bool)
-> (forall a. Ord a => EmptyFalse f a -> a)
-> (forall a. Ord a => EmptyFalse f a -> a)
-> (forall a. Num a => EmptyFalse f a -> a)
-> (forall a. Num a => EmptyFalse f a -> a)
-> Foldable (EmptyFalse f)
forall a. Eq a => a -> EmptyFalse f a -> Bool
forall a. Num a => EmptyFalse f a -> a
forall a. Ord a => EmptyFalse f a -> a
forall m. Monoid m => EmptyFalse f m -> m
forall a. EmptyFalse f a -> Bool
forall a. EmptyFalse f a -> Int
forall a. EmptyFalse f a -> [a]
forall a. (a -> a -> a) -> EmptyFalse f a -> a
forall m a. Monoid m => (a -> m) -> EmptyFalse f a -> m
forall b a. (b -> a -> b) -> b -> EmptyFalse f a -> b
forall a b. (a -> b -> b) -> b -> EmptyFalse f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> EmptyFalse f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => EmptyFalse f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => EmptyFalse f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
EmptyFalse f m -> m
forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> Bool
forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> Int
forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> EmptyFalse f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> EmptyFalse f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> EmptyFalse f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> EmptyFalse 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 :: EmptyFalse f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => EmptyFalse f a -> a
sum :: EmptyFalse f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => EmptyFalse f a -> a
minimum :: EmptyFalse f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => EmptyFalse f a -> a
maximum :: EmptyFalse f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => EmptyFalse f a -> a
elem :: a -> EmptyFalse f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> EmptyFalse f a -> Bool
length :: EmptyFalse f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> Int
null :: EmptyFalse f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> Bool
toList :: EmptyFalse f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => EmptyFalse f a -> [a]
foldl1 :: (a -> a -> a) -> EmptyFalse f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> EmptyFalse f a -> a
foldr1 :: (a -> a -> a) -> EmptyFalse f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> EmptyFalse f a -> a
foldl' :: (b -> a -> b) -> b -> EmptyFalse f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> EmptyFalse f a -> b
foldl :: (b -> a -> b) -> b -> EmptyFalse f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> EmptyFalse f a -> b
foldr' :: (a -> b -> b) -> b -> EmptyFalse f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> EmptyFalse f a -> b
foldr :: (a -> b -> b) -> b -> EmptyFalse f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> EmptyFalse f a -> b
foldMap' :: (a -> m) -> EmptyFalse f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> EmptyFalse f a -> m
foldMap :: (a -> m) -> EmptyFalse f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> EmptyFalse f a -> m
fold :: EmptyFalse f m -> m
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
EmptyFalse f m -> m
Foldable, Functor (EmptyFalse f)
Foldable (EmptyFalse f)
Functor (EmptyFalse f)
-> Foldable (EmptyFalse f)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> EmptyFalse f a -> f (EmptyFalse f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    EmptyFalse f (f a) -> f (EmptyFalse f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> EmptyFalse f a -> m (EmptyFalse f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    EmptyFalse f (m a) -> m (EmptyFalse f a))
-> Traversable (EmptyFalse f)
(a -> f b) -> EmptyFalse f a -> f (EmptyFalse 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 (EmptyFalse f)
forall (f :: * -> *). Traversable f => Foldable (EmptyFalse f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
EmptyFalse f (m a) -> m (EmptyFalse f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
EmptyFalse f (f a) -> f (EmptyFalse f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> EmptyFalse f a -> m (EmptyFalse f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> EmptyFalse f a -> f (EmptyFalse f b)
forall (m :: * -> *) a.
Monad m =>
EmptyFalse f (m a) -> m (EmptyFalse f a)
forall (f :: * -> *) a.
Applicative f =>
EmptyFalse f (f a) -> f (EmptyFalse f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> EmptyFalse f a -> m (EmptyFalse f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> EmptyFalse f a -> f (EmptyFalse f b)
sequence :: EmptyFalse f (m a) -> m (EmptyFalse f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
EmptyFalse f (m a) -> m (EmptyFalse f a)
mapM :: (a -> m b) -> EmptyFalse f a -> m (EmptyFalse f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> EmptyFalse f a -> m (EmptyFalse f b)
sequenceA :: EmptyFalse f (f a) -> f (EmptyFalse f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
EmptyFalse f (f a) -> f (EmptyFalse f a)
traverse :: (a -> f b) -> EmptyFalse f a -> f (EmptyFalse f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> EmptyFalse f a -> f (EmptyFalse f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (EmptyFalse f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (EmptyFalse f)
Traversable)

instance Foldable f => Truthy (EmptyFalse f x) where
  type BooleanRep (EmptyFalse f x) = Bool
  truthy :: EmptyFalse f x -> BooleanRep (EmptyFalse f x)
truthy (EmptyFalse f x
xs) = f x -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null f x
xs

-- | A wrapper for 'Foldable' data structures that 'truthy' evaluates by '(&&*)'-ing all elements
newtype AllTrue f x = AllTrue { AllTrue f x -> f x
unAllTrue :: f x } deriving (Int -> AllTrue f x -> ShowS
[AllTrue f x] -> ShowS
AllTrue f x -> String
(Int -> AllTrue f x -> ShowS)
-> (AllTrue f x -> String)
-> ([AllTrue f x] -> ShowS)
-> Show (AllTrue f x)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) x. Show (f x) => Int -> AllTrue f x -> ShowS
forall (f :: * -> *) x. Show (f x) => [AllTrue f x] -> ShowS
forall (f :: * -> *) x. Show (f x) => AllTrue f x -> String
showList :: [AllTrue f x] -> ShowS
$cshowList :: forall (f :: * -> *) x. Show (f x) => [AllTrue f x] -> ShowS
show :: AllTrue f x -> String
$cshow :: forall (f :: * -> *) x. Show (f x) => AllTrue f x -> String
showsPrec :: Int -> AllTrue f x -> ShowS
$cshowsPrec :: forall (f :: * -> *) x. Show (f x) => Int -> AllTrue f x -> ShowS
Show, AllTrue f x -> AllTrue f x -> Bool
(AllTrue f x -> AllTrue f x -> Bool)
-> (AllTrue f x -> AllTrue f x -> Bool) -> Eq (AllTrue f x)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) x.
Eq (f x) =>
AllTrue f x -> AllTrue f x -> Bool
/= :: AllTrue f x -> AllTrue f x -> Bool
$c/= :: forall (f :: * -> *) x.
Eq (f x) =>
AllTrue f x -> AllTrue f x -> Bool
== :: AllTrue f x -> AllTrue f x -> Bool
$c== :: forall (f :: * -> *) x.
Eq (f x) =>
AllTrue f x -> AllTrue f x -> Bool
Eq, Eq (AllTrue f x)
Eq (AllTrue f x)
-> (AllTrue f x -> AllTrue f x -> Ordering)
-> (AllTrue f x -> AllTrue f x -> Bool)
-> (AllTrue f x -> AllTrue f x -> Bool)
-> (AllTrue f x -> AllTrue f x -> Bool)
-> (AllTrue f x -> AllTrue f x -> Bool)
-> (AllTrue f x -> AllTrue f x -> AllTrue f x)
-> (AllTrue f x -> AllTrue f x -> AllTrue f x)
-> Ord (AllTrue f x)
AllTrue f x -> AllTrue f x -> Bool
AllTrue f x -> AllTrue f x -> Ordering
AllTrue f x -> AllTrue f x -> AllTrue f x
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 (f :: * -> *) x. Ord (f x) => Eq (AllTrue f x)
forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Bool
forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Ordering
forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> AllTrue f x
min :: AllTrue f x -> AllTrue f x -> AllTrue f x
$cmin :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> AllTrue f x
max :: AllTrue f x -> AllTrue f x -> AllTrue f x
$cmax :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> AllTrue f x
>= :: AllTrue f x -> AllTrue f x -> Bool
$c>= :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Bool
> :: AllTrue f x -> AllTrue f x -> Bool
$c> :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Bool
<= :: AllTrue f x -> AllTrue f x -> Bool
$c<= :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Bool
< :: AllTrue f x -> AllTrue f x -> Bool
$c< :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Bool
compare :: AllTrue f x -> AllTrue f x -> Ordering
$ccompare :: forall (f :: * -> *) x.
Ord (f x) =>
AllTrue f x -> AllTrue f x -> Ordering
$cp1Ord :: forall (f :: * -> *) x. Ord (f x) => Eq (AllTrue f x)
Ord, a -> AllTrue f b -> AllTrue f a
(a -> b) -> AllTrue f a -> AllTrue f b
(forall a b. (a -> b) -> AllTrue f a -> AllTrue f b)
-> (forall a b. a -> AllTrue f b -> AllTrue f a)
-> Functor (AllTrue f)
forall a b. a -> AllTrue f b -> AllTrue f a
forall a b. (a -> b) -> AllTrue f a -> AllTrue f b
forall (f :: * -> *) a b.
Functor f =>
a -> AllTrue f b -> AllTrue f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AllTrue f a -> AllTrue f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AllTrue f b -> AllTrue f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> AllTrue f b -> AllTrue f a
fmap :: (a -> b) -> AllTrue f a -> AllTrue f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AllTrue f a -> AllTrue f b
Functor, a -> AllTrue f a -> Bool
AllTrue f m -> m
AllTrue f a -> [a]
AllTrue f a -> Bool
AllTrue f a -> Int
AllTrue f a -> a
AllTrue f a -> a
AllTrue f a -> a
AllTrue f a -> a
(a -> m) -> AllTrue f a -> m
(a -> m) -> AllTrue f a -> m
(a -> b -> b) -> b -> AllTrue f a -> b
(a -> b -> b) -> b -> AllTrue f a -> b
(b -> a -> b) -> b -> AllTrue f a -> b
(b -> a -> b) -> b -> AllTrue f a -> b
(a -> a -> a) -> AllTrue f a -> a
(a -> a -> a) -> AllTrue f a -> a
(forall m. Monoid m => AllTrue f m -> m)
-> (forall m a. Monoid m => (a -> m) -> AllTrue f a -> m)
-> (forall m a. Monoid m => (a -> m) -> AllTrue f a -> m)
-> (forall a b. (a -> b -> b) -> b -> AllTrue f a -> b)
-> (forall a b. (a -> b -> b) -> b -> AllTrue f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AllTrue f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AllTrue f a -> b)
-> (forall a. (a -> a -> a) -> AllTrue f a -> a)
-> (forall a. (a -> a -> a) -> AllTrue f a -> a)
-> (forall a. AllTrue f a -> [a])
-> (forall a. AllTrue f a -> Bool)
-> (forall a. AllTrue f a -> Int)
-> (forall a. Eq a => a -> AllTrue f a -> Bool)
-> (forall a. Ord a => AllTrue f a -> a)
-> (forall a. Ord a => AllTrue f a -> a)
-> (forall a. Num a => AllTrue f a -> a)
-> (forall a. Num a => AllTrue f a -> a)
-> Foldable (AllTrue f)
forall a. Eq a => a -> AllTrue f a -> Bool
forall a. Num a => AllTrue f a -> a
forall a. Ord a => AllTrue f a -> a
forall m. Monoid m => AllTrue f m -> m
forall a. AllTrue f a -> Bool
forall a. AllTrue f a -> Int
forall a. AllTrue f a -> [a]
forall a. (a -> a -> a) -> AllTrue f a -> a
forall m a. Monoid m => (a -> m) -> AllTrue f a -> m
forall b a. (b -> a -> b) -> b -> AllTrue f a -> b
forall a b. (a -> b -> b) -> b -> AllTrue f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AllTrue f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => AllTrue f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => AllTrue f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => AllTrue f m -> m
forall (f :: * -> *) a. Foldable f => AllTrue f a -> Bool
forall (f :: * -> *) a. Foldable f => AllTrue f a -> Int
forall (f :: * -> *) a. Foldable f => AllTrue f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTrue f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTrue f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTrue f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTrue 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 :: AllTrue f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => AllTrue f a -> a
sum :: AllTrue f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => AllTrue f a -> a
minimum :: AllTrue f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AllTrue f a -> a
maximum :: AllTrue f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AllTrue f a -> a
elem :: a -> AllTrue f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AllTrue f a -> Bool
length :: AllTrue f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => AllTrue f a -> Int
null :: AllTrue f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => AllTrue f a -> Bool
toList :: AllTrue f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => AllTrue f a -> [a]
foldl1 :: (a -> a -> a) -> AllTrue f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTrue f a -> a
foldr1 :: (a -> a -> a) -> AllTrue f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTrue f a -> a
foldl' :: (b -> a -> b) -> b -> AllTrue f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTrue f a -> b
foldl :: (b -> a -> b) -> b -> AllTrue f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTrue f a -> b
foldr' :: (a -> b -> b) -> b -> AllTrue f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTrue f a -> b
foldr :: (a -> b -> b) -> b -> AllTrue f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTrue f a -> b
foldMap' :: (a -> m) -> AllTrue f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTrue f a -> m
foldMap :: (a -> m) -> AllTrue f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTrue f a -> m
fold :: AllTrue f m -> m
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => AllTrue f m -> m
Foldable, Functor (AllTrue f)
Foldable (AllTrue f)
Functor (AllTrue f)
-> Foldable (AllTrue f)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AllTrue f a -> f (AllTrue f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AllTrue f (f a) -> f (AllTrue f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AllTrue f a -> m (AllTrue f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AllTrue f (m a) -> m (AllTrue f a))
-> Traversable (AllTrue f)
(a -> f b) -> AllTrue f a -> f (AllTrue 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 (AllTrue f)
forall (f :: * -> *). Traversable f => Foldable (AllTrue f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AllTrue f (m a) -> m (AllTrue f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AllTrue f (f a) -> f (AllTrue f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AllTrue f a -> m (AllTrue f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AllTrue f a -> f (AllTrue f b)
forall (m :: * -> *) a.
Monad m =>
AllTrue f (m a) -> m (AllTrue f a)
forall (f :: * -> *) a.
Applicative f =>
AllTrue f (f a) -> f (AllTrue f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AllTrue f a -> m (AllTrue f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AllTrue f a -> f (AllTrue f b)
sequence :: AllTrue f (m a) -> m (AllTrue f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AllTrue f (m a) -> m (AllTrue f a)
mapM :: (a -> m b) -> AllTrue f a -> m (AllTrue f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AllTrue f a -> m (AllTrue f b)
sequenceA :: AllTrue f (f a) -> f (AllTrue f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AllTrue f (f a) -> f (AllTrue f a)
traverse :: (a -> f b) -> AllTrue f a -> f (AllTrue f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AllTrue f a -> f (AllTrue f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (AllTrue f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (AllTrue f)
Traversable)

instance (Foldable f, Boolean x) => Truthy (AllTrue f x) where
  type BooleanRep (AllTrue f x) = x
  truthy :: AllTrue f x -> BooleanRep (AllTrue f x)
truthy (AllTrue f x
xs) = (x -> x -> x) -> x -> f x -> x
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr x -> x -> x
forall b. Boolean b => b -> b -> b
(&&*) x
forall b. Boolean b => b
true f x
xs

-- | A wrapper for 'Foldable' data structures that 'truthy' evaluates by '(&&*)'-ing all elements’ boolean representations
newtype AllTruthy f x = AllTruthy { AllTruthy f x -> f x
unAllTruthy :: f x } deriving (Int -> AllTruthy f x -> ShowS
[AllTruthy f x] -> ShowS
AllTruthy f x -> String
(Int -> AllTruthy f x -> ShowS)
-> (AllTruthy f x -> String)
-> ([AllTruthy f x] -> ShowS)
-> Show (AllTruthy f x)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) x. Show (f x) => Int -> AllTruthy f x -> ShowS
forall (f :: * -> *) x. Show (f x) => [AllTruthy f x] -> ShowS
forall (f :: * -> *) x. Show (f x) => AllTruthy f x -> String
showList :: [AllTruthy f x] -> ShowS
$cshowList :: forall (f :: * -> *) x. Show (f x) => [AllTruthy f x] -> ShowS
show :: AllTruthy f x -> String
$cshow :: forall (f :: * -> *) x. Show (f x) => AllTruthy f x -> String
showsPrec :: Int -> AllTruthy f x -> ShowS
$cshowsPrec :: forall (f :: * -> *) x. Show (f x) => Int -> AllTruthy f x -> ShowS
Show, AllTruthy f x -> AllTruthy f x -> Bool
(AllTruthy f x -> AllTruthy f x -> Bool)
-> (AllTruthy f x -> AllTruthy f x -> Bool) -> Eq (AllTruthy f x)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) x.
Eq (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
/= :: AllTruthy f x -> AllTruthy f x -> Bool
$c/= :: forall (f :: * -> *) x.
Eq (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
== :: AllTruthy f x -> AllTruthy f x -> Bool
$c== :: forall (f :: * -> *) x.
Eq (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
Eq, Eq (AllTruthy f x)
Eq (AllTruthy f x)
-> (AllTruthy f x -> AllTruthy f x -> Ordering)
-> (AllTruthy f x -> AllTruthy f x -> Bool)
-> (AllTruthy f x -> AllTruthy f x -> Bool)
-> (AllTruthy f x -> AllTruthy f x -> Bool)
-> (AllTruthy f x -> AllTruthy f x -> Bool)
-> (AllTruthy f x -> AllTruthy f x -> AllTruthy f x)
-> (AllTruthy f x -> AllTruthy f x -> AllTruthy f x)
-> Ord (AllTruthy f x)
AllTruthy f x -> AllTruthy f x -> Bool
AllTruthy f x -> AllTruthy f x -> Ordering
AllTruthy f x -> AllTruthy f x -> AllTruthy f x
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 (f :: * -> *) x. Ord (f x) => Eq (AllTruthy f x)
forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Ordering
forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> AllTruthy f x
min :: AllTruthy f x -> AllTruthy f x -> AllTruthy f x
$cmin :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> AllTruthy f x
max :: AllTruthy f x -> AllTruthy f x -> AllTruthy f x
$cmax :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> AllTruthy f x
>= :: AllTruthy f x -> AllTruthy f x -> Bool
$c>= :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
> :: AllTruthy f x -> AllTruthy f x -> Bool
$c> :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
<= :: AllTruthy f x -> AllTruthy f x -> Bool
$c<= :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
< :: AllTruthy f x -> AllTruthy f x -> Bool
$c< :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Bool
compare :: AllTruthy f x -> AllTruthy f x -> Ordering
$ccompare :: forall (f :: * -> *) x.
Ord (f x) =>
AllTruthy f x -> AllTruthy f x -> Ordering
$cp1Ord :: forall (f :: * -> *) x. Ord (f x) => Eq (AllTruthy f x)
Ord, a -> AllTruthy f b -> AllTruthy f a
(a -> b) -> AllTruthy f a -> AllTruthy f b
(forall a b. (a -> b) -> AllTruthy f a -> AllTruthy f b)
-> (forall a b. a -> AllTruthy f b -> AllTruthy f a)
-> Functor (AllTruthy f)
forall a b. a -> AllTruthy f b -> AllTruthy f a
forall a b. (a -> b) -> AllTruthy f a -> AllTruthy f b
forall (f :: * -> *) a b.
Functor f =>
a -> AllTruthy f b -> AllTruthy f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AllTruthy f a -> AllTruthy f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AllTruthy f b -> AllTruthy f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> AllTruthy f b -> AllTruthy f a
fmap :: (a -> b) -> AllTruthy f a -> AllTruthy f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AllTruthy f a -> AllTruthy f b
Functor, a -> AllTruthy f a -> Bool
AllTruthy f m -> m
AllTruthy f a -> [a]
AllTruthy f a -> Bool
AllTruthy f a -> Int
AllTruthy f a -> a
AllTruthy f a -> a
AllTruthy f a -> a
AllTruthy f a -> a
(a -> m) -> AllTruthy f a -> m
(a -> m) -> AllTruthy f a -> m
(a -> b -> b) -> b -> AllTruthy f a -> b
(a -> b -> b) -> b -> AllTruthy f a -> b
(b -> a -> b) -> b -> AllTruthy f a -> b
(b -> a -> b) -> b -> AllTruthy f a -> b
(a -> a -> a) -> AllTruthy f a -> a
(a -> a -> a) -> AllTruthy f a -> a
(forall m. Monoid m => AllTruthy f m -> m)
-> (forall m a. Monoid m => (a -> m) -> AllTruthy f a -> m)
-> (forall m a. Monoid m => (a -> m) -> AllTruthy f a -> m)
-> (forall a b. (a -> b -> b) -> b -> AllTruthy f a -> b)
-> (forall a b. (a -> b -> b) -> b -> AllTruthy f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AllTruthy f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AllTruthy f a -> b)
-> (forall a. (a -> a -> a) -> AllTruthy f a -> a)
-> (forall a. (a -> a -> a) -> AllTruthy f a -> a)
-> (forall a. AllTruthy f a -> [a])
-> (forall a. AllTruthy f a -> Bool)
-> (forall a. AllTruthy f a -> Int)
-> (forall a. Eq a => a -> AllTruthy f a -> Bool)
-> (forall a. Ord a => AllTruthy f a -> a)
-> (forall a. Ord a => AllTruthy f a -> a)
-> (forall a. Num a => AllTruthy f a -> a)
-> (forall a. Num a => AllTruthy f a -> a)
-> Foldable (AllTruthy f)
forall a. Eq a => a -> AllTruthy f a -> Bool
forall a. Num a => AllTruthy f a -> a
forall a. Ord a => AllTruthy f a -> a
forall m. Monoid m => AllTruthy f m -> m
forall a. AllTruthy f a -> Bool
forall a. AllTruthy f a -> Int
forall a. AllTruthy f a -> [a]
forall a. (a -> a -> a) -> AllTruthy f a -> a
forall m a. Monoid m => (a -> m) -> AllTruthy f a -> m
forall b a. (b -> a -> b) -> b -> AllTruthy f a -> b
forall a b. (a -> b -> b) -> b -> AllTruthy f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AllTruthy f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => AllTruthy f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => AllTruthy f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
AllTruthy f m -> m
forall (f :: * -> *) a. Foldable f => AllTruthy f a -> Bool
forall (f :: * -> *) a. Foldable f => AllTruthy f a -> Int
forall (f :: * -> *) a. Foldable f => AllTruthy f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTruthy f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTruthy f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTruthy f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTruthy 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 :: AllTruthy f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => AllTruthy f a -> a
sum :: AllTruthy f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => AllTruthy f a -> a
minimum :: AllTruthy f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AllTruthy f a -> a
maximum :: AllTruthy f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AllTruthy f a -> a
elem :: a -> AllTruthy f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AllTruthy f a -> Bool
length :: AllTruthy f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => AllTruthy f a -> Int
null :: AllTruthy f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => AllTruthy f a -> Bool
toList :: AllTruthy f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => AllTruthy f a -> [a]
foldl1 :: (a -> a -> a) -> AllTruthy f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTruthy f a -> a
foldr1 :: (a -> a -> a) -> AllTruthy f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AllTruthy f a -> a
foldl' :: (b -> a -> b) -> b -> AllTruthy f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTruthy f a -> b
foldl :: (b -> a -> b) -> b -> AllTruthy f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AllTruthy f a -> b
foldr' :: (a -> b -> b) -> b -> AllTruthy f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTruthy f a -> b
foldr :: (a -> b -> b) -> b -> AllTruthy f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AllTruthy f a -> b
foldMap' :: (a -> m) -> AllTruthy f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTruthy f a -> m
foldMap :: (a -> m) -> AllTruthy f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AllTruthy f a -> m
fold :: AllTruthy f m -> m
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
AllTruthy f m -> m
Foldable, Functor (AllTruthy f)
Foldable (AllTruthy f)
Functor (AllTruthy f)
-> Foldable (AllTruthy f)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AllTruthy f a -> f (AllTruthy f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AllTruthy f (f a) -> f (AllTruthy f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AllTruthy f a -> m (AllTruthy f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AllTruthy f (m a) -> m (AllTruthy f a))
-> Traversable (AllTruthy f)
(a -> f b) -> AllTruthy f a -> f (AllTruthy 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 (AllTruthy f)
forall (f :: * -> *). Traversable f => Foldable (AllTruthy f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AllTruthy f (m a) -> m (AllTruthy f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AllTruthy f (f a) -> f (AllTruthy f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AllTruthy f a -> m (AllTruthy f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AllTruthy f a -> f (AllTruthy f b)
forall (m :: * -> *) a.
Monad m =>
AllTruthy f (m a) -> m (AllTruthy f a)
forall (f :: * -> *) a.
Applicative f =>
AllTruthy f (f a) -> f (AllTruthy f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AllTruthy f a -> m (AllTruthy f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AllTruthy f a -> f (AllTruthy f b)
sequence :: AllTruthy f (m a) -> m (AllTruthy f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AllTruthy f (m a) -> m (AllTruthy f a)
mapM :: (a -> m b) -> AllTruthy f a -> m (AllTruthy f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AllTruthy f a -> m (AllTruthy f b)
sequenceA :: AllTruthy f (f a) -> f (AllTruthy f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AllTruthy f (f a) -> f (AllTruthy f a)
traverse :: (a -> f b) -> AllTruthy f a -> f (AllTruthy f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AllTruthy f a -> f (AllTruthy f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (AllTruthy f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (AllTruthy f)
Traversable)

instance (Functor f, Foldable f, Truthy x) => Truthy (AllTruthy f x) where
  type BooleanRep (AllTruthy f x) = BooleanRep x
  truthy :: AllTruthy f x -> BooleanRep (AllTruthy f x)
truthy (AllTruthy f x
xs) = (BooleanRep x -> BooleanRep x -> BooleanRep x)
-> BooleanRep x -> f (BooleanRep x) -> BooleanRep x
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr BooleanRep x -> BooleanRep x -> BooleanRep x
forall b. Boolean b => b -> b -> b
(&&*) BooleanRep x
forall b. Boolean b => b
true (f (BooleanRep x) -> BooleanRep x)
-> f (BooleanRep x) -> BooleanRep x
forall a b. (a -> b) -> a -> b
$ x -> BooleanRep x
forall b. Truthy b => b -> BooleanRep b
truthy (x -> BooleanRep x) -> f x -> f (BooleanRep x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f x
xs

-- | A wrapper for 'Foldable' data structures that 'truthy' evaluates by '(||*)'-ing all elements
newtype AnyTrue f x = AnyTrue { AnyTrue f x -> f x
unAnyTrue :: f x } deriving (Int -> AnyTrue f x -> ShowS
[AnyTrue f x] -> ShowS
AnyTrue f x -> String
(Int -> AnyTrue f x -> ShowS)
-> (AnyTrue f x -> String)
-> ([AnyTrue f x] -> ShowS)
-> Show (AnyTrue f x)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) x. Show (f x) => Int -> AnyTrue f x -> ShowS
forall (f :: * -> *) x. Show (f x) => [AnyTrue f x] -> ShowS
forall (f :: * -> *) x. Show (f x) => AnyTrue f x -> String
showList :: [AnyTrue f x] -> ShowS
$cshowList :: forall (f :: * -> *) x. Show (f x) => [AnyTrue f x] -> ShowS
show :: AnyTrue f x -> String
$cshow :: forall (f :: * -> *) x. Show (f x) => AnyTrue f x -> String
showsPrec :: Int -> AnyTrue f x -> ShowS
$cshowsPrec :: forall (f :: * -> *) x. Show (f x) => Int -> AnyTrue f x -> ShowS
Show, AnyTrue f x -> AnyTrue f x -> Bool
(AnyTrue f x -> AnyTrue f x -> Bool)
-> (AnyTrue f x -> AnyTrue f x -> Bool) -> Eq (AnyTrue f x)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) x.
Eq (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
/= :: AnyTrue f x -> AnyTrue f x -> Bool
$c/= :: forall (f :: * -> *) x.
Eq (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
== :: AnyTrue f x -> AnyTrue f x -> Bool
$c== :: forall (f :: * -> *) x.
Eq (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
Eq, Eq (AnyTrue f x)
Eq (AnyTrue f x)
-> (AnyTrue f x -> AnyTrue f x -> Ordering)
-> (AnyTrue f x -> AnyTrue f x -> Bool)
-> (AnyTrue f x -> AnyTrue f x -> Bool)
-> (AnyTrue f x -> AnyTrue f x -> Bool)
-> (AnyTrue f x -> AnyTrue f x -> Bool)
-> (AnyTrue f x -> AnyTrue f x -> AnyTrue f x)
-> (AnyTrue f x -> AnyTrue f x -> AnyTrue f x)
-> Ord (AnyTrue f x)
AnyTrue f x -> AnyTrue f x -> Bool
AnyTrue f x -> AnyTrue f x -> Ordering
AnyTrue f x -> AnyTrue f x -> AnyTrue f x
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 (f :: * -> *) x. Ord (f x) => Eq (AnyTrue f x)
forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Ordering
forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> AnyTrue f x
min :: AnyTrue f x -> AnyTrue f x -> AnyTrue f x
$cmin :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> AnyTrue f x
max :: AnyTrue f x -> AnyTrue f x -> AnyTrue f x
$cmax :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> AnyTrue f x
>= :: AnyTrue f x -> AnyTrue f x -> Bool
$c>= :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
> :: AnyTrue f x -> AnyTrue f x -> Bool
$c> :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
<= :: AnyTrue f x -> AnyTrue f x -> Bool
$c<= :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
< :: AnyTrue f x -> AnyTrue f x -> Bool
$c< :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Bool
compare :: AnyTrue f x -> AnyTrue f x -> Ordering
$ccompare :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTrue f x -> AnyTrue f x -> Ordering
$cp1Ord :: forall (f :: * -> *) x. Ord (f x) => Eq (AnyTrue f x)
Ord, a -> AnyTrue f b -> AnyTrue f a
(a -> b) -> AnyTrue f a -> AnyTrue f b
(forall a b. (a -> b) -> AnyTrue f a -> AnyTrue f b)
-> (forall a b. a -> AnyTrue f b -> AnyTrue f a)
-> Functor (AnyTrue f)
forall a b. a -> AnyTrue f b -> AnyTrue f a
forall a b. (a -> b) -> AnyTrue f a -> AnyTrue f b
forall (f :: * -> *) a b.
Functor f =>
a -> AnyTrue f b -> AnyTrue f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AnyTrue f a -> AnyTrue f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AnyTrue f b -> AnyTrue f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> AnyTrue f b -> AnyTrue f a
fmap :: (a -> b) -> AnyTrue f a -> AnyTrue f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AnyTrue f a -> AnyTrue f b
Functor, a -> AnyTrue f a -> Bool
AnyTrue f m -> m
AnyTrue f a -> [a]
AnyTrue f a -> Bool
AnyTrue f a -> Int
AnyTrue f a -> a
AnyTrue f a -> a
AnyTrue f a -> a
AnyTrue f a -> a
(a -> m) -> AnyTrue f a -> m
(a -> m) -> AnyTrue f a -> m
(a -> b -> b) -> b -> AnyTrue f a -> b
(a -> b -> b) -> b -> AnyTrue f a -> b
(b -> a -> b) -> b -> AnyTrue f a -> b
(b -> a -> b) -> b -> AnyTrue f a -> b
(a -> a -> a) -> AnyTrue f a -> a
(a -> a -> a) -> AnyTrue f a -> a
(forall m. Monoid m => AnyTrue f m -> m)
-> (forall m a. Monoid m => (a -> m) -> AnyTrue f a -> m)
-> (forall m a. Monoid m => (a -> m) -> AnyTrue f a -> m)
-> (forall a b. (a -> b -> b) -> b -> AnyTrue f a -> b)
-> (forall a b. (a -> b -> b) -> b -> AnyTrue f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnyTrue f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnyTrue f a -> b)
-> (forall a. (a -> a -> a) -> AnyTrue f a -> a)
-> (forall a. (a -> a -> a) -> AnyTrue f a -> a)
-> (forall a. AnyTrue f a -> [a])
-> (forall a. AnyTrue f a -> Bool)
-> (forall a. AnyTrue f a -> Int)
-> (forall a. Eq a => a -> AnyTrue f a -> Bool)
-> (forall a. Ord a => AnyTrue f a -> a)
-> (forall a. Ord a => AnyTrue f a -> a)
-> (forall a. Num a => AnyTrue f a -> a)
-> (forall a. Num a => AnyTrue f a -> a)
-> Foldable (AnyTrue f)
forall a. Eq a => a -> AnyTrue f a -> Bool
forall a. Num a => AnyTrue f a -> a
forall a. Ord a => AnyTrue f a -> a
forall m. Monoid m => AnyTrue f m -> m
forall a. AnyTrue f a -> Bool
forall a. AnyTrue f a -> Int
forall a. AnyTrue f a -> [a]
forall a. (a -> a -> a) -> AnyTrue f a -> a
forall m a. Monoid m => (a -> m) -> AnyTrue f a -> m
forall b a. (b -> a -> b) -> b -> AnyTrue f a -> b
forall a b. (a -> b -> b) -> b -> AnyTrue f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AnyTrue f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => AnyTrue f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTrue f a -> a
forall (f :: * -> *) m. (Foldable f, Monoid m) => AnyTrue f m -> m
forall (f :: * -> *) a. Foldable f => AnyTrue f a -> Bool
forall (f :: * -> *) a. Foldable f => AnyTrue f a -> Int
forall (f :: * -> *) a. Foldable f => AnyTrue f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTrue f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTrue f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTrue f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTrue 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 :: AnyTrue f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => AnyTrue f a -> a
sum :: AnyTrue f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => AnyTrue f a -> a
minimum :: AnyTrue f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTrue f a -> a
maximum :: AnyTrue f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTrue f a -> a
elem :: a -> AnyTrue f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AnyTrue f a -> Bool
length :: AnyTrue f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => AnyTrue f a -> Int
null :: AnyTrue f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => AnyTrue f a -> Bool
toList :: AnyTrue f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => AnyTrue f a -> [a]
foldl1 :: (a -> a -> a) -> AnyTrue f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTrue f a -> a
foldr1 :: (a -> a -> a) -> AnyTrue f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTrue f a -> a
foldl' :: (b -> a -> b) -> b -> AnyTrue f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTrue f a -> b
foldl :: (b -> a -> b) -> b -> AnyTrue f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTrue f a -> b
foldr' :: (a -> b -> b) -> b -> AnyTrue f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTrue f a -> b
foldr :: (a -> b -> b) -> b -> AnyTrue f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTrue f a -> b
foldMap' :: (a -> m) -> AnyTrue f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTrue f a -> m
foldMap :: (a -> m) -> AnyTrue f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTrue f a -> m
fold :: AnyTrue f m -> m
$cfold :: forall (f :: * -> *) m. (Foldable f, Monoid m) => AnyTrue f m -> m
Foldable, Functor (AnyTrue f)
Foldable (AnyTrue f)
Functor (AnyTrue f)
-> Foldable (AnyTrue f)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AnyTrue f a -> f (AnyTrue f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AnyTrue f (f a) -> f (AnyTrue f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AnyTrue f a -> m (AnyTrue f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AnyTrue f (m a) -> m (AnyTrue f a))
-> Traversable (AnyTrue f)
(a -> f b) -> AnyTrue f a -> f (AnyTrue 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 (AnyTrue f)
forall (f :: * -> *). Traversable f => Foldable (AnyTrue f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AnyTrue f (m a) -> m (AnyTrue f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AnyTrue f (f a) -> f (AnyTrue f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AnyTrue f a -> m (AnyTrue f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AnyTrue f a -> f (AnyTrue f b)
forall (m :: * -> *) a.
Monad m =>
AnyTrue f (m a) -> m (AnyTrue f a)
forall (f :: * -> *) a.
Applicative f =>
AnyTrue f (f a) -> f (AnyTrue f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnyTrue f a -> m (AnyTrue f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnyTrue f a -> f (AnyTrue f b)
sequence :: AnyTrue f (m a) -> m (AnyTrue f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AnyTrue f (m a) -> m (AnyTrue f a)
mapM :: (a -> m b) -> AnyTrue f a -> m (AnyTrue f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AnyTrue f a -> m (AnyTrue f b)
sequenceA :: AnyTrue f (f a) -> f (AnyTrue f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AnyTrue f (f a) -> f (AnyTrue f a)
traverse :: (a -> f b) -> AnyTrue f a -> f (AnyTrue f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AnyTrue f a -> f (AnyTrue f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (AnyTrue f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (AnyTrue f)
Traversable)

instance (Foldable f, Boolean x) => Truthy (AnyTrue f x) where
  type BooleanRep (AnyTrue f x) = x
  truthy :: AnyTrue f x -> BooleanRep (AnyTrue f x)
truthy (AnyTrue f x
xs) = (x -> x -> x) -> x -> f x -> x
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr x -> x -> x
forall b. Boolean b => b -> b -> b
(||*) x
forall b. Boolean b => b
false f x
xs

-- | A wrapper for 'Foldable' data structures that 'truthy' evaluates by '(||*)'-ing all elements’ boolean representations
newtype AnyTruthy f x = AnyTruthy { AnyTruthy f x -> f x
unAnyTruthy :: f x } deriving (Int -> AnyTruthy f x -> ShowS
[AnyTruthy f x] -> ShowS
AnyTruthy f x -> String
(Int -> AnyTruthy f x -> ShowS)
-> (AnyTruthy f x -> String)
-> ([AnyTruthy f x] -> ShowS)
-> Show (AnyTruthy f x)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall (f :: * -> *) x. Show (f x) => Int -> AnyTruthy f x -> ShowS
forall (f :: * -> *) x. Show (f x) => [AnyTruthy f x] -> ShowS
forall (f :: * -> *) x. Show (f x) => AnyTruthy f x -> String
showList :: [AnyTruthy f x] -> ShowS
$cshowList :: forall (f :: * -> *) x. Show (f x) => [AnyTruthy f x] -> ShowS
show :: AnyTruthy f x -> String
$cshow :: forall (f :: * -> *) x. Show (f x) => AnyTruthy f x -> String
showsPrec :: Int -> AnyTruthy f x -> ShowS
$cshowsPrec :: forall (f :: * -> *) x. Show (f x) => Int -> AnyTruthy f x -> ShowS
Show, AnyTruthy f x -> AnyTruthy f x -> Bool
(AnyTruthy f x -> AnyTruthy f x -> Bool)
-> (AnyTruthy f x -> AnyTruthy f x -> Bool) -> Eq (AnyTruthy f x)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall (f :: * -> *) x.
Eq (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
/= :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c/= :: forall (f :: * -> *) x.
Eq (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
== :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c== :: forall (f :: * -> *) x.
Eq (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
Eq, Eq (AnyTruthy f x)
Eq (AnyTruthy f x)
-> (AnyTruthy f x -> AnyTruthy f x -> Ordering)
-> (AnyTruthy f x -> AnyTruthy f x -> Bool)
-> (AnyTruthy f x -> AnyTruthy f x -> Bool)
-> (AnyTruthy f x -> AnyTruthy f x -> Bool)
-> (AnyTruthy f x -> AnyTruthy f x -> Bool)
-> (AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x)
-> (AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x)
-> Ord (AnyTruthy f x)
AnyTruthy f x -> AnyTruthy f x -> Bool
AnyTruthy f x -> AnyTruthy f x -> Ordering
AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
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 (f :: * -> *) x. Ord (f x) => Eq (AnyTruthy f x)
forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Ordering
forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
min :: AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
$cmin :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
max :: AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
$cmax :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> AnyTruthy f x
>= :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c>= :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
> :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c> :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
<= :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c<= :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
< :: AnyTruthy f x -> AnyTruthy f x -> Bool
$c< :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Bool
compare :: AnyTruthy f x -> AnyTruthy f x -> Ordering
$ccompare :: forall (f :: * -> *) x.
Ord (f x) =>
AnyTruthy f x -> AnyTruthy f x -> Ordering
$cp1Ord :: forall (f :: * -> *) x. Ord (f x) => Eq (AnyTruthy f x)
Ord, a -> AnyTruthy f b -> AnyTruthy f a
(a -> b) -> AnyTruthy f a -> AnyTruthy f b
(forall a b. (a -> b) -> AnyTruthy f a -> AnyTruthy f b)
-> (forall a b. a -> AnyTruthy f b -> AnyTruthy f a)
-> Functor (AnyTruthy f)
forall a b. a -> AnyTruthy f b -> AnyTruthy f a
forall a b. (a -> b) -> AnyTruthy f a -> AnyTruthy f b
forall (f :: * -> *) a b.
Functor f =>
a -> AnyTruthy f b -> AnyTruthy f a
forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AnyTruthy f a -> AnyTruthy f b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> AnyTruthy f b -> AnyTruthy f a
$c<$ :: forall (f :: * -> *) a b.
Functor f =>
a -> AnyTruthy f b -> AnyTruthy f a
fmap :: (a -> b) -> AnyTruthy f a -> AnyTruthy f b
$cfmap :: forall (f :: * -> *) a b.
Functor f =>
(a -> b) -> AnyTruthy f a -> AnyTruthy f b
Functor, a -> AnyTruthy f a -> Bool
AnyTruthy f m -> m
AnyTruthy f a -> [a]
AnyTruthy f a -> Bool
AnyTruthy f a -> Int
AnyTruthy f a -> a
AnyTruthy f a -> a
AnyTruthy f a -> a
AnyTruthy f a -> a
(a -> m) -> AnyTruthy f a -> m
(a -> m) -> AnyTruthy f a -> m
(a -> b -> b) -> b -> AnyTruthy f a -> b
(a -> b -> b) -> b -> AnyTruthy f a -> b
(b -> a -> b) -> b -> AnyTruthy f a -> b
(b -> a -> b) -> b -> AnyTruthy f a -> b
(a -> a -> a) -> AnyTruthy f a -> a
(a -> a -> a) -> AnyTruthy f a -> a
(forall m. Monoid m => AnyTruthy f m -> m)
-> (forall m a. Monoid m => (a -> m) -> AnyTruthy f a -> m)
-> (forall m a. Monoid m => (a -> m) -> AnyTruthy f a -> m)
-> (forall a b. (a -> b -> b) -> b -> AnyTruthy f a -> b)
-> (forall a b. (a -> b -> b) -> b -> AnyTruthy f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnyTruthy f a -> b)
-> (forall b a. (b -> a -> b) -> b -> AnyTruthy f a -> b)
-> (forall a. (a -> a -> a) -> AnyTruthy f a -> a)
-> (forall a. (a -> a -> a) -> AnyTruthy f a -> a)
-> (forall a. AnyTruthy f a -> [a])
-> (forall a. AnyTruthy f a -> Bool)
-> (forall a. AnyTruthy f a -> Int)
-> (forall a. Eq a => a -> AnyTruthy f a -> Bool)
-> (forall a. Ord a => AnyTruthy f a -> a)
-> (forall a. Ord a => AnyTruthy f a -> a)
-> (forall a. Num a => AnyTruthy f a -> a)
-> (forall a. Num a => AnyTruthy f a -> a)
-> Foldable (AnyTruthy f)
forall a. Eq a => a -> AnyTruthy f a -> Bool
forall a. Num a => AnyTruthy f a -> a
forall a. Ord a => AnyTruthy f a -> a
forall m. Monoid m => AnyTruthy f m -> m
forall a. AnyTruthy f a -> Bool
forall a. AnyTruthy f a -> Int
forall a. AnyTruthy f a -> [a]
forall a. (a -> a -> a) -> AnyTruthy f a -> a
forall m a. Monoid m => (a -> m) -> AnyTruthy f a -> m
forall b a. (b -> a -> b) -> b -> AnyTruthy f a -> b
forall a b. (a -> b -> b) -> b -> AnyTruthy f a -> b
forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AnyTruthy f a -> Bool
forall (f :: * -> *) a. (Foldable f, Num a) => AnyTruthy f a -> a
forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTruthy f a -> a
forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
AnyTruthy f m -> m
forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> Bool
forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> Int
forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> [a]
forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTruthy f a -> a
forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTruthy f a -> m
forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTruthy f a -> b
forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTruthy 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 :: AnyTruthy f a -> a
$cproduct :: forall (f :: * -> *) a. (Foldable f, Num a) => AnyTruthy f a -> a
sum :: AnyTruthy f a -> a
$csum :: forall (f :: * -> *) a. (Foldable f, Num a) => AnyTruthy f a -> a
minimum :: AnyTruthy f a -> a
$cminimum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTruthy f a -> a
maximum :: AnyTruthy f a -> a
$cmaximum :: forall (f :: * -> *) a. (Foldable f, Ord a) => AnyTruthy f a -> a
elem :: a -> AnyTruthy f a -> Bool
$celem :: forall (f :: * -> *) a.
(Foldable f, Eq a) =>
a -> AnyTruthy f a -> Bool
length :: AnyTruthy f a -> Int
$clength :: forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> Int
null :: AnyTruthy f a -> Bool
$cnull :: forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> Bool
toList :: AnyTruthy f a -> [a]
$ctoList :: forall (f :: * -> *) a. Foldable f => AnyTruthy f a -> [a]
foldl1 :: (a -> a -> a) -> AnyTruthy f a -> a
$cfoldl1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTruthy f a -> a
foldr1 :: (a -> a -> a) -> AnyTruthy f a -> a
$cfoldr1 :: forall (f :: * -> *) a.
Foldable f =>
(a -> a -> a) -> AnyTruthy f a -> a
foldl' :: (b -> a -> b) -> b -> AnyTruthy f a -> b
$cfoldl' :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTruthy f a -> b
foldl :: (b -> a -> b) -> b -> AnyTruthy f a -> b
$cfoldl :: forall (f :: * -> *) b a.
Foldable f =>
(b -> a -> b) -> b -> AnyTruthy f a -> b
foldr' :: (a -> b -> b) -> b -> AnyTruthy f a -> b
$cfoldr' :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTruthy f a -> b
foldr :: (a -> b -> b) -> b -> AnyTruthy f a -> b
$cfoldr :: forall (f :: * -> *) a b.
Foldable f =>
(a -> b -> b) -> b -> AnyTruthy f a -> b
foldMap' :: (a -> m) -> AnyTruthy f a -> m
$cfoldMap' :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTruthy f a -> m
foldMap :: (a -> m) -> AnyTruthy f a -> m
$cfoldMap :: forall (f :: * -> *) m a.
(Foldable f, Monoid m) =>
(a -> m) -> AnyTruthy f a -> m
fold :: AnyTruthy f m -> m
$cfold :: forall (f :: * -> *) m.
(Foldable f, Monoid m) =>
AnyTruthy f m -> m
Foldable, Functor (AnyTruthy f)
Foldable (AnyTruthy f)
Functor (AnyTruthy f)
-> Foldable (AnyTruthy f)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> AnyTruthy f a -> f (AnyTruthy f b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    AnyTruthy f (f a) -> f (AnyTruthy f a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> AnyTruthy f a -> m (AnyTruthy f b))
-> (forall (m :: * -> *) a.
    Monad m =>
    AnyTruthy f (m a) -> m (AnyTruthy f a))
-> Traversable (AnyTruthy f)
(a -> f b) -> AnyTruthy f a -> f (AnyTruthy 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 (AnyTruthy f)
forall (f :: * -> *). Traversable f => Foldable (AnyTruthy f)
forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AnyTruthy f (m a) -> m (AnyTruthy f a)
forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AnyTruthy f (f a) -> f (AnyTruthy f a)
forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AnyTruthy f a -> m (AnyTruthy f b)
forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AnyTruthy f a -> f (AnyTruthy f b)
forall (m :: * -> *) a.
Monad m =>
AnyTruthy f (m a) -> m (AnyTruthy f a)
forall (f :: * -> *) a.
Applicative f =>
AnyTruthy f (f a) -> f (AnyTruthy f a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> AnyTruthy f a -> m (AnyTruthy f b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> AnyTruthy f a -> f (AnyTruthy f b)
sequence :: AnyTruthy f (m a) -> m (AnyTruthy f a)
$csequence :: forall (f :: * -> *) (m :: * -> *) a.
(Traversable f, Monad m) =>
AnyTruthy f (m a) -> m (AnyTruthy f a)
mapM :: (a -> m b) -> AnyTruthy f a -> m (AnyTruthy f b)
$cmapM :: forall (f :: * -> *) (m :: * -> *) a b.
(Traversable f, Monad m) =>
(a -> m b) -> AnyTruthy f a -> m (AnyTruthy f b)
sequenceA :: AnyTruthy f (f a) -> f (AnyTruthy f a)
$csequenceA :: forall (f :: * -> *) (f :: * -> *) a.
(Traversable f, Applicative f) =>
AnyTruthy f (f a) -> f (AnyTruthy f a)
traverse :: (a -> f b) -> AnyTruthy f a -> f (AnyTruthy f b)
$ctraverse :: forall (f :: * -> *) (f :: * -> *) a b.
(Traversable f, Applicative f) =>
(a -> f b) -> AnyTruthy f a -> f (AnyTruthy f b)
$cp2Traversable :: forall (f :: * -> *). Traversable f => Foldable (AnyTruthy f)
$cp1Traversable :: forall (f :: * -> *). Traversable f => Functor (AnyTruthy f)
Traversable)

instance (Functor f, Foldable f, Truthy x) => Truthy (AnyTruthy f x) where
  type BooleanRep (AnyTruthy f x) = BooleanRep x
  truthy :: AnyTruthy f x -> BooleanRep (AnyTruthy f x)
truthy (AnyTruthy f x
xs) = (BooleanRep x -> BooleanRep x -> BooleanRep x)
-> BooleanRep x -> f (BooleanRep x) -> BooleanRep x
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr BooleanRep x -> BooleanRep x -> BooleanRep x
forall b. Boolean b => b -> b -> b
(||*) BooleanRep x
forall b. Boolean b => b
false (f (BooleanRep x) -> BooleanRep x)
-> f (BooleanRep x) -> BooleanRep x
forall a b. (a -> b) -> a -> b
$ x -> BooleanRep x
forall b. Truthy b => b -> BooleanRep b
truthy (x -> BooleanRep x) -> f x -> f (BooleanRep x)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f x
xs

-- | A wrapper for 'Truthy' instances that inverts their 'truthy' value
newtype Contrary b = Contrary { Contrary b -> b
unContrary :: b } deriving (Int -> Contrary b -> ShowS
[Contrary b] -> ShowS
Contrary b -> String
(Int -> Contrary b -> ShowS)
-> (Contrary b -> String)
-> ([Contrary b] -> ShowS)
-> Show (Contrary b)
forall b. Show b => Int -> Contrary b -> ShowS
forall b. Show b => [Contrary b] -> ShowS
forall b. Show b => Contrary b -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Contrary b] -> ShowS
$cshowList :: forall b. Show b => [Contrary b] -> ShowS
show :: Contrary b -> String
$cshow :: forall b. Show b => Contrary b -> String
showsPrec :: Int -> Contrary b -> ShowS
$cshowsPrec :: forall b. Show b => Int -> Contrary b -> ShowS
Show, Contrary b -> Contrary b -> Bool
(Contrary b -> Contrary b -> Bool)
-> (Contrary b -> Contrary b -> Bool) -> Eq (Contrary b)
forall b. Eq b => Contrary b -> Contrary b -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Contrary b -> Contrary b -> Bool
$c/= :: forall b. Eq b => Contrary b -> Contrary b -> Bool
== :: Contrary b -> Contrary b -> Bool
$c== :: forall b. Eq b => Contrary b -> Contrary b -> Bool
Eq, Eq (Contrary b)
Eq (Contrary b)
-> (Contrary b -> Contrary b -> Ordering)
-> (Contrary b -> Contrary b -> Bool)
-> (Contrary b -> Contrary b -> Bool)
-> (Contrary b -> Contrary b -> Bool)
-> (Contrary b -> Contrary b -> Bool)
-> (Contrary b -> Contrary b -> Contrary b)
-> (Contrary b -> Contrary b -> Contrary b)
-> Ord (Contrary b)
Contrary b -> Contrary b -> Bool
Contrary b -> Contrary b -> Ordering
Contrary b -> Contrary b -> Contrary b
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 b. Ord b => Eq (Contrary b)
forall b. Ord b => Contrary b -> Contrary b -> Bool
forall b. Ord b => Contrary b -> Contrary b -> Ordering
forall b. Ord b => Contrary b -> Contrary b -> Contrary b
min :: Contrary b -> Contrary b -> Contrary b
$cmin :: forall b. Ord b => Contrary b -> Contrary b -> Contrary b
max :: Contrary b -> Contrary b -> Contrary b
$cmax :: forall b. Ord b => Contrary b -> Contrary b -> Contrary b
>= :: Contrary b -> Contrary b -> Bool
$c>= :: forall b. Ord b => Contrary b -> Contrary b -> Bool
> :: Contrary b -> Contrary b -> Bool
$c> :: forall b. Ord b => Contrary b -> Contrary b -> Bool
<= :: Contrary b -> Contrary b -> Bool
$c<= :: forall b. Ord b => Contrary b -> Contrary b -> Bool
< :: Contrary b -> Contrary b -> Bool
$c< :: forall b. Ord b => Contrary b -> Contrary b -> Bool
compare :: Contrary b -> Contrary b -> Ordering
$ccompare :: forall b. Ord b => Contrary b -> Contrary b -> Ordering
$cp1Ord :: forall b. Ord b => Eq (Contrary b)
Ord, a -> Contrary b -> Contrary a
(a -> b) -> Contrary a -> Contrary b
(forall a b. (a -> b) -> Contrary a -> Contrary b)
-> (forall a b. a -> Contrary b -> Contrary a) -> Functor Contrary
forall a b. a -> Contrary b -> Contrary a
forall a b. (a -> b) -> Contrary a -> Contrary b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Contrary b -> Contrary a
$c<$ :: forall a b. a -> Contrary b -> Contrary a
fmap :: (a -> b) -> Contrary a -> Contrary b
$cfmap :: forall a b. (a -> b) -> Contrary a -> Contrary b
Functor, Contrary a -> Bool
(a -> m) -> Contrary a -> m
(a -> b -> b) -> b -> Contrary a -> b
(forall m. Monoid m => Contrary m -> m)
-> (forall m a. Monoid m => (a -> m) -> Contrary a -> m)
-> (forall m a. Monoid m => (a -> m) -> Contrary a -> m)
-> (forall a b. (a -> b -> b) -> b -> Contrary a -> b)
-> (forall a b. (a -> b -> b) -> b -> Contrary a -> b)
-> (forall b a. (b -> a -> b) -> b -> Contrary a -> b)
-> (forall b a. (b -> a -> b) -> b -> Contrary a -> b)
-> (forall a. (a -> a -> a) -> Contrary a -> a)
-> (forall a. (a -> a -> a) -> Contrary a -> a)
-> (forall a. Contrary a -> [a])
-> (forall a. Contrary a -> Bool)
-> (forall a. Contrary a -> Int)
-> (forall a. Eq a => a -> Contrary a -> Bool)
-> (forall a. Ord a => Contrary a -> a)
-> (forall a. Ord a => Contrary a -> a)
-> (forall a. Num a => Contrary a -> a)
-> (forall a. Num a => Contrary a -> a)
-> Foldable Contrary
forall a. Eq a => a -> Contrary a -> Bool
forall a. Num a => Contrary a -> a
forall a. Ord a => Contrary a -> a
forall m. Monoid m => Contrary m -> m
forall a. Contrary a -> Bool
forall a. Contrary a -> Int
forall a. Contrary a -> [a]
forall a. (a -> a -> a) -> Contrary a -> a
forall m a. Monoid m => (a -> m) -> Contrary a -> m
forall b a. (b -> a -> b) -> b -> Contrary a -> b
forall a b. (a -> b -> b) -> b -> Contrary 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 :: Contrary a -> a
$cproduct :: forall a. Num a => Contrary a -> a
sum :: Contrary a -> a
$csum :: forall a. Num a => Contrary a -> a
minimum :: Contrary a -> a
$cminimum :: forall a. Ord a => Contrary a -> a
maximum :: Contrary a -> a
$cmaximum :: forall a. Ord a => Contrary a -> a
elem :: a -> Contrary a -> Bool
$celem :: forall a. Eq a => a -> Contrary a -> Bool
length :: Contrary a -> Int
$clength :: forall a. Contrary a -> Int
null :: Contrary a -> Bool
$cnull :: forall a. Contrary a -> Bool
toList :: Contrary a -> [a]
$ctoList :: forall a. Contrary a -> [a]
foldl1 :: (a -> a -> a) -> Contrary a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Contrary a -> a
foldr1 :: (a -> a -> a) -> Contrary a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Contrary a -> a
foldl' :: (b -> a -> b) -> b -> Contrary a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Contrary a -> b
foldl :: (b -> a -> b) -> b -> Contrary a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Contrary a -> b
foldr' :: (a -> b -> b) -> b -> Contrary a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Contrary a -> b
foldr :: (a -> b -> b) -> b -> Contrary a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Contrary a -> b
foldMap' :: (a -> m) -> Contrary a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Contrary a -> m
foldMap :: (a -> m) -> Contrary a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Contrary a -> m
fold :: Contrary m -> m
$cfold :: forall m. Monoid m => Contrary m -> m
Foldable, Functor Contrary
Foldable Contrary
Functor Contrary
-> Foldable Contrary
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> Contrary a -> f (Contrary b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Contrary (f a) -> f (Contrary a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Contrary a -> m (Contrary b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Contrary (m a) -> m (Contrary a))
-> Traversable Contrary
(a -> f b) -> Contrary a -> f (Contrary 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 => Contrary (m a) -> m (Contrary a)
forall (f :: * -> *) a.
Applicative f =>
Contrary (f a) -> f (Contrary a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Contrary a -> m (Contrary b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Contrary a -> f (Contrary b)
sequence :: Contrary (m a) -> m (Contrary a)
$csequence :: forall (m :: * -> *) a. Monad m => Contrary (m a) -> m (Contrary a)
mapM :: (a -> m b) -> Contrary a -> m (Contrary b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Contrary a -> m (Contrary b)
sequenceA :: Contrary (f a) -> f (Contrary a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Contrary (f a) -> f (Contrary a)
traverse :: (a -> f b) -> Contrary a -> f (Contrary b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Contrary a -> f (Contrary b)
$cp2Traversable :: Foldable Contrary
$cp1Traversable :: Functor Contrary
Traversable)

instance Truthy b => Truthy (Contrary b) where
  type BooleanRep (Contrary b) = BooleanRep b
  truthy :: Contrary b -> BooleanRep (Contrary b)
truthy (Contrary b
b) = BooleanRep b -> BooleanRep b
forall b. Boolean b => b -> b
notB (BooleanRep b -> BooleanRep b) -> BooleanRep b -> BooleanRep b
forall a b. (a -> b) -> a -> b
$ b -> BooleanRep b
forall b. Truthy b => b -> BooleanRep b
truthy b
b