module ReWire.Prelude where

import ReWire
import Prelude (Bool (..))
import qualified Prelude as GHC

data Maybe a = Nothing | Just a
data Either a b = Left a | Right b

-- | Identity function.
{-# INLINE id #-}
id :: a -> a
id :: forall a. a -> a
id a
x = a
x

-- | Constant function.
{-# INLINE const #-}
const            :: a -> b -> a
const :: forall a b. a -> b -> a
const a
x b
_        =  a
x

-- | Function composition.
{-# INLINE (.) #-}
(.)              :: (b -> c) -> (a -> b) -> a -> c
b -> c
f . :: forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> b
g            =  \ a
x -> b -> c
f (a -> b
g a
x)

{-# INLINE flip #-}
flip                    :: (a -> b -> c) -> b -> a -> c
flip :: forall a b c. (a -> b -> c) -> b -> a -> c
flip a -> b -> c
f b
x a
y              =  a -> b -> c
f a
y b
x

{-# INLINE ($) #-}
($)                     :: (a -> b) -> a -> b
a -> b
f $ :: forall a b. (a -> b) -> a -> b
$ a
x                   =  a -> b
f a
x

-- Boolean type

(&&) :: Bool -> Bool -> Bool
Bool
True  && :: Bool -> Bool -> Bool
&& Bool
b = Bool
b
Bool
False && Bool
_ = Bool
False

(||) :: Bool -> Bool -> Bool
Bool
True  || :: Bool -> Bool -> Bool
|| Bool
_ = Bool
True
Bool
False || Bool
b = Bool
b

not :: Bool -> Bool
not :: Bool -> Bool
not Bool
True  = Bool
False
not Bool
False = Bool
True

{-# INLINE otherwise #-}
otherwise :: Bool
otherwise :: Bool
otherwise = Bool
True

-- Maybe type

{-# INLINE maybe #-}
maybe :: b -> (a -> b) -> Maybe a -> b
maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
maybe b
n a -> b
_ Maybe a
Nothing  = b
n
maybe b
_ a -> b
f (Just a
x) = a -> b
f a
x

-- Either type

{-# INLINE either #-}
either :: (a -> c) -> (b -> c) -> Either a b -> c
either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either a -> c
f b -> c
_ (Left a
x)  = a -> c
f a
x
either a -> c
_ b -> c
g (Right b
y) = b -> c
g b
y

{-# INLINE fst #-}
fst :: (a, b) -> a
fst :: forall a b. (a, b) -> a
fst (a
x, b
_) = a
x

{-# INLINE snd #-}
snd :: (a, b) -> b
snd :: forall a b. (a, b) -> b
snd (a
_, b
y) = b
y

-- | Converts an uncurried function to a curried function.
{-# INLINE curry #-}
curry :: ((a, b) -> c) -> a -> b -> c
curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
curry (a, b) -> c
f a
x b
y = (a, b) -> c
f (a
x, b
y)

-- | Converts a curried function to a function on pairs.
{-# INLINE uncurry #-}
uncurry :: (a -> b -> c) -> ((a, b) -> c)
uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> b -> c
f (a, b)
p = a -> b -> c
f ((a, b) -> a
forall a b. (a, b) -> a
fst (a, b)
p) ((a, b) -> b
forall a b. (a, b) -> b
snd (a, b)
p)

{-# INLINE undefined #-}
undefined :: a
undefined :: forall a. a
undefined = String -> a
forall a. String -> a
error String
"undefined"

{-# INLINE return #-}
return :: GHC.Monad m => a -> m a
return :: forall (m :: * -> *) a. Monad m => a -> m a
return = a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
rwPrimReturn

{-# INLINE pure #-}
pure :: GHC.Monad m => a -> m a
pure :: forall (m :: * -> *) a. Monad m => a -> m a
pure = a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
rwPrimReturn

{-# INLINE (>>=) #-}
(>>=) :: GHC.Monad m => m a -> (a -> m b) -> m b
>>= :: forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
(>>=) = m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
rwPrimBind

{-# INLINE (=<<) #-}
(=<<) :: GHC.Monad m => (a -> m b) -> m a -> m b
=<< :: forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
(=<<) = (m a -> (a -> m b) -> m b) -> (a -> m b) -> m a -> m b
forall a b c. (a -> b -> c) -> b -> a -> c
flip m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
rwPrimBind

{-# INLINE (>>) #-}
(>>) :: GHC.Monad m => m a -> m b -> m b
m a
ma >> :: forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> m b
mb = m a
ma m a -> (a -> m b) -> m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\ a
_ -> m b
mb)

infixr 9 .
infixr 3 &&
infixr 2 ||
infixr 1 =<<
infixr 0 $

infixl 1 >>, >>=