README
¶
Done - Simple Error Handling in Go
Done allows you to focus on your business logic without repetitive if err != nil patterns.
when you write logic:
if err := run(); err != nil{
panic(err)
}
then you can use done:
done.Done(run())
CHINESE README
Features
- Simple error handling: Handle errors quickly with simple functions.
- Supports multiple results: Works well with functions that return a value and an error type.
- Less repeated code: Replace repeated error checks with short and clear functions.
Installation
go get github.com/yyle88/done
How It Works
The Done package wraps error checking into easy-to-use assertions, enabling you to handle errors while focusing on the success path of code.
Core Types
| Type | Description |
|---|---|
Ve[V any] |
Holds a value and an error. Provides methods like Done, Must, and Soft. |
Vpe[V any] |
For pointer values, includes methods such as Sure, Nice, and Good. |
Vce[V comparable] |
For comparable values, provides methods like Same, Diff, and Equals. |
Key Functions
| Function | Description |
|---|---|
Done |
Panics if an error exists. |
Must |
Ensures the error is nil and returns the value. |
Soft |
Logs a warning for errors but does not panic. |
Fata |
Logs the error at a "fatal" level and panics. |
Functionality Summary
| Category | Functions | Description |
|---|---|---|
| Error Handling | Done, Must, Soft |
Panics on error or handles it in a specific way. |
| Result Validation | Sure, Nice, Some |
Ensures the result is not zero and returns it. |
| Result Validation | Good, Fine, Safe |
Ensures the result is not zero without returning it. |
| Zero Value Checking | Zero, None, Void |
Ensures the result is the zero value of its type. |
| Value Comparisons | Same, Diff, Is, Equals |
Checks if values are the same, different, or match specific conditions. |
Advanced Error Handling
| Utility | Description |
|---|---|
Vce |
For comparable values, includes methods like Same, Diff, Is, and Equals. |
Vse |
For string operations, includes methods like HasPrefix, HasSuffix, and Contains. |
Vne |
For numeric operations, includes methods like Gt (greater than), Lt (less than), etc. |
Example Usage
Standard Error Handling
package main
import (
"fmt"
)
func main() {
xyz, err := NewXyz()
if err != nil {
panic(err) // Handle errors manually
}
abc, err := xyz.Abc()
if err != nil {
panic(err)
}
uvw, err := abc.Uvw()
if err != nil {
panic(err)
}
fmt.Println(uvw.Message)
}
Using Done
package main
import (
"fmt"
"github.com/yyle88/done"
)
func main() {
xyz := done.VCE(NewXyz()).Nice()
abc := done.VCE(xyz.Abc()).Nice()
uvw := done.VCE(abc.Uvw()).Nice()
fmt.Println(uvw.Message)
}
This approach simplifies the code by chaining function calls with error handling assertions.
Chaining Operations
Without Done
package main
import (
"fmt"
"strconv"
"github.com/pkg/errors"
)
func main() {
stringNum, err := fetch()
if err != nil {
panic(err)
}
num, err := toInt(stringNum)
if err != nil {
panic(err)
}
if num <= 0 {
panic(errors.New("num <= 0"))
}
fmt.Println(num)
}
With Done
package main
import (
"fmt"
"strconv"
"github.com/yyle88/done"
)
func main() {
num := done.VNE(toInt(done.VCE(fetch()).Nice())).Gt(0)
fmt.Println(num)
}
By using Done, you eliminate repetitive error checks and enable inline assertions for conditions, resulting in cleaner and more maintainable code.
Conclusion
The Done package is a powerful tool for simplifying error handling, especially in informal or small-scale projects. It helps reduce boilerplate, makes error handling concise, and lets you focus on writing clean and efficient business logic.
Give it a try and share your feedback!
License
This project is licensed under the MIT License. See the LICENSE file for details.
Contribute and Support
Welcome to contribute to this project by submitting pull requests or reporting issues.
If you find this package helpful, give it a star on GitHub!
Thank you for your support!
Documentation
¶
Index ¶
- func C0(err error)
- func C1[T1 comparable](v1 T1, err error) T1
- func C2[T1, T2 comparable](v1 T1, v2 T2, err error) (T1, T2)
- func Done(err error)
- func Fata(err error)
- func Fine[V comparable](v V)
- func Full[V *any](v any)
- func Good[V comparable](v V)
- func Must(err error)
- func Nice[V comparable](v V) V
- func None[V comparable](v V)
- func Null[V *any](v any)
- func P0(err error)
- func P1[T1 any](v1 *T1, err error) *T1
- func P2[T1, T2 any](v1 *T1, v2 *T2, err error) (*T1, *T2)
- func Safe[V comparable](v V)
- func Soft(err error)
- func Sure[V comparable](v V) V
- func V0(err error)
- func V1[T1 any](v1 T1, err error) T1
- func V2[T1, T2 any](v1 T1, v2 T2, err error) (T1, T2)
- func Zero[V comparable](v V)
- type Vae
- func (a *Vae[V]) Fine()
- func (a *Vae[V]) Good()
- func (a *Vae[V]) Have()
- func (a *Vae[V]) Len(n int)
- func (a *Vae[V]) Length(n int)
- func (a *Vae[V]) Nice() []V
- func (a *Vae[V]) None()
- func (a *Vae[V]) Safe()
- func (a *Vae[V]) Size(n int)
- func (a *Vae[V]) Some() []V
- func (a *Vae[V]) Sure() []V
- func (a *Vae[V]) Void()
- func (a *Vae[V]) Zero()
- type Vbe
- type Vce
- func (a *Vce[V]) Diff(v V)
- func (a *Vce[V]) Different(v V)
- func (a *Vce[V]) Equals(v V)
- func (a *Vce[V]) Fine()
- func (a *Vce[V]) Good()
- func (a *Vce[V]) Is(v V)
- func (a *Vce[V]) Nice() V
- func (a *Vce[V]) None()
- func (a *Vce[V]) Safe()
- func (a *Vce[V]) Same(v V)
- func (a *Vce[V]) Sure() V
- func (a *Vce[V]) Zero()
- type Ve
- type Vme
- func (a *Vme[K, V]) Fine()
- func (a *Vme[K, V]) Good()
- func (a *Vme[K, V]) Have()
- func (a *Vme[K, V]) Len(n int)
- func (a *Vme[K, V]) Length(n int)
- func (a *Vme[K, V]) Nice() map[K]V
- func (a *Vme[K, V]) None()
- func (a *Vme[K, V]) Safe()
- func (a *Vme[K, V]) Size(n int)
- func (a *Vme[K, V]) Some() map[K]V
- func (a *Vme[K, V]) Sure() map[K]V
- func (a *Vme[K, V]) Void()
- func (a *Vme[K, V]) Zero()
- type Vne
- type Vpe
- type Vse
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func C1 ¶ added in v1.0.16
func C1[T1 comparable](v1 T1, err error) T1
func C2 ¶ added in v1.0.16
func C2[T1, T2 comparable](v1 T1, v2 T2, err error) (T1, T2)
func Nice ¶
func Nice[V comparable](v V) V
Nice means the value is not zero value, then return value
func Sure ¶
func Sure[V comparable](v V) V
Sure means the value is not zero value, then return value
func Zero ¶
func Zero[V comparable](v V)
Zero means the value is a zero value, num is 0, string is "", PTR is none.
Types ¶
type Vae ¶
type Vce ¶
type Vce[V comparable] struct { V V E error *Ve[V] }
func VCE ¶
func VCE[V comparable](val V, err error) *Vce[V]
VCE accept two params. one is comparable and one is error interface
type Vme ¶
type Vme[K comparable, V any] struct { V map[K]V E error *Ve[map[K]V] }
type Vpe ¶
type Vpe[V any] struct { V *V E error *Ve[*V] //这里最好不要继承自 vce-comparable 这个类型，因为指针比较地址相等或者不想等的意义不太大，因此不要提供这些无意义的功能 }
Source Files
Directories