Cast

https://github.com/spf13/cast
Admin
Cast is a Go library that provides easy, safe, and consistent type casting and conversion between...
Tokens:27,721
Snippets:332
Trust Score:9.9
License:MIT
Update:2 months ago
Show doc for...
Tokens:
Raw
### Using Must for initialization

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Example of using Must to cast environment variables where failure should trigger a panic.

```go
package main
import "github.com/spf13/cast"

func main() {
    // In initialization where failures should crash
    port := cast.Must[int](cast.ToIntE(os.Getenv("PORT")))
    
    // This will panic if the environment variable is invalid
}
```

--------------------------------

### Initialize TimeFormat slice

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Example of defining a collection of internal time formats using the TimeFormat structure.

```go
// Formats used internally
var timeFormats = []cast.TimeFormat{
    {"2006-01-02", TimeFormatNoTimezone},
    {time.RFC3339, TimeFormatNumericTimezone},
    {time.RFC1123, TimeFormatNamedTimezone},
}
```

--------------------------------

### Define and use ToDurationSliceE

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Signature and usage examples for casting values to duration slices with error reporting.

```go
func ToDurationSliceE(i any) ([]time.Duration, error)
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    d, _ := cast.ToDurationSliceE([]time.Duration{time.Second, time.Minute})
    d, _ := cast.ToDurationSliceE([]int64{1000000000, 60000000000})    // 1s, 1m
    d, _ := cast.ToDurationSliceE([]string{"1s", "1m", "1h"})
}
```

--------------------------------

### ToBoolE Usage Example

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Demonstrates casting various types to boolean with error handling.

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToBoolE(1)           // true, nil
    cast.ToBoolE(0)           // false, nil
    cast.ToBoolE("true")      // true, nil
    cast.ToBoolE("invalid")   // false, error
    cast.ToBoolE(nil)         // false, nil
}
```

--------------------------------

### ToBool Usage Example

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Demonstrates casting to boolean while silently ignoring errors.

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToBool(1)           // true
    cast.ToBool("invalid")   // false (error silently ignored)
}
```

--------------------------------

### Define and use ToFloat64Slice variants

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Signatures and usage examples for casting values to float64 slices.

```go
func ToFloat64SliceE(i any) ([]float64, error)
func ToFloat64Slice(i any) []float64
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToFloat64Slice([]float64{1.1, 2.2, 3.3})    // []float64{1.1, 2.2, 3.3}
    cast.ToFloat64Slice([]int{1, 2, 3})              // []float64{1.0, 2.0, 3.0}
    cast.ToFloat64Slice([]string{"1.5", "2.5"})      // []float64{1.5, 2.5}
}
```

--------------------------------

### ToStringMapIntE Usage Example

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Demonstrates casting different map types to map[string]int using ToStringMapIntE.

```go
package main
import "github.com/spf13/cast"

func main() {
    m, _ := cast.ToStringMapIntE(map[string]int{"a": 1, "b": 2})
    m, _ := cast.ToStringMapIntE(map[string]any{"a": "10", "b": 20.5})
    // map[string]int{"a": 10, "b": 20}
}
```

--------------------------------

### Triggering Slice Conversion Failures

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Examples of inputs that cause slice conversion failures.

```go
cast.ToIntSliceE([]string{"1", "invalid", "3"})
```

```go
cast.ToStringSliceE(123)
```

--------------------------------

### Define and use ToDurationSlice

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Signature and usage examples for casting values to duration slices, returning an empty slice on error.

```go
func ToDurationSlice(i any) []time.Duration
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    cast.ToDurationSlice([]string{"1s", "2s", "3s"})  // []time.Duration{1s, 2s, 3s}
    cast.ToDurationSlice(nil)                         // []time.Duration{}
}
```

--------------------------------

### Triggering Map Conversion Failures

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Examples of inputs that cause map conversion failures.

```go
cast.ToStringMapStringE([]string{})
```

```go
cast.ToStringMapIntE(map[string]any{"a": "not-a-number"})
```

```go
cast.ToStringMapStringE(map[error]string{errors.New("key"): "val"})
```

--------------------------------

### Triggering Unsupported Type Conversion Errors

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Examples of operations that trigger unsupported type conversion errors.

```go
cast.ToIntE(MyStruct{})
```

```go
cast.ToStringE(complex(1, 2))
```

```go
cast.ToStringMapStringE(map[int]int{1: 2})
```

```go
cast.ToIntSliceE([]struct{}{})
```

--------------------------------

### Cast to uint64

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint64, rejecting negative values. Includes an example of handling valid and invalid inputs.

```go
func ToUint64E(i any) (uint64, error)
func ToUint64(i any) uint64
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToUint64("18446744073709551615")   // max uint64
    cast.ToUint64E(-1)                      // 0, error (negative)
    cast.ToUint64E("-5")                    // 0, error (negative)
}
```

