{-# OPTIONS_HADDOCK show-extensions #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

{- |
Module: Data.Applicable
Description: The 'Applicable' class
Copyright: ⓒ 2022 Anselm Schüler
License: MIT
Maintainer: mail@anselmschueler.com

The 'Applicable' class with its operator '($*)'.
You will likely need the @FlexibleContexts@ extension to use this module’s instances.
-}

module Data.Applicable (
  Applicable(($*)),
  ApplyTo,
  ApplyMap,
  ApplyAp,
  ApplyBind,
  GroupAction,
  ChurchBool,
  ChurchNumeral,
  ChurchTuple
) where

import Data.List (genericIndex)
import Data.Bifunctor (Bifunctor)

-- | A class for types whose values can be applied.
--   Instances are required to be uniquely determined by the applied and applied-to type.
class Applicable f a b | f a -> b where
  -- | Apply a value to another value, producing a result.
  ($*) :: f -> a -> b

instance Applicable (a -> b) a b where
  a -> b
f $* :: (a -> b) -> a -> b
$* a
x = a -> b
f a
x

-- | A wrapper for values.
--   Can be applied to a function '(GHC.Types.->)', applying the function to the inner value.
newtype ApplyTo a = AppTo { ApplyTo a -> a
unAppTo :: a } deriving (ApplyTo a -> ApplyTo a -> Bool
(ApplyTo a -> ApplyTo a -> Bool)
-> (ApplyTo a -> ApplyTo a -> Bool) -> Eq (ApplyTo a)
forall a. Eq a => ApplyTo a -> ApplyTo a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ApplyTo a -> ApplyTo a -> Bool
$c/= :: forall a. Eq a => ApplyTo a -> ApplyTo a -> Bool
== :: ApplyTo a -> ApplyTo a -> Bool
$c== :: forall a. Eq a => ApplyTo a -> ApplyTo a -> Bool
Eq, Eq (ApplyTo a)
Eq (ApplyTo a)
-> (ApplyTo a -> ApplyTo a -> Ordering)
-> (ApplyTo a -> ApplyTo a -> Bool)
-> (ApplyTo a -> ApplyTo a -> Bool)
-> (ApplyTo a -> ApplyTo a -> Bool)
-> (ApplyTo a -> ApplyTo a -> Bool)
-> (ApplyTo a -> ApplyTo a -> ApplyTo a)
-> (ApplyTo a -> ApplyTo a -> ApplyTo a)
-> Ord (ApplyTo a)
ApplyTo a -> ApplyTo a -> Bool
ApplyTo a -> ApplyTo a -> Ordering
ApplyTo a -> ApplyTo a -> ApplyTo a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (ApplyTo a)
forall a. Ord a => ApplyTo a -> ApplyTo a -> Bool
forall a. Ord a => ApplyTo a -> ApplyTo a -> Ordering
forall a. Ord a => ApplyTo a -> ApplyTo a -> ApplyTo a
min :: ApplyTo a -> ApplyTo a -> ApplyTo a
$cmin :: forall a. Ord a => ApplyTo a -> ApplyTo a -> ApplyTo a
max :: ApplyTo a -> ApplyTo a -> ApplyTo a
$cmax :: forall a. Ord a => ApplyTo a -> ApplyTo a -> ApplyTo a
>= :: ApplyTo a -> ApplyTo a -> Bool
$c>= :: forall a. Ord a => ApplyTo a -> ApplyTo a -> Bool
> :: ApplyTo a -> ApplyTo a -> Bool
$c> :: forall a. Ord a => ApplyTo a -> ApplyTo a -> Bool
<= :: ApplyTo a -> ApplyTo a -> Bool
$c<= :: forall a. Ord a => ApplyTo a -> ApplyTo a -> Bool
< :: ApplyTo a -> ApplyTo a -> Bool
$c< :: forall a. Ord a => ApplyTo a -> ApplyTo a -> Bool
compare :: ApplyTo a -> ApplyTo a -> Ordering
$ccompare :: forall a. Ord a => ApplyTo a -> ApplyTo a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (ApplyTo a)
Ord, Int -> ApplyTo a -> ShowS
[ApplyTo a] -> ShowS
ApplyTo a -> String
(Int -> ApplyTo a -> ShowS)
-> (ApplyTo a -> String)
-> ([ApplyTo a] -> ShowS)
-> Show (ApplyTo a)
forall a. Show a => Int -> ApplyTo a -> ShowS
forall a. Show a => [ApplyTo a] -> ShowS
forall a. Show a => ApplyTo a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ApplyTo a] -> ShowS
$cshowList :: forall a. Show a => [ApplyTo a] -> ShowS
show :: ApplyTo a -> String
$cshow :: forall a. Show a => ApplyTo a -> String
showsPrec :: Int -> ApplyTo a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ApplyTo a -> ShowS
Show, ReadPrec [ApplyTo a]
ReadPrec (ApplyTo a)
Int -> ReadS (ApplyTo a)
ReadS [ApplyTo a]
(Int -> ReadS (ApplyTo a))
-> ReadS [ApplyTo a]
-> ReadPrec (ApplyTo a)
-> ReadPrec [ApplyTo a]
-> Read (ApplyTo a)
forall a. Read a => ReadPrec [ApplyTo a]
forall a. Read a => ReadPrec (ApplyTo a)
forall a. Read a => Int -> ReadS (ApplyTo a)
forall a. Read a => ReadS [ApplyTo a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ApplyTo a]
$creadListPrec :: forall a. Read a => ReadPrec [ApplyTo a]
readPrec :: ReadPrec (ApplyTo a)
$creadPrec :: forall a. Read a => ReadPrec (ApplyTo a)
readList :: ReadS [ApplyTo a]
$creadList :: forall a. Read a => ReadS [ApplyTo a]
readsPrec :: Int -> ReadS (ApplyTo a)
$creadsPrec :: forall a. Read a => Int -> ReadS (ApplyTo a)
Read, a -> ApplyTo b -> ApplyTo a
(a -> b) -> ApplyTo a -> ApplyTo b
(forall a b. (a -> b) -> ApplyTo a -> ApplyTo b)
-> (forall a b. a -> ApplyTo b -> ApplyTo a) -> Functor ApplyTo
forall a b. a -> ApplyTo b -> ApplyTo a
forall a b. (a -> b) -> ApplyTo a -> ApplyTo b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ApplyTo b -> ApplyTo a
$c<$ :: forall a b. a -> ApplyTo b -> ApplyTo a
fmap :: (a -> b) -> ApplyTo a -> ApplyTo b
$cfmap :: forall a b. (a -> b) -> ApplyTo a -> ApplyTo b
Functor)

