-- | Various constants which refer to things in the Prelude
module Language.PureScript.Constants.Prelude where

import Data.String (IsString)
import Language.PureScript.PSString (PSString)
import Language.PureScript.Names

-- Operators

apply :: forall a. (IsString a) => a
apply :: forall a. IsString a => a
apply = a
"apply"

applyFlipped :: forall a. (IsString a) => a
applyFlipped :: forall a. IsString a => a
applyFlipped = a
"applyFlipped"

append :: forall a. (IsString a) => a
append :: forall a. IsString a => a
append = a
"append"

mempty :: forall a. (IsString a) => a
mempty :: forall a. IsString a => a
mempty = a
"mempty"

bind :: forall a. (IsString a) => a
bind :: forall a. IsString a => a
bind = a
"bind"

discard :: forall a. (IsString a) => a
discard :: forall a. IsString a => a
discard = a
"discard"

pattern Discard :: Qualified (ProperName 'ClassName)
pattern $bDiscard :: Qualified (ProperName 'ClassName)
$mDiscard :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Discard = Qualified (ByModuleName ControlBind) (ProperName "Discard")

add :: forall a. (IsString a) => a
add :: forall a. IsString a => a
add = a
"add"

sub :: forall a. (IsString a) => a
sub :: forall a. IsString a => a
sub = a
"sub"

mul :: forall a. (IsString a) => a
mul :: forall a. IsString a => a
mul = a
"mul"

div :: forall a. (IsString a) => a
div :: forall a. IsString a => a
div = a
"div"

lessThan :: forall a. (IsString a) => a
lessThan :: forall a. IsString a => a
lessThan = a
"lessThan"

greaterThan :: forall a. (IsString a) => a
greaterThan :: forall a. IsString a => a
greaterThan = a
"greaterThan"

lessThanOrEq :: forall a. (IsString a) => a
lessThanOrEq :: forall a. IsString a => a
lessThanOrEq = a
"lessThanOrEq"

greaterThanOrEq :: forall a. (IsString a) => a
greaterThanOrEq :: forall a. IsString a => a
greaterThanOrEq = a
"greaterThanOrEq"

eq :: forall a. (IsString a) => a
eq :: forall a. IsString a => a
eq = a
"eq"

eq1 :: forall a. (IsString a) => a
eq1 :: forall a. IsString a => a
eq1 = a
"eq1"

notEq :: forall a. (IsString a) => a
notEq :: forall a. IsString a => a
notEq = a
"notEq"

compare :: forall a. (IsString a) => a
compare :: forall a. IsString a => a
compare = a
"compare"

compare1 :: forall a. (IsString a) => a
compare1 :: forall a. IsString a => a
compare1 = a
"compare1"

conj :: forall a. (IsString a) => a
conj :: forall a. IsString a => a
conj = a
"conj"

disj :: forall a. (IsString a) => a
disj :: forall a. IsString a => a
disj = a
"disj"

unsafeIndex :: forall a. (IsString a) => a
unsafeIndex :: forall a. IsString a => a
unsafeIndex = a
"unsafeIndex"

or :: forall a. (IsString a) => a
or :: forall a. IsString a => a
or = a
"or"

and :: forall a. (IsString a) => a
and :: forall a. IsString a => a
and = a
"and"

xor :: forall a. (IsString a) => a
xor :: forall a. IsString a => a
xor = a
"xor"

compose :: forall a. (IsString a) => a
compose :: forall a. IsString a => a
compose = a
"compose"

composeFlipped :: forall a. (IsString a) => a
composeFlipped :: forall a. IsString a => a
composeFlipped = a
"composeFlipped"

map :: forall a. (IsString a) => a
map :: forall a. IsString a => a
map = a
"map"

-- Functions

negate :: forall a. (IsString a) => a
negate :: forall a. IsString a => a
negate = a
"negate"

not :: forall a. (IsString a) => a
not :: forall a. IsString a => a
not = a
"not"

shl :: forall a. (IsString a) => a
shl :: forall a. IsString a => a
shl = a
"shl"

shr :: forall a. (IsString a) => a
shr :: forall a. IsString a => a
shr = a
"shr"

zshr :: forall a. (IsString a) => a
zshr :: forall a. IsString a => a
zshr = a
"zshr"

complement :: forall a. (IsString a) => a
complement :: forall a. IsString a => a
complement = a
"complement"

identity :: forall a. (IsString a) => a
identity :: forall a. IsString a => a
identity = a
"identity"

-- Prelude Values

zero :: forall a. (IsString a) => a
zero :: forall a. IsString a => a
zero = a
"zero"

one :: forall a. (IsString a) => a
one :: forall a. IsString a => a
one = a
"one"

bottom :: forall a. (IsString a) => a
bottom :: forall a. IsString a => a
bottom = a
"bottom"

top :: forall a. (IsString a) => a
top :: forall a. IsString a => a
top = a
"top"

pure' :: forall a. (IsString a) => a
pure' :: forall a. IsString a => a
pure' = a
"pure"

-- Core lib values

runST :: forall a. (IsString a) => a
runST :: forall a. IsString a => a
runST = a
"run"

stRefValue :: forall a. (IsString a) => a
stRefValue :: forall a. IsString a => a
stRefValue = a
"value"

newSTRef :: forall a. (IsString a) => a
newSTRef :: forall a. IsString a => a
newSTRef = a
"new"

readSTRef :: forall a. (IsString a) => a
readSTRef :: forall a. IsString a => a
readSTRef = a
"read"

writeSTRef :: forall a. (IsString a) => a
writeSTRef :: forall a. IsString a => a
writeSTRef = a
"write"

modifySTRef :: forall a. (IsString a) => a
modifySTRef :: forall a. IsString a => a
modifySTRef = a
"modify"

mkFn :: forall a. (IsString a) => a
mkFn :: forall a. IsString a => a
mkFn = a
"mkFn"

runFn :: forall a. (IsString a) => a
runFn :: forall a. IsString a => a
runFn = a
"runFn"

mkEffFn :: forall a. (IsString a) => a
mkEffFn :: forall a. IsString a => a
mkEffFn = a
"mkEffFn"

runEffFn :: forall a. (IsString a) => a
runEffFn :: forall a. IsString a => a
runEffFn = a
"runEffFn"

mkEffectFn :: forall a. (IsString a) => a
mkEffectFn :: forall a. IsString a => a
mkEffectFn = a
"mkEffectFn"

runEffectFn :: forall a. (IsString a) => a
runEffectFn :: forall a. IsString a => a
runEffectFn = a
"runEffectFn"

mkSTFn :: forall a. (IsString a) => a
mkSTFn :: forall a. IsString a => a
mkSTFn = a
"mkSTFn"

runSTFn :: forall a. (IsString a) => a
runSTFn :: forall a. IsString a => a
runSTFn = a
"runSTFn"

-- Type Class Dictionary Names

data EffectDictionaries = EffectDictionaries
  { EffectDictionaries -> PSString
edApplicativeDict :: PSString
  , EffectDictionaries -> PSString
edBindDict :: PSString
  , EffectDictionaries -> PSString
edMonadDict :: PSString
  , EffectDictionaries -> PSString
edWhile :: PSString
  , EffectDictionaries -> PSString
edUntil :: PSString
  }

effDictionaries :: EffectDictionaries
effDictionaries :: EffectDictionaries
effDictionaries = EffectDictionaries
  { edApplicativeDict :: PSString
edApplicativeDict = PSString
"applicativeEff"
  , edBindDict :: PSString
edBindDict = PSString
"bindEff"
  , edMonadDict :: PSString
edMonadDict = PSString
"monadEff"
  , edWhile :: PSString
edWhile = PSString
"whileE"
  , edUntil :: PSString
edUntil = PSString
"untilE"
  }

effectDictionaries :: EffectDictionaries
effectDictionaries :: EffectDictionaries
effectDictionaries = EffectDictionaries
  { edApplicativeDict :: PSString
edApplicativeDict = PSString
"applicativeEffect"
  , edBindDict :: PSString
edBindDict = PSString
"bindEffect"
  , edMonadDict :: PSString
edMonadDict = PSString
"monadEffect"
  , edWhile :: PSString
edWhile = PSString
"whileE"
  , edUntil :: PSString
edUntil = PSString
"untilE"
  }

stDictionaries :: EffectDictionaries
stDictionaries :: EffectDictionaries
stDictionaries = EffectDictionaries
  { edApplicativeDict :: PSString
edApplicativeDict = PSString
"applicativeST"
  , edBindDict :: PSString
edBindDict = PSString
"bindST"
  , edMonadDict :: PSString
edMonadDict = PSString
"monadST"
  , edWhile :: PSString
edWhile = PSString
"while"
  , edUntil :: PSString
edUntil = PSString
"until"
  }

discardUnitDictionary :: forall a. (IsString a) => a
discardUnitDictionary :: forall a. IsString a => a
discardUnitDictionary = a
"discardUnit"

semiringNumber :: forall a. (IsString a) => a
semiringNumber :: forall a. IsString a => a
semiringNumber = a
"semiringNumber"

semiringInt :: forall a. (IsString a) => a
semiringInt :: forall a. IsString a => a
semiringInt = a
"semiringInt"

ringNumber :: forall a. (IsString a) => a
ringNumber :: forall a. IsString a => a
ringNumber = a
"ringNumber"

ringInt :: forall a. (IsString a) => a
ringInt :: forall a. IsString a => a
ringInt = a
"ringInt"

euclideanRingNumber :: forall a. (IsString a) => a
euclideanRingNumber :: forall a. IsString a => a
euclideanRingNumber = a
"euclideanRingNumber"

ordBoolean :: forall a. (IsString a) => a
ordBoolean :: forall a. IsString a => a
ordBoolean = a
"ordBoolean"

ordNumber :: forall a. (IsString a) => a
ordNumber :: forall a. IsString a => a
ordNumber = a
"ordNumber"

ordInt :: forall a. (IsString a) => a
ordInt :: forall a. IsString a => a
ordInt = a
"ordInt"

ordString :: forall a. (IsString a) => a
ordString :: forall a. IsString a => a
ordString = a
"ordString"

ordChar :: forall a. (IsString a) => a
ordChar :: forall a. IsString a => a
ordChar = a
"ordChar"

eqNumber :: forall a. (IsString a) => a
eqNumber :: forall a. IsString a => a
eqNumber = a
"eqNumber"

eqInt :: forall a. (IsString a) => a
eqInt :: forall a. IsString a => a
eqInt = a
"eqInt"

eqString :: forall a. (IsString a) => a
eqString :: forall a. IsString a => a
eqString = a
"eqString"

eqChar :: forall a. (IsString a) => a
eqChar :: forall a. IsString a => a
eqChar = a
"eqChar"

eqBoolean :: forall a. (IsString a) => a
eqBoolean :: forall a. IsString a => a
eqBoolean = a
"eqBoolean"

boundedBoolean :: forall a. (IsString a) => a
boundedBoolean :: forall a. IsString a => a
boundedBoolean = a
"boundedBoolean"

heytingAlgebraBoolean :: forall a. (IsString a) => a
heytingAlgebraBoolean :: forall a. IsString a => a
heytingAlgebraBoolean = a
"heytingAlgebraBoolean"

semigroupString :: forall a. (IsString a) => a
semigroupString :: forall a. IsString a => a
semigroupString = a
"semigroupString"

semigroupoidFn :: forall a. (IsString a) => a
semigroupoidFn :: forall a. IsString a => a
semigroupoidFn = a
"semigroupoidFn"

categoryFn :: forall a. (IsString a) => a
categoryFn :: forall a. IsString a => a
categoryFn = a
"categoryFn"

-- Data.Symbol

pattern DataSymbol :: ModuleName
pattern $bDataSymbol :: ModuleName
$mDataSymbol :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataSymbol = ModuleName "Data.Symbol"

pattern IsSymbol :: Qualified (ProperName 'ClassName)
pattern $bIsSymbol :: Qualified (ProperName 'ClassName)
$mIsSymbol :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
IsSymbol = Qualified (ByModuleName DataSymbol) (ProperName "IsSymbol")

pattern DataReflectable :: ModuleName
pattern $bDataReflectable :: ModuleName
$mDataReflectable :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataReflectable = ModuleName "Data.Reflectable"

pattern Reflectable :: Qualified (ProperName 'ClassName)
pattern $bReflectable :: Qualified (ProperName 'ClassName)
$mReflectable :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Reflectable = Qualified (ByModuleName DataReflectable) (ProperName "Reflectable")

pattern DataOrdering :: ModuleName
pattern $bDataOrdering :: ModuleName
$mDataOrdering :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataOrdering = ModuleName "Data.Ordering"

pattern DataFunctionUncurried :: ModuleName
pattern $bDataFunctionUncurried :: ModuleName
$mDataFunctionUncurried :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataFunctionUncurried = ModuleName "Data.Function.Uncurried"

pattern PartialUnsafe :: ModuleName
pattern $bPartialUnsafe :: ModuleName
$mPartialUnsafe :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
PartialUnsafe = ModuleName "Partial.Unsafe"

pattern Ordering :: Qualified (ProperName 'TypeName)
pattern $bOrdering :: Qualified (ProperName 'TypeName)
$mOrdering :: forall {r}.
Qualified (ProperName 'TypeName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Ordering = Qualified (ByModuleName DataOrdering) (ProperName "Ordering")

pattern LT :: Qualified (ProperName 'ConstructorName)
pattern $bLT :: Qualified (ProperName 'ConstructorName)
$mLT :: forall {r}.
Qualified (ProperName 'ConstructorName)
-> ((# #) -> r) -> ((# #) -> r) -> r
LT = Qualified (ByModuleName DataOrdering) (ProperName "LT")

pattern EQ :: Qualified (ProperName 'ConstructorName)
pattern $bEQ :: Qualified (ProperName 'ConstructorName)
$mEQ :: forall {r}.
Qualified (ProperName 'ConstructorName)
-> ((# #) -> r) -> ((# #) -> r) -> r
EQ = Qualified (ByModuleName DataOrdering) (ProperName "EQ")

pattern GT :: Qualified (ProperName 'ConstructorName)
pattern $bGT :: Qualified (ProperName 'ConstructorName)
$mGT :: forall {r}.
Qualified (ProperName 'ConstructorName)
-> ((# #) -> r) -> ((# #) -> r) -> r
GT = Qualified (ByModuleName DataOrdering) (ProperName "GT")

pattern DataArray :: ModuleName
pattern $bDataArray :: ModuleName
$mDataArray :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataArray = ModuleName "Data.Array"

pattern Eff :: ModuleName
pattern $bEff :: ModuleName
$mEff :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
Eff = ModuleName "Control.Monad.Eff"

pattern Effect :: ModuleName
pattern $bEffect :: ModuleName
$mEffect :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
Effect = ModuleName "Effect"

pattern ST :: ModuleName
pattern $bST :: ModuleName
$mST :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ST = ModuleName "Control.Monad.ST.Internal"

pattern ControlApply :: ModuleName
pattern $bControlApply :: ModuleName
$mControlApply :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlApply = ModuleName "Control.Apply"

pattern Apply :: Qualified (ProperName 'ClassName)
pattern $bApply :: Qualified (ProperName 'ClassName)
$mApply :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Apply = Qualified (ByModuleName ControlApply) (ProperName "Apply")

identApply :: Qualified Ident
identApply :: Qualified Ident
identApply = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
ControlApply) (Text -> Ident
Ident forall a. IsString a => a
apply)

pattern ControlApplicative :: ModuleName
pattern $bControlApplicative :: ModuleName
$mControlApplicative :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlApplicative = ModuleName "Control.Applicative"

pattern Applicative :: Qualified (ProperName 'ClassName)
pattern $bApplicative :: Qualified (ProperName 'ClassName)
$mApplicative :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Applicative = Qualified (ByModuleName ControlApplicative) (ProperName "Applicative")

identPure :: Qualified Ident
identPure :: Qualified Ident
identPure = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
ControlApplicative) (Text -> Ident
Ident forall a. IsString a => a
pure')

pattern ControlSemigroupoid :: ModuleName
pattern $bControlSemigroupoid :: ModuleName
$mControlSemigroupoid :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlSemigroupoid = ModuleName "Control.Semigroupoid"

pattern ControlBind :: ModuleName
pattern $bControlBind :: ModuleName
$mControlBind :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlBind = ModuleName "Control.Bind"

pattern ControlCategory :: ModuleName
pattern $bControlCategory :: ModuleName
$mControlCategory :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlCategory = ModuleName "Control.Category"

pattern Category :: Qualified (ProperName 'ClassName)
pattern $bCategory :: Qualified (ProperName 'ClassName)
$mCategory :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Category = Qualified (ByModuleName ControlCategory) (ProperName "Category")

identIdentity :: Qualified Ident
identIdentity :: Qualified Ident
identIdentity = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
ControlCategory) (Text -> Ident
Ident forall a. IsString a => a
identity)

pattern ControlMonadEffUncurried :: ModuleName
pattern $bControlMonadEffUncurried :: ModuleName
$mControlMonadEffUncurried :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlMonadEffUncurried = ModuleName "Control.Monad.Eff.Uncurried"

pattern EffectUncurried :: ModuleName
pattern $bEffectUncurried :: ModuleName
$mEffectUncurried :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
EffectUncurried = ModuleName "Effect.Uncurried"

pattern ControlMonadSTUncurried :: ModuleName
pattern $bControlMonadSTUncurried :: ModuleName
$mControlMonadSTUncurried :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
ControlMonadSTUncurried = ModuleName "Control.Monad.ST.Uncurried"

pattern DataBounded :: ModuleName
pattern $bDataBounded :: ModuleName
$mDataBounded :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataBounded = ModuleName "Data.Bounded"

pattern DataSemigroup :: ModuleName
pattern $bDataSemigroup :: ModuleName
$mDataSemigroup :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataSemigroup = ModuleName "Data.Semigroup"

identAppend :: Qualified Ident
identAppend :: Qualified Ident
identAppend = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataSemigroup) (Text -> Ident
Ident forall a. IsString a => a
append)

pattern DataMonoid :: ModuleName
pattern $bDataMonoid :: ModuleName
$mDataMonoid :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataMonoid = ModuleName "Data.Monoid"

identMempty :: Qualified Ident
identMempty :: Qualified Ident
identMempty = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataMonoid) (Text -> Ident
Ident forall a. IsString a => a
mempty)

pattern DataHeytingAlgebra :: ModuleName
pattern $bDataHeytingAlgebra :: ModuleName
$mDataHeytingAlgebra :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataHeytingAlgebra = ModuleName "Data.HeytingAlgebra"

pattern DataEq :: ModuleName
pattern $bDataEq :: ModuleName
$mDataEq :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataEq = ModuleName "Data.Eq"

pattern Eq :: Qualified (ProperName 'ClassName)
pattern $bEq :: Qualified (ProperName 'ClassName)
$mEq :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Eq = Qualified (ByModuleName DataEq) (ProperName "Eq")

pattern Eq1 :: Qualified (ProperName 'ClassName)
pattern $bEq1 :: Qualified (ProperName 'ClassName)
$mEq1 :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Eq1 = Qualified (ByModuleName DataEq) (ProperName "Eq1")

identEq :: Qualified Ident
identEq :: Qualified Ident
identEq = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataEq) (Text -> Ident
Ident forall a. IsString a => a
eq)

identEq1 :: Qualified Ident
identEq1 :: Qualified Ident
identEq1 = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataEq) (Text -> Ident
Ident forall a. IsString a => a
eq1)

pattern DataOrd :: ModuleName
pattern $bDataOrd :: ModuleName
$mDataOrd :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataOrd = ModuleName "Data.Ord"

pattern Ord :: Qualified (ProperName 'ClassName)
pattern $bOrd :: Qualified (ProperName 'ClassName)
$mOrd :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Ord = Qualified (ByModuleName DataOrd) (ProperName "Ord")

pattern Ord1 :: Qualified (ProperName 'ClassName)
pattern $bOrd1 :: Qualified (ProperName 'ClassName)
$mOrd1 :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Ord1 = Qualified (ByModuleName DataOrd) (ProperName "Ord1")

identCompare :: Qualified Ident
identCompare :: Qualified Ident
identCompare = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataOrd) (Text -> Ident
Ident forall a. IsString a => a
compare)

identCompare1 :: Qualified Ident
identCompare1 :: Qualified Ident
identCompare1 = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataOrd) (Text -> Ident
Ident forall a. IsString a => a
compare1)

pattern DataFunctor :: ModuleName
pattern $bDataFunctor :: ModuleName
$mDataFunctor :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataFunctor = ModuleName "Data.Functor"

pattern Functor :: Qualified (ProperName 'ClassName)
pattern $bFunctor :: Qualified (ProperName 'ClassName)
$mFunctor :: forall {r}.
Qualified (ProperName 'ClassName)
-> ((# #) -> r) -> ((# #) -> r) -> r
Functor = Qualified (ByModuleName DataFunctor) (ProperName "Functor")

identMap :: Qualified Ident
identMap :: Qualified Ident
identMap = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataFunctor) (Text -> Ident
Ident forall a. IsString a => a
map)

pattern DataSemiring :: ModuleName
pattern $bDataSemiring :: ModuleName
$mDataSemiring :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataSemiring = ModuleName "Data.Semiring"

pattern DataRing :: ModuleName
pattern $bDataRing :: ModuleName
$mDataRing :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataRing = ModuleName "Data.Ring"

pattern DataEuclideanRing :: ModuleName
pattern $bDataEuclideanRing :: ModuleName
$mDataEuclideanRing :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataEuclideanRing = ModuleName "Data.EuclideanRing"

pattern DataFunction :: ModuleName
pattern $bDataFunction :: ModuleName
$mDataFunction :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataFunction = ModuleName "Data.Function"

identFlip :: Qualified Ident
identFlip :: Qualified Ident
identFlip = forall a. QualifiedBy -> a -> Qualified a
Qualified (ModuleName -> QualifiedBy
ByModuleName ModuleName
DataFunction) (Text -> Ident
Ident forall a. IsString a => a
flip)

flip :: forall a. (IsString a) => a
flip :: forall a. IsString a => a
flip = a
"flip"

pattern DataIntBits :: ModuleName
pattern $bDataIntBits :: ModuleName
$mDataIntBits :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
DataIntBits = ModuleName "Data.Int.Bits"

unsafePartial :: forall a. (IsString a) => a
unsafePartial :: forall a. IsString a => a
unsafePartial = a
"unsafePartial"

pattern UnsafeCoerce :: ModuleName
pattern $bUnsafeCoerce :: ModuleName
$mUnsafeCoerce :: forall {r}. ModuleName -> ((# #) -> r) -> ((# #) -> r) -> r
UnsafeCoerce = ModuleName "Unsafe.Coerce"

unsafeCoerceFn :: forall a. (IsString a) => a
unsafeCoerceFn :: forall a. IsString a => a
unsafeCoerceFn = a
"unsafeCoerce"