feat: bring rust type to go

Author: initdc

.github/workflows/matrix-test.yml

@@ -0,0 +1,34 @@
+name: Matrix Test
+
+on:
+  workflow_dispatch:
+  pull_request:
+  push:
+    branches:
+      - master
+      - dev
+
+concurrency:
+  group: ${{ github.sha }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    name: Golang ${{ matrix.go }}
+    strategy:
+      matrix:
+        go:
+          - "1.25"
+          - "1.18"
+
+    steps:
+      - uses: actions/checkout@v5
+      - name: Set up Golang
+        uses: actions/setup-go@v5
+        with:
+          go-version: ${{ matrix.go }}
+      - name: Test option
+        run: cd option && go test -v
+      - name: Test result
+        run: cd result && go test -v

.gitignore

@@ -0,0 +1,39 @@
+# type
+
+Bring the Rust [Result Option] type to Golang
+
+## Installation
+
+  `go get github.com/initdc/type`
+
+## Usage
+
+```go
+import (
+  . "github.com/initdc/type/option"
+  . "github.com/initdc/type/result"
+)
+
+// Option
+s := Some(1)
+
+var s Option[int]
+s.None()
+
+n := None[int]()
+
+// Result
+var r Result[int, string]
+r.Ok(1)
+
+var e Result[int, string]
+e.Err("error")
+
+
+r := Ok[int, string](1)
+e := Err[int, string]("error")
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/initdc/type.

LICENSE

@@ -0,0 +1,3 @@
+module github.com/initdc/type
+
+go 1.18

README.md

@@ -0,0 +1,97 @@
+package option
+
+type Option[T any] struct {
+	value    T    `json:"value"`
+	some     bool `json:"some"`
+	assigned bool `json:"assigned"`
+}
+
+func Some[T any](v T) Option[T] {
+	return Option[T]{
+		value:    v,
+		some:     true,
+		assigned: true,
+	}
+}
+
+func None[T any]() Option[T] {
+	return Option[T]{
+		some:     false,
+		assigned: true,
+	}
+}
+
+func (o *Option[T]) Some(v T) {
+	if o.assigned {
+		panic("Option already assigned")
+	}
+	o.value = v
+	o.some = true
+	o.assigned = true
+}
+
+func (o *Option[T]) None() {
+	if o.assigned {
+		panic("Option already assigned")
+	}
+	o.some = false
+	o.assigned = true
+}
+
+func (o *Option[T]) IsSome() bool {
+	return o.some
+}
+
+func (o *Option[T]) IsSomeAnd(f func(T) bool) bool {
+	if !o.some {
+		return false
+	}
+	return f(o.value)
+}
+
+func (o *Option[T]) IsNone() bool {
+	return !o.some
+}
+
+func (o *Option[T]) IsNoneOr(f func(T) bool) bool {
+	if !o.some {
+		return true
+	}
+	return f(o.value)
+}
+
+func (o *Option[T]) Expect(msg string) T {
+	if o.some {
+		return o.value
+	}
+	panic(msg)
+}
+
+func (o *Option[T]) Unwrap() T {
+	if o.some {
+		return o.value
+	}
+	panic("called Option.Unwrap() on a None value")
+}
+
+func (o *Option[T]) UnwrapOr(def T) T {
+	if o.some {
+		return o.value
+	}
+	return def
+}
+
+func (o *Option[T]) UnwrapOrElse(f func() T) T {
+	if o.some {
+		return o.value
+	}
+	return f()
+}
+
+func (o *Option[T]) UnwrapOrDefault() T {
+	if o.some {
+		return o.value
+	}
+	var zero T
+	return zero
+}

go.mod

@@ -0,0 +1,91 @@
+package option
+
+import (
+	"testing"
+)
+
+func TestIsSome(t *testing.T) {
+	s := Some(1)
+	if s.IsSome() == false {
+		t.Error("TestIsSome case 1 failed")
+	}
+
+	n := None[int]()
+	if n.IsSome() == true {
+		t.Error("TestIsSome case 2 failed")
+	}
+}
+
+func TestIsNone(t *testing.T) {
+	var s Option[int]
+	s.Some(1)
+	if s.IsNone() == true {
+		t.Error("TestIsNone case 1 failed")
+	}
+
+	var n Option[int]
+	n.None()
+	if n.IsNone() == false {
+		t.Error("TestIsNone case 2 failed")
+	}
+}
+
+func TestIsSomeAnd(t *testing.T) {
+	s := Some(1)
+	if s.IsSomeAnd(func(int) bool { return true }) == false {
+		t.Error("TestIsSomeAnd case 1 failed")
+	}
+
+	n := None[int]()
+	if n.IsSomeAnd(func(int) bool { return true }) == true {
+		t.Error("TestIsSomeAnd case 2 failed")
+	}
+}
+
+func TestIsNoneOr(t *testing.T) {
+	s := Some(1)
+	if s.IsNoneOr(func(int) bool { return false }) == true {
+		t.Error("TestIsNoneOr case 1 failed")
+	}
+
+	n := None[int]()
+	if n.IsNoneOr(func(int) bool { return false }) == false {
+		t.Error("TestIsNoneOr case 2 failed")
+	}
+}
+
+func TestUnwrap(t *testing.T) {
+	s := Some(1)
+	if s.Unwrap() != 1 {
+		t.Error("TestUnwrap case 1 failed")
+	}
+
+	n := None[int]()
+	if n.UnwrapOr(99) != 99 {
+		t.Error("TestUnwrap case 2 failed")
+	}
+}
+
+func TestUnwrapOrElse(t *testing.T) {
+	s := Some(1)
+	if s.UnwrapOrElse(func() int { return 99 }) != 1 {
+		t.Error("TestUnwrapOrElse case 1 failed")
+	}
+
+	n := None[int]()
+	if n.UnwrapOrElse(func() int { return 99 }) != 99 {
+		t.Error("TestUnwrapOrElse case 2 failed")
+	}
+}
+
+func TestUnwrapOrDefault(t *testing.T) {
+	s := Some(1)
+	if s.UnwrapOrDefault() != 1 {
+		t.Error("TestUnwrapOrDefault case 1 failed")
+	}
+
+	n := None[int]()
+	if n.UnwrapOrDefault() != 0 {
+		t.Error("TestUnwrapOrDefault case 2 failed")
+	}
+}