instance Applicable (ApplyTo a) (a -> b) b where
  AppTo a
x $* :: ApplyTo a -> (a -> b) -> b
$* a -> b
f = a -> b
f a
x

-- | A wrapper for functions.
--   Can be applied to a 'Functor', 'fmap'-ing the function over the inner values.
newtype ApplyMap a b = AppMap { ApplyMap a b -> a -> b
unAppMap :: a -> b } deriving a -> ApplyMap a b -> ApplyMap a a
(a -> b) -> ApplyMap a a -> ApplyMap a b
(forall a b. (a -> b) -> ApplyMap a a -> ApplyMap a b)
-> (forall a b. a -> ApplyMap a b -> ApplyMap a a)
-> Functor (ApplyMap a)
forall a b. a -> ApplyMap a b -> ApplyMap a a
forall a b. (a -> b) -> ApplyMap a a -> ApplyMap a b
forall a a b. a -> ApplyMap a b -> ApplyMap a a
forall a a b. (a -> b) -> ApplyMap a a -> ApplyMap a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ApplyMap a b -> ApplyMap a a
$c<$ :: forall a a b. a -> ApplyMap a b -> ApplyMap a a
fmap :: (a -> b) -> ApplyMap a a -> ApplyMap a b
$cfmap :: forall a a b. (a -> b) -> ApplyMap a a -> ApplyMap a b
Functor

instance Functor f => Applicable (ApplyMap a b) (f a) (f b) where
  AppMap a -> b
f $* :: ApplyMap a b -> f a -> f b
$* f a
xa = a -> b
f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f a
xa

-- | A wrapper for functions in an applicative functor.
--   Can be applied to an 'Applicative' functor, '(<*>)'-ing it on it.
newtype ApplyAp f a b = AppAp { ApplyAp f a b -> f (a -> b)
unAppAp :: f (a -> b) } deriving a -> ApplyAp f a b -> ApplyAp f a a
(a -> b) -> ApplyAp f a a -> ApplyAp f a b
(forall a b. (a -> b) -> ApplyAp f a a -> ApplyAp f a b)
-> (forall a b. a -> ApplyAp f a b -> ApplyAp f a a)
-> Functor (ApplyAp f a)
forall a b. a -> ApplyAp f a b -> ApplyAp f a a
forall a b. (a -> b) -> ApplyAp f a a -> ApplyAp f a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (f :: * -> *) a a b.
Functor f =>
a -> ApplyAp f a b -> ApplyAp f a a
forall (f :: * -> *) a a b.
Functor f =>
(a -> b) -> ApplyAp f a a -> ApplyAp f a b
<$ :: a -> ApplyAp f a b -> ApplyAp f a a
$c<$ :: forall (f :: * -> *) a a b.
Functor f =>
a -> ApplyAp f a b -> ApplyAp f a a
fmap :: (a -> b) -> ApplyAp f a a -> ApplyAp f a b
$cfmap :: forall (f :: * -> *) a a b.
Functor f =>
(a -> b) -> ApplyAp f a a -> ApplyAp f a b
Functor

