cast

Cast provides a library for consistent and safe type conversion in Go, particularly useful when working with interface{} or dynamic data from formats like YAML, TOML, or JSON.

There are two patterns of conversion methods available:

1. To[Type] methods: These always return the desired type. If the input cannot be converted, the zero value for that type (e.g., 0, "", or nil) is returned.
2. To[Type]E methods: These return the converted value and an error. This allows you to distinguish between a successful conversion to a zero value and a failed conversion.

Use cast.ToInt(in interface{}) to convert various types to an integer. If the input cannot be converted, it returns 0. Supported conversions include floats (truncated), numeric strings, and booleans (true becomes 1, false becomes 0).

cast.ToInt(8)                  // 8
cast.ToInt(8.31)               // 8
cast.ToInt("8")                // 8
cast.ToInt(true)                // 1
cast.ToInt(false)              // 0

var eight interface{} = 8
cast.ToInt(eight)              // 8
cast.ToInt(nil)                // 0

Use cast.ToString(in interface{}) to convert various types to a string. If the input is nil or cannot be converted, it returns an empty string "".

cast.ToString("mayonegg")         // "mayonegg"
cast.ToString(8)                  // "8"
cast.ToString(8.31)               // "8.31"
cast.ToString([]byte("one time")) // "one time"
cast.ToString(nil)                // ""

var foo interface{} = "one more time"
cast.ToString(foo)                // "one more time"

The package provides explicit functions for casting to specific integer types. These functions return the value and an error if the conversion is unsuccessful.

• ToIntE(i any) (int, error)
• ToInt8E(i any) (int8, error)
• ToInt16E(i any) (int16, error)
• ToInt32E(i any) (int32, error)
• ToInt64E(i any) (int64, error)

Use ToStringSliceE to attempt to cast any value into a []string.

Supported behaviors:

• string: Returns a slice of strings split by whitespace (using strings.Fields).
• any: Attempts to convert the value to a single string using ToStringE and returns it as a single-element slice []string{str}.
• slice/array: If the input is a slice or array of types that can be converted to strings, it returns a slice of those strings.

If the conversion fails, it returns an error.

The package provides explicit functions for casting to unsigned integer types. Note that if the input value is negative, these functions will return an error: unable to cast negative value.

• ToUintE(i any) (uint, error)
• ToUint8E(i any) (uint8, error)
• ToUint16E(i any) (uint16, error)
• ToUint32E(i any) (uint32, error)
• ToUint64E(i any) (uint64, error)

Use ToDurationE to convert an interface value to a time.Duration.

Supported types:

• time.Duration: Returns the value directly.
• Integers/Unsigned Integers: Converted to int64 then to time.Duration.
• Floats: Converted to float64 then to time.Duration.
• string: Parsed using time.ParseDuration. If the string does not contain any duration units (n, s, u, m, h), it appends ns to the string before parsing.
• nil: Returns 0.

If the input is an alias that can be resolved, it will attempt to resolve it before failing.