{-|
Module      : Control.Applicative.Logic
Description : Generalized logic operations for Applicative and Alternative functors
Copyright   : (c) Håkon Robbestad Gylterud, Year
License     : BSD-3-Clause
Maintainer  : lyesveasp@openbastille.org
Stability   : experimental
Portability : POSIX

This library contains a generalisation of local functions such as "any" and "all" to Applicative and Alternative functors.
-}
module Control.Applicative.Logic (any,or,all,and,(&&),convert,Searchable,search) where

import Control.Applicative
import Prelude hiding (any,all,and,or,(&&))

true :: (Applicative f, Monoid a) => f a
true :: forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
true = a -> f a
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
forall a. Monoid a => a
mempty

false :: (Alternative f) => f a
false :: forall (f :: * -> *) a. Alternative f => f a
false = f a
forall a. f a
forall (f :: * -> *) a. Alternative f => f a
empty

-- | Generalized version of 'Prelude.any'. It takes a predicate that returns 
-- generalised truth values in an 'Alternative' functor and applies it disjunctively to
-- a foldable structure. I.e. it applies the predicate and folds with <|>.

any :: (Alternative f, Foldable t) => (a -> f b) -> t a -> f b
any :: forall (f :: * -> *) (t :: * -> *) a b.
(Alternative f, Foldable t) =>
(a -> f b) -> t a -> f b
any = ((f b -> t a -> f b) -> f b -> t a -> f b
forall a b. (a -> b) -> a -> b
$ f b
forall (f :: * -> *) a. Alternative f => f a
false) ((f b -> t a -> f b) -> t a -> f b)
-> ((a -> f b) -> f b -> t a -> f b) -> (a -> f b) -> t a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b -> f b) -> f b -> t a -> f b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((a -> f b -> f b) -> f b -> t a -> f b)
-> ((a -> f b) -> a -> f b -> f b)
-> (a -> f b)
-> f b
-> t a
-> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (f b -> f b -> f b
forall a. f a -> f a -> f a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
(<|>) (f b -> f b -> f b) -> (a -> f b) -> a -> f b -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
.)

-- | Generalized version of 'Prelude.all'. It takes a predicate that gives generalized
-- truth values in an Applicative functor on a Monoid and applies it conjunctively to
-- a foldable structure. I.e. it applies the predicate and folds with an applicative
-- lifting of monoidal concatenation ('<>').

all :: (Applicative f, Monoid b, Foldable t)
    => (a -> f b) -> t a -> f b
all :: forall (f :: * -> *) b (t :: * -> *) a.
(Applicative f, Monoid b, Foldable t) =>
(a -> f b) -> t a -> f b
all = ((f b -> t a -> f b) -> f b -> t a -> f b
forall a b. (a -> b) -> a -> b
$ f b
forall (f :: * -> *) a. (Applicative f, Monoid a) => f a
true) ((f b -> t a -> f b) -> t a -> f b)
-> ((a -> f b) -> f b -> t a -> f b) -> (a -> f b) -> t a -> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b -> f b) -> f b -> t a -> f b
forall a b. (a -> b -> b) -> b -> t a -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((a -> f b -> f b) -> f b -> t a -> f b)
-> ((a -> f b) -> a -> f b -> f b)
-> (a -> f b)
-> f b
-> t a
-> f b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((b -> b -> b) -> f b -> f b -> f b
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 b -> b -> b
forall a. Semigroup a => a -> a -> a
(<>) (f b -> f b -> f b) -> (a -> f b) -> a -> f b -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>)


-- | Generalized version of the boolean 'or' to foldable structures of 'Alternative' functorial values.
-- It combines the elements using the alternative choice operator ('<|>').

or :: (Alternative f, Foldable t)
   => t (f a) -> f a
or :: forall (f :: * -> *) (t :: * -> *) a.
(Alternative f, Foldable t) =>
t (f a) -> f a
or = (f a -> f a) -> t (f a) -> f a
forall (f :: * -> *) (t :: * -> *) a b.
(Alternative f, Foldable t) =>
(a -> f b) -> t a -> f b
any f a -> f a
forall a. a -> a
id

-- | Generalized version of the boolean 'and' to foldable structures of
-- 'Applicative' functor applied to monoids. It combines the elements using the
-- monoidal concatenation ('<>').

and :: (Applicative f, Monoid a, Foldable t)
    => t (f a) -> f a
and :: forall (f :: * -> *) a (t :: * -> *).
(Applicative f, Monoid a, Foldable t) =>
t (f a) -> f a
and = (f a -> f a) -> t (f a) -> f a
forall (f :: * -> *) b (t :: * -> *) a.
(Applicative f, Monoid b, Foldable t) =>
(a -> f b) -> t a -> f b
all f a -> f a
forall a. a -> a
id

-- | Generalized version of the boolean '&&' operator for 'Applicative' functors applied to monoids.
--   It sequences and combines two applicative values using the monoidal operation ('<>').
(&&) :: (Applicative f, Monoid a)
     => f a -> f a -> f a
&& :: forall (f :: * -> *) a.
(Applicative f, Monoid a) =>
f a -> f a -> f a
(&&) = (a -> a -> a) -> f a -> f a -> f a
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> a
forall a. Semigroup a => a -> a -> a
(<>)

-- | Converts a foldable structure into an 'Alternative' functor, where each element is lifted into the
-- functor using 'pure' and then combined using the alternative choice operator ('<|>').
--
convert :: (Alternative f, Foldable t)
     => t a -> f a
convert :: forall (f :: * -> *) (t :: * -> *) a.
(Alternative f, Foldable t) =>
t a -> f a
convert = (a -> f a) -> t a -> f a
forall (f :: * -> *) (t :: * -> *) a b.
(Alternative f, Foldable t) =>
(a -> f b) -> t a -> f b
any a -> f a
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

-- | 'Searchable' class represents structures that can be searched using a predicate.
-- An instance may use 'all' or 'any' to iterate over parts of its structure depending
-- on wether the substrcutres are conjunctive or disjunctive.
class (Foldable t) => Searchable t where
    -- | Search a structure using a predicate
    search :: (Alternative f, Monoid b) => (a -> f b) -> t a -> f b

-- | 'Maybe' instance of 'Searchable'.
instance Searchable Maybe where
    search :: forall (f :: * -> *) b a.
(Alternative f, Monoid b) =>
(a -> f b) -> Maybe a -> f b
search = (a -> f b) -> Maybe a -> f b
forall (f :: * -> *) (t :: * -> *) a b.
(Alternative f, Foldable t) =>
(a -> f b) -> t a -> f b
any