Rename Prim.Object to Prim.Record, fix purescript#1768 (purescript#2102)

paf31 · paf31 · commit e11cff57bf0f · 2016-05-10T09:39:43.000-07:00
* Rename Prim.Object to Prim.Record, fix purescript#1768 * Fix some comments
diff --git a/examples/passing/LiberalTypeSynonyms.purs b/examples/passing/LiberalTypeSynonyms.purs
@@ -9,7 +9,7 @@ foo s = s
 
 type AndFoo r = (foo :: String | r)
 
-getFoo :: forall r. Prim.Object (AndFoo r) -> String
+getFoo :: forall r. Prim.Record (AndFoo r) -> String
 getFoo o = o.foo
 
 type F r = { | r } -> { | r }
diff --git a/examples/passing/NewtypeWithRecordUpdate.purs b/examples/passing/NewtypeWithRecordUpdate.purs
@@ -5,9 +5,9 @@ module Main where
 import Prelude
 import Control.Monad.Eff.Console
 
-newtype NewType a = NewType (Object a)
+newtype NewType a = NewType (Record a)
 
-rec1 :: Object (a :: Number, b :: Number, c:: Number)
+rec1 :: Record (a :: Number, b :: Number, c:: Number)
 rec1 = { a: 0.0, b: 0.0, c: 0.0 }
 
 rec2 :: NewType (a :: Number, b :: Number, c :: Number)
diff --git a/examples/passing/RowConstructors.purs b/examples/passing/RowConstructors.purs
@@ -12,7 +12,7 @@ foo = { x: 0.0, y: 0.0, z: 0.0 }
 bar :: { | Bar }
 bar = { x: 0.0, y: 0.0, z: 0.0 }
 
-id' :: Object Foo -> Object Bar
+id' :: Record Foo -> Record Bar
 id' = id
 
 foo' :: { | Foo }
diff --git a/src/Language/PureScript/AST/Declarations.hs b/src/Language/PureScript/AST/Declarations.hs
@@ -351,8 +351,8 @@ data Expr
   --
   | Parens Expr
   -- |
-  -- An object property getter (e.g. `_.x`). This will be removed during
-  -- desugaring and expanded into a lambda that reads a property from an object.
+  -- A record property getter (e.g. `_.x`). This will be removed during
+  -- desugaring and expanded into a lambda that reads a property from a record.
   --
   | ObjectGetter String
   -- |
diff --git a/src/Language/PureScript/Docs/RenderedCode/Render.hs b/src/Language/PureScript/Docs/RenderedCode/Render.hs
@@ -159,7 +159,7 @@ dePrim other = other
 
 convert :: RenderTypeOptions -> Type -> Type
 convert _ (TypeApp (TypeApp f arg) ret) | f == tyFunction = PrettyPrintFunction arg ret
-convert opts (TypeApp o r) | o == tyObject && prettyPrintObjects opts = PrettyPrintObject r
+convert opts (TypeApp o r) | o == tyRecord && prettyPrintObjects opts = PrettyPrintObject r
 convert _ other = other
 
 convertForAlls :: Type -> Type
diff --git a/src/Language/PureScript/Environment.hs b/src/Language/PureScript/Environment.hs
@@ -196,16 +196,16 @@ tyArray :: Type
 tyArray = primTy "Array"
 
 -- |
--- Type constructor for objects
+-- Type constructor for records
 --
-tyObject :: Type
-tyObject = primTy "Object"
+tyRecord :: Type
+tyRecord = primTy "Record"
 
 -- |
--- Check whether a type is an object
+-- Check whether a type is a record
 --
 isObject :: Type -> Bool
-isObject = isTypeOrApplied tyObject
+isObject = isTypeOrApplied tyRecord
 
 -- |
 -- Check whether a type is a function
