feat: update to purs 0.14 -> fix warning "shadowing Type/Row/Constraint type from Prim module"

Author: Serhii Khoma

src/Language/PS/CST.purs

@@ -2,7 +2,7 @@ module Language.PS.CST
   ( module Export
   ) where
 
-import Language.PS.CST.Types.Declaration (AdoBlock, Binder(..), CaseOf, ClassHead, Constraint(..), DataCtor(..), DataHead(..), Declaration(..), DoStatement(..), Expr(..), FixityFields, FixityOp(..), Foreign(..), Guarded(..), GuardedExpr, IfThenElse, Instance, InstanceBinding(..), InstanceHead, Kind(..), Lambda, LetBinding(..), LetIn, PatternGuard, RecordAccessor, RecordUpdate(..), Row, Type(..), TypeVarBinding(..), ValueBindingFields, Where, (====>), (====>>), (====>>>)) as Export
+import Language.PS.CST.Types.Declaration (AdoBlock, Binder(..), CaseOf, ClassHead, PSConstraint(..), DataCtor(..), DataHead(..), Declaration(..), DoStatement(..), Expr(..), FixityFields, FixityOp(..), Foreign(..), Guarded(..), GuardedExpr, IfThenElse, Instance, InstanceBinding(..), InstanceHead, Kind(..), Lambda, LetBinding(..), LetIn, PatternGuard, RecordAccessor, RecordUpdate(..), PSRow, PSType(..), TypeVarBinding(..), ValueBindingFields, Where, (====>), (====>>), (====>>>)) as Export
 import Language.PS.CST.Types.Module (DataMembers(..), Export(..), Import(..), ImportDecl(..), Module(..)) as Export
 import Language.PS.CST.Types.QualifiedName (QualifiedName(..)) as Export
 import Language.PS.CST.Types.Leafs (ClassFundep(..), Comments(..), DeclDeriveType(..), Fixity(..), Ident(..), Label(..), ModuleName(..), OpName(..), OpNameType_TypeOpName, OpNameType_ValueOpName, ProperName(..), ProperNameType_ClassName, ProperNameType_ConstructorName, ProperNameType_KindName, ProperNameType_Namespace, ProperNameType_TypeName, RecordLabeled(..), OpNameType, ProperNameType) as Export

src/Language/PS/CST/Printers.purs