--------------------------------

### Use Basic constraint in generic function

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Example of a generic function using the Basic constraint to cast values.

```go
func parseConfig[T cast.Basic](value string) T {
    return cast.To[T](value)
}

// Usage
portNum := parseConfig[int]("8080")
debug := parseConfig[bool]("true")
timeout := parseConfig[time.Duration]("30s")
```

--------------------------------

### Cast to int64

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Converts any value to an int64 type, with examples showing string, float, and invalid input handling.

```go
func ToInt64E(i any) (int64, error)
func ToInt64(i any) int64
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToInt64("9223372036854775807")    // max int64
    cast.ToInt64(3.14)                     // 3 (truncated)
    cast.ToInt64E("invalid")               // 0, error
}
```

--------------------------------

### Use Number constraint in generic function

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Example of a generic function using the Number constraint to safely convert numeric values.

```go
func convertMetric[T cast.Number](rawValue any) T {
    value, err := cast.ToNumberE[T](rawValue)
    if err != nil {
        return 0
    }
    return value
}

// Usage
count := convertMetric[int64](42)
price := convertMetric[float64]("19.99")
```

--------------------------------

### Triggering JSON Parsing Errors

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Examples of invalid JSON inputs that cause parsing errors in map conversion functions.

```go
cast.ToStringMapE("{ invalid json }")
```

```go
cast.ToStringMapStringE('{"a": 123}')
```

```go
cast.ToStringMapE('{"a": "incomplete')
```

--------------------------------

### Using the Must Helper

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Demonstrates the Must helper for fatal initialization errors and safe usage in init functions.

```go
v := cast.Must[int](cast.ToIntE("not-a-number"))
// panics: unable to cast "not-a-number" of type string to int
```

```go
func init() {
    // If this fails, the program cannot start
    port := cast.Must[int](cast.ToIntE(os.Getenv("PORT")))
}
```

--------------------------------

### Handle Nil and Empty Maps

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Demonstrates how map functions process nil inputs, explicit nil maps, and empty map literals.

```go
var m map[string]string
cast.ToStringMapE(nil)        // error
cast.ToStringMapE(m)          // error (explicit nil)
cast.ToStringMapE(map[string]string{})  // empty map, no error
```

--------------------------------

### Parse configuration from maps using cast

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Demonstrates mapping generic map values to a structured configuration object using cast conversion functions.

```go
package config

import "github.com/spf13/cast"

type ServerConfig struct {
    Port        int
    Debug       bool
    Timeout     time.Duration
    AllowedHosts []string
}

func FromMap(m map[string]any) ServerConfig {
    return ServerConfig{
        Port:        cast.ToInt(m["port"]),
        Debug:       cast.ToBool(m["debug"]),
        Timeout:     cast.ToDuration(m["timeout"]),
        AllowedHosts: cast.ToStringSlice(m["hosts"]),
    }
}
```

--------------------------------

### Run development tasks with just

Source: https://github.com/spf13/cast/blob/master/README.md

Commands for running tests, linting, and formatting the project using the just task runner.

```shell
just test
```

```shell
just lint
```

```shell
just fmt
```

--------------------------------

### Run project maintenance tasks

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Use these commands to execute the test suite, linting, and code formatting for the project.

```bash
just test      # Run all tests
just lint      # Run linters
just fmt       # Auto-format code
```

--------------------------------

### Handle empty string conversion

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Shows that empty strings are converted to zero values without triggering errors.

```go
cast.ToInt("")        // 0
cast.ToFloat64("")    // 0.0
```

--------------------------------

### Usage of ToStringMapInt64E

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Demonstrates converting different map types to map[string]int64.

```go
package main
import "github.com/spf13/cast"

func main() {
    m, _ := cast.ToStringMapInt64E(map[string]int64{"a": 100, "b": 200})
    m, _ := cast.ToStringMapInt64E(map[any]any{1: "100", "two": 200})
    // map[string]int64{"1": 100, "two": 200}
}
```

--------------------------------

### Convert values to float64

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Demonstrates casting various types and strings to float64, including error handling for invalid inputs.

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToFloat64("3.14")              // 3.14
    cast.ToFloat64(42)                  // 42.0
    cast.ToFloat64("1.5e2")             // 150.0
    cast.ToFloat64E("invalid")          // 0.0, error
}
```

--------------------------------

### Handle negative values in numeric conversion

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Shows how unsigned types reject negative values while floating-point types accept them.

```go
cast.ToUintE(-1)     // 0, error
cast.ToUint64E("-10") // 0, error
cast.ToFloatE(-1)    // Valid: -1.0 (floats can be negative)
```

--------------------------------

### Parse numeric strings with different bases

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Demonstrates parsing strings representing hexadecimal, octal, and binary numbers.

```go
cast.ToInt("0x10")    // 16 (hex)
cast.ToInt("010")     // 8 (octal)
cast.ToInt("0b1010")  // 10 (binary)
```

--------------------------------

### Process template data with cast

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Shows how to convert dynamic data structures and handle potential errors using the 'E' suffix methods.

```go
package template

