feat: support sql.Scanner & drive.Valuer

echo_test.go

@@ -1,12 +1,13 @@
 package nill
 
 import (
-	"github.com/labstack/echo/v4"
-	"github.com/stretchr/testify/assert"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
+
+	"github.com/labstack/echo/v4"
+	"github.com/stretchr/testify/assert"
 )
 
 type user struct {
@@ -92,9 +93,9 @@ func TestFromJson(t *testing.T) {
 		}
 
 		assert.True(t, u.Name.Valid)
-		assert.Equal(t, "Jon Snow", u.Name.Value)
+		assert.Equal(t, "Jon Snow", u.Name.V)
 		assert.True(t, u.Email.Valid)
-		assert.Equal(t, "[email protected]", u.Email.Value)
+		assert.Equal(t, "[email protected]", u.Email.V)
 	})
 
 	t.Run("one of the value is null", func(t *testing.T) {
@@ -110,9 +111,9 @@ func TestFromJson(t *testing.T) {
 		}
 
 		assert.True(t, u.Name.Valid)
-		assert.Equal(t, "Jon Snow", u.Name.Value)
+		assert.Equal(t, "Jon Snow", u.Name.V)
 		assert.False(t, u.Email.Valid)
-		assert.Equal(t, "", u.Email.Value)
+		assert.Equal(t, "", u.Email.V)
 	})
 
 	t.Run("one of the value is empty", func(t *testing.T) {
@@ -128,9 +129,9 @@ func TestFromJson(t *testing.T) {
 		}
 
 		assert.True(t, u.Name.Valid)
-		assert.Equal(t, "Jon Snow", u.Name.Value)
+		assert.Equal(t, "Jon Snow", u.Name.V)
 		assert.True(t, u.Email.Valid)
-		assert.Equal(t, "", u.Email.Value)
+		assert.Equal(t, "", u.Email.V)
 	})
 
 	t.Run("only has one value", func(t *testing.T) {
@@ -146,9 +147,9 @@ func TestFromJson(t *testing.T) {
 		}
 
 		assert.True(t, u.Name.Valid)
-		assert.Equal(t, "Jon Snow", u.Name.Value)
+		assert.Equal(t, "Jon Snow", u.Name.V)
 		assert.False(t, u.Email.Valid)
-		assert.Equal(t, "", u.Email.Value)
+		assert.Equal(t, "", u.Email.V)
 	})
 }
 

example_json_test.go

@@ -3,11 +3,12 @@ package nill_test
 import (
 	"encoding/json"
 	"fmt"
-	"github.com/RekeningkuDev/nill"
 	"log"
+
+	"github.com/RekeningkuDev/nill"
 )
 