instance Applicative f => Applicable (ApplyAp f a b) (f a) (f b) where
  AppAp f (a -> b)
f $* :: ApplyAp f a b -> f a -> f b
$* f a
xa = f (a -> b)
f f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> f a
xa

-- | A wrapper for 'Control.Arrow.Kleisli' arrows.
--   Can be applied to a 'Monad', '(>>=)'-ing it on it.
newtype ApplyBind m a b = AppBind { ApplyBind m a b -> a -> m b
unAppBind :: a -> m b } deriving a -> ApplyBind m a b -> ApplyBind m a a
(a -> b) -> ApplyBind m a a -> ApplyBind m a b
(forall a b. (a -> b) -> ApplyBind m a a -> ApplyBind m a b)
-> (forall a b. a -> ApplyBind m a b -> ApplyBind m a a)
-> Functor (ApplyBind m a)
forall a b. a -> ApplyBind m a b -> ApplyBind m a a
forall a b. (a -> b) -> ApplyBind m a a -> ApplyBind m a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
forall (m :: * -> *) a a b.
Functor m =>
a -> ApplyBind m a b -> ApplyBind m a a
forall (m :: * -> *) a a b.
Functor m =>
(a -> b) -> ApplyBind m a a -> ApplyBind m a b
<$ :: a -> ApplyBind m a b -> ApplyBind m a a
$c<$ :: forall (m :: * -> *) a a b.
Functor m =>
a -> ApplyBind m a b -> ApplyBind m a a
fmap :: (a -> b) -> ApplyBind m a a -> ApplyBind m a b
$cfmap :: forall (m :: * -> *) a a b.
Functor m =>
(a -> b) -> ApplyBind m a a -> ApplyBind m a b
Functor

instance Monad m => Applicable (ApplyBind m a b) (m a) (m b) where
  AppBind a -> m b
f $* :: ApplyBind m a b -> m a -> m b
$* m a
xa = m a
xa m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= a -> m b
f