@@ -232,14 +232,14 @@ primTypes :: M.Map (Qualified (ProperName 'TypeName)) (Kind, TypeKind)
 primTypes =
   M.fromList
     [ (primName "Function", (FunKind Star (FunKind Star Star), ExternData))
-    , (primName "Array", (FunKind Star Star, ExternData))
-    , (primName "Object", (FunKind (Row Star) Star, ExternData))
-    , (primName "String", (Star, ExternData))
-    , (primName "Char", (Star, ExternData))
-    , (primName "Number", (Star, ExternData))
-    , (primName "Int", (Star, ExternData))
-    , (primName "Boolean", (Star, ExternData))
-    , (primName "Partial", (Star, ExternData))
+    , (primName "Array",    (FunKind Star Star, ExternData))
+    , (primName "Record",   (FunKind (Row Star) Star, ExternData))
+    , (primName "String",   (Star, ExternData))
+    , (primName "Char",     (Star, ExternData))
+    , (primName "Number",   (Star, ExternData))
+    , (primName "Int",      (Star, ExternData))
+    , (primName "Boolean",  (Star, ExternData))
+    , (primName "Partial",  (Star, ExternData))
     ]
 
 -- |
diff --git a/src/Language/PureScript/Parser/Types.hs b/src/Language/PureScript/Parser/Types.hs
@@ -25,7 +25,7 @@ parseFunction :: TokenParser Type
 parseFunction = parens rarrow >> return tyFunction
 
 parseObject :: TokenParser Type
-parseObject = braces $ TypeApp tyObject <$> parseRow
+parseObject = braces $ TypeApp tyRecord <$> parseRow
 
 parseTypeWildcard :: TokenParser Type
 parseTypeWildcard = do
diff --git a/src/Language/PureScript/Pretty/Types.hs b/src/Language/PureScript/Pretty/Types.hs
@@ -99,7 +99,7 @@ insertPlaceholders :: Type -> Type
 insertPlaceholders = everywhereOnTypesTopDown convertForAlls . everywhereOnTypes convert
   where
   convert (TypeApp (TypeApp f arg) ret) | f == tyFunction = PrettyPrintFunction arg ret
-  convert (TypeApp o r) | o == tyObject = PrettyPrintObject r
+  convert (TypeApp o r) | o == tyRecord = PrettyPrintObject r
   convert other = other
   convertForAlls (ForAll ident ty _) = go [ident] ty
     where
diff --git a/src/Language/PureScript/Sugar/TypeClasses.hs b/src/Language/PureScript/Sugar/TypeClasses.hs
@@ -233,7 +233,7 @@ typeClassDictionaryDeclaration name args implies members =
         ]
       members' = map (first runIdent . memberToNameAndType) members
       mtys = members' ++ superclassTypes
-  in TypeSynonymDeclaration (coerceProperName name) args (TypeApp tyObject $ rowFromList (mtys, REmpty))
+  in TypeSynonymDeclaration (coerceProperName name) args (TypeApp tyRecord $ rowFromList (mtys, REmpty))
 
 typeClassMemberToDictionaryAccessor
   :: ModuleName
@@ -251,7 +251,7 @@ typeClassMemberToDictionaryAccessor mn name args (PositionedDeclaration pos com
 typeClassMemberToDictionaryAccessor _ _ _ _ = internalError "Invalid declaration in type class definition"
 
 unit :: Type
-unit = TypeApp tyObject REmpty
+unit = TypeApp tyRecord REmpty
 
 typeInstanceDictionaryDeclaration
   :: forall m
@@ -285,8 +285,8 @@ typeInstanceDictionaryDeclaration name mn deps className tys decls =
       members <- zip (map typeClassMemberName decls) <$> traverse (memberToValue memberTypes) decls
 
       -- Create the type of the dictionary
-      -- The type is an object type, but depending on type instance dependencies, may be constrained.
-      -- The dictionary itself is an object literal.
+      -- The type is a record type, but depending on type instance dependencies, may be constrained.
+      -- The dictionary itself is a record literal.
       let superclasses = superClassDictionaryNames implies `zip`
             [ Abs (Left (Ident C.__unused)) (SuperClassDictionary superclass tyArgs)
             | (Constraint superclass suTyArgs _) <- implies
diff --git a/src/Language/PureScript/Sugar/TypeClasses/Deriving.hs b/src/Language/PureScript/Sugar/TypeClasses/Deriving.hs
@@ -410,7 +410,7 @@ mkVar :: Ident -> Expr
 mkVar = mkVarMn Nothing
 
 objectType :: Type -> Maybe Type
-objectType (TypeApp (TypeConstructor (Qualified (Just (ModuleName [ProperName "Prim"])) (ProperName "Object"))) rec) = Just rec
+objectType (TypeApp (TypeConstructor (Qualified (Just (ModuleName [ProperName "Prim"])) (ProperName "Record"))) rec) = Just rec
 objectType _ = Nothing
 
 decomposeRec :: Type -> [(String, Type)]
diff --git a/src/Language/PureScript/TypeChecker/Subsumption.hs b/src/Language/PureScript/TypeChecker/Subsumption.hs
@@ -53,7 +53,7 @@ subsumes' val ty1 (KindedType ty2 _) =
 subsumes' (Just val) (ConstrainedType constraints ty1) ty2 = do
   dicts <- getTypeClassDictionaries
   subsumes' (Just $ foldl App val (map (flip TypeClassDictionary dicts) constraints)) ty1 ty2
-subsumes' val (TypeApp f1 r1) (TypeApp f2 r2) | f1 == tyObject && f2 == tyObject = do
+subsumes' val (TypeApp f1 r1) (TypeApp f2 r2) | f1 == tyRecord && f2 == tyRecord = do
   let
     (ts1, r1') = rowToList r1
     (ts2, r2') = rowToList r2
@@ -80,7 +80,7 @@ subsumes' val (TypeApp f1 r1) (TypeApp f2 r2) | f1 == tyObject && f2 == tyObject
                        REmpty -> throwError . errorMessage $ PropertyIsMissing p2
                        _ -> unifyTypes r1' (RCons p2 ty2 rest)
                      go ((p1, ty1) : ts1) ts2 rest r2'
-subsumes' val ty1 ty2@(TypeApp obj _) | obj == tyObject = subsumes val ty2 ty1
+subsumes' val ty1 ty2@(TypeApp obj _) | obj == tyRecord = subsumes val ty2 ty1
 subsumes' val ty1 ty2 = do
   unifyTypes ty1 ty2
   return val
diff --git a/src/Language/PureScript/TypeChecker/Types.hs b/src/Language/PureScript/TypeChecker/Types.hs
@@ -254,21 +254,21 @@ infer' (Literal (ObjectLiteral ps)) = do
   ensureNoDuplicateProperties ps
   ts <- traverse (infer . snd) ps
   let fields = zipWith (\name (TypedValue _ _ t) -> (name, t)) (map fst ps) ts
-      ty = TypeApp tyObject $ rowFromList (fields, REmpty)
+      ty = TypeApp tyRecord $ rowFromList (fields, REmpty)
   return $ TypedValue True (Literal (ObjectLiteral (zip (map fst ps) ts))) ty
 infer' (ObjectUpdate o ps) = do
   ensureNoDuplicateProperties ps
   row <- freshType
   newVals <- zipWith (\(name, _) t -> (name, t)) ps <$> traverse (infer . snd) ps
   let newTys = map (\(name, TypedValue _ _ ty) -> (name, ty)) newVals
   oldTys <- zip (map fst ps) <$> replicateM (length ps) freshType
-  let oldTy = TypeApp tyObject $ rowFromList (oldTys, row)
+  let oldTy = TypeApp tyRecord $ rowFromList (oldTys, row)
   o' <- TypedValue True <$> check o oldTy <*> pure oldTy
-  return $ TypedValue True (ObjectUpdate o' newVals) $ TypeApp tyObject $ rowFromList (newTys, row)
+  return $ TypedValue True (ObjectUpdate o' newVals) $ TypeApp tyRecord $ rowFromList (newTys, row)
 infer' (Accessor prop val) = rethrow (addHint (ErrorCheckingAccessor val prop)) $ do
   field <- freshType
   rest <- freshType
-  typed <- check val (TypeApp tyObject (RCons prop field rest))
+  typed <- check val (TypeApp tyRecord (RCons prop field rest))
   return $ TypedValue True (Accessor prop typed) field
 infer' (Abs (Left arg) ret) = do
   ty <- freshType
@@ -402,7 +402,7 @@ inferBinder val (LiteralBinder (ObjectLiteral props)) = do
   row <- freshType
   rest <- freshType
   m1 <- inferRowProperties row rest props
-  unifyTypes val (TypeApp tyObject row)
+  unifyTypes val (TypeApp tyRecord row)
   return m1
   where
   inferRowProperties :: Type -> Type -> [(String, Binder)] -> m (M.Map Ident Type)
@@ -616,26 +616,26 @@ check' (IfThenElse cond th el) ty = do
   th' <- check th ty
   el' <- check el ty
   return $ TypedValue True (IfThenElse cond' th' el') ty
-check' e@(Literal (ObjectLiteral ps)) t@(TypeApp obj row) | obj == tyObject = do
+check' e@(Literal (ObjectLiteral ps)) t@(TypeApp obj row) | obj == tyRecord = do
   ensureNoDuplicateProperties ps
   ps' <- checkProperties e ps row False
   return $ TypedValue True (Literal (ObjectLiteral ps')) t
 check' (TypeClassDictionaryConstructorApp name ps) t = do
   ps' <- check' ps t
   return $ TypedValue True (TypeClassDictionaryConstructorApp name ps') t
-check' e@(ObjectUpdate obj ps) t@(TypeApp o row) | o == tyObject = do
+check' e@(ObjectUpdate obj ps) t@(TypeApp o row) | o == tyRecord = do
   ensureNoDuplicateProperties ps
   -- We need to be careful to avoid duplicate labels here.
   -- We check _obj_ against the type _t_ with the types in _ps_ replaced with unknowns.
   let (propsToCheck, rest) = rowToList row
       (removedProps, remainingProps) = partition (\(p, _) -> p `elem` map fst ps) propsToCheck
   us <- zip (map fst removedProps) <$> replicateM (length ps) freshType
-  obj' <- check obj (TypeApp tyObject (rowFromList (us ++ remainingProps, rest)))
+  obj' <- check obj (TypeApp tyRecord (rowFromList (us ++ remainingProps, rest)))
   ps' <- checkProperties e ps row True
   return $ TypedValue True (ObjectUpdate obj' ps') t
 check' (Accessor prop val) ty = rethrow (addHint (ErrorCheckingAccessor val prop)) $ do
   rest <- freshType
-  val' <- check val (TypeApp tyObject (RCons prop ty rest))
+  val' <- check val (TypeApp tyRecord (RCons prop ty rest))
   return $ TypedValue True (Accessor prop val') ty
 check' v@(Constructor c) ty = do
   env <- getEnv
@@ -698,7 +698,7 @@ checkProperties expr ps row lax = let (ts, r') = rowToList row in go ps ts r' wh
         v' <- check v ty
         ps'' <- go ps' (delete (p, ty) ts) r
         return $ (p, v') : ps''
-  go _ _ _ = throwError . errorMessage $ ExprDoesNotHaveType expr (TypeApp tyObject row)
+  go _ _ _ = throwError . errorMessage $ ExprDoesNotHaveType expr (TypeApp tyRecord row)
 
 -- | Check the type of a function application, rethrowing errors to provide a better error message
 checkFunctionApplication ::
