Module

Language.PS.SmartCST

Package: purescript-ps-cst
Repository: purescript-codegen/purescript-ps-cst

Re-exports from Language.PS.CST.ReservedNames

#reservedNames Source

reservedNames :: Set String

#quoteIfReserved Source

quoteIfReserved :: String -> String

#appendUnderscoreIfReserved Source

appendUnderscoreIfReserved :: String -> String

Re-exports from Language.PS.CST.Sugar.Leafs

#mkRowLabels Source

mkRowLabels :: forall type_. Array (String /\ type_) -> Array { label :: Label, type_ :: type_ }

#mkRowLabel Source

mkRowLabel :: forall type_. (String /\ type_) -> { label :: Label, type_ :: type_ }

#mkModuleName Source

mkModuleName :: NonEmptyArray String -> ModuleName

#emptyRow Source

emptyRow :: forall labelType type_. { rowLabels :: Array labelType, rowTail :: Maybe type_ }

Re-exports from Language.PS.CST.Types.Leafs

#RecordLabeled Source

data RecordLabeled a

Constructors

RecordPun Ident
RecordField Label a

Instances

#ProperNameType_TypeConstructor Source

data ProperNameType_TypeConstructor :: ProperNameType

#ProperNameType_Namespace Source

data ProperNameType_Namespace :: ProperNameType

#ProperNameType_ConstructorName Source

data ProperNameType_ConstructorName :: ProperNameType

#ProperNameType_ClassName Source

data ProperNameType_ClassName :: ProperNameType

#ProperNameType Source

data ProperNameType

#ProperName Source

newtype ProperName (proxy :: ProperNameType)

Constructors

ProperName String

Instances

Newtype (ProperName proxy) _
Generic (ProperName proxy) _
Eq (ProperName proxy)
Ord (ProperName proxy)
Show (ProperName proxy)

#OpNameType_ValueOpName Source

data OpNameType_ValueOpName :: OpNameType

#OpNameType_TypeOpName Source

data OpNameType_TypeOpName :: OpNameType

#OpNameType Source

data OpNameType

#OpName Source

newtype OpName (proxy :: OpNameType)

Constructors

OpName String

Instances

Newtype (OpName proxy) _
Generic (OpName proxy) _
Eq (OpName proxy)
Ord (OpName proxy)
Show (OpName proxy)

#ModuleName Source

newtype ModuleName

Constructors

ModuleName (NonEmptyArray (ProperName ProperNameType_Namespace))

Instances

#Label Source

newtype Label

Constructors

Label String

Instances

#Ident Source

newtype Ident

Constructors

Ident String

Instances

#Fixity Source

data Fixity

Constructors

Instances

#DeclDeriveType Source

data DeclDeriveType

Constructors

Instances

#Comments Source

data Comments

Constructors

OneLineComments (Array String)
Rendered as
```
-- | line1
-- | line2
```
BlockComments (Array String)
Rendered as
```
{-
  line1
  line2
-}
```

Instances

#ClassFundep Source

data ClassFundep

Constructors

FundepDetermines (NonEmptyArray Ident) (NonEmptyArray Ident)

Instances

Generic ClassFundep _
FundepDetermined (NonEmptyArray Ident) -- parser is not allowing it (i.e. class Foo a | a)?
Eq ClassFundep
Ord ClassFundep
Show ClassFundep

Re-exports from Language.PS.SmartCST.ProcessModule

#Module Source

newtype Module

Constructors

Module { declarations :: Array Declaration, exports :: Array Export, moduleName :: ModuleName }

#printModule Source

printModule :: Module -> Doc Void

#moduleToCstModule Source

moduleToCstModule :: Module -> Module

Re-exports from Language.PS.SmartCST.Sugar.Declaration

#typeRow Source

typeRow :: Array (String /\ PSType) -> PSType

#typeRecord Source

typeRecord :: Array (String /\ PSType) -> PSType

#stringType Source

stringType :: PSType

#numberType Source

numberType :: PSType

#maybeType Source

maybeType :: PSType -> PSType

#booleanType Source

booleanType :: PSType

#arrayType Source

arrayType :: PSType -> PSType

Re-exports from Language.PS.SmartCST.Types.Declaration

#Where Source