import "github.com/spf13/cast"

// Process YAML/JSON frontmatter
func ProcessFrontmatter(data map[string]any) map[string]string {
    return cast.ToStringMapString(data)
}

// Handle dynamic metadata
func GetIntValue(data map[string]any, key string, defaultVal int) int {
    v, err := cast.ToIntE(data[key])
    if err != nil {
        return defaultVal
    }
    return v
}
```

--------------------------------

### Convert to Time with Location

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Demonstrates using time.Location to interpret a string timestamp in a specific timezone.

```go
loc, _ := time.LoadLocation("America/Chicago")
t, _ := cast.ToTimeInDefaultLocationE("2023-01-15 10:00:00", loc)
// Time interpreted as Chicago time
```

--------------------------------

### Define float64 conversion functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Signatures for converting any value to float64, with an error-returning variant available.

```go
func ToFloat64E(i any) (float64, error)
func ToFloat64(i any) float64
```

--------------------------------

### Define float32 conversion functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Signatures for converting any value to float32, with an error-returning variant available.

```go
func ToFloat32E(i any) (float32, error)
func ToFloat32(i any) float32
```

--------------------------------

### Common Error Handling Patterns

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Standard idioms for managing conversion results, including explicit checks, silent failures, panics, and chained validation.

```go
// Pattern 1: Explicit error check
value, err := cast.ToIntE(input)
if err != nil {
    log.Printf("conversion failed: %v", err)
    value = defaultValue
}

// Pattern 2: Ignore error (use zero value)
count := cast.ToInt(input)

// Pattern 3: Panic on error (initialization)
port := cast.Must[int](cast.ToIntE(os.Getenv("PORT")))

// Pattern 4: Chain with validation
if v, err := cast.ToIntE(input); err != nil || v < 0 {
    return errors.New("invalid value")
}
```

--------------------------------

### Convert arrays to slices

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Arrays are converted to slices using reflection.

```go
arr := [3]string{"a", "b", "c"}
cast.ToStringSlice(arr)    // []string{"a", "b", "c"}
```

--------------------------------

### Convert values to string using ToString

Source: https://github.com/spf13/cast/blob/master/README.md

Converts various types to a string representation. Returns an empty string if the input is nil or cannot be converted.

```go
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"
```

--------------------------------

### Helper Functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/REFERENCE_GUIDE.md

Utility functions for handling conversions.

```APIDOC
## Helper Functions

### Description
Utility functions to simplify conversion logic.

### Functions
- Must[T](v T, err error) T

### Usage
Must panics if the error returned by an 'E' variant function is non-nil, otherwise it returns the value.
```

--------------------------------

### Wrap Errors with Context in Go

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Use fmt.Errorf with the %w verb to wrap conversion errors with additional application context.

```go
import (
    "fmt"
    "github.com/spf13/cast"
)

func parseConfig(key string, value string, targetType interface{}) (interface{}, error) {
    // ... conversion code ...
    result, err := cast.ToIntE(value)
    if err != nil {
        return nil, fmt.Errorf("config error: failed to parse %s: %w", key, err)
    }
    return result, nil
}
```

--------------------------------

### Define ToFloat32SliceE

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Signature for casting any value to a float32 slice with error reporting.

```go
func ToFloat32SliceE(i any) ([]float32, error)
```

--------------------------------

### Split strings into slices

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

String-to-slice conversion splits the input string based on whitespace.

```go
cast.ToStringSlice("one two three")     // []string{"one", "two", "three"}
cast.ToStringSlice("hello world")       // []string{"hello", "world"}
```

--------------------------------

### Casting to Duration with Error Handling

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Use ToDurationE to convert values to time.Duration while receiving potential errors.

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    d, _ := cast.ToDurationE(1000000000)      // 1 second (nanoseconds)
    d, _ := cast.ToDurationE("30s")           // 30 seconds
    d, _ := cast.ToDurationE("1h30m")         // 1.5 hours
    d, _ := cast.ToDurationE("100")           // 100ns (unit assumed)
    d, _ := cast.ToDurationE(int64(5000000000)) // 5 seconds
    cast.ToDurationE(nil)                     // 0ns, nil
}
```

--------------------------------

### Define ToStringMapInt64E signature

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Function signature for casting to map[string]int64 with error reporting.

```go
func ToStringMapInt64E(i any) (map[string]int64, error)
```

--------------------------------

### Define ToStringMapInt64 signature

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Function signature for casting to map[string]int64, returning an empty map on failure.

```go
func ToStringMapInt64(i any) map[string]int64
```

--------------------------------

### Chain with Validation in Go

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Combine error checking with custom business logic validation.

