Documentation
¶
Overview ¶
Package try is a package for try.ToX functions that implement the error checking. try.ToX functions check 'if err != nil' and if it throws the err to the error handlers, which are implemented by the err2 package. More information about err2 and try packager roles can be seen in the FileCopy example:
...
r := try.To1(os.Open(src))
defer r.Close()
w := try.To1(os.Create(dst))
defer err2.Handle(&err, func() {
os.Remove(dst)
})
defer w.Close()
try.To1(io.Copy(w, r))
return nil
...
All of the try package functions are as fast as the simple 'if err != nil {' statement, thanks to the compiler inlining and optimization.
Note that try.ToX function names end to a number (x) because:
"No variadic type parameters. There is no support for variadic type parameters, which would permit writing a single generic function that takes different numbers of both type parameters and regular parameters." - Go Generics
The leading number at the end of the To2 tells that To2 takes two different non-error arguments, and the third one must be an error value.
Looking at the FileCopy example again, you see that all the functions are directed to try.To1 are returning (type1, error) tuples. All of these tuples are the correct input to try.To1. However, if you have a function that returns (type1, type2, error), you must use try.To2 function to check the error. Currently the try.To3 takes (3 + 1) return values which is the greatest amount. If more is needed, let us know.
Example (CopyFile) ¶
package main
import (
"fmt"
"io"
"os"
"github.com/lainio/err2"
"github.com/lainio/err2/try"
)
func main() {
copyFile := func(src, dst string) (err error) {
defer err2.Handle(&err, "copy %s %s", src, dst)
// These try package helpers are as fast as Check() calls which is as
// fast as `if err != nil {}`
r := try.To1(os.Open(src))
defer r.Close()
w := try.To1(os.Create(dst))
defer err2.Handle(&err, func() {
os.Remove(dst)
})
defer w.Close()
try.To1(io.Copy(w, r))
return nil
}
err := copyFile("/notfound/path/file.go", "/notfound/path/file.bak")
if err != nil {
fmt.Println(err)
}
}
Output: copy /notfound/path/file.go /notfound/path/file.bak: open /notfound/path/file.go: no such file or directory
Index ¶
- func Is(err, filter error) bool
- func IsEOF(err error) bool
- func IsEOF1[T any](v T, err error) (bool, T)
- func IsEOF2[T, U any](v1 T, v2 U, err error) (bool, T, U)
- func IsExist(err error) bool
- func IsNotAccess(err error) bool
- func IsNotExist(err error) bool
- func IsNotFound(err error) bool
- func IsNotFound1[T any](v T, err error) (bool, T)
- func To(err error)
- func To1[T any](v T, err error) T
- func To2[T, U any](v1 T, v2 U, err error) (T, U)
- func To3[T, U, V any](v1 T, v2 U, v3 V, err error) (T, U, V)
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Is ¶
Is function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the filter before throwing an error. The false return value tells that there are no errors and the true value that the error is the filter.
Example (ErrorHappens) ¶
package main
import (
"fmt"
"io"
"github.com/lainio/err2"
"github.com/lainio/err2/try"
)
var errForTesting = fmt.Errorf("error for %s", "testing")
func main() {
copyStream := func(src string) (s string, err error) {
defer err2.Handle(&err, "copy stream (%s)", src)
err = errForTesting
try.Is(err, io.EOF)
return src, nil
}
str, err := copyStream("testing string")
if err != nil {
fmt.Println(err)
}
fmt.Println(str)
}
Output: copy stream (testing string): error for testing
Example (ErrorHappensNot) ¶
package main
import (
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/try"
)
var errForTesting = fmt.Errorf("error for %s", "testing")
func main() {
copyStream := func(src string) (s string, err error) {
defer err2.Handle(&err, "copy stream %s", src)
err = fmt.Errorf("something: %w", errForTesting)
if try.Is(err, errForTesting) {
return "wrapping works", nil
}
return src, nil
}
str, err := copyStream("testing string")
if err != nil {
fmt.Println(err)
}
fmt.Println(str)
}
Output: wrapping works
func IsEOF ¶
IsEOF function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'io.EOF' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'io.EOF'.
func IsEOF1 ¶
IsEOF1 function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'io.EOF' before throwing an error. The false return value tells that there are no errors and the true value that the error is the 'io.EOF'.
Example ¶
package main
import (
"bytes"
"fmt"
"github.com/lainio/err2"
"github.com/lainio/err2/try"
)
func main() {
copyStream := func(src string) (s string, err error) {
defer err2.Handle(&err)
in := bytes.NewBufferString(src)
tmp := make([]byte, 4)
var out bytes.Buffer
for eof, n := try.IsEOF1(in.Read(tmp)); !eof; eof, n = try.IsEOF1(in.Read(tmp)) {
out.Write(tmp[:n])
}
return out.String(), nil
}
str, err := copyStream("testing string")
if err != nil {
fmt.Println(err)
}
fmt.Println(str)
}
Output: testing string
func IsEOF2 ¶
IsEOF2 function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'io.EOF' before throwing an error. The false return value tells that there are no errors and the true value that the error is the 'io.EOF'.
func IsExist ¶ added in v0.8.11
IsExist function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'err2.Exist' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'err2.Exist'.
func IsNotAccess ¶ added in v0.8.11
IsNotAccess function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'err2.NotAccess' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'err2.NotAccess'.
func IsNotExist ¶ added in v0.8.11
IsNotExist function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'err2.NotExist' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'err2.NotExist'.
func IsNotFound ¶ added in v0.8.11
IsNotFound function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'err2.NotFound' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'err2.NotFound'.
func IsNotFound1 ¶ added in v0.8.11
IsNotFound1 function performs a filtered error check for the given argument. It's the same as To function, but it checks if the error matches the 'err2.NotFound' before throwing an error. The false return value tells that there are no errors. The true tells that the err's chain includes 'err2.NotFound'.
Example ¶
package main
import (
"fmt"
"os"
"github.com/lainio/err2"
"github.com/lainio/err2/try"
)
func FindObject(key int) (val string, err error) {
defer err2.Handle(&err)
// both of the following lines can be used to transport err2.NotFound
// you can try by outcommenting err2.Throwf
//err2.Throwf("panic transport: %w", err2.NotFound)
return "", err2.NotFound
}
func main() {
// To see how automatic stack tracing works WITH panic transport please run
// this example with:
// go test -v -run='^ExampleNotFound$'
// pick up your poison: outcomment the nil line to see how error tracing
// works.
err2.SetErrorTracer(os.Stderr)
err2.SetErrorTracer(nil)
find := func(key int) string {
defer err2.Catch(func(err error) {
fmt.Println("ERROR:", err)
})
found, value := try.IsNotFound1(FindObject(key))
if found {
return fmt.Sprintf("cannot find key (%d)", key)
}
return "value for key is:" + value
}
fmt.Println(find(1))
}
Output: cannot find key (1)
func To ¶
func To(err error)
To is a helper function to call functions which returns (error) and check the error value. If an error occurs, it panics the error where err2 handlers can catch it if needed.
func To1 ¶
To1 is a helper function to call functions which returns (any, error) and check the error value. If an error occurs, it panics the error where err2 handlers can catch it if needed.
Types ¶
This section is empty.
Source Files