{- |
Module      : Antelude.Internal.TypesClasses
Description : Just contains Antelude's internal base of types and typeclasses.
Maintainer  : dneavesdev@pm.me
-}
module Antelude.Internal.TypesClasses
  ( -- * Types
    -- ** Basics
    -- | Reexport from 'Data.Bool'
    Bool (..)
    -- | Reexport from 'Data.Char'
  , Char
    -- | Reexport from 'Data.String'
  , String
    -- | Reexport from 'Data.Int'
  , Int
    -- | Reexport from 'Prelude'
  , Integer
    -- | Reexport from 'Prelude'
  , Float
    -- | Reexport from 'Prelude'
  , Double
    -- | Reexport from 'Data.Ratio'
  , Rational
    -- | Reexport from 'Data.Word'
  , Word
    -- ** Container-Types
    -- *** List and List-ish
    -- | Reexport from 'Data.List'
  , List
    -- | Reexport from 'Data.List.NonEmpty'
  , NonEmpty (..)
    -- | Reexport from 'Data.Array' of the "array" package
  , Array
    -- *** Formally-Named Tuples
  , Pair
  , Trio
    -- ** External-Package-Types
  , ByteString
  , ByteStringLazy
  , Map
  , MapLazy
  , Text
  , TextLazy
    -- | Reexport from 'Data.Set' of the "containers" package
  , Set
    -- | Reexport from 'Data.Sequence' of the "containers" package
  , Seq
    -- ** Other Important Things
    -- | Reexport from 'Data.Maybe'
  , Maybe (..)
    -- | Reexport from 'Data.Either'
  , Either (..)
  , Result (..)
    -- | Reexport from 'Data.Ord'
  , Ordering (..)
    -- | Reexport from 'Text.Show'
  , ShowS
    -- | Reexport from 'Text.Read'
  , ReadS
    -- | Reexport from 'System.IO'
  , IO
    -- | Reexport from 'System.IO'
  , FilePath
    -- | Reexport from 'System.IO.Error'
  , IOError
    -- | Reexport from 'Data.Void'
  , Void
    -- * Classes
    -- ** Numeric Classes
    -- | Reexport from 'Prelude'
  , Num ((+), (-), (*))
    -- | Reexport from 'Prelude'
  , Real
    -- | Reexport from 'Prelude'
  , Integral
    -- | Reexport from 'Prelude'
  , Fractional ((/))
    -- | Reexport from 'Prelude'
  , Floating ((**))
    -- | Reexport from 'Prelude'
  , RealFrac
    -- | Reexport from 'Prelude'
  , RealFloat
    -- ** The "Theorum-Based" Classes
    -- | Reexport from 'Data.Semigroup'
  , Semigroup ((<>))
    -- | Reexport from 'Data.Monoid'
  , Monoid
    -- | Reexport from 'Control.Monad'
  , Functor (..)
    -- | Reexport from 'Control.Applicative'
  , Alternative (empty, (<|>))
  , Applicative (..)
    -- | Reexport from 'Control.Monad'
  , Monad (..)
    -- | Reexport from 'Control.Monad.IO.Class'
  , MonadIO (..)
    -- | Reexport from 'Control.Monad'
  , MonadPlus
    -- | Reexport from 'Control.Monad.Fail'
  , MonadFail
    -- ** The Rest of the Classes
    -- | Reexport from 'Data.Eq'
  , Eq (..)
    -- | Reexport from 'Data.Ord'
  , Ord ((<), (>), (<=), (>=))
    -- | Reexport from 'Prelude'
  , Enum
    -- | Reexport from 'Prelude'
  , Bounded
    -- | Reexport from 'Data.Foldable'
  , Foldable
    -- | Reexport from 'Data.Traversable'
  , Traversable
    -- | Reexport from 'Text.Show'
  , Show (show, showList)
    -- | Reexport from 'Text.Read'
  , Read
  ) where

import safe           Control.Applicative    ( Alternative (..) )
import safe           Control.Monad          ( MonadPlus (..) )
import safe           Control.Monad.IO.Class ( MonadIO (..) )

