core

package module

v0.6.4 Latest Latest Go to latest Published: Feb 1, 2026 License: MIT Imports: 19 Imported by: 47

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/gildas/go-core

README ¶

go-core

My core stuff with types, code, etc that I use almost everywhere

Slice generics

These functions were added before the Go standard library added generics support for slices in the slices package. While some of these functions are now available in the standard library, others are still not available. Wherever possible, prefer using the standard library functions (my functions will revert to using the standard library functions when possible).

Contains

You can check if a slice contains a value with Contains method:

slice := []int{1, 2, 3, 4, 5}

fmt.Println(core.Contains(slice, 4)) // true
fmt.Println(core.Contains(slice, 6)) // false

Contains works with all comparable types.

If the slice type is more complex, you can use ContainsWithFunc method:

type User struct {
  ID int
  Name string
}

slice := []User{
  {ID: 1, Name: "John"},
  {ID: 2, Name: "Jane"},
  {ID: 3, Name: "Bob"},
}

fmt.Println(core.ContainsWithFunc(slice, User{Name: "John"}, func(item, john User) bool {
  return item.Name == john.Name
})) // true

If the struct implements the core.Named interface, you can use the core.MatchNamed method:

fmt.Println(core.ContainsWithFunc(slice, User{Name: "John"}, core.MatchNamed)) // true

Same goes for core.Identifiable and core.StringIdentifiable interfaces.

Find

You can find a value in a slice with Find method:

slice := []int{1, 2, 3, 4, 5}
number, found := core.Find(slice, 4)

Find works with all comparable types.

If the slice type is more complex, you can use FindWithFunc method:

type User struct {
  ID int
  Name string
}

slice := []User{
  {ID: 1, Name: "John"},
  {ID: 2, Name: "Jane"},
  {ID: 3, Name: "Bob"},
}

user, found := core.FindWithFunc(slice, User{Name: "John"}, func(a, b User) bool {
  return a.Name == b.Name
})

If the struct implements the core.Named interface, you can use the core.MatchNamed method:

fmt.Println(core.FindWithFunc(slice, User{Name: "John"}, core.MatchNamed)) // true

Same goes for core.Identifiable and core.StringIdentifiable interfaces.

EqualSlices

You can check if two slices are equal with EqualSlices method:

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{1, 2, 3, 4, 5}

fmt.Println(core.EqualSlices(slice1, slice2)) // true

EqualSlices works with all comparable types.

If the slice type is more complex, you can use EqualSlicesWithFunc method:

type User struct {
  ID int
  Name string
}

slice1 := []User{
  {ID: 1, Name: "John"},
  {ID: 2, Name: "Jane"},
  {ID: 3, Name: "Bob"},
}

slice2 := []User{
  {ID: 1, Name: "John"},
  {ID: 2, Name: "Jane"},
  {ID: 3, Name: "Bob"},
}

fmt.Println(core.EqualSlicesWithFunc(slice1, slice2, func(a, b User) bool {
  return a.Name == b.Name
})) // true

Filter

You can filter a slice with Filter method:

slice := []int{1, 2, 3, 4, 5}

fmt.Println(core.Filter(slice, func(element int) bool {
  return element > 3
})) // [4 5]

Join

You can join a slice with Join method:

slice := []int{1, 2, 3, 4, 5}

fmt.Println(core.Join(slice, ",")) // 1,2,3,4,5

If the slice type is more complex, you can use JoinWithFunc method:

type User struct {
  ID int
  Name string
}

slice := []User{
  {ID: 1, Name: "John"},
  {ID: 2, Name: "Jane"},
  {ID: 3, Name: "Bob"},
}

fmt.Println(core.JoinWithFunc(slice, ",", func(element User) string {
  return element.Name
})) // John,Jane,Bob

Map

You can map a slice with Map method:

slice := []int{1, 2, 3, 4, 5}

fmt.Println(core.Map(slice, func(element int) int {
  return element * 2
})) // [2 4 6 8 10]

The returned slice is a new slice, the original slice is not modified.

Reduce

You can reduce a slice with Reduce method:

slice := []int{1, 2, 3, 4, 5}

fmt.Println(core.Reduce(slice, func(accumulator, element int) int {
  return accumulator + element
})) // 15