-- | A wrapper for 'Semigroup' members, representing the associated group action.
--   Can be applied to another member, '(<>)'-ing them.
newtype GroupAction a = GrpAct { GroupAction a -> a
unGrpAct :: a } deriving (GroupAction a -> GroupAction a -> Bool
(GroupAction a -> GroupAction a -> Bool)
-> (GroupAction a -> GroupAction a -> Bool) -> Eq (GroupAction a)
forall a. Eq a => GroupAction a -> GroupAction a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GroupAction a -> GroupAction a -> Bool
$c/= :: forall a. Eq a => GroupAction a -> GroupAction a -> Bool
== :: GroupAction a -> GroupAction a -> Bool
$c== :: forall a. Eq a => GroupAction a -> GroupAction a -> Bool
Eq, Eq (GroupAction a)
Eq (GroupAction a)
-> (GroupAction a -> GroupAction a -> Ordering)
-> (GroupAction a -> GroupAction a -> Bool)
-> (GroupAction a -> GroupAction a -> Bool)
-> (GroupAction a -> GroupAction a -> Bool)
-> (GroupAction a -> GroupAction a -> Bool)
-> (GroupAction a -> GroupAction a -> GroupAction a)
-> (GroupAction a -> GroupAction a -> GroupAction a)
-> Ord (GroupAction a)
GroupAction a -> GroupAction a -> Bool
GroupAction a -> GroupAction a -> Ordering
GroupAction a -> GroupAction a -> GroupAction a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (GroupAction a)
forall a. Ord a => GroupAction a -> GroupAction a -> Bool
forall a. Ord a => GroupAction a -> GroupAction a -> Ordering
forall a. Ord a => GroupAction a -> GroupAction a -> GroupAction a
min :: GroupAction a -> GroupAction a -> GroupAction a
$cmin :: forall a. Ord a => GroupAction a -> GroupAction a -> GroupAction a
max :: GroupAction a -> GroupAction a -> GroupAction a
$cmax :: forall a. Ord a => GroupAction a -> GroupAction a -> GroupAction a
>= :: GroupAction a -> GroupAction a -> Bool
$c>= :: forall a. Ord a => GroupAction a -> GroupAction a -> Bool
> :: GroupAction a -> GroupAction a -> Bool
$c> :: forall a. Ord a => GroupAction a -> GroupAction a -> Bool
<= :: GroupAction a -> GroupAction a -> Bool
$c<= :: forall a. Ord a => GroupAction a -> GroupAction a -> Bool
< :: GroupAction a -> GroupAction a -> Bool
$c< :: forall a. Ord a => GroupAction a -> GroupAction a -> Bool
compare :: GroupAction a -> GroupAction a -> Ordering
$ccompare :: forall a. Ord a => GroupAction a -> GroupAction a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (GroupAction a)
Ord, Int -> GroupAction a -> ShowS
[GroupAction a] -> ShowS
GroupAction a -> String
(Int -> GroupAction a -> ShowS)
-> (GroupAction a -> String)
-> ([GroupAction a] -> ShowS)
-> Show (GroupAction a)
forall a. Show a => Int -> GroupAction a -> ShowS
forall a. Show a => [GroupAction a] -> ShowS
forall a. Show a => GroupAction a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GroupAction a] -> ShowS
$cshowList :: forall a. Show a => [GroupAction a] -> ShowS
show :: GroupAction a -> String
$cshow :: forall a. Show a => GroupAction a -> String
showsPrec :: Int -> GroupAction a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> GroupAction a -> ShowS
Show, ReadPrec [GroupAction a]
ReadPrec (GroupAction a)
Int -> ReadS (GroupAction a)
ReadS [GroupAction a]
(Int -> ReadS (GroupAction a))
-> ReadS [GroupAction a]
-> ReadPrec (GroupAction a)
-> ReadPrec [GroupAction a]
-> Read (GroupAction a)
forall a. Read a => ReadPrec [GroupAction a]
forall a. Read a => ReadPrec (GroupAction a)
forall a. Read a => Int -> ReadS (GroupAction a)
forall a. Read a => ReadS [GroupAction a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GroupAction a]
$creadListPrec :: forall a. Read a => ReadPrec [GroupAction a]
readPrec :: ReadPrec (GroupAction a)
$creadPrec :: forall a. Read a => ReadPrec (GroupAction a)
readList :: ReadS [GroupAction a]
$creadList :: forall a. Read a => ReadS [GroupAction a]
readsPrec :: Int -> ReadS (GroupAction a)
$creadsPrec :: forall a. Read a => Int -> ReadS (GroupAction a)
Read, a -> GroupAction b -> GroupAction a
(a -> b) -> GroupAction a -> GroupAction b
(forall a b. (a -> b) -> GroupAction a -> GroupAction b)
-> (forall a b. a -> GroupAction b -> GroupAction a)
-> Functor GroupAction
forall a b. a -> GroupAction b -> GroupAction a
forall a b. (a -> b) -> GroupAction a -> GroupAction b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> GroupAction b -> GroupAction a
$c<$ :: forall a b. a -> GroupAction b -> GroupAction a
fmap :: (a -> b) -> GroupAction a -> GroupAction b
$cfmap :: forall a b. (a -> b) -> GroupAction a -> GroupAction b
Functor)

instance Semigroup a => Applicable (GroupAction a) a a where
  GrpAct a
a $* :: GroupAction a -> a -> a
$* a
b = a
a a -> a -> a
forall a. Semigroup a => a -> a -> a
<> a
b

