Documentation
¶
Overview ¶
Package risky contains a bunch of bad ideas for APIs and operations that will definitely lead to panics and deadlocks and incorrect behavior when used incorrectly.
At the same time, these operations may be useful in the right situations, and the package name "risky" indicates (like "unsafe") that the operation should be handled with care.
Index ¶
- func Apply[T any](fn func(T) T, in []T) []T
- func Block[T any](fn func(context.Context) T) T
- func BlockForceOp[T any](fn func(context.Context) (T, error)) T
- func Cast[T any](in any) T
- func Check[T any](out T, err error) (T, bool)
- func Force[T any](out T, _ error) T
- func ForceOp[T any](fn func() (T, error)) (out T)
- func Ignore[T any](fn func(T) error, arg T)
- func IgnoreMust[T any, O any](fn func(T) (O, error), arg T) O
- func List[T any](iter *fun.Iterator[T]) *dt.List[T]
- func Observe[T any](iter *fun.Iterator[T], fn fun.Handler[T])
- func Recover()
- func Slice[T any](iter *fun.Iterator[T]) []T
- func Try[T any](op func(T) (T, error), input T) (out T)
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func Apply ¶ added in v0.10.0
func Apply[T any](fn func(T) T, in []T) []T
Apply processes an input slice, with the provided function, returning a new slice that holds the result.
func Block ¶
Block runs the function with a context that is never canceled. Use this in cases where you don't want to plumb a context through *and* the operation cannot block on the context.
func BlockForceOp ¶
BlockForce combines Block with ForceOp to run a function with a context that is never canceled, ignoring any panics and returning the output value.
func Cast ¶ added in v0.10.0
Cast just provides as a wrapper in.(T); however, risky.Cast(in) has the benefit of raising the redflag that it should!
func Check ¶
Check takes two values and returns the first value and a second "ok" value. The second value is true if the error is nil (isOK) and false otherwise. This is not too risky.
func Force ¶
Force swallows an error, and returns the output, as a non-panic'ing form of risky.Force.
size += risky.Force(buffer.Write([]byte("hello world")))
func ForceOp ¶
ForceOp, is like Force, except it takes the function and calls it itself so that it can ignore a possible panic and return an output. In the case of a panic or an error the output value is often the zero value for the type.
func Ignore ¶
Ignore runs a function that takes an arbitrary argument and ignores the error and swallows any panic. This is a risky move: usually functions panic for a reason, but for certain invariants this may be useful.
Be aware, that while Ignore will recover from any panics, defers within the ignored function will not run unless there is a call to recover *before* the defer.
func IgnoreMust ¶
IgnoreMust runs a function that takes an arbitrary argument and ignores the error and swallows any panic, returning the output of the function, likely a Zero value, in the case of an error. This is a risky move: usually functions panic for a reason, but for certain invariants this may be useful.
Be aware, that while Ignore will recover from any panics, defers within the ignored function will not run unless there is a call to recover *before* the defer.
func Observe ¶ added in v0.10.0
Observe is a fun.Observe wrapper that uses a background context, and converts the possible error returned by fun.Observe into a panic. In general fun.Observe only returns an error if the input iterator errors (or panics) or the handler function panics.
Types ¶
This section is empty.
Source Files