```go
v, err := cast.ToIntE(input)
if err != nil || v < 0 || v > 100 {
    return fmt.Errorf("invalid percentage: %s", input)
}
return v
```

--------------------------------

### Panic on Error in Go

Source: https://github.com/spf13/cast/blob/master/_autodocs/errors.md

Use the Must helper to trigger a panic if the conversion fails.

```go
// Panics if parsing fails
port := cast.Must[int](cast.ToIntE(os.Getenv("PORT")))
```

--------------------------------

### ToDurationE

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Casts any value to time.Duration with explicit error reporting.

```APIDOC
## func ToDurationE(i any) (time.Duration, error)

### Description
Casts any value to time.Duration type, with error reporting. Supports integers (nanoseconds), floats (nanoseconds), and strings (Go duration format).

### Parameters
- **i** (any) - Required - Value to cast

### Returns
- **Value** (time.Duration) - Converted duration value
- **Error** (error) - Non-nil if conversion fails
```

--------------------------------

### Handle Conversion Errors

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Comparison between E-suffixed functions that return errors and standard functions that return zero values on failure.

```go
v, err := cast.ToIntE("42")    // Returns both value and error
if err != nil {
    // Handle conversion failure
}
```

```go
v := cast.ToInt("42")          // Returns 0 on error (silent)
```

--------------------------------

### Handle API request parameters

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Extracts and sanitizes request parameters from a map, applying default values when necessary.

```go
package handlers

import (
    "github.com/spf13/cast"
)

func GetUserList(params map[string]any) error {
    pageNum := cast.ToInt(params["page"])
    if pageNum < 1 {
        pageNum = 1
    }
    
    limit := cast.ToInt(params["limit"])
    if limit < 1 || limit > 100 {
        limit = 20
    }
    
    sortField := cast.ToString(params["sort"])
    if sortField == "" {
        sortField = "created"
    }
    
    // Use pageNum, limit, sortField...
    return nil
}
```

--------------------------------

### Define float64Provider interface

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Interface for types that can provide a float64 value.

```go
type float64Provider interface {
    Float64() float64
}
```

```go
type Duration struct {
    hours   int
    minutes int
}

func (d Duration) Float64() float64 {
    return float64(d.hours) + float64(d.minutes)/60.0
}

// Can be converted using cast.ToFloat64E
result := cast.ToFloat64E(Duration{1, 30})  // 1.5
```

--------------------------------

### Define errorMsgWith Constant

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Standard format string for conversion errors that wrap an underlying error.

```go
const errorMsgWith = "unable to cast %#v of type %T to %T: %w"
```

--------------------------------

### Cast to map[string]any returning empty map on error

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Uses ToStringMap to convert inputs to a map, defaulting to an empty map if conversion is not possible.

```go
func ToStringMap(i any) map[string]any
```

```go
package main
import "github.com/spf13/cast"

func main() {
    m := cast.ToStringMap(map[string]any{"key": "value"})
    m := cast.ToStringMap(`{"a":1,"b":"text"}`)
}
```

--------------------------------

### Cast to time.Time with location and error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Use ToTimeInDefaultLocationE to interpret naive time strings within a specific timezone location.

```go
func ToTimeInDefaultLocationE(i any, location *time.Location) (time.Time, error)
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    loc, _ := time.LoadLocation("America/New_York")
    
    // String without timezone info → interpreted in America/New_York
    t, _ := cast.ToTimeInDefaultLocationE("2023-01-15 10:30:00", loc)
    
    // String with timezone info → uses provided timezone, location ignored
    t, _ := cast.ToTimeInDefaultLocationE("2023-01-15T10:30:00Z", loc)
    
    // nil location → uses local timezone
    t, _ := cast.ToTimeInDefaultLocationE("2023-01-15", nil)
}
```

--------------------------------

### Cast to map[string]any with error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Uses ToStringMapE to convert inputs to a map, returning an error if the conversion fails.

```go
func ToStringMapE(i any) (map[string]any, error)
```

```go
package main
import "github.com/spf13/cast"

func main() {
    m, _ := cast.ToStringMapE(map[string]any{"a": 1, "b": "two"})
    m, _ := cast.ToStringMapE(map[any]any{1: "one", "two": 2})
    // map[string]any{"1": "one", "two": 2}
    
    m, _ := cast.ToStringMapE(`{"name":"John","age":30}`)
    // map[string]any{"name": "John", "age": 30}
}
```

--------------------------------

### Resolve Custom Types with Cast

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Demonstrates how named types based on supported underlying types are resolved, while unsupported types like structs return an error.

```go
type MyInt int

v := cast.ToInt(MyInt(42))  // Works: resolves MyInt to int

type Config struct {
    Port int
}

cast.ToInt(Config{})  // Error: struct type not supported
```

--------------------------------

### ToStringMapIntE Function Signature

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

The signature for the error-reporting map conversion function.