-- | A wrapper for 'Bool's.
--   When applied to a value, uses the Church encoding of Booleans.
--   The Church encoding of Booleans is a binary function
--   that returns its first argument for 'True', and its second for 'False'.
newtype ChurchBool = ChBool { ChurchBool -> Bool
unChBool :: Bool } deriving (ChurchBool -> ChurchBool -> Bool
(ChurchBool -> ChurchBool -> Bool)
-> (ChurchBool -> ChurchBool -> Bool) -> Eq ChurchBool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChurchBool -> ChurchBool -> Bool
$c/= :: ChurchBool -> ChurchBool -> Bool
== :: ChurchBool -> ChurchBool -> Bool
$c== :: ChurchBool -> ChurchBool -> Bool
Eq, Eq ChurchBool
Eq ChurchBool
-> (ChurchBool -> ChurchBool -> Ordering)
-> (ChurchBool -> ChurchBool -> Bool)
-> (ChurchBool -> ChurchBool -> Bool)
-> (ChurchBool -> ChurchBool -> Bool)
-> (ChurchBool -> ChurchBool -> Bool)
-> (ChurchBool -> ChurchBool -> ChurchBool)
-> (ChurchBool -> ChurchBool -> ChurchBool)
-> Ord ChurchBool
ChurchBool -> ChurchBool -> Bool
ChurchBool -> ChurchBool -> Ordering
ChurchBool -> ChurchBool -> ChurchBool
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
min :: ChurchBool -> ChurchBool -> ChurchBool
$cmin :: ChurchBool -> ChurchBool -> ChurchBool
max :: ChurchBool -> ChurchBool -> ChurchBool
$cmax :: ChurchBool -> ChurchBool -> ChurchBool
>= :: ChurchBool -> ChurchBool -> Bool
$c>= :: ChurchBool -> ChurchBool -> Bool
> :: ChurchBool -> ChurchBool -> Bool
$c> :: ChurchBool -> ChurchBool -> Bool
<= :: ChurchBool -> ChurchBool -> Bool
$c<= :: ChurchBool -> ChurchBool -> Bool
< :: ChurchBool -> ChurchBool -> Bool
$c< :: ChurchBool -> ChurchBool -> Bool
compare :: ChurchBool -> ChurchBool -> Ordering
$ccompare :: ChurchBool -> ChurchBool -> Ordering
$cp1Ord :: Eq ChurchBool
Ord, Int -> ChurchBool -> ShowS
[ChurchBool] -> ShowS
ChurchBool -> String
(Int -> ChurchBool -> ShowS)
-> (ChurchBool -> String)
-> ([ChurchBool] -> ShowS)
-> Show ChurchBool
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChurchBool] -> ShowS
$cshowList :: [ChurchBool] -> ShowS
show :: ChurchBool -> String
$cshow :: ChurchBool -> String
showsPrec :: Int -> ChurchBool -> ShowS
$cshowsPrec :: Int -> ChurchBool -> ShowS
Show, ReadPrec [ChurchBool]
ReadPrec ChurchBool
Int -> ReadS ChurchBool
ReadS [ChurchBool]
(Int -> ReadS ChurchBool)
-> ReadS [ChurchBool]
-> ReadPrec ChurchBool
-> ReadPrec [ChurchBool]
-> Read ChurchBool
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ChurchBool]
$creadListPrec :: ReadPrec [ChurchBool]
readPrec :: ReadPrec ChurchBool
$creadPrec :: ReadPrec ChurchBool
readList :: ReadS [ChurchBool]
$creadList :: ReadS [ChurchBool]
readsPrec :: Int -> ReadS ChurchBool
$creadsPrec :: Int -> ReadS ChurchBool
Read, Int -> ChurchBool
ChurchBool -> Int
ChurchBool -> [ChurchBool]
ChurchBool -> ChurchBool
ChurchBool -> ChurchBool -> [ChurchBool]
ChurchBool -> ChurchBool -> ChurchBool -> [ChurchBool]
(ChurchBool -> ChurchBool)
-> (ChurchBool -> ChurchBool)
-> (Int -> ChurchBool)
-> (ChurchBool -> Int)
-> (ChurchBool -> [ChurchBool])
-> (ChurchBool -> ChurchBool -> [ChurchBool])
-> (ChurchBool -> ChurchBool -> [ChurchBool])
-> (ChurchBool -> ChurchBool -> ChurchBool -> [ChurchBool])
-> Enum ChurchBool
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
enumFromThenTo :: ChurchBool -> ChurchBool -> ChurchBool -> [ChurchBool]
$cenumFromThenTo :: ChurchBool -> ChurchBool -> ChurchBool -> [ChurchBool]
enumFromTo :: ChurchBool -> ChurchBool -> [ChurchBool]
$cenumFromTo :: ChurchBool -> ChurchBool -> [ChurchBool]
enumFromThen :: ChurchBool -> ChurchBool -> [ChurchBool]
$cenumFromThen :: ChurchBool -> ChurchBool -> [ChurchBool]
enumFrom :: ChurchBool -> [ChurchBool]
$cenumFrom :: ChurchBool -> [ChurchBool]
fromEnum :: ChurchBool -> Int
$cfromEnum :: ChurchBool -> Int
toEnum :: Int -> ChurchBool
$ctoEnum :: Int -> ChurchBool
pred :: ChurchBool -> ChurchBool
$cpred :: ChurchBool -> ChurchBool
succ :: ChurchBool -> ChurchBool
$csucc :: ChurchBool -> ChurchBool
Enum, ChurchBool
ChurchBool -> ChurchBool -> Bounded ChurchBool
forall a. a -> a -> Bounded a
maxBound :: ChurchBool
$cmaxBound :: ChurchBool
minBound :: ChurchBool
$cminBound :: ChurchBool
Bounded)

