{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE ExplicitNamespaces #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE TypeOperators #-}
module FirstPrelude (
Bool(False, True),
(&&), (||), not, otherwise,
Maybe(Nothing, Just),
maybe,
Either(Left, Right),
either,
Char, String,
fst, snd, curry, uncurry,
(==), (/=),
(<), (<=), (>=), (>), max, min,
succ, pred,
enumFrom, enumFromThen,
enumFromTo, enumFromThenTo,
Integer,
(+), (-), (*), negate, abs, signum, fromInteger,
quot, rem, div, mod, quotRem, divMod, toInteger,
(^),
fmap,
(>>=), (>>), return,
fail,
foldr,
foldl,
id, const, (.), flip, ($), until,
asTypeOf, error, errorWithoutStackTrace, undefined,
seq,
List.map, (List.++), List.filter,
List.head, List.last, List.tail, List.init, (List.!!),
null, length,
List.reverse,
List.scanl, List.scanl1, List.scanr, List.scanr1,
List.iterate, List.repeat, List.replicate, List.cycle,
List.take, List.drop,
List.takeWhile, List.dropWhile,
List.span, List.break,
List.splitAt,
List.zip, List.zip3,
List.zipWith, List.zipWith3,
List.unzip, List.unzip3,
List.lines, List.words, List.unlines, List.unwords,
Show(showsPrec, show),
read,
IO,
putChar,
putStr, putStrLn, print,
getChar,
getLine, getContents, interact,
FilePath,
readFile, writeFile, appendFile, readIO, readLn,
IOError, ioError, userError,
) where
import qualified Control.Monad as Monad
import System.IO
import System.IO.Error
import qualified Data.List as List
import Data.Either
import Data.Functor ( (<$>) )
import Data.Maybe
import Data.Tuple
import GHC.Base hiding ( foldr, mapM, sequence, Eq(..), Ord(..), Monad(..) )
import qualified Text.Read as Read
import qualified GHC.Enum as Enum
import qualified GHC.Num as Num
import GHC.Num(Integer)
import qualified GHC.Real as NumR
import qualified Data.Ord as Ord
import qualified Data.Eq as Eq
import GHC.Show
import GHC.TypeLits
import qualified Data.Foldable as Foldable
length :: [a] -> Integer
length :: forall a. [a] -> Integer
length [] = Integer
0
length (a
_:[a]
xs) = Integer
1 Integer -> Integer -> Integer
+ forall a. [a] -> Integer
length [a]
xs
(==), (/=), (<), (<=), (>=), (>) :: Integer -> Integer -> Bool
== :: Integer -> Integer -> Bool
(==) = forall a. Eq a => a -> a -> Bool
(Eq.==)
/= :: Integer -> Integer -> Bool
(/=) = forall a. Eq a => a -> a -> Bool
(Eq./=)
< :: Integer -> Integer -> Bool
(<) = forall a. Ord a => a -> a -> Bool
(Ord.<)
<= :: Integer -> Integer -> Bool
(<=) = forall a. Ord a => a -> a -> Bool
(Ord.<=)
>= :: Integer -> Integer -> Bool
(>=) = forall a. Ord a => a -> a -> Bool
(Ord.>=)
> :: Integer -> Integer -> Bool
(>) = forall a. Ord a => a -> a -> Bool
(Ord.>)
max, min :: Integer -> Integer -> Integer
max :: Integer -> Integer -> Integer
max = forall a. Ord a => a -> a -> a
Ord.max
min :: Integer -> Integer -> Integer
min = forall a. Ord a => a -> a -> a
Ord.min
succ, pred :: Integer -> Integer
succ :: Integer -> Integer
succ = forall a. Enum a => a -> a
Enum.succ
pred :: Integer -> Integer
pred = forall a. Enum a => a -> a
Enum.pred
enumFrom :: Integer -> [Integer]
enumFrom :: Integer -> [Integer]
enumFrom = forall a. Enum a => a -> [a]
Enum.enumFrom
enumFromThen :: Integer -> Integer -> [Integer]
enumFromThen :: Integer -> Integer -> [Integer]
enumFromThen = forall a. Enum a => a -> a -> [a]
Enum.enumFromThen
enumFromTo :: Integer -> Integer -> [Integer]
enumFromTo :: Integer -> Integer -> [Integer]
enumFromTo = forall a. Enum a => a -> a -> [a]
Enum.enumFromTo
enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]
enumFromThenTo :: Integer -> Integer -> Integer -> [Integer]
enumFromThenTo = forall a. Enum a => a -> a -> a -> [a]
Enum.enumFromThenTo
(+), (-), (*), quot, rem, div, mod :: Integer -> Integer -> Integer
+ :: Integer -> Integer -> Integer
(+) = forall a. Num a => a -> a -> a
(Num.+)
(-) = forall a. Num a => a -> a -> a
(Num.-)
* :: Integer -> Integer -> Integer
(*) = forall a. Num a => a -> a -> a
(Num.*)
quot :: Integer -> Integer -> Integer
quot = forall a. Integral a => a -> a -> a
NumR.quot
rem :: Integer -> Integer -> Integer
rem = forall a. Integral a => a -> a -> a
NumR.rem
div :: Integer -> Integer -> Integer
div = forall a. Integral a => a -> a -> a
NumR.div
mod :: Integer -> Integer -> Integer
mod = forall a. Integral a => a -> a -> a
NumR.mod
negate, abs, signum, fromInteger, toInteger :: Integer -> Integer
negate :: Integer -> Integer
negate = forall a. Num a => a -> a
Num.negate
abs :: Integer -> Integer
abs = forall a. Num a => a -> a
Num.abs
signum :: Integer -> Integer
signum = forall a. Num a => a -> a
Num.signum
fromInteger :: Integer -> Integer
fromInteger = forall a. a -> a
id
toInteger :: Integer -> Integer
toInteger = forall a. a -> a
id
quotRem, divMod :: Integer -> Integer -> (Integer, Integer)
quotRem :: Integer -> Integer -> (Integer, Integer)
quotRem = forall a. Integral a => a -> a -> (a, a)
NumR.quotRem
divMod :: Integer -> Integer -> (Integer, Integer)
divMod = forall a. Integral a => a -> a -> (a, a)
NumR.divMod
(^) :: Integer -> Integer -> Integer
^ :: Integer -> Integer -> Integer
(^) = forall a b. (Num a, Integral b) => a -> b -> a
(NumR.^)
null :: [a] -> Bool
null :: forall a. [a] -> Bool
null = forall (t :: * -> *) a. Foldable t => t a -> Bool
Foldable.null
foldl :: (b -> a -> b) -> b -> [a] -> b
foldl :: forall b a. (b -> a -> b) -> b -> [a] -> b
foldl = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl
foldr :: (a -> b -> b) -> b -> [a] -> b
foldr :: forall a b. (a -> b -> b) -> b -> [a] -> b
foldr = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
Foldable.foldr
return :: a -> IO a
return :: forall a. a -> IO a
return = forall (m :: * -> *) a. Monad m => a -> m a
Monad.return
(>>) :: IO a -> IO b -> IO b
>> :: forall a b. IO a -> IO b -> IO b
(>>) = forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(Monad.>>)
(>>=) :: IO a -> (a -> IO b) -> IO b
>>= :: forall a b. IO a -> (a -> IO b) -> IO b
(>>=) = forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(Monad.>>=)
fail :: String -> IO a
fail :: forall a. String -> IO a
fail = (forall (m :: * -> *) a. MonadFail m => String -> m a
Monad.fail)
read :: String -> Integer
read :: String -> Integer
read = forall a. Read a => String -> a
Read.read
instance TypeError
(Text "Cannot show (pretty print) functions (yours is of type "
:<>: ShowType a :<>: Text " -> " :<>: ShowType b :<>: Text ")"
:$$: Text "" :$$: Text "Perhaps there is a missing argument?" :$$: Text "")
=> Show (a -> b) where
show :: (a -> b) -> String
show = forall a. HasCallStack => a
undefined