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

import Prelude.Compat

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

-- Prim values

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

-- Prim

partial :: forall a. (IsString a) => a
partial :: a
partial = a
"Partial"

pattern Prim :: ModuleName
pattern $bPrim :: ModuleName
$mPrim :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
Prim = ModuleName "Prim"

pattern Partial :: Qualified (ProperName 'ClassName)
pattern $bPartial :: Qualified (ProperName 'ClassName)
$mPartial :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
Partial = Qualified (Just Prim) (ProperName "Partial")

pattern Record :: Qualified (ProperName 'TypeName)
pattern $bRecord :: Qualified (ProperName 'TypeName)
$mRecord :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Record = Qualified (Just Prim) (ProperName "Record")

pattern Type :: Qualified (ProperName 'TypeName)
pattern $bType :: Qualified (ProperName 'TypeName)
$mType :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Type = Qualified (Just Prim) (ProperName "Type")

pattern Constraint :: Qualified (ProperName 'TypeName)
pattern $bConstraint :: Qualified (ProperName 'TypeName)
$mConstraint :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Constraint = Qualified (Just Prim) (ProperName "Constraint")

pattern Function :: Qualified (ProperName 'TypeName)
pattern $bFunction :: Qualified (ProperName 'TypeName)
$mFunction :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Function = Qualified (Just Prim) (ProperName "Function")

pattern Array :: Qualified (ProperName 'TypeName)
pattern $bArray :: Qualified (ProperName 'TypeName)
$mArray :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Array = Qualified (Just Prim) (ProperName "Array")

pattern Row :: Qualified (ProperName 'TypeName)
pattern $bRow :: Qualified (ProperName 'TypeName)
$mRow :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
Row = Qualified (Just Prim) (ProperName "Row")

-- Prim.Boolean

pattern PrimBoolean :: ModuleName
pattern $bPrimBoolean :: ModuleName
$mPrimBoolean :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimBoolean = ModuleName "Prim.Boolean"

booleanTrue :: Qualified (ProperName 'TypeName)
booleanTrue :: Qualified (ProperName 'TypeName)
booleanTrue = Maybe ModuleName
-> ProperName 'TypeName -> Qualified (ProperName 'TypeName)
forall a. Maybe ModuleName -> a -> Qualified a
Qualified (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
PrimBoolean) (Text -> ProperName 'TypeName
forall (a :: ProperNameType). Text -> ProperName a
ProperName Text
"True")

booleanFalse :: Qualified (ProperName 'TypeName)
booleanFalse :: Qualified (ProperName 'TypeName)
booleanFalse = Maybe ModuleName
-> ProperName 'TypeName -> Qualified (ProperName 'TypeName)
forall a. Maybe ModuleName -> a -> Qualified a
Qualified (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
PrimBoolean) (Text -> ProperName 'TypeName
forall (a :: ProperNameType). Text -> ProperName a
ProperName Text
"False")

-- Prim.Coerce

pattern PrimCoerce :: ModuleName
pattern $bPrimCoerce :: ModuleName
$mPrimCoerce :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimCoerce = ModuleName "Prim.Coerce"

pattern Coercible :: Qualified (ProperName 'ClassName)
pattern $bCoercible :: Qualified (ProperName 'ClassName)
$mCoercible :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
Coercible = Qualified (Just PrimCoerce) (ProperName "Coercible")

-- Prim.Ordering

pattern PrimOrdering :: ModuleName
pattern $bPrimOrdering :: ModuleName
$mPrimOrdering :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimOrdering = ModuleName "Prim.Ordering"

orderingLT :: Qualified (ProperName 'TypeName)
orderingLT :: Qualified (ProperName 'TypeName)
orderingLT = Maybe ModuleName
-> ProperName 'TypeName -> Qualified (ProperName 'TypeName)
forall a. Maybe ModuleName -> a -> Qualified a
Qualified (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
PrimOrdering) (Text -> ProperName 'TypeName
forall (a :: ProperNameType). Text -> ProperName a
ProperName Text
"LT")

orderingEQ :: Qualified (ProperName 'TypeName)
orderingEQ :: Qualified (ProperName 'TypeName)
orderingEQ = Maybe ModuleName
-> ProperName 'TypeName -> Qualified (ProperName 'TypeName)
forall a. Maybe ModuleName -> a -> Qualified a
Qualified (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
PrimOrdering) (Text -> ProperName 'TypeName
forall (a :: ProperNameType). Text -> ProperName a
ProperName Text
"EQ")

orderingGT :: Qualified (ProperName 'TypeName)
orderingGT :: Qualified (ProperName 'TypeName)
orderingGT = Maybe ModuleName
-> ProperName 'TypeName -> Qualified (ProperName 'TypeName)
forall a. Maybe ModuleName -> a -> Qualified a
Qualified (ModuleName -> Maybe ModuleName
forall a. a -> Maybe a
Just ModuleName
PrimOrdering) (Text -> ProperName 'TypeName
forall (a :: ProperNameType). Text -> ProperName a
ProperName Text
"GT")

-- Prim.Row

pattern PrimRow :: ModuleName
pattern $bPrimRow :: ModuleName
$mPrimRow :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimRow = ModuleName "Prim.Row"

pattern RowUnion :: Qualified (ProperName 'ClassName)
pattern $bRowUnion :: Qualified (ProperName 'ClassName)
$mRowUnion :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
RowUnion = Qualified (Just PrimRow) (ProperName "Union")

pattern RowNub :: Qualified (ProperName 'ClassName)
pattern $bRowNub :: Qualified (ProperName 'ClassName)
$mRowNub :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
RowNub = Qualified (Just PrimRow) (ProperName "Nub")

pattern RowCons :: Qualified (ProperName 'ClassName)
pattern $bRowCons :: Qualified (ProperName 'ClassName)
$mRowCons :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
RowCons = Qualified (Just PrimRow) (ProperName "Cons")

pattern RowLacks :: Qualified (ProperName 'ClassName)
pattern $bRowLacks :: Qualified (ProperName 'ClassName)
$mRowLacks :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
RowLacks = Qualified (Just PrimRow) (ProperName "Lacks")

-- Prim.RowList

pattern PrimRowList :: ModuleName
pattern $bPrimRowList :: ModuleName
$mPrimRowList :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimRowList = ModuleName "Prim.RowList"

pattern RowToList :: Qualified (ProperName 'ClassName)
pattern $bRowToList :: Qualified (ProperName 'ClassName)
$mRowToList :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
RowToList = Qualified (Just PrimRowList) (ProperName "RowToList")

pattern RowListNil :: Qualified (ProperName 'TypeName)
pattern $bRowListNil :: Qualified (ProperName 'TypeName)
$mRowListNil :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
RowListNil = Qualified (Just PrimRowList) (ProperName "Nil")

pattern RowListCons :: Qualified (ProperName 'TypeName)
pattern $bRowListCons :: Qualified (ProperName 'TypeName)
$mRowListCons :: forall r.
Qualified (ProperName 'TypeName)
-> (Void# -> r) -> (Void# -> r) -> r
RowListCons = Qualified (Just PrimRowList) (ProperName "Cons")

-- Prim.Symbol

pattern PrimSymbol :: ModuleName
pattern $bPrimSymbol :: ModuleName
$mPrimSymbol :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimSymbol = ModuleName "Prim.Symbol"

pattern SymbolCompare :: Qualified (ProperName 'ClassName)
pattern $bSymbolCompare :: Qualified (ProperName 'ClassName)
$mSymbolCompare :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
SymbolCompare = Qualified (Just PrimSymbol) (ProperName "Compare")

pattern SymbolAppend :: Qualified (ProperName 'ClassName)
pattern $bSymbolAppend :: Qualified (ProperName 'ClassName)
$mSymbolAppend :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
SymbolAppend = Qualified (Just PrimSymbol) (ProperName "Append")

pattern SymbolCons :: Qualified (ProperName 'ClassName)
pattern $bSymbolCons :: Qualified (ProperName 'ClassName)
$mSymbolCons :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
SymbolCons = Qualified (Just PrimSymbol) (ProperName "Cons")

-- Prim.TypeError

pattern PrimTypeError :: ModuleName
pattern $bPrimTypeError :: ModuleName
$mPrimTypeError :: forall r. ModuleName -> (Void# -> r) -> (Void# -> r) -> r
PrimTypeError = ModuleName "Prim.TypeError"

pattern Fail :: Qualified (ProperName 'ClassName)
pattern $bFail :: Qualified (ProperName 'ClassName)
$mFail :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
Fail = Qualified (Just PrimTypeError) (ProperName "Fail")

pattern Warn :: Qualified (ProperName 'ClassName)
pattern $bWarn :: Qualified (ProperName 'ClassName)
$mWarn :: forall r.
Qualified (ProperName 'ClassName)
-> (Void# -> r) -> (Void# -> r) -> r
Warn = Qualified (Just PrimTypeError) (ProperName "Warn")

primModules :: [ModuleName]
primModules :: [ModuleName]
primModules = [ModuleName
Prim, ModuleName
PrimBoolean, ModuleName
PrimCoerce, ModuleName
PrimOrdering, ModuleName
PrimRow, ModuleName
PrimRowList, ModuleName
PrimSymbol, ModuleName
PrimTypeError]

typ :: forall a. (IsString a) => a
typ :: a
typ = a
"Type"

kindBoolean :: forall a. (IsString a) => a
kindBoolean :: a
kindBoolean = a
"Boolean"

kindOrdering :: forall a. (IsString a) => a
kindOrdering :: a
kindOrdering = a
"Ordering"

kindRowList :: forall a. (IsString a) => a
kindRowList :: a
kindRowList = a
"RowList"

symbol :: forall a. (IsString a) => a
symbol :: a
symbol = a
"Symbol"

doc :: forall a. (IsString a) => a
doc :: a
doc = a
"Doc"

row :: forall a. (IsString a) => a
row :: a
row = a
"Row"

constraint :: forall a. (IsString a) => a
constraint :: a
constraint = a
"Constraint"

-- Modules

prim :: forall a. (IsString a) => a
prim :: a
prim = a
"Prim"

moduleBoolean :: forall a. (IsString a) => a
moduleBoolean :: a
moduleBoolean = a
"Boolean"

moduleCoerce :: forall a. (IsString a) => a
moduleCoerce :: a
moduleCoerce = a
"Coerce"

moduleOrdering :: forall a. (IsString a) => a
moduleOrdering :: a
moduleOrdering = a
"Ordering"

moduleRow :: forall a. (IsString a) => a
moduleRow :: a
moduleRow = a
"Row"

moduleRowList :: forall a. (IsString a) => a
moduleRowList :: a
moduleRowList = a
"RowList"

moduleSymbol :: forall a. (IsString a) => a
moduleSymbol :: a
moduleSymbol = a
"Symbol"

typeError :: forall a. (IsString a) => a
typeError :: a
typeError = a
"TypeError"