diff --git a/ArraySchema.go b/ArraySchema.go
index 2a9c0a2..9325d55 100644
--- a/ArraySchema.go
+++ b/ArraySchema.go
@@ -22,16 +22,22 @@ type ArraySchema struct {
 	RawItems *json.RawMessage `json:"items"`
 }
 
+func NewArraySchema() *ArraySchema {
+
+	ret := new(ArraySchema)
+	ret.typeCode = SCHEMATYPE_ARRAY
+	return ret
+}
+
 /*
   Creates a new integer schema from a byte slice that can be interpreted as json.
 */
-func NewArraySchema(contents []byte, context *SchemaParseContext) (*ArraySchema, error) {
+func ParseArraySchema(contents []byte, context *SchemaParseContext) (*ArraySchema, error) {
 
 	var ret *ArraySchema
 	var err error
 
-	ret = new(ArraySchema)
-	ret.typeCode = SCHEMATYPE_ARRAY
+	ret = NewArraySchema()
 
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
diff --git a/BooleanSchema.go b/BooleanSchema.go
index 42e2ee0..469e18e 100644
--- a/BooleanSchema.go
+++ b/BooleanSchema.go
@@ -11,16 +11,22 @@ type BooleanSchema struct {
 	Schema
 }
 
+func NewBooleanSchema() *BooleanSchema {
+
+	ret := new(BooleanSchema)
+	ret.typeCode = SCHEMATYPE_BOOLEAN
+	return ret
+}
+
 /*
   Creates a new integer schema from a byte slice that can be interpreted as json.
 */
-func NewBooleanSchema(contents []byte, context *SchemaParseContext) (*BooleanSchema, error) {
+func ParseBooleanSchema(contents []byte, context *SchemaParseContext) (*BooleanSchema, error) {
 
 	var ret *BooleanSchema
 	var err error
 
-	ret = new(BooleanSchema)
-	ret.typeCode = SCHEMATYPE_BOOLEAN
+	ret = NewBooleanSchema()
 
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
diff --git a/IntegerSchema.go b/IntegerSchema.go
index 1a4fd75..cac13dd 100644
--- a/IntegerSchema.go
+++ b/IntegerSchema.go
@@ -17,17 +17,23 @@ type IntegerSchema struct {
 	Enum             *[]int `json:"enum"`
 }
 
+func NewIntegerSchema() *IntegerSchema {
+
+	ret := new(IntegerSchema)
+	ret.typeCode = SCHEMATYPE_INTEGER
+	return ret
+}
+
 /*
   Creates a new integer schema from a byte slice that can be interpreted as json.
 */
-func NewIntegerSchema(contents []byte, context *SchemaParseContext) (*IntegerSchema, error) {
+func ParseIntegerSchema(contents []byte, context *SchemaParseContext) (*IntegerSchema, error) {
 
 	var ret *IntegerSchema
 	var err error
 
-	ret = new(IntegerSchema)
+	ret = NewIntegerSchema()
 
-	ret.typeCode = SCHEMATYPE_INTEGER
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
 		return ret, err
diff --git a/NumberSchema.go b/NumberSchema.go
index 339bb2d..bbda3ee 100644
--- a/NumberSchema.go
+++ b/NumberSchema.go
@@ -17,16 +17,22 @@ type NumberSchema struct {
 	Enum             *[]float64 `json:"enum"`
 }
 
+func NewNumberSchema() *NumberSchema {
+
+	ret := new(NumberSchema)
+	ret.typeCode = SCHEMATYPE_NUMBER
+	return ret
+}
+
 /*
   Creates a new integer schema from a byte slice that can be interpreted as json.
 */
-func NewNumberSchema(contents []byte, context *SchemaParseContext) (*NumberSchema, error) {
+func ParseNumberSchema(contents []byte, context *SchemaParseContext) (*NumberSchema, error) {
 
 	var ret *NumberSchema
 	var err error
 
-	ret = new(NumberSchema)
-	ret.typeCode = SCHEMATYPE_NUMBER
+	ret = NewNumberSchema()
 
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
diff --git a/ObjectSchema.go b/ObjectSchema.go
index 9078d2d..c81362c 100644
--- a/ObjectSchema.go
+++ b/ObjectSchema.go
@@ -24,27 +24,34 @@ type ObjectSchema struct {
 	UnconstrainedProperties SortableStringArray
 }
 
+func NewObjectSchema() *ObjectSchema {
+
+	var ret *ObjectSchema
+
+	ret = new(ObjectSchema)
+	ret.typeCode = SCHEMATYPE_OBJECT
+	ret.Properties = make(map[string]TypeSchema)
+
+	return ret
+}
 /*
   Creates a new object schema from a byte slice that can be interpreted as json.
   Object schemas may contain multiple schemas.
 */
-func NewObjectSchema(contents []byte, context *SchemaParseContext) (*ObjectSchema, error) {
+func ParseObjectSchema(contents []byte, context *SchemaParseContext) (*ObjectSchema, error) {
 
 	var ret *ObjectSchema
 	var sub TypeSchema
 	var subschemaBytes []byte
 	var err error
 
-	ret = new(ObjectSchema)
-	ret.typeCode = SCHEMATYPE_OBJECT
+	ret = NewObjectSchema()
 
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
 		return ret, err
 	}
 
-	ret.Properties = make(map[string]TypeSchema, len(ret.RawProperties))
-
 	err = ret.checkRequiredProperties()
 	if err != nil {
 		return ret, err
diff --git a/StringSchema.go b/StringSchema.go
index 5bdecec..746f83f 100644
--- a/StringSchema.go
+++ b/StringSchema.go
@@ -17,16 +17,22 @@ type StringSchema struct {
 	Enum          *[]string `json:"enum"`
 }
 
+func NewStringSchema() *StringSchema {
+
+	ret := new(StringSchema)
+	ret.typeCode = SCHEMATYPE_STRING
+	return ret
+}
+
 /*
   Creates a new integer schema from a byte slice that can be interpreted as json.
 */
-func NewStringSchema(contents []byte, context *SchemaParseContext) (*StringSchema, error) {
+func ParseStringSchema(contents []byte, context *SchemaParseContext) (*StringSchema, error) {
 
 	var ret *StringSchema
 	var err error
 
-	ret = new(StringSchema)
-	ret.typeCode = SCHEMATYPE_STRING
+	ret = NewStringSchema()
 
 	err = json.Unmarshal(contents, &ret)
 	if err != nil {
diff --git a/parsing.go b/parsing.go
index 650e298..c16f637 100644
--- a/parsing.go
+++ b/parsing.go
@@ -166,22 +166,22 @@ func ParseSchema(contentsBytes []byte, defaultTitle string, context *SchemaParse
 	switch schemaType {
 
 	case "boolean":
-		schema, err = NewBooleanSchema(contentsBytes, context)
+		schema, err = ParseBooleanSchema(contentsBytes, context)
 
 	case "integer":
-		schema, err = NewIntegerSchema(contentsBytes, context)
+		schema, err = ParseIntegerSchema(contentsBytes, context)
 
 	case "number":
-		schema, err = NewNumberSchema(contentsBytes, context)
+		schema, err = ParseNumberSchema(contentsBytes, context)
 
 	case "string":
-		schema, err = NewStringSchema(contentsBytes, context)
+		schema, err = ParseStringSchema(contentsBytes, context)
 
 	case "array":
-		schema, err = NewArraySchema(contentsBytes, context)
+		schema, err = ParseArraySchema(contentsBytes, context)
 
 	case "object":
-		schema, err = NewObjectSchema(contentsBytes, context)
+		schema, err = ParseObjectSchema(contentsBytes, context)
 
 	default:
 		errorMsg := fmt.Sprintf("Unrecognized schema type: '%s'", schemaType)