Sort

You can sort a slice with Sort method:

slice := []int{5, 2, 3, 1, 4}

fmt.Println(core.Sort(slice, func(a, b int) {
  return a < b
})) // [1 2 3 4 5]

The Sort method is an in-place sort, the original slice is modified.

The Sort method is now calling the slices.SortFunc from the standard library.

Convert to/from []any

You can convert a slice to/from []any with ToAnySlice and FromAnySlice methods:

slice := []int{1, 2, 3, 4, 5}
anySlice := core.ConvertToAnySlice(slice)
fmt.Println(anySlice) // [1 2 3 4 5]
newSlice := core.ConvertFromAnySlice[int](anySlice)
fmt.Println(newSlice) // [1 2 3 4 5]

If the []any slice came from a JSON unmarshalling, FromAnySlice will marshal/unmarshal each element to convert it to the target type.

type Person struct {
  Name string
  Age  int
}
var anySlice []any

_ = json.Unmarshal([]byte(`[{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}]`), &anySlice)
personSlice := core.ConvertFromAnySlice[Person](anySlice)
fmt.Println(personSlice) // [{Alice 30} {Bob 25}]

Time and Duration helpers

The core.Time mimics the time.Time and adds JSON serialization support to and from RFC 3339 time strings.

The core.Duration mimics the time.Duration and adds JSON serialization support to and from duration strings. Its core.ParseDuration also understands most of the ISO 8601 duration formats. It marshals to milliseconds. It can unmarshal from milliseconds, GO duration strings, and ISO 8601 duration strings.

Example:

type User struct {
  Name      string
  CreatedAt core.Time
  Duration  core.Duration
}

user := User{
  Name:      "John",
  CreatedAt: core.Now(),
  Duration:  core.Duration(5 * time.Second),
}

data, err := json.Marshal(user)
if err != nil {
  panic(err)
}

fmt.Println(string(data))
// {"Name":"John","CreatedAt":"2021-01-01T00:00:00Z","Duration":"5000"}

string.Replace(string(data), "5000", "PT5S", 1)

var user2 User
err = json.Unmarshal(data, &user2)
if err != nil {
  panic(err)
}
fmt.Println(user2.Duration) // 5s

The core.Timestamp type is an alias for core.Time and it is used to represent timestamps in milliseconds. It marshals into milliseconds and unmarshals from milliseconds (string or integer).

Environment Variable helpers

You can get an environment variable with GetEnvAsX methods, where X is one of bool, time.Duration, int, string, time.Time, url.URL, uuid.UUID, if the environment variable is not set or the conversion fails, the default value is returned.

Example:

// GetEnvAsBool
v := core.GetEnvAsBool("ENV_VAR", false)
// GetEnvAsDuration
v := core.GetEnvAsDuration("ENV_VAR", 5 * time.Second)
// GetEnvAsString
v := core.GetEnvAsString("ENV_VAR", "default")
// GetEnvAsTime
v := core.GetEnvAsTime("ENV_VAR", time.Now())
// GetEnvAsURL
v := core.GetEnvAsURL("ENV_VAR", &url.URL{Scheme: "https", Host: "example.com"})
// GetEnvAsUUID
v := core.GetEnvAsUUID("ENV_VAR", uuid.New())

Notes:

GetEnvAsBool returns true if the environment variable is set to true, 1, on or yes, otherwise it returns false. It is also case-insensitive.
GetEnvAsDuration accepts any duration string that can be parsed by core.ParseDuration, see below in the Time and Duration Helpers section.
GetEnvAsTime accepts an RFC 3339 time string.
GetEnvAsURL fallback can be a url.URL, a *url.URL, or a string.

Common Interfaces

The core.Identifiable interface is used to represent an object that has an ID in the form of a uuid.UUID.

The core.StringIdentifiable interface is used to represent an object that has an ID in the form of a string.

The core.Named interface is used to represent an object that has a name in the form of a string.

The core.TypeCarrier interface is used to represent an object that has a type in the form of a string.

The core.IsZeroer interface is used to represent an object that can be checked if it is zero. This interace is compatible with the IsZero method used by the encoding/json package.

The core.GoString interface is used to represent an object that can be converted to a Go string.

HTTP Response helpers

