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!

# README