import safe           Data.Array             ( Array )
import safe qualified Data.ByteString        as BS ( ByteString )
import safe qualified Data.ByteString.Lazy   as BL ( ByteString )
import safe           Data.List.NonEmpty     ( NonEmpty (..) )
import safe qualified Data.Map               as MapL ( Map )
import safe qualified Data.Map.Strict        as MapS ( Map )
import safe           Data.Sequence          ( Seq (..) )
import safe           Data.Set               ( Set )
import safe qualified Data.Text              as TS ( Text )
import safe qualified Data.Text.Lazy         as TL ( Text )
import safe           Data.Void              ( Void )

import safe           Prelude
  ( Applicative (..)
  , Bool (..)
  , Bounded (..)
  , Char
  , Double
  , Either (..)
  , Enum (..)
  , Eq (..)
  , FilePath
  , Float
  , Floating (..)
  , Foldable (..)
  , Fractional (..)
  , Functor (..)
  , IO
  , IOError
  , Int
  , Integer
  , Integral (..)
  , Maybe (..)
  , Monad (..)
  , MonadFail (..)
  , Monoid (..)
  , Num (..)
  , Ord (..)
  , Ordering (..)
  , Rational
  , Read (..)
  , ReadS
  , Real (..)
  , RealFloat (..)
  , RealFrac (..)
  , Semigroup (..)
  , Show (..)
  , ShowS
  , String
  , Traversable (..)
  , Word
  )


-- | Explicit naming of the 'List' brackets.
type List a = [a]


-- | A two-element Tuple
type Pair a b = (a, b)


-- | A three-element Tuple
type Trio a b c = (a, b, c)


-- | Aliased reexport from 'Data.Text' of the "text" package
type Text = TS.Text


-- | Aliased reexport from 'Data.ByteString' of the "bytestring" package
type ByteString = BS.ByteString


-- | Aliased reexport from 'Data.Text.Lazy' of the "text" package
type TextLazy = TL.Text


-- | Aliased reexport from 'Data.ByteString.Lazy' of the "bytestring" package
type ByteStringLazy = BL.ByteString


-- | Aliased reexport from 'Data.Map.Strict' of the "containers" package
type Map key val = MapS.Map key val


-- | Aliased reexport from 'Data.Map.Lazy' of the "containers" package
type MapLazy key val = MapL.Map key val