-func ExampleTypeMarshal() {
+func ExampleType() {
 	type BarTest struct {
 		Text nill.Type[string] `json:"text"`
 	}
@@ -19,10 +20,10 @@ func ExampleTypeMarshal() {
 	foo := FooTest{
 		Bar: nill.Type[BarTest]{
 			Valid: true,
-			Value: BarTest{
+			V: BarTest{
 				Text: nill.Type[string]{
 					Valid: true,
-					Value: "test",
+					V:     "test",
 				},
 			},
 		},

float32.go

@@ -5,50 +5,50 @@ type Float32 Type[float32]
 
 // NewFloat32 creates a new Float32.
 func NewFloat32(value float32) Float32 {
-	return Float32{Valid: true, Value: value}
+	return Float32{Valid: true, V: value}
 }
 
 // Add adds value to Float32.
 func (v *Float32) Add(value float32) {
-	v.Value += value
+	v.V += value
 }
 
 // Sub subtracts value from Float32.
 func (v *Float32) Sub(value float32) {
-	v.Value -= value
+	v.V -= value
 }
 
 // Mul multiplies Float32 by value.
 func (v *Float32) Mul(value float32) {
-	v.Value *= value
+	v.V *= value
 }
 
 // Div divides Float32 by value.
 func (v *Float32) Div(value float32) {
-	v.Value /= value
+	v.V /= value
 }
 
 // Inc calculates the remainder of Float32 divided by value.
 func (v *Float32) Inc() {
-	v.Value++
+	v.V++
 }
 
 // Dec decrements Float32 by 1.
 func (v *Float32) Dec() {
-	v.Value--
+	v.V--
 }
 
 // Zero returns true if Float32 is zero.
 func (v *Float32) Zero() bool {
-	return v.Value == 0
+	return v.V == 0
 }
 
 // Positive returns true if Float32 is positive.
 func (v *Float32) Positive() bool {
-	return v.Value > 0
+	return v.V > 0
 }
 
 // Negative returns true if Float32 is negative.
 func (v *Float32) Negative() bool {
-	return v.Value < 0
+	return v.V < 0
 }

float32_test.go

@@ -1,40 +1,41 @@
 package nill
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFloat32(t *testing.T) {
 	t.Run("add", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Add(1)
-		assert.Equal(t, Float32{Valid: true, Value: 2.5}, value)
+		assert.Equal(t, Float32{Valid: true, V: 2.5}, value)
 	})
 	t.Run("sub", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Sub(1)
-		assert.Equal(t, Float32{Valid: true, Value: 0.5}, value)
+		assert.Equal(t, Float32{Valid: true, V: 0.5}, value)
 	})
 	t.Run("mul", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Mul(5)
-		assert.Equal(t, Float32{Valid: true, Value: 7.5}, value)
+		assert.Equal(t, Float32{Valid: true, V: 7.5}, value)
 	})
 	t.Run("div", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Div(5)
-		assert.Equal(t, Float32{Valid: true, Value: 0.3}, value)
+		assert.Equal(t, Float32{Valid: true, V: 0.3}, value)
 	})
 	t.Run("inc", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Inc()
-		assert.Equal(t, Float32{Valid: true, Value: 2.5}, value)
+		assert.Equal(t, Float32{Valid: true, V: 2.5}, value)
 	})
 	t.Run("dec", func(t *testing.T) {
 		value := NewFloat32(1.5)
 		value.Dec()
-		assert.Equal(t, Float32{Valid: true, Value: 0.5}, value)
+		assert.Equal(t, Float32{Valid: true, V: 0.5}, value)
 	})
 	t.Run("zero", func(t *testing.T) {
 		value := NewFloat32(0)

float64.go

@@ -3,50 +3,50 @@ package nill
 type Float64 Type[float64]
 
 func NewFloat64(value float64) Float64 {
-	return Float64{Valid: true, Value: value}
+	return Float64{Valid: true, V: value}
 }
 
 // Add adds value to Float32.
 func (v *Float64) Add(value float64) {
-	v.Value += value
+	v.V += value
 }
 
 // Sub subtracts value from Float32.
 func (v *Float64) Sub(value float64) {
-	v.Value -= value
+	v.V -= value
 }
 
 // Mul multiplies Float32 by value.
 func (v *Float64) Mul(value float64) {
-	v.Value *= value
+	v.V *= value
 }
 
 // Div divides Float32 by value.
 func (v *Float64) Div(value float64) {
-	v.Value /= value
+	v.V /= value
 }
 
 // Inc calculates the remainder of Float32 divided by value.
 func (v *Float64) Inc() {
-	v.Value++
+	v.V++
 }
 
 // Dec decrements Float32 by 1.
 func (v *Float64) Dec() {
-	v.Value--
+	v.V--
 }
 
 // Zero returns true if Float32 is zero.
 func (v *Float64) Zero() bool {
-	return v.Value == 0
+	return v.V == 0
 }
 
 // Positive returns true if Float32 is positive.
 func (v *Float64) Positive() bool {
-	return v.Value > 0
+	return v.V > 0
 }
 
 // Negative returns true if Float32 is negative.
 func (v *Float64) Negative() bool {
-	return v.Value < 0
+	return v.V < 0
 }

float64_test.go

@@ -1,40 +1,41 @@
 package nill
 
 import (
-	"github.com/stretchr/testify/assert"
 	"testing"
+
+	"github.com/stretchr/testify/assert"
 )
 
 func TestFloat64(t *testing.T) {
 	t.Run("add", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Add(1)
-		assert.Equal(t, Float64{Valid: true, Value: 2.5}, value)
+		assert.Equal(t, Float64{Valid: true, V: 2.5}, value)
 	})
 	t.Run("sub", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Sub(1)
-		assert.Equal(t, Float64{Valid: true, Value: 0.5}, value)
+		assert.Equal(t, Float64{Valid: true, V: 0.5}, value)
 	})
 	t.Run("mul", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Mul(5)
-		assert.Equal(t, Float64{Valid: true, Value: 7.5}, value)
+		assert.Equal(t, Float64{Valid: true, V: 7.5}, value)
 	})
 	t.Run("div", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Div(5)
-		assert.Equal(t, Float64{Valid: true, Value: 0.3}, value)
+		assert.Equal(t, Float64{Valid: true, V: 0.3}, value)
 	})
 	t.Run("inc", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Inc()
-		assert.Equal(t, Float64{Valid: true, Value: 2.5}, value)
+		assert.Equal(t, Float64{Valid: true, V: 2.5}, value)
 	})
 	t.Run("dec", func(t *testing.T) {
 		value := NewFloat64(1.5)
 		value.Dec()
-		assert.Equal(t, Float64{Valid: true, Value: 0.5}, value)
+		assert.Equal(t, Float64{Valid: true, V: 0.5}, value)
 	})
 	t.Run("zero", func(t *testing.T) {
 		value := NewFloat64(0)