Use pointers for Hints and HintSet

This avoids copying the values on each new call to infer.

Author: bombsimon

examples/infer_multiple_string_rows.go

@@ -3,7 +3,7 @@ package main
 import (
 	"encoding/json"
 
-	"github.com/bombsimon/jtd-infer-go"
+	jtdinfer "github.com/bombsimon/jtd-infer-go"
 )
 
 func main() {
@@ -12,7 +12,7 @@ func main() {
 		`{"name":"Jane", "age": 48, "something_nullable": null}`,
 	}
 	schema := jtdinfer.
-		InferStrings(rows, jtdinfer.WithoutHints()).
+		InferStrings(rows, jtdinfer.NewHints()).
 		IntoSchema()
 
 	j, _ := json.MarshalIndent(schema, "", "  ")

examples/infer_simple_value.go

@@ -3,12 +3,12 @@ package main
 import (
 	"encoding/json"
 
-	"github.com/bombsimon/jtd-infer-go"
+	jtdinfer "github.com/bombsimon/jtd-infer-go"
 )
 
 func main() {
 	schema := jtdinfer.
-		NewInferrer(jtdinfer.WithoutHints()).
+		NewInferrer(jtdinfer.NewHints()).
 		Infer("my-string").
 		IntoSchema()
 

examples/infer_with_hints.go

@@ -3,7 +3,7 @@ package main
 import (
 	"encoding/json"
 
-	"github.com/bombsimon/jtd-infer-go"
+	jtdinfer "github.com/bombsimon/jtd-infer-go"
 )
 
 func main() {
@@ -23,7 +23,7 @@ func main() {
 			"discriminator":[{"type":"s", "value":"foo"},{"type":"n", "value":3.14}]
 		}`,
 	}
-	hints := jtdinfer.Hints{
+	hints := &jtdinfer.Hints{
 		DefaultNumType: jtdinfer.NumTypeUint32,
 		Enums:          jtdinfer.NewHintSet().Add([]string{"work", "department"}),
 		Values:         jtdinfer.NewHintSet().Add([]string{"values"}),

hints.go

@@ -7,19 +7,23 @@ const Wildcard = "-"
 // values and discriminators.
 type Hints struct {
 	DefaultNumType NumType
-	Enums          HintSet
-	Values         HintSet
-	Discriminator  HintSet
+	Enums          *HintSet
+	Values         *HintSet
+	Discriminator  *HintSet
 }
 
-// WithoutHints is a shorthand to return empty hints.
-func WithoutHints() Hints {
-	return Hints{}
+// NewHints creates a new empty non nil `Hints`.
+func NewHints() *Hints {
+	return &Hints{
+		Enums:         NewHintSet(),
+		Values:        NewHintSet(),
+		Discriminator: NewHintSet(),
+	}
 }
 
 // SubHints will return the sub hints for all hint sets for the passed key.
-func (h Hints) SubHints(key string) Hints {
-	return Hints{
+func (h Hints) SubHints(key string) *Hints {
+	return &Hints{
 		DefaultNumType: h.DefaultNumType,
 		Enums:          h.Enums.SubHints(key),
 		Values:         h.Values.SubHints(key),
@@ -28,18 +32,18 @@ func (h Hints) SubHints(key string) Hints {
 }
 
 // IsEnumActive checks if the enum hint set is active.
-func (h Hints) IsEnumActive() bool {
+func (h *Hints) IsEnumActive() bool {
 	return h.Enums.IsActive()
 }
 
 // IsValuesActive checks if the values hint set is active.
-func (h Hints) IsValuesActive() bool {
+func (h *Hints) IsValuesActive() bool {
 	return h.Values.IsActive()
 }
 
 // PeekActiveDiscriminator will peek the currently active discriminator, if any.
 // The returned boolean tells if there is an active discriminator.
-func (h Hints) PeekActiveDiscriminator() (string, bool) {
+func (h *Hints) PeekActiveDiscriminator() (string, bool) {
 	return h.Discriminator.PeekActive()
 }
 
@@ -49,21 +53,21 @@ type HintSet struct {
 }
 
 // NewHintSet creates a new empty `HintSet`.
-func NewHintSet() HintSet {
-	return HintSet{
+func NewHintSet() *HintSet {
+	return &HintSet{
 		Values: [][]string{},
 	}
 }
 
 // Add will add a path (slice) to the `HintSet`.
-func (h HintSet) Add(v []string) HintSet {
+func (h *HintSet) Add(v []string) *HintSet {
 	h.Values = append(h.Values, v)
 	return h
 }
 
 // SubHints will filter all the current sets and keep those who's first element
 // matches the passed key or wildcard.
-func (h HintSet) SubHints(key string) HintSet {
+func (h *HintSet) SubHints(key string) *HintSet {
 	filteredValues := [][]string{}
 
 	for _, values := range h.Values {
@@ -77,13 +81,13 @@ func (h HintSet) SubHints(key string) HintSet {
 		}
 	}
 
-	return HintSet{
+	return &HintSet{
 		Values: filteredValues,
 	}
 }
 
 // IsActive returns true if any set in the hint set his active.
-func (h HintSet) IsActive() bool {
+func (h *HintSet) IsActive() bool {
 	for _, valueList := range h.Values {
 		if len(valueList) == 0 {
 			return true
@@ -95,7 +99,7 @@ func (h HintSet) IsActive() bool {
 
 // PeekActive returns the currently active value if any. The returned boolean
 // tells if a value was found.
-func (h HintSet) PeekActive() (string, bool) {
+func (h *HintSet) PeekActive() (string, bool) {
 	for _, values := range h.Values {
 		if len(values) != 1 {
 			continue

inferred_schema.go

@@ -64,7 +64,9 @@ func NewInferredSchema() *InferredSchema {
 // https://github.com/jsontypedef/json-typedef-infer/blob/master/src/inferred_schema.rs.
 // Since we don't have enums of this kind in Go we're using a struct with
 // pointers to a schema instead of wrapping the enums.
-func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
+func (i *InferredSchema) Infer(value any, hints *Hints) *InferredSchema {
+	hints = ensureHints(hints)
+
 	if value == nil {
 		return &InferredSchema{
 			SchemaType: SchemaTypeNullable,
@@ -314,7 +316,7 @@ func (i *InferredSchema) Infer(value any, hints Hints) *InferredSchema {
 }
 
 // IntoSchema will convert an `InferredSchema` to a final `Schema`.
-func (i *InferredSchema) IntoSchema(hints Hints) Schema {
+func (i *InferredSchema) IntoSchema(hints *Hints) Schema {
 	switch i.SchemaType {
 	case SchemaTypeUnknown, SchemaTypeAny:
 		return Schema{}
@@ -387,3 +389,23 @@ func (i *InferredSchema) IntoSchema(hints Hints) Schema {
 
 	return Schema{}
 }
+
+func ensureHints(hints *Hints) *Hints {
+	if hints == nil {
+		return NewHints()
+	}
+
+	if hints.Enums == nil {
+		hints.Enums = NewHintSet()
+	}
+
+	if hints.Values == nil {
+		hints.Values = NewHintSet()
+	}
+
+	if hints.Discriminator == nil {
+		hints.Discriminator = NewHintSet()
+	}
+
+	return hints
+}

inferrer.go

@@ -8,11 +8,11 @@ import (
 // hints used when inferring.
 type Inferrer struct {
 	Inference *InferredSchema
-	Hints     Hints
+	Hints     *Hints
 }
 
 // NewInferrer will create a new inferrer with a default `InferredSchema`.
-func NewInferrer(hints Hints) *Inferrer {
+func NewInferrer(hints *Hints) *Inferrer {
 	return &Inferrer{
 		Inference: NewInferredSchema(),
 		Hints:     hints,
@@ -39,7 +39,7 @@ func (i *Inferrer) IntoSchema() Schema {
 //
 // If you need to infer simple values like strings or integers they can be
 // passed directly to `Infer`.
-func InferStrings(rows []string, hints Hints) *Inferrer {
+func InferStrings(rows []string, hints *Hints) *Inferrer {
 	inferrer := NewInferrer(hints)
 
 	for _, row := range rows {

inferrer_test.go

@@ -20,13 +20,13 @@ func TestJTDInfer(t *testing.T) {
 			"hobbies": {Elements: &Schema{Type: jtd.TypeString}},
 		},
 	}
-	gotSchema := InferStrings(rows, WithoutHints()).IntoSchema()
+	gotSchema := InferStrings(rows, NewHints()).IntoSchema()
 
 	assert.EqualValues(t, expectedSchema, gotSchema)
 }
 
 func TestJTDInferrerWithEnumHints(t *testing.T) {
-	hints := Hints{
+	hints := &Hints{
 		Enums: NewHintSet().
 			Add([]string{"name"}).
 			Add([]string{"address", "city"}),
@@ -74,7 +74,7 @@ func TestJTDInferrerWithEnumHints(t *testing.T) {
 }
 
 func TestJTDInferWithValuesHints(t *testing.T) {
-	hints := Hints{
+	hints := &Hints{
 		Values: NewHintSet().Add([]string{}),
 	}
 
@@ -96,7 +96,7 @@ func TestJTDInferWithValuesHints(t *testing.T) {
 }
 
 func TestJTDInferWithDiscriminatorHints(t *testing.T) {
-	hints := Hints{
+	hints := &Hints{
 		Discriminator: NewHintSet().Add([]string{"-", "type"}),
 	}