core.RespondWithJSON is a helper function that marshals a payload into an http.ResponseWriter as JSON. It also sets the Content-Type header to application/json.

core.RespondWithHTMLTemplate is a helper function that executes a template on a given data and writes the result into an http.ResponseWriter. It also sets the Content-Type header to text/html.

core.RespondWithError is a helper function that marshals an error into an http.ResponseWriter as JSON. It also sets the Content-Type header to application/json.

The core.GetReference function gets a reference of an object, if the object implements core.Identifiable, core.StringIdentifiable, or fmt.Stringer, the reference will use the ID, otherwise it will return the object itself.

Example:

type User struct {
  ID uuid.UUID
  Name string
}
func (user User) GetID() uuid.UUID {
  return user.ID
}

core.RespondWithJSON(w, http.StatusAccepted, core.GetReference(user)) // this will send a response like {"id": "12345678-1234-5678-1234-567812345678"}

The core.Decorate function gets a decorated object of an object, if the object implements core.Identifiable, core.StringIdentifiable, or fmt.Stringer, the decorated object will contain the object and a selfURI field.

Example:

type User struct {
  ID uuid.UUID
  Name string
}

func (user User) GetID() uuid.UUID {
  return user.ID
}

core.RespondWithJSON(w, http.StatusAccepted, core.Decorate(user, "/users"))
// this will send a response like:
//  {"id": "12345678-1234-5678-1234-567812345678", "selfURI": "/users/12345678-1234-5678-1234-567812345678"}

Type Registries

core.TypeRegistry is a type registry that can be used to unmarshal JSON core.TypeCarrier objects into the correct type:

type User struct {
  ID   uuid.UUID
  Name string
}

func (user User) GetType() string {
  return "user"
}

type Product struct {
  ID   uuid.UUID
  Name string
}

func (product Product) GetType() string {
  return "product"
}

registry := core.TypeRegistry{}

registry.Add(User{}, Product{})

var user User

err := registry.UnmarshalJSON([]byte(`{"type": "user", "ID": "00000000-0000-0000-0000-000000000000", "Name": "John"}`), &user)
if err != nil {
  panic(err)
}

fmt.Println(user)

registry := core.CaseInsensitiveTypeRegistry{}

registry.Add(User{}, Product{})

var user User

err := registry.UnmarshalJSON([]byte(`{"type": "UsEr", "ID": "00000000-0000-0000-0000-000000000000", "Name": "John"}`), &user)
if err != nil {
  panic(err)
}

fmt.Println(user)

Notes:

The default JSON property name for the type is type, but it can be changed by adding strings to the UnmarshalJSON method.

Miscellaneous

core.ExecEvery executes a function every duration:

stop, ping, change := core.ExecEvery(5 * time.Second, func() {
  fmt.Println("ping")
})

time.Sleep(15 * time.Second)
change <- 10 * time.Second
time.Sleep(15 * time.Second)
stop <- true

Notes:

stop is a channel that can be used to stop the execution.
ping is a channel that can be used to force the execution of the func at any time.
change is a channel that can be used to change the execution duration.

core.FlexInt, core.FlexInt8, core.FlexInt16, core.FlexInt32, core.FlexInt64 are types that can be unmarshalled from a string or an integer:

type User struct {
  ID core.FlexInt
}

user := User{}
json.Unmarshal([]byte(`{"ID": 1}`), &user)
json.Unmarshal([]byte(`{"ID": "1"}`), &user)

core.Must is a helper function that panics if the error is not nil from a function that returns a value and an error:

func DoSomething() (string, error) {
  return "", errors.New("error")
}

func main() {
  value := core.Must(DoSomething()).(string)
}

core.URL is an alias for url.URL that marshals as a string and unmarshals from a string. When unmarshaling, if the value is nil or empty, the unmarshaled value is nil (it is not considered as an error).

core.UUID is an alias for uuid.UUID that marshals as a string and unmarshals from a string. When unmarshaling, if the value is nil or empty, the unmarshaled value is uuid.Nil (it is not considered as an error). It also implements the fmt.Stringer, core.Identifiable and core.IsZeroer interfaces.

You can cap strings with core.CappedString:

str := "Hello, World!"
cappedStr := core.CappedString(str, 8)
fmt.Println(cappedStr) // Hello...

