---------------------------------------------------------------------
---Module      :   Zeros
--      a naive and simple data type
--      usable to stand in for most kinds of nothing
--      added Either and Maybe to import wherever needed
--
----------------------------------------------------------------------
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE DefaultSignatures #-}
{-# LANGUAGE TypeOperators #-}

{-# OPTIONS -Wall #-}

module Uniform.Zero
  ( module Uniform.Zero,
    module Data.Maybe,
    module Data.Either,
    -- module GHC.Generics,
  )
where

import Data.Either
  ( Either (..),
    either,
    fromLeft,
    fromRight,
    isLeft,
    isRight,
    lefts,
    partitionEithers,
    rights,
  )
import Data.Maybe
  ( Maybe (..),
    catMaybes,
    fromJust,
    fromMaybe,
    isJust,
    isNothing,
    listToMaybe,
    mapMaybe,
    maybe,
    maybeToList,
  )
import GHC.Generics

-- | a minimal algebraic type with nothing than an identity
--  useful to identify a specific value in a type
class Zeros z where
  zero :: z
  default zero :: (Generic z, GZero (Rep z)) => z
  zero = Rep z Any -> z
forall a x. Generic a => Rep a x -> a
to Rep z Any
forall (a :: * -> *) x. GZero a => a x
gzero

  isZero, notZero :: Eq z => z -> Bool
  isZero z
z = z
forall z. Zeros z => z
zero z -> z -> Bool
forall a. Eq a => a -> a -> Bool
== z
z
  notZero = Bool -> Bool
not (Bool -> Bool) -> (z -> Bool) -> z -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. z -> Bool
forall z. (Zeros z, Eq z) => z -> Bool
isZero

class GZero a where
  gzero :: a x

instance GZero U1 where
  gzero :: U1 x
gzero = U1 x
forall k (p :: k). U1 p
U1

instance Zeros a => GZero (K1 i a) where
  gzero :: K1 i a x
gzero = a -> K1 i a x
forall k i c (p :: k). c -> K1 i c p
K1 a
forall z. Zeros z => z
zero

instance (GZero a, GZero b) => GZero (a :*: b) where
  gzero :: (:*:) a b x
gzero = a x
forall (a :: * -> *) x. GZero a => a x
gzero a x -> b x -> (:*:) a b x
forall k (f :: k -> *) (g :: k -> *) (p :: k).
f p -> g p -> (:*:) f g p
:*: b x
forall (a :: * -> *) x. GZero a => a x
gzero

instance GZero a => GZero (M1 i c a) where
  gzero :: M1 i c a x
gzero = a x -> M1 i c a x
forall k i (c :: Meta) (f :: k -> *) (p :: k). f p -> M1 i c f p
M1 a x
forall (a :: * -> *) x. GZero a => a x
gzero

instance Zeros Char where zero :: Char
zero = Char
' '

instance Zeros () where zero :: ()
zero = ()

instance Zeros Bool where zero :: Bool
zero = Bool
False

-- is this contrary to the Unix tradition?

instance Zeros Int where zero :: Int
zero = Int
0

instance Zeros [a] where zero :: [a]
zero = []

instance (Zeros a, Zeros b) => Zeros (a, b) where zero :: (a, b)
zero = (a
forall z. Zeros z => z
zero, b
forall z. Zeros z => z
zero)

instance (Zeros a, Zeros b, Zeros c) => Zeros (a, b, c) where
  zero :: (a, b, c)
zero = (a
forall z. Zeros z => z
zero, b
forall z. Zeros z => z
zero, c
forall z. Zeros z => z
zero)

instance (Zeros a, Zeros b, Zeros c, Zeros d) => Zeros (a, b, c, d) where
  zero :: (a, b, c, d)
zero = (a
forall z. Zeros z => z
zero, b
forall z. Zeros z => z
zero, c
forall z. Zeros z => z
zero, d
forall z. Zeros z => z
zero)

instance
  (Zeros a, Zeros b, Zeros c, Zeros d, Zeros e) =>
  Zeros (a, b, c, d, e)
  where
  zero :: (a, b, c, d, e)
zero = (a
forall z. Zeros z => z
zero, b
forall z. Zeros z => z
zero, c
forall z. Zeros z => z
zero, d
forall z. Zeros z => z
zero, e
forall z. Zeros z => z
zero)

instance Zeros (Maybe a) where zero :: Maybe a
zero = Maybe a
forall a. Maybe a
Nothing