{- |
   The 'Result err ok' type, with variants `Err err` and 'Ok ok'.
   Similar to the 'Either' type, but with better naming, and disambiguates the purposes.
-}
data Result err ok
  = Err err
  | Ok ok
  deriving (Result err ok -> Result err ok -> Bool
(Result err ok -> Result err ok -> Bool)
-> (Result err ok -> Result err ok -> Bool) -> Eq (Result err ok)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall err ok.
(Eq err, Eq ok) =>
Result err ok -> Result err ok -> Bool
$c== :: forall err ok.
(Eq err, Eq ok) =>
Result err ok -> Result err ok -> Bool
== :: Result err ok -> Result err ok -> Bool
$c/= :: forall err ok.
(Eq err, Eq ok) =>
Result err ok -> Result err ok -> Bool
/= :: Result err ok -> Result err ok -> Bool
Eq, Eq (Result err ok)
Eq (Result err ok) =>
(Result err ok -> Result err ok -> Ordering)
-> (Result err ok -> Result err ok -> Bool)
-> (Result err ok -> Result err ok -> Bool)
-> (Result err ok -> Result err ok -> Bool)
-> (Result err ok -> Result err ok -> Bool)
-> (Result err ok -> Result err ok -> Result err ok)
-> (Result err ok -> Result err ok -> Result err ok)
-> Ord (Result err ok)
Result err ok -> Result err ok -> Bool
Result err ok -> Result err ok -> Ordering
Result err ok -> Result err ok -> Result err ok
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 err ok. (Ord err, Ord ok) => Eq (Result err ok)
forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Bool
forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Ordering
forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Result err ok
$ccompare :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Ordering
compare :: Result err ok -> Result err ok -> Ordering
$c< :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Bool
< :: Result err ok -> Result err ok -> Bool
$c<= :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Bool
<= :: Result err ok -> Result err ok -> Bool
$c> :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Bool
> :: Result err ok -> Result err ok -> Bool
$c>= :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Bool
>= :: Result err ok -> Result err ok -> Bool
$cmax :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Result err ok
max :: Result err ok -> Result err ok -> Result err ok
$cmin :: forall err ok.
(Ord err, Ord ok) =>
Result err ok -> Result err ok -> Result err ok
min :: Result err ok -> Result err ok -> Result err ok
Ord, ReadPrec [Result err ok]
ReadPrec (Result err ok)
Int -> ReadS (Result err ok)
ReadS [Result err ok]
(Int -> ReadS (Result err ok))
-> ReadS [Result err ok]
-> ReadPrec (Result err ok)
-> ReadPrec [Result err ok]
-> Read (Result err ok)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall err ok. (Read err, Read ok) => ReadPrec [Result err ok]
forall err ok. (Read err, Read ok) => ReadPrec (Result err ok)
forall err ok. (Read err, Read ok) => Int -> ReadS (Result err ok)
forall err ok. (Read err, Read ok) => ReadS [Result err ok]
$creadsPrec :: forall err ok. (Read err, Read ok) => Int -> ReadS (Result err ok)
readsPrec :: Int -> ReadS (Result err ok)
$creadList :: forall err ok. (Read err, Read ok) => ReadS [Result err ok]
readList :: ReadS [Result err ok]
$creadPrec :: forall err ok. (Read err, Read ok) => ReadPrec (Result err ok)
readPrec :: ReadPrec (Result err ok)
$creadListPrec :: forall err ok. (Read err, Read ok) => ReadPrec [Result err ok]
readListPrec :: ReadPrec [Result err ok]
Read, Int -> Result err ok -> ShowS
[Result err ok] -> ShowS
Result err ok -> String
(Int -> Result err ok -> ShowS)
-> (Result err ok -> String)
-> ([Result err ok] -> ShowS)
-> Show (Result err ok)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall err ok. (Show err, Show ok) => Int -> Result err ok -> ShowS
forall err ok. (Show err, Show ok) => [Result err ok] -> ShowS
forall err ok. (Show err, Show ok) => Result err ok -> String
$cshowsPrec :: forall err ok. (Show err, Show ok) => Int -> Result err ok -> ShowS
showsPrec :: Int -> Result err ok -> ShowS
$cshow :: forall err ok. (Show err, Show ok) => Result err ok -> String
show :: Result err ok -> String
$cshowList :: forall err ok. (Show err, Show ok) => [Result err ok] -> ShowS
showList :: [Result err ok] -> ShowS
Show)


instance Functor (Result err) where
  fmap :: (okA -> okB) -> Result err okA -> Result err okB
  fmap :: forall a b. (a -> b) -> Result err a -> Result err b
fmap okA -> okB
_ (Err err
err) = err -> Result err okB
forall err ok. err -> Result err ok
Err err
err
  fmap okA -> okB
fn (Ok okA
ok)  = okB -> Result err okB
forall err ok. ok -> Result err ok
Ok (okA -> okB
fn okA
ok)


instance Applicative (Result err) where
  pure :: ok -> Result err ok
  pure :: forall a. a -> Result err a
pure = ok -> Result err ok
forall err ok. ok -> Result err ok
Ok


  (<*>) :: Result err (okA -> okB) -> Result err okA -> Result err okB
  Err err
err <*> :: forall a b. Result err (a -> b) -> Result err a -> Result err b
<*> Result err okA
_  = err -> Result err okB
forall err ok. err -> Result err ok
Err err
err
  Ok okA -> okB
okFn <*> Result err okA
ok = (okA -> okB) -> Result err okA -> Result err okB
forall a b. (a -> b) -> Result err a -> Result err b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap okA -> okB
okFn Result err okA
ok


instance Monad (Result err) where
  (>>=) :: Result err okA -> (okA -> Result err okB) -> Result err okB
  Err err
err >>= :: forall a b. Result err a -> (a -> Result err b) -> Result err b
>>= okA -> Result err okB
_ = err -> Result err okB
forall err ok. err -> Result err ok
Err err
err
  Ok okA
ok >>= okA -> Result err okB
fn  = okA -> Result err okB
fn okA
ok