You can give your own suffix to the capped string:

str := "Hello, World!"
cappedStr := core.CappedStringWithSuffix(str, 8, "***")
fmt.Println(cappedStr) // Hello***

Documentation ¶

Overview ¶

This package contains various helpers for the Go language

Index ¶

Variables
func Atoi(value string, fallback int) int
func CappedString(s string, length int) string
func CappedStringWith(s string, length int, suffix string) string
func Contains[S ~[]T, T comparable](slice S, value T) bool
func ContainsWithFunc[S ~[]T, T any](slice S, value T, predicate func(item T, value T) bool) bool
func ConvertFromAnySlice[T any](items []any) []T
func ConvertToAnySlice[S ~[]T, T any](items S) []any
func DecodeUUID(encoded string) (uuid.UUID, error)
func EncodeUUID(uuid uuid.UUID) string
func EqualIdentifiable[T Identifiable](a, b T) bool
func EqualNamed[T Named](a, b T) bool
func EqualSlices[S ~[]T, T comparable](a, b S) bool
func EqualSlicesWithFunc[S ~[]T, T any](a, b S, compare func(T, T) bool) bool
func EqualStringIdentifiable[T StringIdentifiable](a, b T) bool
func ExecEvery(job func(tick int64, at time.Time, changeme chan time.Duration), ...) (chan bool, chan bool, chan time.Duration)
func ExponentialBackoff(attempt int, initialDelay time.Duration, maxDelay time.Duration, ...) time.Duration
func Filter[S ~[]T, T any](items S, filter func(T) bool) (result []T)
func Find[S ~[]T, T comparable](items S, value T) (t T, found bool)
func FindWithFunc[S ~[]T, T any](items S, predicate func(T) bool) (t T, found bool)
func GetEnvAsBool(name string, fallback bool) bool
func GetEnvAsDuration(name string, fallback time.Duration) time.Duration
func GetEnvAsInt(name string, fallback int) int
func GetEnvAsString(name, fallback string) string
func GetEnvAsTime(name string, fallback time.Time) time.Time
func GetEnvAsURL(name string, fallback any) *url.URL
func GetEnvAsUUID(name string, fallback uuid.UUID) uuid.UUID
func GetReference(element any) any
func Join[S ~[]T, T fmt.Stringer](items S, separator string) string
func JoinWithFunc[S ~[]T, T any](items S, separator string, stringer func(item T) string) string
func Map[S ~[]T, T any, R any](items S, mapper func(T) R) (result []R)
func MapJoin[K comparable, T any](maps ...map[K]T) map[K]T
func MatchIdentifiable[T Identifiable](search T) func(T) bool
func MatchNamed[T Named](search T) func(T) bool
func MatchStringIdentifiable[T StringIdentifiable](search T) func(T) bool
func Must[T any](value T, err error) T
func ParseDuration(value string) (duration time.Duration, err error)
func Reduce[T any, R any](items []T, initial R, reducer func(R, T) R) (result R)
func RespondWithError(w http.ResponseWriter, code int, err error)
func RespondWithHTMLTemplate(w http.ResponseWriter, code int, template *template.Template, name string, ...)
func RespondWithJSON(w http.ResponseWriter, code int, payload any)
func Sort[S ~[]T, T any](items S, sorter func(T, T) bool)
type CaseInsensitiveTypeRegistry
- func (registry CaseInsensitiveTypeRegistry) Add(classes ...TypeCarrier) CaseInsensitiveTypeRegistry
- func (registry CaseInsensitiveTypeRegistry) SupportedTypes() []string
- func (registry CaseInsensitiveTypeRegistry) UnmarshalJSON(payload []byte, typetag ...string) (any, error)
type DecoratedResource
- func Decorate(item any, rootpath string) *DecoratedResource
- func DecorateAll[S ~[]T, T any](items S, rootpath string) []DecoratedResource
- func DecorateWithURL(item any, root url.URL) *DecoratedResource
- func (resource DecoratedResource) MarshalJSON() ([]byte, error)
- func (resource DecoratedResource) ResourceName() string
type Duration
- func (duration Duration) AsDuration() time.Duration
- func (duration Duration) MarshalJSON() ([]byte, error)
- func (duration Duration) String() string
- func (duration Duration) ToISO8601() string
- func (duration *Duration) UnmarshalJSON(payload []byte) (err error)
type FlexInt
- func (i *FlexInt) UnmarshalJSON(payload []byte) error
type FlexInt8
- func (i *FlexInt8) UnmarshalJSON(payload []byte) error
type FlexInt16
- func (i *FlexInt16) UnmarshalJSON(payload []byte) error
type FlexInt32
- func (i *FlexInt32) UnmarshalJSON(payload []byte) error
type FlexInt64
- func (i *FlexInt64) UnmarshalJSON(payload []byte) error
type GoString
type Identifiable
type IsZeroer
type Named
type StringIdentifiable
type Time
- func Date(year int, month time.Month, day, hour, min, sec, nsec int, loc *time.Location) Time
- func DateUTC(year int, month time.Month, day, hour, min, sec, nsec int) Time
- func Now() Time
- func NowIn(loc *time.Location) Time
- func NowUTC() Time
- func ParseTime(value string) (Time, error)
- func ParseTimeIn(value string, loc *time.Location) (Time, error)
- func (t Time) After(u Time) bool
- func (t Time) AsTime() time.Time
- func (t Time) Before(u Time) bool
- func (t Time) BeginOfDay() Time
- func (t Time) Date() (year int, month time.Month, day int)
- func (t Time) EndOfDay() Time
- func (t Time) Equal(u Time) bool
- func (t Time) Format(layout string) string
- func (t Time) IsZero() bool
- func (t Time) Location() *time.Location
- func (t Time) MarshalJSON() ([]byte, error)
- func (t Time) String() string
- func (t Time) Tomorrow() Time
- func (t Time) UTC() Time
- func (t *Time) UnmarshalJSON(payload []byte) (err error)
- func (t Time) Yesterday() Time
type Timestamp
- func TimestampFromJSEpoch(epoch int64) Timestamp
- func TimestampNow() Timestamp
- func (t Timestamp) JSEpoch() int64
- func (t Timestamp) MarshalJSON() ([]byte, error)
- func (t Timestamp) String() string
- func (t *Timestamp) UnmarshalJSON(payload []byte) (err error)
type TypeCarrier
type TypeRegistry
- func (registry TypeRegistry) Add(classes ...TypeCarrier) TypeRegistry
- func (registry TypeRegistry) SupportedTypes() []string
- func (registry TypeRegistry) UnmarshalJSON(payload []byte, typetag ...string) (any, error)
type URL
- func (u URL) AsURL() url.URL
- func (u URL) MarshalJSON() ([]byte, error)
- func (u *URL) String() string
- func (u *URL) UnmarshalJSON(payload []byte) (err error)
type UUID
- func (id UUID) GetID() uuid.UUID
- func (id UUID) IsZero() bool
- func (id UUID) MarshalText() ([]byte, error)
- func (id UUID) String() string
- func (id *UUID) UnmarshalText(payload []byte) (err error)