```go
func ToStringMapIntE(i any) (map[string]int, error)
```

--------------------------------

### Parse string to time.Time in UTC

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Parses a string into a time.Time object using predefined formats, defaulting to UTC.

```go
func StringToDate(s string) (time.Time, error)
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.StringToDate("2023-01-15")              // 2023-01-15 00:00:00 +0000 UTC
    cast.StringToDate("2023-01-15T10:30:00Z")    // 2023-01-15 10:30:00 +0000 UTC
    cast.StringToDate("invalid")                 // error
}
```

--------------------------------

### ToStringMapInt Function Signature

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

The signature for the non-error-reporting map conversion function.

```go
func ToStringMapInt(i any) map[string]int
```

--------------------------------

### Cast to string with error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Use ToStringE to convert values to strings while receiving an error if the conversion is unsupported.

```go
func ToStringE(i any) (string, error)
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToStringE("hello")       // "hello", nil
    cast.ToStringE(42)            // "42", nil
    cast.ToStringE(3.14)          // "3.14", nil
    cast.ToStringE([]byte("hi"))  // "hi", nil
    cast.ToStringE(nil)           // "", nil
}
```

--------------------------------

### float64Provider

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Interface for types that can provide a float64 value, used by numeric conversion functions.

```APIDOC
## interface float64Provider

### Description
Interface for types that can provide a float64 value. This is used by numeric conversion functions to support custom numeric types.

### Method Signature
`Float64() float64`

### Example
```go
type Duration struct {
    hours   int
    minutes int
}

func (d Duration) Float64() float64 {
    return float64(d.hours) + float64(d.minutes)/60.0
}

// Can be converted using cast.ToFloat64E
result := cast.ToFloat64E(Duration{1, 30})  // 1.5
```
```

--------------------------------

### Cast to uint32

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint32, rejecting negative values.

```go
func ToUint32E(i any) (uint32, error)
func ToUint32(i any) uint32
```

--------------------------------

### ToUint64 / ToUint64E

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint64. Rejects negative values.

```APIDOC
## func ToUint64E(i any) (uint64, error)
## func ToUint64(i any) uint64

### Description
Casts any value to `uint64` type. Rejects negative values.

### Parameters
- **i** (any) - Required - Value to cast

### Response
- **Value** (uint64) - Converted uint64 value
- **Error** (error) - Non-nil if conversion fails or negative value

### Example
```go
cast.ToUint64("18446744073709551615")   // max uint64
cast.ToUint64E(-1)                      // 0, error (negative)
cast.ToUint64E("-5")                    // 0, error (negative)
```
```

--------------------------------

### Cast to uint

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint, rejecting negative values.

```go
func ToUintE(i any) (uint, error)
func ToUint(i any) uint
```

--------------------------------

### Convert values to integer using ToInt

Source: https://github.com/spf13/cast/blob/master/README.md

Converts various types to an integer. Returns 0 if the input is nil or cannot be converted.

```go
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
```

--------------------------------

### Wrap single values in slices

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Non-slice values are wrapped into a single-element slice.

```go
cast.ToStringSlice(42)                  // []string{"42"}
cast.ToStringSlice("hello")             // []string{"hello"}
```

--------------------------------

### Define errorMsg Constant

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Standard format string for conversion errors without underlying causes.

```go
const errorMsg = "unable to cast %#v of type %T to %T"
```

--------------------------------

### Boolean Slice Casting Functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Functions for converting values to []bool. ToBoolSliceE provides error reporting, while ToBoolSlice returns an empty slice on failure.

```go
func ToBoolSliceE(i any) ([]bool, error)
```

```go
func ToBoolSlice(i any) []bool
```

```go
package main
import "github.com/spf13/cast"

func main() {
    s, _ := cast.ToBoolSliceE([]bool{true, false})     // []bool{true, false}
    s, _ := cast.ToBoolSliceE([]any{1, 0, "true"})     // []bool{true, false, true}
    s, _ := cast.ToBoolSliceE([]int{1, 2, 0})          // []bool{true, true, false}
}
```

--------------------------------

### Type Conversion Functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/REFERENCE_GUIDE.md

The library provides a wide range of conversion functions categorized by target type (Boolean, String, Time, Duration, Integer, Float, and Slices). Functions ending in 'E' return an error as a second return value, while standard functions return the zero value on failure.

```APIDOC
## Type Conversion Functions

### Description
Functions to convert input data into specific types. Standard functions return the zero value on failure, while 'E' variants return (value, error).

### Examples
- ToBool(i interface{}) bool
- ToBoolE(i interface{}) (bool, error)
- ToInt(i interface{}) int
- ToIntE(i interface{}) (int, error)
- ToString(i interface{}) string
- ToStringE(i interface{}) (string, error)
- ToFloat64(i interface{}) float64
- ToFloat64E(i interface{}) (float64, error)
```

--------------------------------