type Where = { expr :: Expr, whereBindings :: Array LetBinding }

#ValueBindingFields Source

type ValueBindingFields = { binders :: Array Binder, guarded :: Guarded, name :: Ident }

#TypeVarBinding Source

data TypeVarBinding

Constructors

TypeVarKinded Ident PSType
TypeVarName Ident

Instances

#RecordUpdate Source

data RecordUpdate

Constructors

Instances

#RecordAccessor Source

type RecordAccessor = { recExpr :: Expr, recPath :: NonEmptyArray Label }

#PatternGuard Source

type PatternGuard = { binder :: Maybe Binder, expr :: Expr }

#PSType Source

data PSType

Constructors

TypeVar Ident
TypeConstructor (SmartQualifiedName (ProperName ProperNameType_TypeConstructor))
TypeWildcard
TypeHole Ident
TypeString String
TypeRow PSRow
TypeRecord PSRow
TypeApp PSType PSType
TypeForall (NonEmptyArray TypeVarBinding) PSType
TypeArr PSType PSType
TypeKinded PSType PSType
TypeOp PSType (SmartQualifiedName (OpName OpNameType_TypeOpName)) PSType
TypeConstrained PSConstraint PSType

Instances

Generic PSType _
TypeOpName (SmartQualifiedName (OpName OpNameType_TypeOpName)) TypeArrName TypeParens PSType -- generated automatically
Eq PSType
Ord PSType
Show PSType

#PSRow Source

type PSRow = { rowLabels :: Array { label :: Label, type_ :: PSType }, rowTail :: Maybe PSType }

#PSConstraint Source

newtype PSConstraint

Constructors

PSConstraint { args :: Array PSType, className :: SmartQualifiedName (ProperName ProperNameType_ClassName) }

Instances

Generic PSConstraint _
ConstraintParens PSConstraint
Eq PSConstraint
Ord PSConstraint
Show PSConstraint

#LetIn Source

type LetIn = { bindings :: NonEmptyArray LetBinding, body :: Expr }

#LetBinding Source

data LetBinding

Constructors

LetBindingSignature { ident :: Ident, type_ :: PSType }
LetBindingName ValueBindingFields
LetBindingPattern { binder :: Binder, where_ :: Where }

Instances

#Lambda Source

type Lambda = { binders :: NonEmptyArray Binder, body :: Expr }

#InstanceHead Source

type InstanceHead = { instClass :: SmartQualifiedName (ProperName ProperNameType_ClassName), instConstraints :: Array PSConstraint, instName :: Ident, instTypes :: NonEmptyArray PSType }

#InstanceBinding Source

data InstanceBinding

Constructors

InstanceBindingSignature { ident :: Ident, type_ :: PSType }
InstanceBindingName ValueBindingFields

Instances

#Instance Source

type Instance = { body :: Array InstanceBinding, head :: InstanceHead }

#IfThenElse Source

type IfThenElse = { cond :: Expr, false_ :: Expr, true_ :: Expr }

#GuardedExpr Source

type GuardedExpr = { patterns :: NonEmptyArray PatternGuard, where_ :: Where }

#Guarded Source

data Guarded

Constructors

Unconditional (Where)
Guarded (NonEmptyArray GuardedExpr)

Instances

#Foreign Source

data Foreign

Constructors

ForeignValue { ident :: Ident, type_ :: PSType }
ForeignData { kind_ :: PSType, name :: ProperName ProperNameType_TypeConstructor }
ForeignKind { name :: ProperName ProperNameType_TypeConstructor }

Instances

#FixityOp Source

data FixityOp

Constructors

Instances

#FixityFields Source

type FixityFields = { keyword :: Fixity, operator :: FixityOp, precedence :: Int }

#Expr Source

data Expr

Constructors

ExprHole Ident
ExprSection
ExprIdent (SmartQualifiedName Ident)
ExprVar Ident
ExprConstructor (SmartQualifiedNameConstructor)
ExprBoolean Boolean
ExprChar Char
ExprString String
ExprNumber (Either Int Number)
ExprArray (Array Expr)
ExprRecord (Array (RecordLabeled Expr))
ExprTyped Expr PSType
ExprInfix Expr Expr Expr
ExprOp Expr (SmartQualifiedName (OpName OpNameType_ValueOpName)) Expr
ExprOpName (SmartQualifiedName (OpName OpNameType_ValueOpName))
ExprNegate Expr
ExprRecordAccessor RecordAccessor
ExprRecordUpdate Expr (NonEmptyArray RecordUpdate)
ExprApp Expr Expr
ExprLambda Lambda
ExprIf IfThenElse
ExprCase CaseOf
ExprLet LetIn
ExprDo (NonEmptyArray DoStatement)
ExprAdo AdoBlock