Constants ¶

This section is empty.

Variables ¶

View Source

var VERSION = "0.6.4"

VERSION is the version of this application

Functions ¶

func Atoi ¶ added in v0.2.0

func Atoi(value string, fallback int) int

Atoi convert a string to an int using a fallback if the conversion fails

func CappedString ¶ added in v0.6.4

func CappedString(s string, length int) string

CappedString returns a string capped to the given length.

If the string is longer than the given length, it is truncated and "..." is appended.

Note: the original string is not modified, a truncated copy is returned.

Example:

// Cap a string to 10 characters
str := "This is a long string"
cappedStr := CappedString(str, 10) // "This is a ..."

func CappedStringWith ¶ added in v0.6.4

func CappedStringWith(s string, length int, suffix string) string

CappedStringWith returns a string capped to the given length with a custom suffix.

If the string is longer than the given length, it is truncated and the suffix is appended.

Note: the original string is not modified, a truncated copy is returned.

Example:

// Cap a string to 10 characters with " (more)" suffix
str := "This is a long string"
cappedStr := CappedStringWith(str, 10, " (more)") // "Thi (more)"

func Contains ¶ added in v0.5.3

func Contains[S ~[]T, T comparable](slice S, value T) bool

Contains checks if a slice contains a value.

Example ¶