### Cast to map[string]bool

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Use ToStringMapBool to convert values to a map[string]bool, returning an empty map if the conversion fails.

```go
func ToStringMapBool(i any) map[string]bool
```

--------------------------------

### Cast to Slice with Default Empty Return

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Use ToSlice to convert a value to a []any slice, returning an empty slice if the conversion fails.

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToSlice([]any{1, 2, 3})    // []any{1, 2, 3}
    cast.ToSlice("invalid")         // []any{}
}
```

--------------------------------

### Cast to map[string][]string

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Uses ToStringMapStringSlice to convert input to a map, returning an empty map if the conversion fails.

```go
func ToStringMapStringSlice(i any) map[string][]string
```

```go
package main
import "github.com/spf13/cast"

func main() {
    m := cast.ToStringMapStringSlice(map[string][]string{
        "colors": {"red", "green", "blue"},
    })
}
```

--------------------------------

### Cast to int

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Converts any value to an int, returning zero if the conversion fails.

```go
func ToInt(i any) int
```

--------------------------------

### Must function signature

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

The generic function signature for the Must helper.

```go
func Must[T any](i any, err error) T
```

--------------------------------

### Cast to time.Time with error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Use ToTimeE to convert values to time.Time with explicit error handling. It supports strings, Unix timestamps, and returns zero time for nil inputs.

```go
func ToTimeE(i any) (time.Time, error)
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    t, _ := cast.ToTimeE("2023-01-15")              // Parsed as date
    t, _ := cast.ToTimeE("2023-01-15T10:30:00Z")    // RFC3339 with UTC
    t, _ := cast.ToTimeE(int64(1673779200))         // Unix timestamp
    cast.ToTimeE(nil)                                // time.Time{}, nil
}
```

--------------------------------

### Perform element-wise slice conversion

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Numeric and boolean slice conversions process each element individually, with numeric types potentially undergoing truncation.

```go
cast.ToIntSlice([]float64{1.9, 2.1, 3.5})  // []int{1, 2, 3} (truncates)
cast.ToBoolSlice([]int{0, 1, 2, -1})       // []bool{false, true, true, true}
```

--------------------------------

### Parse numeric Unix timestamps to time.Time

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Converts integer-based Unix timestamps into time.Time objects.

```go
cast.ToTime(int64(0))              // 1970-01-01 00:00:00 UTC
cast.ToTime(int64(1673779200))     // 2023-01-15 10:00:00 UTC
cast.ToTime(uint32(2147483647))    // 2038-01-19 03:14:07 UTC
```

--------------------------------

### Parse fractional Unix timestamps

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Floating-point timestamps are truncated to the nearest integer second.

```go
cast.ToTime(1673779200.5)          // Treated as 1673779200 (seconds only)
```

--------------------------------

### ToSliceE

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Casts any value to a []any slice type, returning the slice and an error if the conversion fails.

```APIDOC
## func ToSliceE(i any) ([]any, error)

### Description
Casts any value to a []any slice type, with error reporting. If the input cannot be converted to a slice, an error is returned.

### Parameters
- **i** (any) - Required - The value to cast to a slice.

### Returns
- **Value** ([]any) - The converted slice.
- **Error** (error) - Non-nil if the conversion fails.

### Example
```go
s, err := cast.ToSliceE([]any{1, "two", 3.0})
```
```

--------------------------------

### Parse string to time.Time in a specific location

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Parses a string into a time.Time object, interpreting naive times within the provided time.Location.

```go
func StringToDateInDefaultLocation(s string, location *time.Location) (time.Time, error)
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    loc, _ := time.LoadLocation("Asia/Tokyo")
    t, _ := cast.StringToDateInDefaultLocation("2023-01-15", loc)
    // 2023-01-15 00:00:00 +0900 JST (Tokyo time)
}
```

--------------------------------

### Cast to string silently

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Use ToString to convert values to strings, returning an empty string if the conversion fails.

```go
func ToString(i any) string
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToString(42)     // "42"
    cast.ToString(nil)    // ""
}
```

--------------------------------

### ToDuration

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Casts any value to time.Duration, returning zero duration on error.

```APIDOC
## func ToDuration(i any) time.Duration

### Description
Casts any value to time.Duration, returning zero duration on error. Identical behavior to ToDurationE but silently discards errors.

### Parameters
- **i** (any) - Required - Value to cast

### Returns
- **Value** (time.Duration) - Converted duration value (zero on error)
```

--------------------------------

### Cast to time.Time with location silently

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/time-types.md

Use ToTimeInDefaultLocation to convert values to time.Time in a specific location, returning zero time on error.

```go
func ToTimeInDefaultLocation(i any, location *time.Location) time.Time
```

```go
package main
import (
    "time"
    "github.com/spf13/cast"
)

