{-# LANGUAGE Safe #-}
----------------------------------------------------------------------------
-- |
-- Module      :  Algebra.PartialOrd
-- Copyright   :  (C) 2010-2015 Maximilian Bolingbroke, 2015-2019 Oleg Grenrus
-- License     :  BSD-3-Clause (see the file LICENSE)
--
-- Maintainer  :  Oleg Grenrus <oleg.grenrus@iki.fi>
--
----------------------------------------------------------------------------
module Algebra.PartialOrd (
    -- * Partial orderings
    PartialOrd(..),
    partialOrdEq,

    -- * Fixed points of chains in partial orders
    lfpFrom, unsafeLfpFrom,
    gfpFrom, unsafeGfpFrom
  ) where

import           Data.Foldable     (Foldable (..))
import           Data.Hashable     (Hashable (..))
import qualified Data.HashMap.Lazy as HM
import qualified Data.HashSet      as HS
import qualified Data.IntMap       as IM
import qualified Data.IntSet       as IS
import qualified Data.List.Compat  as L
import qualified Data.Map          as Map
import           Data.Monoid       (All (..), Any (..))
import qualified Data.Set          as Set
import           Data.Void         (Void)

-- | A partial ordering on sets
-- (<http://en.wikipedia.org/wiki/Partially_ordered_set>) is a set equipped
-- with a binary relation, `leq`, that obeys the following laws
--
-- @
-- Reflexive:     a ``leq`` a
-- Antisymmetric: a ``leq`` b && b ``leq`` a ==> a == b
-- Transitive:    a ``leq`` b && b ``leq`` c ==> a ``leq`` c
-- @
--
-- Two elements of the set are said to be `comparable` when they are are
-- ordered with respect to the `leq` relation. So
--
-- @
-- `comparable` a b ==> a ``leq`` b || b ``leq`` a
-- @
--
-- If `comparable` always returns true then the relation `leq` defines a
-- total ordering (and an `Ord` instance may be defined). Any `Ord` instance is
-- trivially an instance of `PartialOrd`. 'Algebra.Lattice.Ordered' provides a
-- convenient wrapper to satisfy 'PartialOrd' given 'Ord'.
--
-- As an example consider the partial ordering on sets induced by set
-- inclusion.  Then for sets `a` and `b`,
--
-- @
-- a ``leq`` b
-- @
--
-- is true when `a` is a subset of `b`.  Two sets are `comparable` if one is a
-- subset of the other. Concretely
--
-- @
-- a = {1, 2, 3}
-- b = {1, 3, 4}
-- c = {1, 2}
--
-- a ``leq`` a = `True`
-- a ``leq`` b = `False`
-- a ``leq`` c = `False`
-- b ``leq`` a = `False`
-- b ``leq`` b = `True`
-- b ``leq`` c = `False`
-- c ``leq`` a = `True`
-- c ``leq`` b = `False`
-- c ``leq`` c = `True`
--
-- `comparable` a b = `False`
-- `comparable` a c = `True`
-- `comparable` b c = `False`
-- @
class Eq a => PartialOrd a where
    -- | The relation that induces the partial ordering
    leq :: a -> a -> Bool

    -- | Whether two elements are ordered with respect to the relation. A
    -- default implementation is given by
    --
    -- @
    -- 'comparable' x y = 'leq' x y '||' 'leq' y x
    -- @
    comparable :: a -> a -> Bool
    comparable a
x a
y = forall a. PartialOrd a => a -> a -> Bool
leq a
x a
y Bool -> Bool -> Bool
|| forall a. PartialOrd a => a -> a -> Bool
leq a
y a
x

-- | The equality relation induced by the partial-order structure. It satisfies
-- the laws of an equivalence relation:
-- @
-- Reflexive:  a == a
-- Symmetric:  a == b ==> b == a
-- Transitive: a == b && b == c ==> a == c
-- @
partialOrdEq :: PartialOrd a => a -> a -> Bool
partialOrdEq :: forall a. PartialOrd a => a -> a -> Bool
partialOrdEq a
x a
y = forall a. PartialOrd a => a -> a -> Bool
leq a
x a
y Bool -> Bool -> Bool
&& forall a. PartialOrd a => a -> a -> Bool
leq a
y a
x

instance PartialOrd () where
    leq :: () -> () -> Bool
leq ()
_ ()
_ = Bool
True

-- | @since 2
instance PartialOrd Bool where
    leq :: Bool -> Bool -> Bool
leq = forall a. Ord a => a -> a -> Bool
(<=)

instance PartialOrd Any where
    leq :: Any -> Any -> Bool
leq = forall a. Ord a => a -> a -> Bool
(<=)

instance PartialOrd All where
    leq :: All -> All -> Bool
leq = forall a. Ord a => a -> a -> Bool
(<=)

instance PartialOrd Void where
    leq :: Void -> Void -> Bool
leq Void
_ Void
_ = Bool
True

-- | @'leq' = 'Data.List.isSequenceOf'@.
instance Eq a => PartialOrd [a] where
    leq :: [a] -> [a] -> Bool
leq = forall a. Eq a => [a] -> [a] -> Bool
L.isSubsequenceOf

instance Ord a => PartialOrd (Set.Set a) where
    leq :: Set a -> Set a -> Bool
leq = forall a. Ord a => Set a -> Set a -> Bool
Set.isSubsetOf

instance PartialOrd IS.IntSet where
    leq :: IntSet -> IntSet -> Bool
leq = IntSet -> IntSet -> Bool
IS.isSubsetOf

instance (Eq k, Hashable k) => PartialOrd (HS.HashSet k) where
    leq :: HashSet k -> HashSet k -> Bool
leq HashSet k
a HashSet k
b = forall a. HashSet a -> Bool
HS.null (forall a. (Eq a, Hashable a) => HashSet a -> HashSet a -> HashSet a
HS.difference HashSet k
a HashSet k
b)

instance (Ord k, PartialOrd v) => PartialOrd (Map.Map k v) where
    leq :: Map k v -> Map k v -> Bool
leq = forall k a b.
Ord k =>
(a -> b -> Bool) -> Map k a -> Map k b -> Bool
Map.isSubmapOfBy forall a. PartialOrd a => a -> a -> Bool
leq

instance PartialOrd v => PartialOrd (IM.IntMap v) where
    leq :: IntMap v -> IntMap v -> Bool
leq = forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IM.isSubmapOfBy forall a. PartialOrd a => a -> a -> Bool
leq

instance (Eq k, Hashable k, PartialOrd v) => PartialOrd (HM.HashMap k v) where
    HashMap k v
x leq :: HashMap k v -> HashMap k v -> Bool
`leq` HashMap k v
y = {- wish: HM.isSubmapOfBy leq -}
        forall k v. HashMap k v -> Bool
HM.null (forall k v w.
(Eq k, Hashable k) =>
HashMap k v -> HashMap k w -> HashMap k v
HM.difference HashMap k v
x HashMap k v
y) Bool -> Bool -> Bool
&& All -> Bool
getAll (forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold forall a b. (a -> b) -> a -> b
$ forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3) -> HashMap k v1 -> HashMap k v2 -> HashMap k v3
HM.intersectionWith (\v
vx v
vy -> Bool -> All
All (v
vx forall a. PartialOrd a => a -> a -> Bool
`leq` v
vy)) HashMap k v
x HashMap k v
y)

instance (PartialOrd a, PartialOrd b) => PartialOrd (a, b) where
    -- NB: *not* a lexical ordering. This is because for some component partial orders, lexical
    -- ordering is incompatible with the transitivity axiom we require for the derived partial order
    (a
x1, b
y1) leq :: (a, b) -> (a, b) -> Bool
`leq` (a
x2, b
y2) = a
x1 forall a. PartialOrd a => a -> a -> Bool
`leq` a
x2 Bool -> Bool -> Bool
&& b
y1 forall a. PartialOrd a => a -> a -> Bool
`leq` b
y2

-- | Ordinal sum.
--
-- @since 2.1
instance (PartialOrd a, PartialOrd b) => PartialOrd (Either a b) where
    leq :: Either a b -> Either a b -> Bool
leq (Right b
x) (Right b
y) = forall a. PartialOrd a => a -> a -> Bool
leq b
x b
y
    leq (Right b
_) Either a b
_         = Bool
False
    leq Either a b
_         (Right b
_) = Bool
True
    leq (Left a
x)  (Left a
y)  = forall a. PartialOrd a => a -> a -> Bool
leq a
x a
y

    comparable :: Either a b -> Either a b -> Bool
comparable (Right b
x) (Right b
y) = forall a. PartialOrd a => a -> a -> Bool
comparable b
x b
y
    comparable (Right b
_) Either a b
_         = Bool
True
    comparable Either a b
_         (Right b
_) = Bool
True
    comparable (Left a
x)  (Left a
y)  = forall a. PartialOrd a => a -> a -> Bool
comparable a
x a
y

-- | Least point of a partially ordered monotone function. Checks that the function is monotone.
lfpFrom :: PartialOrd a => a -> (a -> a) -> a
lfpFrom :: forall a. PartialOrd a => a -> (a -> a) -> a
lfpFrom = forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
lfpFrom' forall a. PartialOrd a => a -> a -> Bool
leq

-- | Least point of a partially ordered monotone function. Does not checks that the function is monotone.
unsafeLfpFrom :: Eq a => a -> (a -> a) -> a
unsafeLfpFrom :: forall a. Eq a => a -> (a -> a) -> a
unsafeLfpFrom = forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
lfpFrom' (\a
_ a
_ -> Bool
True)