items := []string{"apple", "banana", "cherry"}

found := core.Contains(items, "banana")
fmt.Println("Found banana:", found)

notFound := core.Contains(items, "date")
fmt.Println("Found date:", notFound)

Output:
Found banana: true
Found date: false

func ContainsWithFunc ¶ added in v0.5.3

func ContainsWithFunc[S ~[]T, T any](slice S, value T, predicate func(item T, value T) bool) bool

ContainsWithFunc checks if a slice contains a value using a custom function.

The function f should return true if the slice item matches the value.

If T implements Identifiable or StringIdentifiable or Named, consider using MatchIdentifiable, MatchStringIdentifiable or MatchNamed as the matching/equality function.

Example ¶

items := []Something1{{"apple"}, {"banana"}, {"cherry"}}

found := core.ContainsWithFunc(items, Something1{"banana"}, func(a, b Something1) bool {
	return a.Data == b.Data
})
fmt.Println("Found banana:", found)

notFound := core.ContainsWithFunc(items, Something1{"date"}, func(a, b Something1) bool {
	return a.Data == b.Data
})
fmt.Println("Found date:", notFound)

Output:
Found banana: true
Found date: false

func ConvertFromAnySlice ¶ added in v0.6.4

func ConvertFromAnySlice[T any](items []any) []T

ConvertFromAnySlice converts a slice of any interface to a slice of specific type T.

If an item cannot be converted to type T, it is skipped.

If an item is not of type T, it attempts to marshal and unmarshal it as JSON. This allows to convert a JSON payload with an array of objects into a slice of T. Note that this requires that the item can be marshaled to JSON and that T can be unmarshaled from JSON and is slower than a direct type assertion.

Example:

// Convert a slice of any to a slice of strings
anySlice := []any{"one", "two", "three"}
stringSlice := ConvertFromAnySlice[string](anySlice)

Example ¶

anySlice := []any{"one", "two", "three"}
stringSlice := core.ConvertFromAnySlice[string](anySlice)
fmt.Println(stringSlice)

anySlice = []any{"one", 2, "three", 4.0, "five"}
stringSlice = core.ConvertFromAnySlice[string](anySlice)
fmt.Println(stringSlice)

Output:
[one two three]
[one three five]

func ConvertToAnySlice ¶ added in v0.6.4

func ConvertToAnySlice[S ~[]T, T any](items S) []any

ConvertToAnySlice converts a slice of specific type T to a slice of any interface.

Example:

// Convert a slice of strings to a slice of any
stringSlice := []string{"one", "two", "three"}
anySlice := ConvertToAnySlice[string](stringSlice)

Example ¶

stringSlice := []string{"one", "two", "three"}
anySlice := core.ConvertToAnySlice(stringSlice)
fmt.Println(anySlice)

intSlice := []int{1, 2, 3, 4, 5}
anySlice = core.ConvertToAnySlice(intSlice)
fmt.Println(anySlice)

Output:
[one two three]
[1 2 3 4 5]

func DecodeUUID ¶ added in v0.2.0

func DecodeUUID(encoded string) (uuid.UUID, error)

DecodeUUID decodes a UUID from a 22 char long string

func EncodeUUID ¶ added in v0.2.0

func EncodeUUID(uuid uuid.UUID) string

EncodeUUID encodes a UUID in a 22 char long string

func EqualIdentifiable ¶ added in v0.5.10

func EqualIdentifiable[T Identifiable](a, b T) bool

EqualIdentifiable compares two values for equality by their Identifier

func EqualNamed ¶ added in v0.5.10

func EqualNamed[T Named](a, b T) bool

EqualNamed compares two values for equality by name

func EqualSlices ¶ added in v0.5.3

func EqualSlices[S ~[]T, T comparable](a, b S) bool

EqualSlices checks if two slices are equal.

Two slices are equal if they have the same length and all elements of the first slice exist in the second slice. And vice versa.

Example ¶

slice1 := []string{"apple", "banana", "cherry"}
slice2 := []string{"cherry", "banana", "apple"}

equal := core.EqualSlices(slice1, slice2)
fmt.Println("Slices are equal:", equal)

slice3 := []string{"apple", "banana", "date"}

