Skip to main content

Type manipulation - Core helpers

This page lists all type operations available in the core package of lo.

Help improve this documentation

This documentation is still new and evolving. If you spot any mistakes, unclear explanations, or missing details, please open an issue.

Your feedback helps us improve!

  • Nil​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns a nil pointer of type.

    lo.Nil[string]()
    // (*string)(nil)

    lo.Nil[int]()
    // (*int)(nil)

    Useful when you need a nil pointer of a specific type without declaring a variable first.

    Similar:
    fromptrisnilisnotniltoptr
    Prototype:
    func Nil[T any]() *T

  • IsNil​

    typecore
    🧩 Source📚 GoDoc

    Returns true if the input is nil or points to a nil value. This works with pointers, interfaces, maps, slices, channels, and functions.

    result := lo.IsNil(nil)
    // true

    var ptr *int
    result = lo.IsNil(ptr)
    // true

    result = lo.IsNil(42)
    // false

    result = lo.IsNil("hello")
    // false

    var iface interface{}
    result = lo.IsNil(iface)
    // true

    iface = 42
    result = lo.IsNil(iface)
    // false
    Similar:
    emptyisemptyisnotemptyisnotnil
    Prototype:
    func IsNil(x any) bool

  • IsNotNil​

    typecore
    🧩 Source📚 GoDoc

    Returns true if the input is not nil and does not point to a nil value. This works with pointers, interfaces, maps, slices, channels, and functions.

    result := lo.IsNotNil(nil)
    // false

    var ptr *int
    result = lo.IsNotNil(ptr)
    // false

    result = lo.IsNotNil(42)
    // true

    result = lo.IsNotNil("hello")
    // true

    var iface interface{}
    result = lo.IsNotNil(iface)
    // false

    iface = 42
    result = lo.IsNotNil(iface)
    // true
    Similar:
    emptyisemptyisnilisnotempty
    Prototype:
    func IsNotNil(x any) bool

  • ToPtr​

    typecore
    🧩 Source📚 GoDoc

    Returns a pointer to the provided value.

    ptr := lo.ToPtr(42)
    // *int pointing to 42

    ptr = lo.ToPtr("hello")
    // *string pointing to "hello"

    ptr = lo.ToPtr([]int{1, 2, 3})
    // *[]int pointing to []int{1, 2, 3}
    Similar:
    emptyabletoptrfromptrfromptrorfromsliceptrtosliceptr
    Prototype:
    func ToPtr[T any](x T) *T

  • FromPtr​

    typecore
    🧩 Source📚 GoDoc

    Dereferences a pointer and returns the underlying value. If the pointer is nil, returns the zero value for the type. This is a safe way to extract values from optional pointers without risking panics.

    ptr := lo.ToPtr(42)
    value := lo.FromPtr(ptr)
    // value: 42

    value = lo.FromPtr[string](nil)
    // value: "" (zero value for string)

    value = lo.FromPtr[int](nil)
    // value: 0 (zero value for int)

    // Working with structs
    type Person struct {
        Name string
        Age  int
    }
    var personPtr *Person
    person := lo.FromPtr(personPtr)
    // person: Person{Name: "", Age: 0} (zero value for Person)
    Similar:
    emptyabletoptrfromptrorfromsliceptrtoptrtosliceptr
    Prototype:
    func FromPtr[T any](x *T) T

  • FromPtrOr​

    typecore
    🧩 Source📚 GoDoc

    Returns the value pointed to by the pointer, or the fallback value if the pointer is nil.

    ptr := lo.ToPtr(42)
    value := lo.FromPtrOr(ptr, 0)
    // 42

    value = lo.FromPtrOr[string](nil, "default")
    // "default"

    value = lo.FromPtrOr[int](nil, -1)
    // -1

    ptr = nil
    value = lo.FromPtrOr(ptr, 999)
    // 999
    Similar:
    emptyabletoptrfromptrfromsliceptrtoptrtosliceptrvalueor
    Prototype:
    func FromPtrOr[T any](x *T, fallback T) T

  • EmptyableToPtr​

    typecore
    🧩 Source📚 GoDoc

    Returns a pointer to the provided value, or nil if the value is empty (zero value). This is useful for avoiding pointers to empty values.

    ptr := lo.EmptyableToPtr("")
    // nil (because empty string is zero value)

    ptr = lo.EmptyableToPtr("hello")
    // *string pointing to "hello"

    ptr = lo.EmptyableToPtr(0)
    // nil (because 0 is zero value for int)

    ptr = lo.EmptyableToPtr(42)
    // *int pointing to 42
    Similar:
    fromptrfromptrorfromsliceptrtoptrtosliceptr
    Prototype:
    func EmptyableToPtr[T any](x T) *T

  • ToSlicePtr​

    typecore
    🧩 Source📚 GoDoc

    Converts a slice of values to a slice of pointers to those values.

    slice := []int{1, 2, 3}
    ptrs := lo.ToSlicePtr(slice)
    // []*int{&1, &2, &3}

    slice = []string{"a", "b", "c"}
    ptrs = lo.ToSlicePtr(slice)
    // []*string{&"a", &"b", &"c"}

    slice = []int{}
    ptrs = lo.ToSlicePtr(slice)
    // []*int{}
    Similar:
    emptyabletoptrfromptrfromptrorfromsliceptrtoptr
    Prototype:
    func ToSlicePtr[T any](collection []T) []*T

  • FromSlicePtr​

    typecore
    🧩 Source📚 GoDoc

    Converts a slice of pointers to a slice of values. Nil pointers are converted to zero values.

    a, b, c := 1, 2, 3
    ptrs := []*int{&a, &b, &c}
    slice := lo.FromSlicePtr(ptrs)
    // []int{1, 2, 3}

    a, b = "hello", "world"
    ptrs = []*string{&a, nil, &b}
    slice = lo.FromSlicePtr(ptrs)
    // []string{"hello", "", "world"} (nil pointer becomes zero value)

    ptrs = []*int{}
    slice = lo.FromSlicePtr(ptrs)
    // []int{}
    Similar:
    emptyabletoptrfromptrfromptrortoptrtosliceptr
    Prototype:
    func FromSlicePtr[T any](collection []*T) []T

  • Empty​

    typecore
    🧩 Source📚 GoDoc

    Returns the zero value for the specified type. This is useful when you need an empty value of a specific type.

    result := lo.Empty[string]()
    // "" (zero value for string)

    result = lo.Empty[int]()
    // 0 (zero value for int)

    result = lo.Empty[[]int]()
    // []int{} (zero value for slice)

    result = lo.Empty[map[string]int]()
    // map[string]int{} (zero value for map)

    result = lo.Empty[*int]()
    // nil (zero value for pointer)
    Similar:
    coalescemaporemptycoalesceoremptycoalescesliceoremptyisemptyisnotempty
    Prototype:
    func Empty[T any]() T

  • IsEmpty​

    typecore
    🧩 Source📚 GoDoc

    Returns true if the value is empty (zero value) for comparable types. This works with strings, numbers, slices, maps, pointers, etc.

    result := lo.IsEmpty("")
    // true (empty string)

    result = lo.IsEmpty("hello")
    // false

    result = lo.IsEmpty(0)
    // true (zero value for int)

    result = lo.IsEmpty(42)
    // false

    result = lo.IsEmpty([]int{})
    // true (empty slice)

    result = lo.IsEmpty([]int{1, 2, 3})
    // false

    result = lo.IsEmpty(map[string]int{})
    // true (empty map)

    var ptr *int
    result = lo.IsEmpty(ptr)
    // true (nil pointer)
    Similar:
    emptyisnilisnotemptyisnotnil
    Prototype:
    func IsEmpty[T comparable](v T) bool

  • IsNotEmpty​

    typecore
    🧩 Source📚 GoDoc

    Returns true if the value is not empty (not zero value) for comparable types. This is the opposite of IsEmpty.

    result := lo.IsNotEmpty("")
    // false (empty string)

    result = lo.IsNotEmpty("hello")
    // true

    result = lo.IsNotEmpty(0)
    // false (zero value for int)

    result = lo.IsNotEmpty(42)
    // true

    result = lo.IsNotEmpty([]int{})
    // false (empty slice)

    result = lo.IsNotEmpty([]int{1, 2, 3})
    // true

    result = lo.IsNotEmpty(map[string]int{})
    // false (empty map)

    var ptr *int
    result = lo.IsNotEmpty(ptr)
    // false (nil pointer)
    Similar:
    emptyisemptyisnilisnotnil
    Prototype:
    func IsNotEmpty[T comparable](v T) bool

  • ToAnySlice​

    typecore
    🧩 Source📚 GoDoc

    Converts a typed slice to a slice of empty interface values (any). This is useful when working with heterogeneous data.

    ints := []int{1, 2, 3}
    result := lo.ToAnySlice(ints)
    // []any{1, 2, 3}

    strings := []string{"a", "b", "c"}
    result = lo.ToAnySlice(strings)
    // []any{"a", "b", "c"}

    custom := []struct{ Name string }{{Name: "Alice"}, {Name: "Bob"}}
    result = lo.ToAnySlice(custom)
    // []any{struct{ Name string }{Name: "Alice"}, struct{ Name string }{Name: "Bob"}}
    Similar:
    fromanyslicefromsliceptrtosliceptr
    Prototype:
    func ToAnySlice[T any](collection []T) []any

  • FromAnySlice​

    typecore
    🧩 Source📚 GoDoc

    Converts a slice of empty interface values back to a typed slice. Returns the converted slice and a boolean indicating success. All elements must be of the target type.

    data := []any{1, 2, 3}
    result, ok := lo.FromAnySlice[int](data)
    // []int{1, 2, 3}, true

    data = []any{"a", "b", "c"}
    result, ok = lo.FromAnySlice[string](data)
    // []string{"a", "b", "c"}, true

    data = []any{1, "b", 3} // mixed types
    result, ok = lo.FromAnySlice[int](data)
    // []int{}, false (conversion failed due to string element)

    data = []any{} // empty slice
    result, ok = lo.FromAnySlice[int](data)
    // []int{}, true (empty slice always succeeds)
    Similar:
    fromsliceptrtoanyslicetosliceptr
    Prototype:
    func FromAnySlice[T any](in []any) ([]T, bool)

  • Coalesce​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-zero value from the provided comparable arguments, with a boolean indicating if a non-zero value was found.

    // With strings - returns first non-empty string
    result, ok := lo.Coalesce("", "foo", "bar")
    // result: "foo", ok: true

    // All zero values - returns zero value with false
    result, ok = lo.Coalesce("", "")
    // result: "", ok: false

    // With integers - zero is considered zero value
    result, ok = lo.Coalesce(0, 42, 100)
    // result: 42, ok: true

    // With floats - zero is considered zero value
    result, ok = lo.Coalesce(0.0, 3.14, 2.71)
    // result: 3.14, ok: true

    // With pointers - nil is zero value for pointer types
    var s *string
    str := "hello"
    result, ok = lo.Coalesce(nil, &str)
    // result: &str, ok: true

    // All nil pointers
    result, ok = lo.Coalesce[*string](nil, nil, nil)
    // result: nil, ok: false
    Similar:
    coalescemapcoalescemaporemptycoalesceoremptycoalesceslicecoalescesliceoremptyemptyfromptrorvalueor
    Prototype:
    func Coalesce[T comparable](values ...T) (T, bool)

  • CoalesceOrEmpty​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-zero value from the provided comparable arguments, or the zero value if all arguments are zero.

    result := lo.CoalesceOrEmpty("", "foo", "bar")
    // "foo"

    result = lo.CoalesceOrEmpty("", "")
    // ""

    result = lo.CoalesceOrEmpty(0, 42, 100)
    // 42

    result = lo.CoalesceOrEmpty(0.0, 0.0, 0.0)
    // 0.0
    Similar:
    coalescecoalescemapcoalescemaporemptycoalesceslicecoalescesliceoremptyemptyvalueor
    Prototype:
    func CoalesceOrEmpty[T comparable](v ...T) T

  • CoalesceSlice​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-empty slice from the provided arguments, with a boolean indicating if a non-empty slice was found.

    result, ok := lo.CoalesceSlice([]int{}, []int{1, 2, 3}, []int{4, 5})
    // []int{1, 2, 3}, true

    result, ok = lo.CoalesceSlice([]int{}, []int{})
    // []int{}, false

    result, ok = lo.CoalesceSlice([]string{}, []string{"a", "b"}, []string{"c"})
    // []string{"a", "b"}, true
    Similar:
    coalescecoalescemapcoalescemaporemptycoalesceoremptycoalescesliceoremptyempty
    Prototype:
    func CoalesceSlice[T any](v ...[]T) ([]T, bool)

  • CoalesceSliceOrEmpty​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-empty slice from the provided arguments, or an empty slice if all arguments are empty.

    result := lo.CoalesceSliceOrEmpty([]int{}, []int{1, 2, 3}, []int{4, 5})
    // []int{1, 2, 3}

    result = lo.CoalesceSliceOrEmpty([]int{}, []int{})
    // []int{}

    result = lo.CoalesceSliceOrEmpty([]string{}, []string{"a", "b"}, []string{"c"})
    // []string{"a", "b"}
    Similar:
    coalescecoalescemapcoalescemaporemptycoalesceoremptycoalescesliceempty
    Prototype:
    func CoalesceSliceOrEmpty[T any](v ...[]T) []T

  • CoalesceMap​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-empty map from the provided arguments, with a boolean indicating if a non-empty map was found.

    result, ok := lo.CoalesceMap(map[string]int{}, map[string]int{"a": 1}, map[string]int{"b": 2})
    // map[string]int{"a": 1}, true

    result, ok = lo.CoalesceMap(map[string]int{}, map[string]int{})
    // map[string]int{}, false

    result, ok = lo.CoalesceMap(map[int]string{}, map[int]string{1: "one"}, map[int]string{2: "two"})
    // map[int]string{1: "one"}, true
    Similar:
    coalescecoalescemaporemptycoalesceoremptycoalesceslicecoalescesliceoremptyempty
    Prototype:
    func CoalesceMap[K comparable, V any](v ...map[K]V) (map[K]V, bool)

  • CoalesceMapOrEmpty​

    typecore
    🧩 Source📚 GoDoc🎮 Try on Go Playground

    Returns the first non-empty map from the provided arguments, or an empty map if all arguments are empty.

    result := lo.CoalesceMapOrEmpty(map[string]int{}, map[string]int{"a": 1}, map[string]int{"b": 2})
    // map[string]int{"a": 1}

    result = lo.CoalesceMapOrEmpty(map[string]int{}, map[string]int{})
    // map[string]int{}

    result = lo.CoalesceMapOrEmpty(map[int]string{}, map[int]string{1: "one"}, map[int]string{2: "two"})
    // map[int]string{1: "one"}
    Similar:
    coalescecoalescemapcoalesceoremptycoalesceslicecoalescesliceoremptyempty
    Prototype:
    func CoalesceMapOrEmpty[K comparable, V any](v ...map[K]V) map[K]V