@@ -18,7 +18,7 @@ import Language.PS.CST.Printers.TypeLevel (printConstraint, printConstraintList,
 import Language.PS.CST.Printers.Utils (dot, dquotesIf, exprShouldBeOnNextLine, labelNeedsQuotes, maybeWrapInParentheses, parens, printAndConditionallyAddNewlinesBetween, printLabelledGroup, shouldBeNoNewlineBetweenDeclarations, shouldBeNoNewlineBetweenInstanceBindings, shouldBeNoNewlineBetweenLetBindings, unwrapText, (<%%>))
 import Language.PS.CST.ReservedNames (appendUnderscoreIfReserved, quoteIfReserved)
 import Language.PS.CST.Sugar.QualifiedName (nonQualifiedName)
-import Language.PS.CST.Types.Declaration (Binder(..), Constraint(..), DataCtor(..), DataHead(..), Declaration(..), Expr(..), FixityOp(..), Foreign(..), Guarded(..), Instance, InstanceBinding(..), InstanceHead, LetBinding(..), RecordUpdate(..), Type(..), ValueBindingFields)
+import Language.PS.CST.Types.Declaration (Binder(..), PSConstraint(..), DataCtor(..), DataHead(..), Declaration(..), Expr(..), FixityOp(..), Foreign(..), Guarded(..), Instance, InstanceBinding(..), InstanceHead, LetBinding(..), RecordUpdate(..), PSType(..), ValueBindingFields)
 import Language.PS.CST.Types.Leafs (Comments(..), DeclDeriveType(..), ProperName(..), RecordLabeled(..))
 import Language.PS.CST.Types.Module (Module(..))
 
@@ -97,7 +97,7 @@ printDeclaration (DeclDerive { comments, deriveType, head: { instName, instConst
       , unwrapText instName
       ]
 
-    instConstraint = Constraint { className: instClass
+    instConstraint = PSConstraint { className: instClass
                                 , args: NonEmptyArray.toArray instTypes
                                 }
 
@@ -330,7 +330,7 @@ printRecordUpdate (RecordUpdateBranch label recordUpdates) = (text <<< appendUnd
 printAssignmentDecl
   :: String
   -> DataHead
-  -> Array Type
+  -> Array PSType
   -> Doc Void
 printAssignmentDecl reservedWord (DataHead { dataHdName, dataHdVars }) types =
   (flexGroup $
@@ -345,14 +345,14 @@ printAssignmentDecl reservedWord (DataHead { dataHdName, dataHdVars }) types =
 
     sep = spaceBreak <> text "| "
 
-dataCtorToType :: DataCtor -> Type
+dataCtorToType :: DataCtor -> PSType
 dataCtorToType (DataCtor ctor) = foldl TypeApp initType ctor.dataCtorFields
   where
     initType =
       TypeConstructor (nonQualifiedName (coerceProperName ctor.dataCtorName))
 
 -- TODO add printing of constraints
-instanceHeadToType :: InstanceHead -> Type
+instanceHeadToType :: InstanceHead -> PSType
 instanceHeadToType inst = foldl TypeApp initType inst.instTypes
   where
     initType = TypeConstructor (coerceProperName <$> inst.instClass)

src/Language/PS/CST/Printers/TypeLevel.purs

@@ -13,7 +13,7 @@ import Dodo (Doc, alignCurrentColumn, bothNotEmpty, break, encloseEmptyAlt, flex
 import Dodo.Common (leadingComma)
 import Language.PS.CST.Printers.Utils (dquotesIf, labelNeedsQuotes, parens, printLabelledGroup, printModuleName, softSpace, unwrapText, (<%%>))
 import Language.PS.CST.ReservedNames (appendUnderscoreIfReserved)
-import Language.PS.CST.Types.Declaration (Constraint(..), Kind(..), Row, Type(..), TypeVarBinding(..))
+import Language.PS.CST.Types.Declaration (PSConstraint(..), Kind(..), PSRow, PSType(..), TypeVarBinding(..))
 import Language.PS.CST.Types.Leafs (ClassFundep(..), Fixity(..), Ident, Label(..), OpName, ProperName)
 import Language.PS.CST.Types.QualifiedName (QualifiedName(..))
 
@@ -59,10 +59,10 @@ printQualifiedName_AnyOpNameType (QualifiedName qualifiedName) = case qualifiedN
   Nothing -> (text <<< appendUnderscoreIfReserved <<< unwrap) qualifiedName.qualName
   (Just moduleName) -> printModuleName moduleName <> text "." <> parens ((text <<< appendUnderscoreIfReserved <<< unwrap) qualifiedName.qualName)
 
-printType :: Type -> Doc Void
+printType :: PSType -> Doc Void
 printType = printType' false
 
-printType' :: Boolean -> Type -> Doc Void
+printType' :: Boolean -> PSType -> Doc Void
 printType' _ (TypeVar a) =  unwrapText a
 printType' _ TypeWildcard = text "_"
 printType' _ (TypeConstructor c) = printQualifiedName_AnyProperNameType c
@@ -164,7 +164,7 @@ printType' _ (TypeOp a op b) =
 printType' _ (TypeConstrained c t) =
   printConstraint c <> spaceBreak <> text "=> " <> printType' false t
 
-printRow :: String -> String -> Row -> Doc Void
+printRow :: String -> String -> PSRow -> Doc Void
 printRow open close { rowLabels, rowTail } =
   alignCurrentColumn $
   encloseEmptyAlt (text open <> space) (spaceBreak <> text close) (text (open <> close)) $
@@ -179,8 +179,8 @@ printRow open close { rowLabels, rowTail } =
 
     printTl t = text "| " <> printType' false t
 
-printConstraint :: Constraint -> Doc Void
-printConstraint (Constraint { className, args }) =
+printConstraint :: PSConstraint -> Doc Void
+printConstraint (PSConstraint { className, args }) =
   foldWithSeparator sep apps
 
   where
@@ -199,7 +199,7 @@ printConstraint (Constraint { className, args }) =
 
     sep = spaceBreak
 
-printConstraintList :: NonEmptyArray Constraint -> Doc Void
+printConstraintList :: NonEmptyArray PSConstraint -> Doc Void
 printConstraintList cs =
   parenIf (NonEmptyArray.length cs > 1)
   $ foldWithSeparator leadingComma (flexGroup <<< printConstraint <$> cs)

src/Language/PS/CST/Sugar/Declaration.purs

@@ -1,6 +1,6 @@
 module Language.PS.CST.Sugar.Declaration where
 
-import Language.PS.CST.Types.Declaration (Type(..))
+import Language.PS.CST.Types.Declaration (PSType(..))
 import Language.PS.CST.Types.Leafs (ProperName(..))
 import Language.PS.CST.Sugar.QualifiedName (nonQualifiedName)
 import Language.PS.CST.Sugar.Leafs (mkRowLabels)
@@ -9,23 +9,23 @@ import Prelude
 import Data.Maybe (Maybe(..))
 import Data.Tuple.Nested (type (/\))
 
-typeRecord :: Array (String /\ Type) -> Type
+typeRecord :: Array (String /\ PSType) -> PSType
 typeRecord labels = TypeRecord { rowLabels: mkRowLabels labels, rowTail: Nothing }
 
-typeRow :: Array (String /\ Type) -> Type
+typeRow :: Array (String /\ PSType) -> PSType
 typeRow labels = TypeRow { rowLabels: mkRowLabels labels, rowTail: Nothing }
 
-booleanType :: Type
+booleanType :: PSType
 booleanType = TypeConstructor $ nonQualifiedName $ ProperName "Boolean"
 
-numberType :: Type
+numberType :: PSType
 numberType = TypeConstructor $ nonQualifiedName $ ProperName "Number"
 
-stringType :: Type
+stringType :: PSType
 stringType = TypeConstructor $ nonQualifiedName $ ProperName "String"
 
-arrayType :: Type -> Type
+arrayType :: PSType -> PSType
 arrayType = TypeApp (TypeConstructor $ nonQualifiedName $ ProperName "Array")
 
-maybeType :: Type -> Type
+maybeType :: PSType -> PSType
 maybeType = TypeApp (TypeConstructor $ nonQualifiedName $ ProperName "Maybe")

src/Language/PS/CST/Types/Declaration.purs

@@ -21,18 +21,18 @@ data Declaration
   | DeclType
     { comments :: Maybe Comments
     , head :: DataHead
-    , type_ :: Type
+    , type_ :: PSType
     }
   | DeclNewtype
     { comments :: Maybe Comments
     , head :: DataHead
     , name :: ProperName ProperNameType_ConstructorName
-    , type_ :: Type
+    , type_ :: PSType
     }
   | DeclClass
     { comments :: Maybe Comments
     , head :: ClassHead
-    , methods :: Array { ident :: Ident, type_ :: Type }
+    , methods :: Array { ident :: Ident, type_ :: PSType }
     }
   | DeclInstanceChain
     { comments :: Maybe Comments
@@ -46,7 +46,7 @@ data Declaration
   | DeclSignature
     { comments :: Maybe Comments
     , ident :: Ident
-    , type_ :: Type
+    , type_ :: PSType
     }
   | DeclValue
     { comments :: Maybe Comments
@@ -68,13 +68,13 @@ instance showDeclaration :: Show Declaration where show = genericShow
 
 type InstanceHead =
   { instName :: Ident
-  , instConstraints :: Array Constraint
+  , instConstraints :: Array PSConstraint
   , instClass :: QualifiedName (ProperName ProperNameType_ClassName)
-  , instTypes :: NonEmptyArray Type
+  , instTypes :: NonEmptyArray PSType
   }
 
 data Foreign
-  = ForeignValue { ident :: Ident, type_ :: Type }
+  = ForeignValue { ident :: Ident, type_ :: PSType }
   | ForeignData { name :: ProperName ProperNameType_TypeName, kind_ :: Kind }
   | ForeignKind { name :: ProperName ProperNameType_KindName }
 
@@ -98,31 +98,31 @@ derive instance eqFixityOp :: Eq FixityOp
 derive instance ordFixityOp :: Ord FixityOp
 instance showFixityOp :: Show FixityOp where show = genericShow
 
-data Type
+data PSType
   = TypeVar Ident
   | TypeConstructor (QualifiedName (ProperName ProperNameType_TypeName))
   | TypeWildcard
   | TypeHole Ident
   | TypeString String
-  | TypeRow Row
-  | TypeRecord Row
-  | TypeApp Type Type
-  | TypeForall (NonEmptyArray TypeVarBinding) Type
-  | TypeArr Type Type
-  | TypeKinded Type Kind
-  | TypeOp Type (QualifiedName (OpName OpNameType_TypeOpName)) Type -- like TypeArr, but with custom type alias
-  | TypeConstrained Constraint Type
+  | TypeRow PSRow
+  | TypeRecord PSRow
+  | TypeApp PSType PSType
+  | TypeForall (NonEmptyArray TypeVarBinding) PSType
+  | TypeArr PSType PSType
+  | TypeKinded PSType Kind
+  | TypeOp PSType (QualifiedName (OpName OpNameType_TypeOpName)) PSType -- like TypeArr, but with custom type alias
+  | TypeConstrained PSConstraint PSType
   --
   -- no need to implement
   --
   -- | TypeOpName (QualifiedName (OpName OpNameType_TypeOpName))
   -- | TypeArrName
-  -- | TypeParens Type
+  -- | TypeParens PSType
 
-derive instance genericType :: Generic Type _
-derive instance eqType :: Eq Type
-derive instance ordType :: Ord Type
-instance showType :: Show Type where show x = genericShow x
+derive instance genericType :: Generic PSType _
+derive instance eqType :: Eq PSType
+derive instance ordType :: Ord PSType
+instance showType :: Show PSType where show x = genericShow x
 
 data Kind
   = KindName (QualifiedName (ProperName ProperNameType_KindName))
@@ -157,7 +157,7 @@ instance showDataHead :: Show DataHead where show = genericShow
 
 newtype DataCtor = DataCtor
   { dataCtorName :: ProperName ProperNameType_ConstructorName
-  , dataCtorFields :: Array Type
+  , dataCtorFields :: Array PSType
   }
 
 derive instance newtypeDataCtor :: Newtype DataCtor _
@@ -166,28 +166,28 @@ derive instance eqDataCtor :: Eq DataCtor
 derive instance ordDataCtor :: Ord DataCtor
 instance showDataCtor :: Show DataCtor where show = genericShow
 
-type Row =
-  { rowLabels :: Array { label :: Label, type_ :: Type }
-  , rowTail :: Maybe Type
+type PSRow =
+  { rowLabels :: Array { label :: Label, type_ :: PSType }
+  , rowTail :: Maybe PSType
   }
 
-newtype Constraint
-  = Constraint
+newtype PSConstraint
+  = PSConstraint
     { className :: QualifiedName (ProperName ProperNameType_ClassName)
-    , args :: Array Type
+    , args :: Array PSType
     }
-  -- | ConstraintParens Constraint
+  -- | ConstraintParens PSConstraint
 
-derive instance genericConstraint :: Generic Constraint _
-derive instance eqConstraint :: Eq Constraint
-derive instance ordConstraint :: Ord Constraint
-instance showConstraint :: Show Constraint where show = genericShow
+derive instance genericConstraint :: Generic PSConstraint _
+derive instance eqConstraint :: Eq PSConstraint
+derive instance ordConstraint :: Ord PSConstraint
+instance showConstraint :: Show PSConstraint where show = genericShow
 
 -- Delimeted or separated
 type ClassHead =
   { name :: ProperName ProperNameType_ClassName
   , vars :: Array TypeVarBinding
-  , super :: Array Constraint
+  , super :: Array PSConstraint
   , fundeps :: Array ClassFundep
   }
 
@@ -208,7 +208,7 @@ data Binder
   | BinderNumber (Either Int Number)
   | BinderArray (Array Binder)
   | BinderRecord (Array (RecordLabeled Binder))
-  | BinderTyped Binder Type
+  | BinderTyped Binder PSType
   | BinderOp Binder (QualifiedName (OpName OpNameType_ValueOpName)) Binder
   -- | BinderParens Binder -- no need
 
@@ -232,7 +232,7 @@ type Where =
   }
 
 data LetBinding
-  = LetBindingSignature { ident :: Ident, type_ :: Type }
+  = LetBindingSignature { ident :: Ident, type_ :: PSType }
   | LetBindingName ValueBindingFields
   | LetBindingPattern { binder :: Binder, where_ :: Where }
 
@@ -262,7 +262,7 @@ data Expr
   | ExprNumber (Either Int Number)
   | ExprArray (Array Expr)
   | ExprRecord (Array (RecordLabeled Expr))
-  | ExprTyped Expr Type
+  | ExprTyped Expr PSType
   | ExprInfix Expr Expr Expr -- e.g. `1 : 2 : Nil`
   | ExprOp Expr (QualifiedName (OpName OpNameType_ValueOpName)) Expr
   | ExprOpName (QualifiedName (OpName OpNameType_ValueOpName))
@@ -334,7 +334,7 @@ type AdoBlock =
   }
 
 data InstanceBinding
-  = InstanceBindingSignature { ident :: Ident, type_ :: Type }
+  = InstanceBindingSignature { ident :: Ident, type_ :: PSType }
   | InstanceBindingName ValueBindingFields
 
 derive instance genericInstanceBinding :: Generic InstanceBinding _

src/Language/PS/SmartCST.purs

@@ -4,7 +4,7 @@ module Language.PS.SmartCST
 
 import Language.PS.SmartCST.Types.SmartQualifiedName (SmartQualifiedName(..)) as Export
 import Language.PS.SmartCST.Types.SmartQualifiedNameConstructor (SmartQualifiedNameConstructor(..)) as Export
-import Language.PS.SmartCST.Types.Declaration (AdoBlock, Binder(..), CaseOf, ClassHead, Constraint(..), DataCtor(..), DataHead(..), Declaration(..), DoStatement(..), Expr(..), FixityFields, FixityOp(..), Foreign(..), Guarded(..), GuardedExpr, IfThenElse, Instance, InstanceBinding(..), InstanceHead, Kind(..), Lambda, LetBinding(..), LetIn, PatternGuard, RecordAccessor, RecordUpdate(..), Row, Type(..), TypeVarBinding(..), ValueBindingFields, Where, (====>), (====>>), (====>>>)) as Export
+import Language.PS.SmartCST.Types.Declaration (AdoBlock, Binder(..), CaseOf, ClassHead, PSConstraint(..), DataCtor(..), DataHead(..), Declaration(..), DoStatement(..), Expr(..), FixityFields, FixityOp(..), Foreign(..), Guarded(..), GuardedExpr, IfThenElse, Instance, InstanceBinding(..), InstanceHead, Kind(..), Lambda, LetBinding(..), LetIn, PatternGuard, RecordAccessor, RecordUpdate(..), PSRow, PSType(..), TypeVarBinding(..), ValueBindingFields, Where, (====>), (====>>), (====>>>)) as Export
 import Language.PS.SmartCST.ProcessModule (Module(..), moduleToCstModule, printModule) as Export
 import Language.PS.SmartCST.Sugar.Declaration (arrayType, booleanType, maybeType, numberType, stringType, typeRecord, typeRow) as Export
 import Language.PS.CST.Sugar.Leafs (emptyRow, mkModuleName, mkRowLabel, mkRowLabels) as Export