Instances

Generic Expr _
ExprParens Expr -- no need
Eq Expr
Ord Expr
Show Expr

#DoStatement Source

data DoStatement

Constructors

DoLet (NonEmptyArray LetBinding)
DoDiscard Expr
DoBind { binder :: Binder, expr :: Expr }

Instances

#Declaration Source

data Declaration

Constructors

DeclData { comments :: Maybe Comments, constructors :: Array DataCtor, head :: DataHead }
DeclType { comments :: Maybe Comments, head :: DataHead, type_ :: PSType }
DeclNewtype { comments :: Maybe Comments, head :: DataHead, name :: ProperName ProperNameType_ConstructorName, type_ :: PSType }
DeclClass { comments :: Maybe Comments, head :: ClassHead, methods :: Array { ident :: Ident, type_ :: PSType } }
DeclInstanceChain { comments :: Maybe Comments, instances :: NonEmptyArray (Instance) }
DeclDerive { comments :: Maybe Comments, deriveType :: DeclDeriveType, head :: InstanceHead }
DeclSignature { comments :: Maybe Comments, ident :: Ident, type_ :: PSType }
DeclValue { comments :: Maybe Comments, valueBindingFields :: ValueBindingFields }
DeclFixity { comments :: Maybe Comments, fixityFields :: FixityFields }
DeclForeign { comments :: Maybe Comments, foreign_ :: Foreign }

Instances

#DataHead Source

newtype DataHead

Constructors

DataHead { dataHdName :: ProperName ProperNameType_TypeConstructor, dataHdVars :: Array TypeVarBinding }

Instances

#DataCtor Source

newtype DataCtor

Constructors

DataCtor { dataCtorFields :: Array PSType, dataCtorName :: ProperName ProperNameType_ConstructorName }

Instances

#ClassHead Source

type ClassHead = { fundeps :: Array ClassFundep, name :: ProperName ProperNameType_ClassName, super :: Array PSConstraint, vars :: Array TypeVarBinding }

#CaseOf Source

type CaseOf = { branches :: NonEmptyArray { binders :: NonEmptyArray Binder, body :: Guarded }, head :: NonEmptyArray Expr }

#Binder Source

data Binder

Constructors

BinderWildcard
BinderVar Ident
BinderNamed { binder :: Binder, ident :: Ident }
BinderConstructor { args :: Array Binder, name :: SmartQualifiedNameConstructor }
BinderBoolean Boolean
BinderChar Char
BinderString String
BinderNumber (Either Int Number)
BinderArray (Array Binder)
BinderRecord (Array (RecordLabeled Binder))
BinderTyped Binder PSType
BinderOp Binder (SmartQualifiedName (OpName OpNameType_ValueOpName)) Binder

Instances

Generic Binder _
BinderParens Binder -- no need
Eq Binder
Ord Binder
Show Binder

#AdoBlock Source

type AdoBlock = { result :: Expr, statements :: Array DoStatement }

#(====>>) Source

Operator alias for Language.PS.SmartCST.Types.Declaration.TypeArr (right-associative / precedence 5)

#(====>) Source

Operator alias for Language.PS.SmartCST.Types.Declaration.ExprLambda (left-associative / precedence 5)

Re-exports from Language.PS.SmartCST.Types.SmartQualifiedName

#SmartQualifiedName Source

data SmartQualifiedName a

Constructors

Instances

Generic (SmartQualifiedName a) _
Functor SmartQualifiedName
(Eq a) => Eq (SmartQualifiedName a)
(Ord a) => Ord (SmartQualifiedName a)
(Show a) => Show (SmartQualifiedName a)

Re-exports from Language.PS.SmartCST.Types.SmartQualifiedNameConstructor

#SmartQualifiedNameConstructor Source

data SmartQualifiedNameConstructor