{-# INLINE lfpFrom' #-}
lfpFrom' :: Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
lfpFrom' :: forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
lfpFrom' a -> a -> Bool
check a
init_x a -> a
f = a -> a
go a
init_x
  where go :: a -> a
go a
x | a
x' forall a. Eq a => a -> a -> Bool
== a
x      = a
x
             | a
x a -> a -> Bool
`check` a
x' = a -> a
go a
x'
             | Bool
otherwise    = forall a. HasCallStack => [Char] -> a
error [Char]
"lfpFrom: non-monotone function"
          where x' :: a
x' = a -> a
f a
x


-- | Greatest fixed point of a partially ordered antinone function. Checks that the function is antinone.
{-# INLINE gfpFrom #-}
gfpFrom :: PartialOrd a => a -> (a -> a) -> a
gfpFrom :: forall a. PartialOrd a => a -> (a -> a) -> a
gfpFrom = forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
gfpFrom' forall a. PartialOrd a => a -> a -> Bool
leq

-- | Greatest fixed point of a partially ordered antinone function. Does not check that the function is antinone.
{-# INLINE unsafeGfpFrom #-}
unsafeGfpFrom :: Eq a => a -> (a -> a) -> a
unsafeGfpFrom :: forall a. Eq a => a -> (a -> a) -> a
unsafeGfpFrom = forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
gfpFrom' (\a
_ a
_ -> Bool
True)

{-# INLINE gfpFrom' #-}
gfpFrom' :: Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
gfpFrom' :: forall a. Eq a => (a -> a -> Bool) -> a -> (a -> a) -> a
gfpFrom' a -> a -> Bool
check a
init_x a -> a
f = a -> a
go a
init_x
  where go :: a -> a
go a
x | a
x' forall a. Eq a => a -> a -> Bool
== a
x      = a
x
             | a
x' a -> a -> Bool
`check` a
x = a -> a
go a
x'
             | Bool
otherwise    = forall a. HasCallStack => [Char] -> a
error [Char]
"gfpFrom: non-antinone function"
          where x' :: a
x' = a -> a
f a
x