notEqual := core.EqualSlices(slice1, slice3)
fmt.Println("Slices are equal:", notEqual)

Output:
Slices are equal: true
Slices are equal: false

func EqualSlicesWithFunc ¶ added in v0.5.3

func EqualSlicesWithFunc[S ~[]T, T any](a, b S, compare func(T, T) bool) bool

EqualSlicesWithFunc checks if two slices are equal.

Two slices are equal if they have the same length and all elements of the first slice exist in the second slice. And vice versa.

Example ¶

slice1 := []Something{Something1{"apple"}, Something1{"banana"}, Something1{"cherry"}}
slice2 := []Something{Something1{"cherry"}, Something1{"banana"}, Something1{"apple"}}

equal := core.EqualSlicesWithFunc(slice1, slice2, func(a, b Something) bool {
	return a.GetData() == b.GetData()
})
fmt.Println("Slices are equal:", equal)

slice3 := []Something{Something1{"apple"}, Something1{"banana"}, Something1{"date"}}

notEqual := core.EqualSlicesWithFunc(slice1, slice3, func(a, b Something) bool {
	return a.GetData() == b.GetData()
})
fmt.Println("Slices are equal:", notEqual)

Output:
Slices are equal: true
Slices are equal: false

func EqualStringIdentifiable ¶ added in v0.5.10

func EqualStringIdentifiable[T StringIdentifiable](a, b T) bool

EqualStringIdentifiable compares two values for equality by their Identifier

func ExecEvery ¶

func ExecEvery(job func(tick int64, at time.Time, changeme chan time.Duration), every time.Duration) (chan bool, chan bool, chan time.Duration)

ExecEvery runs a func as a go routine regularly

returns 3 chans:

- a chan to stop the time loop, pipe true

- a chan to force the job execution on demand

- a chan to change the ticker interval

the invoked func can modify the interval by piping a new Duration to its given chan

the func is executed once before the ticker starts

func ExponentialBackoff ¶ added in v0.6.3

func ExponentialBackoff(attempt int, initialDelay time.Duration, maxDelay time.Duration, jitter float64) time.Duration

ExponentialBackoff returns a duration to wait before retrying an operation, using an exponential backoff algorithm.

The delay is calculated as initialDelay * 2^(attempt-1), with a maximum of maxDelay. Attempt is 1-based (i.e. the first attempt is 1).

A jitter factor is applied to the delay to avoid thundering herd problems. The jitter is a random value between -jitter * delay and +jitter * delay.

func Filter ¶ added in v0.5.0

func Filter[S ~[]T, T any](items S, filter func(T) bool) (result []T)

Filter filters a slice of items based on a filter function

Note: The result is a new slice, the original is not modified

Example:

// Filter all positive numbers in a slice
numbers := Filter(numbers, func(number int) bool {
	return number > 0
})

Example ¶

// Filter all even numbers in a slice
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
evens := core.Filter(numbers, func(number int) bool {
	return number%2 == 0
})
fmt.Println(evens)

Output:
[2 4 6 8 10]

func Find ¶ added in v0.5.9

func Find[S ~[]T, T comparable](items S, value T) (t T, found bool)

Find finds a value in a slice

Example ¶

items := []string{"apple", "banana", "cherry"}

result, found := core.Find(items, "banana")
fmt.Println("Found banana:", found)
if found {
	fmt.Println("Banana is:", result)
}

_, found = core.Find(items, "date")
fmt.Println("Found date:", found)

Output:
Found banana: true
Banana is: banana
Found date: false

func FindWithFunc ¶ added in v0.5.9

func FindWithFunc[S ~[]T, T any](items S, predicate func(T) bool) (t T, found bool)

FindWithFunc is a function that finds a value in a slice

Note that the returned value is a copy of the item in the slice.

Example ¶

items := []Something1{{"apple"}, {"banana"}, {"cherry"}}

result, found := core.FindWithFunc(items, func(item Something1) bool {
	return item.Data == "banana"
})
fmt.Println("Found banana:", found)
if found {
	fmt.Println("Banana is:", result.Data)
}

_, found = core.FindWithFunc(items, func(item Something1) bool {
	return item.Data == "date"
})
fmt.Println("Found date:", found)

Output:
Found banana: true
Banana is: banana
Found date: false