Rename boxed to unboxed

docs/serialization.md

@@ -86,13 +86,13 @@ It's represented in JSON to:
     }
 
 
-Boxed type
-----------
+Unboxed type
+------------
 
-Boxed type is equivalent to 1-member record type in runtime, but it's equivalent
-to its internal type in JSON representation.  For example:
+Unboxed type is equivalent to 1-member record type in runtime,
+but it's equivalent to its internal type in JSON representation.  For example:
 
-    boxed offset (float64);
+    unboxed offset (float64);
 
     record payload (
         offset left,
@@ -112,7 +112,7 @@ The internal type might be a record type as well:
         float64 top,
     );
 
-    boxed coord (point);
+    unboxed coord (point);
 
     record payload (
         coord location,
@@ -131,14 +131,14 @@ It's represented in JSON as:
 
 The internal type also can be a option/set/list/map type:
 
-    boxed box-option (text?);
+    unboxed box-option (text?);
 
     enum color = red | green | blue;
-    boxed box-set ({color});
+    unboxed box-set ({color});
 
-    boxed box-list ([float64]);
+    unboxed box-list ([float64]);
 
-    boxed box-map ({uuid: datetime});
+    unboxed box-map ({uuid: datetime});
 
     record payload (
         box-option a,

examples/shapes.nrm

@@ -1,11 +1,11 @@
 # Module consists zero or more type declarations.
 
-boxed offset (float64);
-# The key difference between boxed type and reocrd type consisting of a single
+unboxed offset (float64);
+# The key difference between unboxed type and reocrd type consisting of a single
 # field is that the former has the same JSON representation to its target type,
 # while the latter has thicker JSON representation than its only field.
 #
-# For example, a value of `boxed offset (float);` type is represented
+# For example, a value of `unboxed offset (float);` type is represented
 # in JSON as:
 #
 #     120.5

src/Nirum/Constructs/Identifier.hs

@@ -52,12 +52,12 @@ import Nirum.Constructs (Construct(toCode))
 data Identifier = Identifier T.Text deriving (Show)
 
 reservedKeywords :: S.Set Identifier
-reservedKeywords = [ "boxed"
-                   , "enum"
+reservedKeywords = [ "enum"
                    , "record"
                    , "service"
                    , "throws"
                    , "type"
+                   , "unboxed"
                    , "union"
                    ]
 

src/Nirum/Constructs/TypeDeclaration.hs

@@ -47,7 +47,7 @@ import Nirum.Constructs.TypeExpression (TypeExpression)
 
 data Type
     = Alias { canonicalType :: TypeExpression }
-    | BoxedType { innerType :: TypeExpression }
+    | UnboxedType { innerType :: TypeExpression }
     | EnumType { members :: DeclarationSet EnumMember }
     | RecordType { fields :: DeclarationSet Field }
     | UnionType { tags :: DeclarationSet Tag }
@@ -143,9 +143,9 @@ instance Construct TypeDeclaration where
                  , " = ", toCode cname, ";"
                  , toCodeWithPrefix "\n" (A.lookupDocs annotationSet')
                  ]
-    toCode (TypeDeclaration name' (BoxedType itype) annotationSet') =
+    toCode (TypeDeclaration name' (UnboxedType itype) annotationSet') =
         T.concat [ toCode annotationSet'
-                 , "boxed ", toCode name'
+                 , "unboxed ", toCode name'
                  , " (", toCode itype, ");"
                  , toCodeWithPrefix "\n" (A.lookupDocs annotationSet')]
     toCode (TypeDeclaration name' (EnumType members') annotationSet') =

src/Nirum/Parser.hs

@@ -5,7 +5,6 @@ module Nirum.Parser ( Parser
                     , aliasTypeDeclaration
                     , annotation
                     , annotationSet
-                    , boxedTypeDeclaration
                     , docs
                     , enumTypeDeclaration
                     , file
@@ -28,6 +27,7 @@ module Nirum.Parser ( Parser
                     , typeExpression
                     , typeExpressionWithoutOptionModifier
                     , typeIdentifier
+                    , unboxedTypeDeclaration
                     , unionTypeDeclaration
                     ) where
 
@@ -94,9 +94,9 @@ import Nirum.Constructs.TypeDeclaration ( EnumMember(EnumMember)
                                         , Field(Field)
                                         , Tag(Tag)
                                         , Type( Alias
-                                              , BoxedType
                                               , EnumType
                                               , RecordType
+                                              , UnboxedType
                                               , UnionType
                                               )
                                         , TypeDeclaration( Import
@@ -266,24 +266,24 @@ aliasTypeDeclaration = do
     return $ TypeDeclaration name' (Alias canonicalType) annotationSet''
 
 
-boxedTypeDeclaration :: Parser TypeDeclaration
-boxedTypeDeclaration = do
-    annotationSet' <- annotationSet <?> "boxed type annotations"
-    string' "boxed" <?> "boxed type keyword"
+unboxedTypeDeclaration :: Parser TypeDeclaration
+unboxedTypeDeclaration = do
+    annotationSet' <- annotationSet <?> "unboxed type annotations"
+    string' "unboxed" <?> "unboxed type keyword"
     spaces
-    typename <- identifier <?> "boxed type name"
+    typename <- identifier <?> "unboxed type name"
     let name' = Name typename typename
     spaces
     char '('
     spaces
-    innerType <- typeExpression <?> "inner type of boxed type"
+    innerType <- typeExpression <?> "inner type of unboxed type"
     spaces
     char ')'
     spaces
     char ';'
-    docs' <- optional $ try $ spaces >> (docs <?> "boxed type docs")
+    docs' <- optional $ try $ spaces >> (docs <?> "unboxed type docs")
     annotationSet'' <- annotationsWithDocs annotationSet' docs'
-    return $ TypeDeclaration name' (BoxedType innerType) annotationSet''
+    return $ TypeDeclaration name' (UnboxedType innerType) annotationSet''
 
 enumMember :: Parser EnumMember
 enumMember = do
@@ -462,12 +462,12 @@ typeDeclaration = do
     annotationSet' <- annotationSet <?> "type annotations"
     spaces
     typeDecl <- choice
-        [ unless' ["union", "record", "enum", "boxed"] aliasTypeDeclaration
-        , unless' ["union", "record", "enum"] boxedTypeDeclaration
+        [ unless' ["union", "record", "enum", "unboxed"] aliasTypeDeclaration
+        , unless' ["union", "record", "enum"] unboxedTypeDeclaration
         , unless' ["union", "record"] enumTypeDeclaration
         , unless' ["union"] recordTypeDeclaration
         , unionTypeDeclaration
-        ] <?> "type declaration (e.g. boxed, enum, record, union)"
+        ] <?> "type declaration (e.g. enum, record, unboxed, union)"
     -- In theory, though it preconsumes annotationSet' before parsing typeDecl
     -- so that typeDecl itself has no annotations, to prepare for an
     -- unlikely situation (that I bet it'll never happen)

src/Nirum/Targets/Python.hs

@@ -69,10 +69,10 @@ import Nirum.Constructs.TypeDeclaration ( EnumMember(EnumMember)
                                         , PrimitiveTypeIdentifier(..)
                                         , Tag(Tag)
                                         , Type( Alias
-                                              , BoxedType
                                               , EnumType
                                               , PrimitiveType
                                               , RecordType
+                                              , UnboxedType
                                               , UnionType
                                               )
                                         , TypeDeclaration(..)
@@ -311,22 +311,23 @@ compileTypeDeclaration src TypeDeclaration { typename = typename'
 {toClassName' typename'} = $ctypeExpr
     |]
 compileTypeDeclaration src TypeDeclaration { typename = typename'
-                                           , type' = BoxedType itype } = do
+                                           , type' = UnboxedType itype } = do
     let className = toClassName' typename'
     itypeExpr <- compileTypeExpression src itype
     insertStandardImport "typing"
-    insertThirdPartyImports [ ("nirum.validate", ["validate_boxed_type"])
-                            , ("nirum.serialize", ["serialize_boxed_type"])
-                            , ("nirum.deserialize", ["deserialize_boxed_type"])
-                            ]
+    insertThirdPartyImports
+        [ ("nirum.validate", ["validate_unboxed_type"])
+        , ("nirum.serialize", ["serialize_unboxed_type"])
+        , ("nirum.deserialize", ["deserialize_unboxed_type"])
+        ]
     return [qq|
 class $className:
     # TODO: docstring
 
-    __nirum_boxed_type__ = $itypeExpr
+    __nirum_inner_type__ = $itypeExpr
 
     def __init__(self, value: $itypeExpr) -> None:
-        validate_boxed_type(value, $itypeExpr)
+        validate_unboxed_type(value, $itypeExpr)
         self.value = value  # type: $itypeExpr
 
     def __eq__(self, other) -> bool:
@@ -337,11 +338,11 @@ class $className:
         return hash(self.value)
 
     def __nirum_serialize__(self) -> typing.Any:
-        return serialize_boxed_type(self)
+        return serialize_unboxed_type(self)
 
     @classmethod
     def __nirum_deserialize__(cls: type, value: typing.Any) -> '{className}':
-        return deserialize_boxed_type(cls, value)
+        return deserialize_unboxed_type(cls, value)
 
     def __repr__(self) -> str:
         return '\{0.__module__\}.\{0.__qualname__\}(\{1!r\})'.format(

test/Nirum/Constructs/ModuleSpec.hs

@@ -20,7 +20,7 @@ spec =
         let docsAnno = A.docs "path string"
             pathT = TypeDeclaration "path" (Alias "text") (singleton docsAnno)
             offsetT =
-                TypeDeclaration "offset" (BoxedType "float64") empty
+                TypeDeclaration "offset" (UnboxedType "float64") empty
             decls = [ Import ["foo", "bar"] "baz" empty
                     , Import ["foo", "bar"] "qux" empty
                     , Import ["zzz"] "qqq" empty
@@ -45,7 +45,7 @@ import zzz (ppp, qqq);
 type path = text;
 # path string
 
-boxed offset (float64);
+unboxed offset (float64);
 |]
             toCode mod2 `shouldBe` [q|# module level docs...
 # blahblah
@@ -56,5 +56,5 @@ import zzz (ppp, qqq);
 type path = text;
 # path string
 
-boxed offset (float64);
+unboxed offset (float64);
 |]

test/Nirum/Constructs/TypeDeclarationSpec.hs

@@ -46,10 +46,10 @@ spec = do
             specify "toCode" $ do
                 toCode a `shouldBe` "type path = text;"
                 toCode b `shouldBe` "type path = text;\n# docs"
-        context "BoxedType" $ do
-            let boxed = BoxedType "float64"
+        context "UnboxedType" $ do
+            let unboxed = UnboxedType "float64"
                 a = TypeDeclaration { typename = "offset"
-                                    , type' = boxed
+                                    , type' = unboxed
                                     , typeAnnotations = empty
                                     }
                 b = a { typeAnnotations = singleDocs "docs" }
@@ -60,8 +60,8 @@ spec = do
                 docs a `shouldBe` Nothing
                 docs b `shouldBe` Just "docs"
             specify "toCode" $ do
-                toCode a `shouldBe` "boxed offset (float64);"
-                toCode b `shouldBe` "boxed offset (float64);\n# docs"
+                toCode a `shouldBe` "unboxed offset (float64);"
+                toCode b `shouldBe` "unboxed offset (float64);\n# docs"
         context "EnumType" $ do
             let enumMembers = [ EnumMember "kr" empty
                               , EnumMember "jp" (singleDocs "Japan")