make scalar types accessible

collection.go

@@ -464,13 +464,13 @@ func (c *collection) ValuesAtPath(document Document, queryPath QueryPath) ([]Sca
 func valuesFromResult(result gjson.Result) ([]Scalar, error) {
 	switch result.Type {
 	case gjson.String:
-		return []Scalar{stringScalar(result.Str)}, nil
+		return []Scalar{StringScalar(result.Str)}, nil
 	case gjson.True:
-		return []Scalar{boolScalar(true)}, nil
+		return []Scalar{BoolScalar(true)}, nil
 	case gjson.False:
-		return []Scalar{boolScalar(false)}, nil
+		return []Scalar{BoolScalar(false)}, nil
 	case gjson.Number:
-		return []Scalar{float64Scalar(result.Num)}, nil
+		return []Scalar{Float64Scalar(result.Num)}, nil
 	case gjson.Null:
 		return []Scalar{}, nil
 	default:

index_part.go

@@ -87,11 +87,11 @@ func (j fieldIndexer) Tokenize(scalar Scalar) []Scalar {
 		return []Scalar{scalar}
 	}
 
-	if s, ok := scalar.(stringScalar); ok {
+	if s, ok := scalar.(StringScalar); ok {
 		tokens := j.tokenizer(string(s))
 		result := make([]Scalar, len(tokens))
 		for i, t := range tokens {
-			result[i] = stringScalar(t)
+			result[i] = StringScalar(t)
 		}
 		return result
 	}

transform.go

@@ -30,8 +30,8 @@ type Transform func(Scalar) Scalar
 // ToLower transforms all Unicode letters mapped to their lower case.
 // It only transforms objects that conform to the Stringer interface.
 func ToLower(scalar Scalar) Scalar {
-	if s, ok := scalar.(stringScalar); ok {
-		return stringScalar(strings.ToLower(string(s)))
+	if s, ok := scalar.(StringScalar); ok {
+		return StringScalar(strings.ToLower(string(s)))
 	}
 
 	return scalar

transform_test.go

@@ -48,11 +48,11 @@ func (t testIndexPart) Tokenize(value Scalar) []Scalar {
 	if t.tokenizer == nil {
 		return []Scalar{value}
 	}
-	if s, ok := value.(stringScalar); ok {
+	if s, ok := value.(StringScalar); ok {
 		tokens := t.tokenizer(string(s))
 		result := make([]Scalar, len(tokens))
 		for i, t := range tokens {
-			result[i] = stringScalar(t)
+			result[i] = StringScalar(t)
 		}
 		return result
 	}

types.go

@@ -59,38 +59,38 @@ type Scalar interface {
 	value() interface{}
 }
 
-type stringScalar string
+type StringScalar string
 
-func (ss stringScalar) Bytes() []byte {
+func (ss StringScalar) Bytes() []byte {
 	return []byte(ss)
 }
 
-func (ss stringScalar) value() interface{} {
+func (ss StringScalar) value() interface{} {
 	return string(ss)
 }
 
-type boolScalar bool
+type BoolScalar bool
 
-func (bs boolScalar) Bytes() []byte {
+func (bs BoolScalar) Bytes() []byte {
 	if bs {
 		return []byte{1}
 	}
 	return []byte{0}
 }
 
-func (bs boolScalar) value() interface{} {
+func (bs BoolScalar) value() interface{} {
 	return bool(bs)
 }
 
-type float64Scalar float64
+type Float64Scalar float64
 
-func (fs float64Scalar) Bytes() []byte {
+func (fs Float64Scalar) Bytes() []byte {
 	var buf [8]byte
 	binary.BigEndian.PutUint64(buf[:], math.Float64bits(float64(fs)))
 	return buf[:]
 }
 
-func (fs float64Scalar) value() interface{} {
+func (fs Float64Scalar) value() interface{} {
 	return float64(fs)
 }
 
@@ -101,11 +101,11 @@ var ErrInvalidValue = errors.New("invalid value")
 func ParseScalar(value interface{}) (Scalar, error) {
 	switch castValue := value.(type) {
 	case bool:
-		return boolScalar(castValue), nil
+		return BoolScalar(castValue), nil
 	case string:
-		return stringScalar(castValue), nil
+		return StringScalar(castValue), nil
 	case float64:
-		return float64Scalar(castValue), nil
+		return Float64Scalar(castValue), nil
 	}
 
 	return nil, ErrInvalidValue

types_test.go

@@ -123,37 +123,37 @@ func TestParseScalar(t *testing.T) {
 
 func TestScalar_Bytes(t *testing.T) {
 	t.Run("ok - string", func(t *testing.T) {
-		s := stringScalar("string")
+		s := StringScalar("string")
 
 		assert.Equal(t, []byte("string"), s.Bytes())
 	})
 
 	t.Run("ok - number", func(t *testing.T) {
-		s := float64Scalar(1.0)
+		s := Float64Scalar(1.0)
 
 		assert.Equal(t, []byte{0x3f, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, s.Bytes())
 	})
 
 	t.Run("ok - negative number", func(t *testing.T) {
-		s := float64Scalar(-1.0)
+		s := Float64Scalar(-1.0)
 
 		assert.Equal(t, []byte{0xbf, 0xf0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, s.Bytes())
 	})
 
 	t.Run("ok - 0", func(t *testing.T) {
-		s := float64Scalar(0.0)
+		s := Float64Scalar(0.0)
 
 		assert.Equal(t, []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, s.Bytes())
 	})
 
 	t.Run("ok - true", func(t *testing.T) {
-		s := boolScalar(true)
+		s := BoolScalar(true)
 
 		assert.Equal(t, []byte{0x01}, s.Bytes())
 	})
 
 	t.Run("ok - false", func(t *testing.T) {
-		s := boolScalar(false)
+		s := BoolScalar(false)
 
 		assert.Equal(t, []byte{0x0}, s.Bytes())
 	})