instance Applicable ChurchBool a (a -> a) where
  $* :: ChurchBool -> a -> a -> a
($*) (ChBool Bool
True) a
t a
_ = a
t
  ($*) (ChBool Bool
False) a
_ a
f = a
f

-- | Update the 'Bool' in a 'ChurchBool'.
mapChBool :: (Bool -> Bool) -> ChurchBool -> ChurchBool
mapChBool :: (Bool -> Bool) -> ChurchBool -> ChurchBool
mapChBool Bool -> Bool
f (ChBool Bool
x) = Bool -> ChurchBool
ChBool (Bool -> ChurchBool) -> Bool -> ChurchBool
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
f Bool
x

-- | A wrapper for natural numbers (Approximated by 'Integral').
--   When applied to a value, uses the Church encoding of natural numbers.
--   Church numerals represent the number _n_ as a function that take another function and repeatedly applies it _n_ times.
newtype ChurchNumeral a = ChNum { ChurchNumeral a -> a
unChNum :: a } deriving (ChurchNumeral a -> ChurchNumeral a -> Bool
(ChurchNumeral a -> ChurchNumeral a -> Bool)
-> (ChurchNumeral a -> ChurchNumeral a -> Bool)
-> Eq (ChurchNumeral a)
forall a. Eq a => ChurchNumeral a -> ChurchNumeral a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c/= :: forall a. Eq a => ChurchNumeral a -> ChurchNumeral a -> Bool
== :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c== :: forall a. Eq a => ChurchNumeral a -> ChurchNumeral a -> Bool
Eq, Eq (ChurchNumeral a)
Eq (ChurchNumeral a)
-> (ChurchNumeral a -> ChurchNumeral a -> Ordering)
-> (ChurchNumeral a -> ChurchNumeral a -> Bool)
-> (ChurchNumeral a -> ChurchNumeral a -> Bool)
-> (ChurchNumeral a -> ChurchNumeral a -> Bool)
-> (ChurchNumeral a -> ChurchNumeral a -> Bool)
-> (ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a)
-> (ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a)
-> Ord (ChurchNumeral a)
ChurchNumeral a -> ChurchNumeral a -> Bool
ChurchNumeral a -> ChurchNumeral a -> Ordering
ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (ChurchNumeral a)
forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Bool
forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Ordering
forall a.
Ord a =>
ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
min :: ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
$cmin :: forall a.
Ord a =>
ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
max :: ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
$cmax :: forall a.
Ord a =>
ChurchNumeral a -> ChurchNumeral a -> ChurchNumeral a
>= :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c>= :: forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Bool
> :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c> :: forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Bool
<= :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c<= :: forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Bool
< :: ChurchNumeral a -> ChurchNumeral a -> Bool
$c< :: forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Bool
compare :: ChurchNumeral a -> ChurchNumeral a -> Ordering
$ccompare :: forall a. Ord a => ChurchNumeral a -> ChurchNumeral a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (ChurchNumeral a)
Ord, Int -> ChurchNumeral a -> ShowS
[ChurchNumeral a] -> ShowS
ChurchNumeral a -> String
(Int -> ChurchNumeral a -> ShowS)
-> (ChurchNumeral a -> String)
-> ([ChurchNumeral a] -> ShowS)
-> Show (ChurchNumeral a)
forall a. Show a => Int -> ChurchNumeral a -> ShowS
forall a. Show a => [ChurchNumeral a] -> ShowS
forall a. Show a => ChurchNumeral a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ChurchNumeral a] -> ShowS
$cshowList :: forall a. Show a => [ChurchNumeral a] -> ShowS
show :: ChurchNumeral a -> String
$cshow :: forall a. Show a => ChurchNumeral a -> String
showsPrec :: Int -> ChurchNumeral a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> ChurchNumeral a -> ShowS
Show, ReadPrec [ChurchNumeral a]
ReadPrec (ChurchNumeral a)
Int -> ReadS (ChurchNumeral a)
ReadS [ChurchNumeral a]
(Int -> ReadS (ChurchNumeral a))
-> ReadS [ChurchNumeral a]
-> ReadPrec (ChurchNumeral a)
-> ReadPrec [ChurchNumeral a]
-> Read (ChurchNumeral a)
forall a. Read a => ReadPrec [ChurchNumeral a]
forall a. Read a => ReadPrec (ChurchNumeral a)
forall a. Read a => Int -> ReadS (ChurchNumeral a)
forall a. Read a => ReadS [ChurchNumeral a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [ChurchNumeral a]
$creadListPrec :: forall a. Read a => ReadPrec [ChurchNumeral a]
readPrec :: ReadPrec (ChurchNumeral a)
$creadPrec :: forall a. Read a => ReadPrec (ChurchNumeral a)
readList :: ReadS [ChurchNumeral a]
$creadList :: forall a. Read a => ReadS [ChurchNumeral a]
readsPrec :: Int -> ReadS (ChurchNumeral a)
$creadsPrec :: forall a. Read a => Int -> ReadS (ChurchNumeral a)
Read, a -> ChurchNumeral b -> ChurchNumeral a
(a -> b) -> ChurchNumeral a -> ChurchNumeral b
(forall a b. (a -> b) -> ChurchNumeral a -> ChurchNumeral b)
-> (forall a b. a -> ChurchNumeral b -> ChurchNumeral a)
-> Functor ChurchNumeral
forall a b. a -> ChurchNumeral b -> ChurchNumeral a
forall a b. (a -> b) -> ChurchNumeral a -> ChurchNumeral b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ChurchNumeral b -> ChurchNumeral a
$c<$ :: forall a b. a -> ChurchNumeral b -> ChurchNumeral a
fmap :: (a -> b) -> ChurchNumeral a -> ChurchNumeral b
$cfmap :: forall a b. (a -> b) -> ChurchNumeral a -> ChurchNumeral b
Functor)