func main() {
    loc, _ := time.LoadLocation("Europe/London")
    cast.ToTimeInDefaultLocation("2023-01-15", loc)  // Parsed in London time
}
```

--------------------------------

### Cast to int with error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Converts any value to an int, returning an error if the conversion fails.

```go
func ToIntE(i any) (int, error)
```

--------------------------------

### Cast to string slice with default return

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Uses ToStringSlice to convert values to []string, returning an empty slice if conversion is not possible.

```go
func ToStringSlice(i any) []string
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToStringSlice([]string{"a", "b", "c"})    // []string{"a", "b", "c"}
    cast.ToStringSlice("one two three")            // []string{"one", "two", "three"}
    cast.ToStringSlice("invalid")                  // []string{} (no conversion possible)
}
```

--------------------------------

### ToString

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Casts any value to a string, returning the zero value (empty string) if an error occurs.

```APIDOC
## func ToString(i any) string

### Description
Casts any value to a string. This function behaves identically to ToStringE but silently discards any errors, returning an empty string on failure.

### Parameters
- **i** (any) - Required - The value to be cast to a string.

### Returns
- **Value** (string) - The converted string value or an empty string if conversion fails.

### Example
```go
cast.ToString(42)     // "42"
cast.ToString(nil)    // ""
```
```

--------------------------------

### Validate and normalize user input

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Uses error-returning cast methods to validate input types and enforce business logic constraints.

```go
package validators

import "github.com/spf13/cast"

func ValidateUserAge(ageInput any) (int, error) {
    age, err := cast.ToIntE(ageInput)
    if err != nil {
        return 0, fmt.Errorf("age must be a number: %w", err)
    }
    if age < 0 || age > 150 {
        return 0, fmt.Errorf("age must be between 0 and 150: got %d", age)
    }
    return age, nil
}
```

--------------------------------

### Cast to Slice with Error Reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Use ToSliceE to convert a value to a []any slice, returning an error if the conversion fails.

```go
package main
import "github.com/spf13/cast"

func main() {
    s, _ := cast.ToSliceE([]any{1, "two", 3.0})     // []any{1, "two", 3.0}
    s, _ := cast.ToSliceE([]map[string]any{{"a": 1}}) // []any{map[string]any{"a": 1}}
}
```

--------------------------------

### Unsigned Integer Slice Casting Functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Functions for converting values to various unsigned integer slice types. These reject negative values during conversion.

```go
func ToUintSliceE(i any) ([]uint, error)
func ToUintSlice(i any) []uint
```

```go
func ToUint8SliceE(i any) ([]uint8, error)
func ToUint8Slice(i any) []uint8
```

```go
func ToUint16SliceE(i any) ([]uint16, error)
func ToUint16Slice(i any) []uint16
```

```go
func ToUint32SliceE(i any) ([]uint32, error)
func ToUint32Slice(i any) []uint32
```

```go
func ToUint64SliceE(i any) ([]uint64, error)
func ToUint64Slice(i any) []uint64
```

--------------------------------

### ToInt / ToIntE

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to an int. ToIntE returns an error on failure, while ToInt returns zero.

```APIDOC
## func ToIntE(i any) (int, error)
## func ToInt(i any) int

### Description
Casts any value to an int type. ToIntE provides error reporting, while ToInt returns zero if the conversion fails.

### Parameters
- **i** (any) - Required - The value to cast.

### Returns
- **Value** (int) - The converted integer value.
- **Error** (error) - Non-nil if conversion fails (ToIntE only).
```

--------------------------------

### Define Type Constraints

Source: https://github.com/spf13/cast/blob/master/_autodocs/README.md

Interfaces defining supported types for generic operations, including basic types and numeric categories.

```go
type Basic interface {
    string | bool | Number | time.Time | time.Duration
}

type Number interface {
    int | int8 | int16 | int32 | int64 |
    uint | uint8 | uint16 | uint32 | uint64 |
    float32 | float64
}
```

--------------------------------

### Cast to uint8

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint8, rejecting negative values.

```go
func ToUint8E(i any) (uint8, error)
func ToUint8(i any) uint8
```

--------------------------------

### Cast to string slice with error reporting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Uses ToStringSliceE to convert values to []string, returning an error if the conversion fails.

```go
func ToStringSliceE(i any) ([]string, error)
```

```go
package main
import "github.com/spf13/cast"

func main() {
    s, _ := cast.ToStringSliceE([]string{"a", "b"})  // []string{"a", "b"}
    s, _ := cast.ToStringSliceE([]any{1, "two", 3})  // []string{"1", "two", "3"}
    s, _ := cast.ToStringSliceE("hello world")       // []string{"hello", "world"}
    s, _ := cast.ToStringSliceE(42)                  // []string{"42"}
}
```

--------------------------------

### Define unsigned constraint

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Internal constraint for unsigned integer operations.

```go
type unsigned interface {
    uint | uint8 | uint16 | uint32 | uint64
}
```

--------------------------------

### ToInt64 / ToInt64E

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to an int64.

```APIDOC
## func ToInt64E(i any) (int64, error)
## func ToInt64(i any) int64

