{-# LANGUAGE GADTs            #-}
{-# LANGUAGE TypeFamilies     #-}
{-# LANGUAGE ConstraintKinds  #-}
{-# LANGUAGE TypeOperators    #-}
{-# LANGUAGE FlexibleContexts #-}
module Generics.Simplistic.Derive.Eq where

import Data.Proxy

import Generics.Simplistic
import Generics.Simplistic.Util

geq' :: (OnLeaves Eq f) => SRep I f -> SRep I f -> Bool
geq' :: SRep I f -> SRep I f -> Bool
geq' x :: SRep I f
x y :: SRep I f
y = Bool
-> (SRep (I :*: I) f -> Bool) -> Maybe (SRep (I :*: I) f) -> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False SRep (I :*: I) f -> Bool
forall (f :: * -> *). OnLeaves Eq f => SRep (I :*: I) f -> Bool
sameLeaves (Maybe (SRep (I :*: I) f) -> Bool)
-> Maybe (SRep (I :*: I) f) -> Bool
forall a b. (a -> b) -> a -> b
$ SRep I f -> SRep I f -> Maybe (SRep (I :*: I) f)
forall k (w :: * -> *) (f :: k -> *) (z :: * -> *).
SRep w f -> SRep z f -> Maybe (SRep (w :*: z) f)
zipSRep SRep I f
x SRep I f
y
  where
    sameLeaves :: (OnLeaves Eq f) => SRep (I :*: I) f -> Bool
    sameLeaves :: SRep (I :*: I) f -> Bool
sameLeaves = Proxy Eq
-> (forall x. Eq x => (:*:) I I x -> Bool)
-> (Bool -> Bool -> Bool)
-> Bool
-> SRep (I :*: I) f
-> Bool
forall (c :: * -> Constraint) (rep :: * -> *) (w :: * -> *) r.
OnLeaves c rep =>
Proxy c
-> (forall x. c x => w x -> r)
-> (r -> r -> r)
-> r
-> SRep w rep
-> r
repLeavesC (Proxy Eq
forall k (t :: k). Proxy t
Proxy :: Proxy Eq) ((I x -> I x -> Bool) -> (:*:) I I x -> Bool
forall k (f :: k -> *) (x :: k) (g :: k -> *) a.
(f x -> g x -> a) -> (:*:) f g x -> a
uncurry' I x -> I x -> Bool
forall a. Eq a => a -> a -> Bool
(==)) Bool -> Bool -> Bool
(&&) Bool
True

geq :: (Generic a, GShallow (Rep a), OnLeaves Eq (Rep a))
    => a -> a -> Bool
geq :: a -> a -> Bool
geq x :: a
x y :: a
y = SRep I (Rep a) -> SRep I (Rep a) -> Bool
forall (f :: * -> *). OnLeaves Eq f => SRep I f -> SRep I f -> Bool
geq' (a -> SRep I (Rep a)
forall a. Simplistic a => a -> SRep I (Rep a)
fromS a
x) (a -> SRep I (Rep a)
forall a. Simplistic a => a -> SRep I (Rep a)
fromS a
y)