{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE NoStarIsType #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Prelude.Singletons
-- Copyright   :  (C) 2013 Richard Eisenberg
-- License     :  BSD-style (see LICENSE)
-- Maintainer  :  Ryan Scott
-- Stability   :  experimental
-- Portability :  non-portable
--
-- Mimics the Haskell Prelude, but with singleton types. Includes the basic
-- singleton definitions. Note: This is currently very incomplete!
--
-- Because many of these definitions are produced by Template Haskell, it is
-- not possible to create proper Haddock documentation. Also, please excuse
-- the apparent repeated variable names. This is due to an interaction between
-- Template Haskell and Haddock.
--
----------------------------------------------------------------------------

module Prelude.Singletons (
  -- * Basic singleton definitions
  module Data.Singletons,

  -- * Promoted and singled types, classes, and related functions

  -- ** Basic data types
  SBool(SFalse, STrue),
  If, sIf,
  type (&&), (%&&), type (||), (%||), Not, sNot, Otherwise, sOtherwise,

  SMaybe(SNothing, SJust),
  -- | 'maybe_' is a reimplementation of the 'maybe' function with a different
  -- name to avoid clashing with the 'Maybe' data type when promoted.
  maybe_, Maybe_, sMaybe_,

  SEither(SLeft, SRight),
  -- | 'either_' is a reimplementation of the 'either' function with a different
  -- name to avoid clashing with the 'Either' data type when promoted.
  either_, Either_, sEither_,

  SOrdering(SLT, SEQ, SGT),
  SChar, Symbol, -- The closest things we have to Char and String
  SList(..),

  -- *** Tuples
  STuple0(..), STuple2(..), STuple3(..), STuple4(..),
  STuple5(..), STuple6(..), STuple7(..),
  Fst, sFst, Snd, sSnd, Curry, sCurry, Uncurry, sUncurry,

  -- ** Basic type classes
  PEq(type (==), type (/=)), SEq((%==), (%/=)),
  POrd(Compare, type (<), type (<=), type (>=), type (>), Max, Min),
  SOrd(sCompare, (%<), (%<=), (%>=), (%>), sMax, sMin),
  -- | As a matter of convenience, the "Prelude.Singletons" does /not/ export
  -- promoted/singletonized @succ@ and @pred@, due to likely conflicts with
  -- unary numbers. Please import "Data.Singletons.Base.Enum" directly if
  -- you want these.
  PEnum( -- Succ, Pred,
         ToEnum, FromEnum,
         {-
         See the comments in Data.Singletons.Base.Enum for why these are not defined.
         -}
         -- EnumFrom, EnumFromThen,
         EnumFromTo, EnumFromThenTo),
  SEnum( -- sSucc, sPred,
         sToEnum, sFromEnum,
         {-
         See the comments in Data.Singletons.Base.Enum for why these are not defined.
         -}
         -- sEnumFrom, sEnumFromThen,
         sEnumFromTo, sEnumFromThenTo),
  PBounded(MinBound, MaxBound), SBounded(sMinBound, sMaxBound),

  -- ** Numbers

  {-
  There are no singled counterparts to any of the following numeric types. The
  closest thing is Nat, which we deliberately do not export to avoid clashing
  with unary natural number data types.

  -- *** Numeric types
  Int, Integer, Float, Double,
  Rational, Word,
  -}

  -- *** Numeric type classes
  PNum(type (+), type (-), type (*), Negate, Abs, Signum, FromInteger),
  SNum((%+), (%-), (%*), sNegate, sAbs, sSignum, sFromInteger),
  {-
  We currently do not promote or single any of the following classes. Some
  of these functions have Nat-specialized versions in GHC.TypeLits.Singletons,
  however (e.g., Div and Mod).
  -}
  -- Real(toRational),
  -- Integral(quot, rem, div, mod, quotRem, divMod, toInteger),
  -- Fractional((/), recip, fromRational),
  -- Floating(pi, exp, log, sqrt, (**), logBase, sin, cos, tan,
  --          asin, acos, atan, sinh, cosh, tanh, asinh, acosh, atanh),
  -- RealFrac(properFraction, truncate, round, ceiling, floor),
  -- RealFloat(floatRadix, floatDigits, floatRange, decodeFloat,
  --           encodeFloat, exponent, significand, scaleFloat, isNaN,
  --           isInfinite, isDenormalized, isIEEE, isNegativeZero, atan2),

  -- *** Numeric functions
  Subtract, sSubtract,
  {-
  The following functions require classes such as Integral, Real, and
  Fractional, which we do not promote or single. Some of these functions have
  Nat-specialized versions in GHC.TypeLits.Singletons, however (e.g., (^)).
  -}
  -- even, odd, gcd, lcm, (^), (^^),
  -- fromIntegral, realToFrac,

  -- ** Semigroups and Monoids
  PSemigroup(type (<>)), SSemigroup((%<>)),
  PMonoid(Mempty, Mappend, Mconcat), SMonoid(sMempty, sMappend, sMconcat),

  -- ** Monads and functors
  PFunctor(Fmap, type (<$)), SFunctor(sFmap, (%<$)), type (<$>), (%<$>),
  PApplicative(Pure, type (<*>), type (*>), type (<*), LiftA2),
  SApplicative(sPure, (%<*>), (%*>), (%<*), sLiftA2),
  PMonad(type (>>=), type (>>), Return),
  SMonad((%>>=), (%>>), sReturn),
  PMonadFail(Fail), SMonadFail(sFail),
  MapM_, sMapM_, Sequence_, sSequence_, type (=<<), (%=<<),

  -- ** Folds and traversals
  PFoldable(Elem, FoldMap, Foldr, Foldl, Foldr1, Foldl1,
            Maximum, Minimum, Product, Sum),
  SFoldable(sElem, sFoldMap, sFoldr, sFoldl, sFoldr1, sFoldl1,
            sMaximum, sMinimum, sProduct, sSum),
  PTraversable(Traverse, SequenceA, MapM, Sequence),
  STraversable(sTraverse, sSequenceA, sMapM, sSequence),

  -- ** Miscellaneous functions
  Id, sId, Const, sConst, type (.), (%.), Flip, sFlip, type ($), (%$), Until, sUntil,
  AsTypeOf, sAsTypeOf,
  Error, sError, ErrorWithoutStackTrace, sErrorWithoutStackTrace,
  Undefined, sUndefined,
  Seq, sSeq, type ($!), (%$!),

  -- * List operations
  Map, sMap, type (++), (%++), Filter, sFilter,
  Head, sHead, Last, sLast, Tail, sTail, Init, sInit, type (!!), (%!!),
  Null, sNull, Length, sLength,
  Reverse, sReverse,
  -- *** Special folds
  And, sAnd, Or, sOr, Any, sAny, All, sAll,
  Concat, sConcat, ConcatMap, sConcatMap,
  -- ** Building lists
  -- *** Scans
  Scanl, sScanl, Scanl1, sScanl1, Scanr, sScanr, Scanr1, sScanr1,
  -- *** Infinite lists
  {-
  Unsurprisingly, most operations on infinite lists won't promote.
  The `replicate` function is the lone exception.
  -}
  -- iterate, repeat,
  Replicate, sReplicate,
  -- cycle,
  -- ** Sublists
  Take, sTake, Drop, sDrop,
  TakeWhile, sTakeWhile, DropWhile, sDropWhile,
  Span, sSpan, Break, sBreak,
  SplitAt, sSplitAt,
  -- ** Searching lists
  NotElem, sNotElem,
  Lookup, sLookup,
  -- ** Zipping and unzipping lists
  Zip, sZip, Zip3, sZip3,
  ZipWith, sZipWith, ZipWith3, sZipWith3,
  Unzip, sUnzip, Unzip3, sUnzip3,
  -- ** Functions on @Symbol@s
  {-
  The `lines` and `words` functions cannot yet be promoted.
  See the comments in `Data.List.Singletons.Internal`.
  -}
  -- lines, words,
  Unlines, sUnlines, Unwords, sUnwords,

  -- * Converting to and from @Symbol@
  -- ** Converting to @Symbol@
  SymbolS,
  show_,
  PShow(ShowsPrec, ShowList, Show_), SShow(sShowsPrec, sShowList, sShow_),
  Shows, sShows,
  ShowChar, sShowChar, ShowString, sShowString, ShowParen, sShowParen,
  {-
  We do not currently promote or single the Read class.

  -- ** Converting from @Symbol@
  ReadS,
  Read(readsPrec, readList),
  reads, readParen, read, lex,
  -}

  {-
  We do not promote or single anything involving IO.

  -- * Basic Input and output
  IO,
  -- ** Simple I\/O operations
  -- All I/O functions defined here are character oriented.  The
  -- treatment of the newline character will vary on different systems.
  -- For example, two characters of input, return and linefeed, may
  -- read as a single newline character.  These functions cannot be
  -- used portably for binary I/O.
  -- *** Output functions
  putChar,
  putStr, putStrLn, print,
  -- *** Input functions
  getChar,
  getLine, getContents, interact,
  -- *** Files
  FilePath,
  readFile, writeFile, appendFile, readIO, readLn,
  -- ** Exception handling in the I\/O monad
  IOError, ioError, userError,
  -}

  -- * Defunctionalization symbols

  -- ** Basic data types
  FalseSym0, TrueSym0,
  IfSym0, IfSym1, IfSym2, IfSym3,
  type (&&@#@$), type (&&@#@$$), type (&&@#@$$$),
  type (||@#@$), type (||@#@$$), type (||@#@$$$),
  NotSym0, NotSym1,
  OtherwiseSym0,

  NothingSym0, JustSym0, JustSym1,
  Maybe_Sym0, Maybe_Sym1, Maybe_Sym2, Maybe_Sym3,

  LeftSym0, LeftSym1, RightSym0, RightSym1,
  Either_Sym0, Either_Sym1, Either_Sym2, Either_Sym3,

  LTSym0, EQSym0, GTSym0,
  (:@#@$), (:@#@$$), (:@#@$$$), NilSym0,

  -- *** Tuples
  Tuple0Sym0,
  Tuple2Sym0, Tuple2Sym1, Tuple2Sym2,
  Tuple3Sym0, Tuple3Sym1, Tuple3Sym2, Tuple3Sym3,
  Tuple4Sym0, Tuple4Sym1, Tuple4Sym2, Tuple4Sym3, Tuple4Sym4,
  Tuple5Sym0, Tuple5Sym1, Tuple5Sym2, Tuple5Sym3, Tuple5Sym4, Tuple5Sym5,
  Tuple6Sym0, Tuple6Sym1, Tuple6Sym2, Tuple6Sym3, Tuple6Sym4, Tuple6Sym5, Tuple6Sym6,
  Tuple7Sym0, Tuple7Sym1, Tuple7Sym2, Tuple7Sym3, Tuple7Sym4, Tuple7Sym5, Tuple7Sym6, Tuple7Sym7,
  FstSym0, FstSym1, SndSym0, SndSym1,
  CurrySym0, CurrySym1, CurrySym2, CurrySym3,
  UncurrySym0, UncurrySym1, UncurrySym2,

  -- ** Basic type classes
  type (==@#@$), type (==@#@$$), type (==@#@$$$),
  type (/=@#@$), type (/=@#@$$), type (/=@#@$$$),

  CompareSym0, CompareSym1, CompareSym2,
  type (<@#@$),  type (<@#@$$),  type (<@#@$$$),
  type (<=@#@$), type (<=@#@$$), type (<=@#@$$$),
  type (>@#@$),  type (>@#@$$),  type (>@#@$$$),
  type (>=@#@$), type (>=@#@$$), type (>=@#@$$$),
  MaxSym0, MaxSym1, MaxSym2,
  MinSym0, MinSym1, MinSym2,

  ToEnumSym0, ToEnumSym1,
  FromEnumSym0, FromEnumSym1,
  EnumFromToSym0, EnumFromToSym1, EnumFromToSym2,
  EnumFromThenToSym0, EnumFromThenToSym1, EnumFromThenToSym2, EnumFromThenToSym3,

  MinBoundSym0, MaxBoundSym0,

  -- ** Numbers

  -- *** Numeric type classes
  type (+@#@$), type (+@#@$$), type (+@#@$$$),
  type (-@#@$), type (-@#@$$), type (-@#@$$$),
  type (*@#@$), type (*@#@$$), type (*@#@$$$),
  NegateSym0, NegateSym1,
  AbsSym0, AbsSym1,
  SignumSym0, SignumSym1,
  FromIntegerSym0, FromIntegerSym1,

  -- *** Numeric functions
  SubtractSym0, SubtractSym1, SubtractSym2,

  -- ** Semigroups and Monoids
  type (<>@#@$), type (<>@#@$$), type (<>@#@$$$),
  MemptySym0,
  MappendSym0, MappendSym1, MappendSym2,
  MconcatSym0, MconcatSym1,

  -- ** Monads and functors
  FmapSym0, FmapSym1, FmapSym2,
  type (<$@#@$),  type (<$@#@$$),  type (<$@#@$$$),
  type (<$>@#@$), type (<$>@#@$$), type (<$>@#@$$$),
  PureSym0, PureSym1,
  type (<*>@#@$), type (<*>@#@$$), type (<*>@#@$$$),
  type (*>@#@$),  type (*>@#@$$),  type (*>@#@$$$),
  type (<*@#@$),  type (<*@#@$$),  type (<*@#@$$$),
  LiftA2Sym0, LiftA2Sym1, LiftA2Sym2, LiftA2Sym3,
  type (>>=@#@$), type (>>=@#@$$), type (>>=@#@$$$),
  type (>>@#@$),  type (>>@#@$$),  type (>>@#@$$$),
  ReturnSym0, ReturnSym1, FailSym0, FailSym1,
  MapM_Sym0, MapM_Sym1, MapM_Sym2,
  Sequence_Sym0, Sequence_Sym1,
  type (=<<@#@$), type (=<<@#@$$), type (=<<@#@$$$),

  -- ** Folds and traversals
  ElemSym0, ElemSym1, ElemSym2,
  FoldMapSym0, FoldMapSym1, FoldMapSym2,
  FoldrSym0, FoldrSym1, FoldrSym2, FoldrSym3,
  FoldlSym0, FoldlSym1, FoldlSym2, FoldlSym3,
  Foldr1Sym0, Foldr1Sym1, Foldr1Sym2,
  Foldl1Sym0, Foldl1Sym1, Foldl1Sym2,
  MaximumSym0, MaximumSym1,
  MinimumSym0, MinimumSym1,
  ProductSym0, ProductSym1,
  SumSym0, SumSym1,

  TraverseSym0, TraverseSym1, TraverseSym2,
  SequenceASym0, SequenceASym1,
  MapMSym0, MapMSym1, MapMSym2,
  SequenceSym0, SequenceSym1,

  -- ** Miscellaneous functions
  IdSym0, IdSym1, ConstSym0, ConstSym1, ConstSym2,
  type (.@#@$),  type (.@#@$$),  type (.@#@$$$), type (.@#@$$$$),
  FlipSym0, FlipSym1, FlipSym2, FlipSym3,
  type ($@#@$),  type ($@#@$$),  type ($@#@$$$),
  UntilSym0, UntilSym1, UntilSym2, UntilSym3,
  AsTypeOfSym0, AsTypeOfSym1, AsTypeOfSym2,
  ErrorSym0, ErrorSym1,
  ErrorWithoutStackTraceSym0, ErrorWithoutStackTraceSym1,
  UndefinedSym0,
  SeqSym0, SeqSym1, SeqSym2,
  type ($!@#@$), type ($!@#@$$), type ($!@#@$$$),

  -- * List operations
  MapSym0, MapSym1, MapSym2,
  type (++@#@$), type (++@#@$$), type (++@#@$$$),
  FilterSym0, FilterSym1, FilterSym2,
  HeadSym0, HeadSym1, LastSym0, LastSym1,
  TailSym0, TailSym1, InitSym0, InitSym1,
  type (!!@#@$), type (!!@#@$$), type (!!@#@$$$),
  NullSym0, NullSym1,
  LengthSym0, LengthSym1,
  ReverseSym0, ReverseSym1,
  -- *** Special folds
  AndSym0, AndSym1, OrSym0, OrSym1,
  AnySym0, AnySym1, AnySym2,
  AllSym0, AllSym1, AllSym2,
  ConcatSym0, ConcatSym1,
  ConcatMapSym0, ConcatMapSym1, ConcatMapSym2,
  -- ** Building lists
  -- *** Scans
  ScanlSym0, ScanlSym1, ScanlSym2, ScanlSym3,
  Scanl1Sym0, Scanl1Sym1, Scanl1Sym2,
  ScanrSym0, ScanrSym1, ScanrSym2, ScanrSym3,
  Scanr1Sym0, Scanr1Sym1, Scanr1Sym2,
  -- *** Infinite lists
  ReplicateSym0, ReplicateSym1, ReplicateSym2,
  -- ** Sublists
  TakeSym0, TakeSym1, TakeSym2,
  DropSym0, DropSym1, DropSym2,
  TakeWhileSym0, TakeWhileSym1, TakeWhileSym2,
  DropWhileSym0, DropWhileSym1, DropWhileSym2,
  DropWhileEndSym0, DropWhileEndSym1, DropWhileEndSym2,
  SpanSym0, SpanSym1, SpanSym2,
  BreakSym0, BreakSym1, BreakSym2,
  SplitAtSym0, SplitAtSym1, SplitAtSym2,
  -- ** Searching lists
  NotElemSym0, NotElemSym1, NotElemSym2,
  LookupSym0, LookupSym1, LookupSym2,
  -- ** Zipping and unzipping lists
  ZipSym0, ZipSym1, ZipSym2,
  Zip3Sym0, Zip3Sym1, Zip3Sym2, Zip3Sym3,
  ZipWithSym0, ZipWithSym1, ZipWithSym2, ZipWithSym3,
  ZipWith3Sym0, ZipWith3Sym1, ZipWith3Sym2, ZipWith3Sym3,
  UnzipSym0, UnzipSym1, Unzip3Sym0, Unzip3Sym1,
  -- ** Functions on @Symbol@s
  UnlinesSym0, UnlinesSym1, UnwordsSym0, UnwordsSym1,

  -- * Converting to and from @Symbol@
  -- ** Converting to @Symbol@
  ShowsPrecSym0, ShowsPrecSym1, ShowsPrecSym2, ShowsPrecSym3,
  ShowListSym0, ShowListSym1, ShowListSym2,
  Show_Sym0, Show_Sym1,
  ShowsSym0, ShowsSym1, ShowsSym2,
  ShowCharSym0, ShowCharSym1, ShowCharSym2,
  ShowStringSym0, ShowStringSym1, ShowStringSym2,
  ShowParenSym0, ShowParenSym1, ShowParenSym2
  ) where

import Control.Applicative.Singletons
  hiding (Const, ConstSym0, ConstSym1)
import Control.Monad.Singletons
import Data.Bool.Singletons
import Data.Either.Singletons
import Data.Eq.Singletons
import Data.Foldable.Singletons
import Data.List.Singletons
import Data.Maybe.Singletons
import Data.Monoid.Singletons
       ( PMonoid(..), SMonoid(..), MemptySym0, MappendSym0
       , MappendSym1, MappendSym2, MconcatSym0, MconcatSym1 )
import Data.Ord.Singletons
import Data.Semigroup.Singletons
       ( PSemigroup(..), SSemigroup(..)
       , type (<>@#@$), type (<>@#@$$), type (<>@#@$$$) )
import Data.Singletons
import Data.Singletons.Base.Enum
  hiding (Succ, Pred, SuccSym0, SuccSym1, PredSym0, PredSym1, sSucc, sPred)
import Data.Traversable.Singletons
import Data.Tuple.Singletons
import GHC.Base.Singletons
  hiding (Foldr, FoldrSym0, FoldrSym1, FoldrSym2, FoldrSym3, sFoldr)
import GHC.Num.Singletons
import GHC.TypeLits.Singletons
import Text.Show.Singletons