### Description
Casts any value to an int64 type.

### Parameters
- **i** (any) - Required - Value to cast.

### Returns
- **Value** (int64) - Converted int64 value.
- **Error** (error) - Non-nil if conversion fails (ToInt64E only).

### Example
```go
cast.ToInt64("9223372036854775807")    // max int64
cast.ToInt64(3.14)                     // 3 (truncated)
cast.ToInt64E("invalid")               // 0, error
```
```

--------------------------------

### Define float64EProvider interface

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Interface for types that can provide a float64 value with error reporting.

```go
type float64EProvider interface {
    Float64() (float64, error)
}
```

```go
type Measurement struct {
    value float64
    valid bool
}

func (m Measurement) Float64() (float64, error) {
    if !m.valid {
        return 0, fmt.Errorf("measurement invalid")
    }
    return m.value, nil
}

// Can be converted using cast.ToFloat64E
result, err := cast.ToFloat64E(Measurement{3.14, true})
```

--------------------------------

### Cast to uint16

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/numeric-types.md

Casts any value to uint16, rejecting negative values.

```go
func ToUint16E(i any) (uint16, error)
func ToUint16(i any) uint16
```

--------------------------------

### ToStringMapBool

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/map-types.md

Casts any value to map[string]bool, returning an empty map if the conversion fails.

```APIDOC
## func ToStringMapBool(i any) map[string]bool

### Description
Casts any value to map[string]bool, returning empty map on error.

### Parameters
- **i** (any) - Required - Value to cast

### Returns
- **Value** (map[string]bool) - Converted map (empty on error)
```

--------------------------------

### ToStringSlice

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Converts input values into a slice of strings. It handles arrays, splits strings by whitespace, and wraps single values into a single-element slice.

```APIDOC
## ToStringSlice(i interface{}) []string

### Description
Converts the provided input into a slice of strings. Arrays are converted via reflection, strings are split by whitespace, and other types are wrapped as a single element.

### Examples
```go
cast.ToStringSlice([3]string{"a", "b", "c"}) // []string{"a", "b", "c"}
cast.ToStringSlice("one two three")           // []string{"one", "two", "three"}
cast.ToStringSlice(42)                        // []string{"42"}
```
```

--------------------------------

### Integer Slice Casting Functions

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Functions for converting values to various integer slice types. These include standard int, int8, int16, int32, and int64 variants.

```go
func ToIntSliceE(i any) ([]int, error)
```

```go
func ToIntSlice(i any) []int
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToIntSlice([]int{1, 2, 3})            // []int{1, 2, 3}
    cast.ToIntSlice([]any{"1", 2, 3.5})        // []int{1, 2, 3}
    cast.ToIntSlice([]string{"10", "20"})      // []int{10, 20}
}
```

```go
func ToInt8SliceE(i any) ([]int8, error)
func ToInt8Slice(i any) []int8
```

```go
func ToInt16SliceE(i any) ([]int16, error)
func ToInt16Slice(i any) []int16
```

```go
func ToInt32SliceE(i any) ([]int32, error)
func ToInt32Slice(i any) []int32
```

```go
func ToInt64SliceE(i any) ([]int64, error)
func ToInt64Slice(i any) []int64
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.ToInt64Slice([]int64{100, 200, 300})       // []int64{100, 200, 300}
    cast.ToInt64Slice([]any{10, "20", 30.0})        // []int64{10, 20, 30}
}
```

--------------------------------

### Generic To Casting

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/basic-types.md

Casts any value to a Basic type, returning the zero value if an error occurs.

```go
func To[T Basic](i any) T
```

```go
package main
import "github.com/spf13/cast"

func main() {
    cast.To[int]("42")      // 42
    cast.To[string](3.14)   // "3.14"
    cast.To[bool]("invalid")// false
}
```

--------------------------------

### Define integer constraint

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Internal constraint for signed integer operations.

```go
type integer interface {
    int | int8 | int16 | int32 | int64
}
```

--------------------------------

### ToIntSlice

Source: https://github.com/spf13/cast/blob/master/_autodocs/api-reference/slice-types.md

Converts input slices into a slice of integers using element-wise conversion.

```APIDOC
## ToIntSlice(i interface{}) []int

### Description
Converts elements of a slice to integers. Numeric values are truncated if necessary.

### Examples
```go
cast.ToIntSlice([]float64{1.9, 2.1, 3.5}) // []int{1, 2, 3}
```
```

--------------------------------

### Define Basic type constraint

Source: https://github.com/spf13/cast/blob/master/_autodocs/types.md

Constraint for functions accepting basic types that the package can cast to.

```go
type Basic interface {
    string | bool | Number | time.Time | time.Duration
}
```
Tokens:
Raw