instance Integral a => Applicable (ChurchNumeral a) (a -> a) (a -> a) where
  $* :: ChurchNumeral a -> (a -> a) -> a -> a
($*) (ChNum a
n) a -> a
f a
x = [a] -> a -> a
forall i a. Integral i => [a] -> i -> a
genericIndex ((a -> a) -> a -> [a]
forall a. (a -> a) -> a -> [a]
iterate a -> a
f a
x) a
n

-- | A wrapper for tuples '(,)'.
--   When applied to a value, uses the Church encoding of tuples.
--   The Church encoding of tuples applies a function to the values inside a tuple.
newtype ChurchTuple a b = ChTup { ChurchTuple a b -> (a, b)
unChTup :: (a, b) } deriving (ChurchTuple a b -> ChurchTuple a b -> Bool
(ChurchTuple a b -> ChurchTuple a b -> Bool)
-> (ChurchTuple a b -> ChurchTuple a b -> Bool)
-> Eq (ChurchTuple a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
(Eq a, Eq b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
/= :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c/= :: forall a b.
(Eq a, Eq b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
== :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c== :: forall a b.
(Eq a, Eq b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
Eq, Eq (ChurchTuple a b)
Eq (ChurchTuple a b)
-> (ChurchTuple a b -> ChurchTuple a b -> Ordering)
-> (ChurchTuple a b -> ChurchTuple a b -> Bool)
-> (ChurchTuple a b -> ChurchTuple a b -> Bool)
-> (ChurchTuple a b -> ChurchTuple a b -> Bool)
-> (ChurchTuple a b -> ChurchTuple a b -> Bool)
-> (ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b)
-> (ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b)
-> Ord (ChurchTuple a b)
ChurchTuple a b -> ChurchTuple a b -> Bool
ChurchTuple a b -> ChurchTuple a b -> Ordering
ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a 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 a b. (Ord a, Ord b) => Eq (ChurchTuple a b)
forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Ordering
forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b
min :: ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b
$cmin :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b
max :: ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b
$cmax :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> ChurchTuple a b
>= :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c>= :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
> :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c> :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
<= :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c<= :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
< :: ChurchTuple a b -> ChurchTuple a b -> Bool
$c< :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Bool
compare :: ChurchTuple a b -> ChurchTuple a b -> Ordering
$ccompare :: forall a b.
(Ord a, Ord b) =>
ChurchTuple a b -> ChurchTuple a b -> Ordering
$cp1Ord :: forall a b. (Ord a, Ord b) => Eq (ChurchTuple a b)
Ord, Int -> ChurchTuple a b -> ShowS
[ChurchTuple a b] -> ShowS
ChurchTuple a b -> String
(Int -> ChurchTuple a b -> ShowS)
-> (ChurchTuple a b -> String)
-> ([ChurchTuple a b] -> ShowS)
-> Show (ChurchTuple a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show a, Show b) => Int -> ChurchTuple a b -> ShowS
forall a b. (Show a, Show b) => [ChurchTuple a b] -> ShowS
forall a b. (Show a, Show b) => ChurchTuple a b -> String
showList :: [ChurchTuple a b] -> ShowS
$cshowList :: forall a b. (Show a, Show b) => [ChurchTuple a b] -> ShowS
show :: ChurchTuple a b -> String
$cshow :: forall a b. (Show a, Show b) => ChurchTuple a b -> String
showsPrec :: Int -> ChurchTuple a b -> ShowS
$cshowsPrec :: forall a b. (Show a, Show b) => Int -> ChurchTuple a b -> ShowS
Show, ReadPrec [ChurchTuple a b]
ReadPrec (ChurchTuple a b)
Int -> ReadS (ChurchTuple a b)
ReadS [ChurchTuple a b]
(Int -> ReadS (ChurchTuple a b))
-> ReadS [ChurchTuple a b]
-> ReadPrec (ChurchTuple a b)
-> ReadPrec [ChurchTuple a b]
-> Read (ChurchTuple a b)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall a b. (Read a, Read b) => ReadPrec [ChurchTuple a b]
forall a b. (Read a, Read b) => ReadPrec (ChurchTuple a b)
forall a b. (Read a, Read b) => Int -> ReadS (ChurchTuple a b)
forall a b. (Read a, Read b) => ReadS [ChurchTuple a b]
readListPrec :: ReadPrec [ChurchTuple a b]
$creadListPrec :: forall a b. (Read a, Read b) => ReadPrec [ChurchTuple a b]
readPrec :: ReadPrec (ChurchTuple a b)
$creadPrec :: forall a b. (Read a, Read b) => ReadPrec (ChurchTuple a b)
readList :: ReadS [ChurchTuple a b]
$creadList :: forall a b. (Read a, Read b) => ReadS [ChurchTuple a b]
readsPrec :: Int -> ReadS (ChurchTuple a b)
$creadsPrec :: forall a b. (Read a, Read b) => Int -> ReadS (ChurchTuple a b)
Read, a -> ChurchTuple a b -> ChurchTuple a a
(a -> b) -> ChurchTuple a a -> ChurchTuple a b
(forall a b. (a -> b) -> ChurchTuple a a -> ChurchTuple a b)
-> (forall a b. a -> ChurchTuple a b -> ChurchTuple a a)
-> Functor (ChurchTuple a)
forall a b. a -> ChurchTuple a b -> ChurchTuple a a
forall a b. (a -> b) -> ChurchTuple a a -> ChurchTuple a b
forall a a b. a -> ChurchTuple a b -> ChurchTuple a a
forall a a b. (a -> b) -> ChurchTuple a a -> ChurchTuple a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> ChurchTuple a b -> ChurchTuple a a
$c<$ :: forall a a b. a -> ChurchTuple a b -> ChurchTuple a a
fmap :: (a -> b) -> ChurchTuple a a -> ChurchTuple a b
$cfmap :: forall a a b. (a -> b) -> ChurchTuple a a -> ChurchTuple a b
Functor, (a -> b) -> (c -> d) -> ChurchTuple a c -> ChurchTuple b d
(a -> b) -> ChurchTuple a c -> ChurchTuple b c
(b -> c) -> ChurchTuple a b -> ChurchTuple a c
(forall a b c d.
 (a -> b) -> (c -> d) -> ChurchTuple a c -> ChurchTuple b d)
-> (forall a b c. (a -> b) -> ChurchTuple a c -> ChurchTuple b c)
-> (forall b c a. (b -> c) -> ChurchTuple a b -> ChurchTuple a c)
-> Bifunctor ChurchTuple
forall a b c. (a -> b) -> ChurchTuple a c -> ChurchTuple b c
forall b c a. (b -> c) -> ChurchTuple a b -> ChurchTuple a c
forall a b c d.
(a -> b) -> (c -> d) -> ChurchTuple a c -> ChurchTuple b d
forall (p :: * -> * -> *).
(forall a b c d. (a -> b) -> (c -> d) -> p a c -> p b d)
-> (forall a b c. (a -> b) -> p a c -> p b c)
-> (forall b c a. (b -> c) -> p a b -> p a c)
-> Bifunctor p
second :: (b -> c) -> ChurchTuple a b -> ChurchTuple a c
$csecond :: forall b c a. (b -> c) -> ChurchTuple a b -> ChurchTuple a c
first :: (a -> b) -> ChurchTuple a c -> ChurchTuple b c
$cfirst :: forall a b c. (a -> b) -> ChurchTuple a c -> ChurchTuple b c
bimap :: (a -> b) -> (c -> d) -> ChurchTuple a c -> ChurchTuple b d
$cbimap :: forall a b c d.
(a -> b) -> (c -> d) -> ChurchTuple a c -> ChurchTuple b d
Bifunctor)

instance Applicable (ChurchTuple a b) (a -> b -> c) c where
  ChTup (a
x, b
y) $* :: ChurchTuple a b -> (a -> b -> c) -> c
$* a -> b -> c
f = a -> b -> c
f a
x b
y