optional: implemented new generic type for optional types

.golangci.yml

@@ -20,10 +20,13 @@ linters:
 
   exclusions:
     rules:
-      - path-except: cmd/generator/*.go
+      - path: cmd/generator/
         linters:
         - forbidigo        # fmt functions are not forbidden here
         - gochecknoglobals # global variables are not forbidden here
+      - path: _test.go
+        linters:
+        - wrapcheck
 
   settings:
     godot:

cmd/generator/generator.go

@@ -239,6 +239,8 @@ type {{.Name}} struct {
 	exists bool
 }
 
+var _ commonInterface[{{.Type}}] = (*{{.Name}})(nil)
+
 // Some{{.Name}} creates an optional {{.Name}} with the given {{.Type}} value.
 // The returned {{.Name}} will have IsSome() == true and IsZero() == false.
 //

doc.go

@@ -1,5 +1,5 @@
 // Package option provides a type-safe way to represent optional values in Go.
-// An Optional[T] can either contain a value of type T (Some) or be empty (None).
+// A Generic[T] can either contain a value of type T (Some) or be empty (None).
 //
 // This is useful for:
 // - Clearly representing nullable fields in structs.

errors.go

@@ -28,6 +28,10 @@ func newDecodeWithCodeError(operationType string, code byte) error {
 	}
 }
 
+func getGenericTypeName[T any]() string {
+	return fmt.Sprintf("Generic[%T]", zero[T]())
+}
+
 func newDecodeError(operationType string, err error) error {
 	if err == nil {
 		return nil
@@ -40,6 +44,18 @@ func newDecodeError(operationType string, err error) error {
 	}
 }
 
+func newDecodeGenericError[T any](err error) error {
+	if err == nil {
+		return nil
+	}
+
+	return DecodeError{
+		Type:   getGenericTypeName[T](),
+		Code:   NoneByte(),
+		Parent: err,
+	}
+}
+
 // EncodeError is returned when encoding failed due to stream errors.
 type EncodeError struct {
 	Type   string
@@ -58,3 +74,11 @@ func newEncodeError(operationType string, err error) error {
 
 	return EncodeError{Type: operationType, Parent: err}
 }
+
+func newEncodeGenericError[T any](err error) error {
+	if err == nil {
+		return nil
+	}
+
+	return EncodeError{Type: getGenericTypeName[T](), Parent: err}
+}

errors_test.go

@@ -1,4 +1,5 @@
 package option //nolint:testpackage
+
 // this is unit test, that checks internal logic of error constructing.
 
 import (
@@ -13,7 +14,7 @@ var (
 	errTest = errors.New("some error")
 )
 
-func TestDecodeError_Error(t *testing.T) {
+func TestEncodeError_Error(t *testing.T) {
 	t.Parallel()
 
 	t.Run("newEncodeError with error", func(t *testing.T) {
@@ -32,9 +33,26 @@ func TestDecodeError_Error(t *testing.T) {
 
 		require.NoError(t, a)
 	})
+
+	t.Run("newEncoderGenericError", func(t *testing.T) {
+		t.Parallel()
+
+		a := newEncodeGenericError[int](errTest)
+
+		require.Error(t, a)
+		assert.Equal(t, "failed to encode Generic[int]: some error", a.Error())
+	})
+
+	t.Run("newEncodeGenericError without error", func(t *testing.T) {
+		t.Parallel()
+
+		a := newEncodeGenericError[int](nil)
+
+		require.NoError(t, a)
+	})
 }
 
-func TestEncodeError_Error(t *testing.T) {
+func TestDecodeError_Error(t *testing.T) {
 	t.Parallel()
 
 	t.Run("newDecodeError with error", func(t *testing.T) {
@@ -62,4 +80,21 @@ func TestEncodeError_Error(t *testing.T) {
 		require.Error(t, a)
 		assert.Equal(t, "failed to decode Byte, invalid code: 1", a.Error())
 	})
+
+	t.Run("newDecodeGenericError", func(t *testing.T) {
+		t.Parallel()
+
+		a := newDecodeGenericError[int](errTest)
+
+		require.Error(t, a)
+		assert.Equal(t, "failed to decode Generic[int]: some error", a.Error())
+	})
+
+	t.Run("newDecodeGenericError without error", func(t *testing.T) {
+		t.Parallel()
+
+		a := newDecodeGenericError[int](nil)
+
+		require.NoError(t, a)
+	})
 }