{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE PolyKinds #-}

module Chassis
  ( -- * Void
    Void,
    absurd,

    -- * Bool
    Bool (..),
    not,

    -- * Numbers
    Int,

    -- * String/Text/ByteString
    String,
    ByteString,
    Text,
    Show (..),

    -- * Classic Algebra
    Semigroup (..),
    Monoid (..),
    Eq (..),
    Ord (..),

    -- * Function Application
    ($),
    (&),

    -- * IO
    IO,

    -- * Maybe
    Maybe (..),
    maybe,

    -- * Either
    Either (..),
    either,

    -- * NonEmpty
    NonEmpty (..),

    -- * Map
    Map,

    -- * Tuples & Currying
    fst,
    snd,
    const,
    curry,
    uncurry,

    -- * Foldable
    Foldable (..),

    -- * Functor
    Functor (..),
    ($>),
    (<$>),
    void,

    -- * Applicative
    Applicative (..),
    when,
    unless,
    whenM,
    whenJust,

    -- * Traversable
    Traversable (..),
    traverse_,
    for_,
    filterM,

    -- * Monad
    Monad (..),
    join,
    forM_,
    forM,
    mapM_,
    sequence_,
    (=<<),
    (>=>),

    -- * Contravariant
    Contravariant (..),
    (>$<),
    Predicate,
    Equivalence,
    Comparison,
    Op,

    -- * Distributive
    Distributive (..),

    -- * Comonad
    Comonad (..),
    (=>=),
    (<<=),

    -- * Profunctor
    Profunctor (..),
    Strong (..),
    Choice (..),

    -- * Category
    Category (..),
    Arrow (..),
    Kleisli (..),
    (>>>),
    (<<<),

    -- * EnvT
    Env,
    EnvT (..),
    env,
    runEnv,
    runEnvT,

    -- * Extensible Records
    Rec (..),
    RMap,
    rtraverse,
    rcast,
    CoRec (..),
    type (∈),

    -- * Compose
    (:.),
    Compose (..),
    onCompose,

    -- * Generic
    Generic,

    -- * Time
    UTCTime,

    -- * Path
    Path,
    Rel,
    Abs,
    File,
    Dir,
    mkRelDir,
    mkRelFile,
    mkAbsDir,
    mkAbsFile,
    (</>),
    flip,
    rights,

    -- * Kinds
    Type,
    Constraint,

    -- * First Class Families
    Exp,
    Eval,
    FMap,

    -- * Exceptions
    Exception (..),
    SomeException,
  )
where

import Composite.CoRecord
  ( CoRec
      ( CoVal
      ),
  )
import Control.Applicative
  ( Applicative
      ( liftA2,
        pure,
        (<*>)
      ),
  )
import Control.Arrow
  ( Arrow
      ( arr,
        first,
        second,
        (&&&),
        (***)
      ),
    Kleisli (runKleisli),
  )
import Control.Category
  ( Category
      ( id,
        (.)
      ),
    (<<<),
    (>>>),
  )
import Control.Comonad
  ( Comonad
      ( duplicate,
        extend,
        extract
      ),
    (<<=),
    (=>=),
  )
import Control.Comonad.Env
  ( Env,
    EnvT (EnvT),
    env,
    runEnv,
    runEnvT,
  )
import Control.Exception
  ( Exception
      ( displayException
      ),
    SomeException,
  )
import Control.Monad
  ( Monad
      ( return,
        (>>),
        (>>=)
      ),
    filterM,
    forM,
    forM_,
    join,
    mapM,
    mapM_,
    sequence,
    sequence_,
    unless,
    void,
    when,
    (=<<),
    (>=>),
  )
import Control.Monad.Extra
  ( whenJust,
    whenM,
  )
import Data.ByteString
  ( ByteString,
  )
import Data.Distributive
  ( Distributive (distribute),
  )
import Data.Either
  ( Either
      ( Left,
        Right
      ),
    either,
    rights,
  )
import Data.Foldable
  ( Foldable (foldl', foldr),
    for_,
    traverse_,
  )
import Data.Function
  ( ( &
    ),
  )
import Data.Functor
  ( Functor (fmap),
    ($>),
    (<$),
    (<$>),
  )
import Data.Functor.Contravariant
  ( Comparison,
    Contravariant
      ( contramap
      ),
    Equivalence,
    Op,
    Predicate,
    (>$<),
  )
import Data.Kind
  ( Constraint,
    Type,
  )
import Data.List.NonEmpty
  ( NonEmpty ((:|)),
  )
import Data.Map
  ( Map,
  )
import Data.Maybe
  ( Maybe
      ( Just,
        Nothing
      ),
    maybe,
  )
import Data.Profunctor
  ( Choice
      ( left',
        right'
      ),
    Profunctor
      ( dimap,
        lmap,
        rmap
      ),
    Strong
      ( first',
        second'
      ),
  )
import Data.Text
  ( Text,
  )
import Data.Time
  ( UTCTime,
  )
import Data.Vinyl
  ( RMap,
    Rec (RNil, (:&)),
    rcast,
    rtraverse,
    type (∈),
  )
import Data.Vinyl.Functor
  ( Compose (getCompose),
    onCompose,
    type (:.),
  )
import Data.Void
  ( Void,
    absurd,
  )
import Fcf
  ( Eval,
    Exp,
  )
import Fcf.Class.Functor
  ( FMap,
  )
import GHC.Generics
  ( Generic,
  )
import Path
  ( Abs,
    Dir,
    File,
    Path,
    Rel,
    mkAbsDir,
    mkAbsFile,
    mkRelDir,
    mkRelFile,
    (</>),
  )
import Prelude
  ( Bool
      ( False,
        True
      ),
    Eq
      ( (/=),
        (==)
      ),
    IO,
    Int,
    Monoid
      ( mempty
      ),
    Ord
      ( compare,
        max,
        min,
        (<),
        (<=),
        (>),
        (>=)
      ),
    Semigroup
      ( (<>)
      ),
    Show
      ( show
      ),
    String,
    Traversable
      ( traverse
      ),
    const,
    curry,
    flip,
    fst,
    not,
    snd,
    uncurry,
    ($),
  )