NOTE: Requires go1.18
Go-Chainable is a library using generics to mimic the functional .map(x -> y).reduce(x -> y, z) patterns of javascript. List is also inspired by Java's ArrayList.
array := []string { "hello", "world" }
list := lists.New[string, any](array)
or get an empty list
list := lists.NewEmpty[string, any]()
First type parameter is the type of the List's values.
The second type parameter for a list is needed only for when calling list.Reduce(). If you won't need to call .Reduce() then set the second type argument as any and forget it.
import "github.com/neurocollective/go_chainable/lists"
array := []int{1, 2}
list := lists.New[int, any](array)
doubled := list.Map(func(val int, index int) int {
return val * 2
})
fmt.Println(doubled.String()) // -> [2 4]
import "github.com/neurocollective/go_chainable/lists"
array := []int { 1, 2 }
list := lists.New[int, any](array)
newList := list.Filter(func(val int, index int) bool {
return val < 2
})
error, size := newList.Size()
fmt.Println(size) // -> 1
import "github.com/neurocollective/go_chainable/lists"
array := []int { 1, 2 }
list := lists.New[int, int](array) // second type passed to New is the "result" type used by reducer as return type
added := list.Reduce(func(accumulator int, val int, index int) int {
return accumulator + val
}, 0)
fmt.Println(added) // -> 3
array := []int { 1, 2, 3 }
list := lists.New[int, int](array)
added := list.Map(func(val int, index int) int {
return val + 1
}).Filter(func(val int, index int) bool {
return val < 4
}).Reduce(func(accumulator int, val int, index int) int {
return accumulator + val
}, 0)
fmt.Println(added) // -> 5
import "github.com/neurocollective/go_chainable/maps"
theMap := maps.NewEmpty[string, string, string]()
theMap.Set("hey", "dude")
theMap.Set("sup", "brah")
mappedList := theMap.Map(func(value string, key string, i int) string {
return key + "_" + value
})
fmt.Println(mappedList.String()) // -> [hey_dude sup_brah]
import "github.com/neurocollective/go_chainable/maps"
theMap := maps.NewEmpty[string, string, string]()
theMap.Set("hey", "dude")
theMap.Set("sup", "brah")
initial := "When I meet someone new, I always say: "
message := theMap.Reduce(func(accumulator string, value string, key string, i int) string {
return accumulator + key + " " + value + " "
}, initial)
fmt.Println(message) // -> "When I meet someone new, I always say: hey dude sup brah"
ok github.com/neurocollective/go_chainable/lists 0.001s coverage: 80.4% of statements
ok github.com/neurocollective/go_chainable/maps 0.001s coverage: 97.4% of statements
.Raw()
Returns a raw underlying []T
.RawPointer()
Returns the raw Pointer to the underlying []T
.Map(mapper func(value T, index int) T) *List[T, R]
Calls the mapper function for each element, passing in value and int. The underlying slice is changed to a new slice, with each element being the returned value from mapper.
.MapFull(mapper func(value T, index int, array *[]T) T) *List[T, R]
Same as .Map but the mapper function takes a pointer to the underlying slice as an additional argument.
.Reduce(reducer func(accumulator R, value T, index int) R, initial R) R)
Calls the reducer function for each element, passing in accumulator value and int. On the first call to reducer the accumulator value is the initial value. But each subsequent call receives an accumulator that is the returned R value from the previous call to reducer.
.ReduceFull(reducer func(accumulator R, value T, index int, array *[]T) R, initial R) R
Same as .Reduce but the reducer function takes a pointer to the underlying slice as an additional argument.
.ForEach(operation func(element T, index int) T) *List[T, R]
Calls the operation on each element in the slice, returning nothing from each invocation. The unmodified *List[T, R] is returned.
.ForEachFull(operation func(element T, index int, array *[]T)) *List[T, R]
Same as .ForEach but the operation function takes a pointer to the underlying slice as an additional argument.
Filter(filterFunc func(element T, index int) bool) *List[T, R]
Calls filterFunc for each element in the slice. This populates a new slice, which only receives the T at that index if filterFunc return true. The List[T, R] then points to the new, filtered array.
.FilterFull(filterFunc func(element T, index int, array *[]T) bool) *List[T, R]
Same as .ForEach but the filterFunc function takes a pointer to the underlying slice as an additional argument.
.Append(addition *[]T) *List[T, R]
Adds the values from []T to the List[T, R].
.Add(value T) *List[T, R]
Adds the value T to the List[T, R].
.Get(index int) (error, T)
Returns the value T of the element at index. Returns an error if the underlying slice is a nil pointer or requested index would be out of bounds.
.SetCap(capacity int) *List[T, R]
Set the capacity of the underlying slice.
.IncrementCap(capacity int) *List[T, R]
Increase the capacity of the underlying slice by the int value capacity.
.Find(finder func(element T, index int) bool) (error, *T)
Calls finder on every element in the slice. As soon as finder returns true, the T value at that index is retured. If findernever returns true after traversing all values, an error is returned.
.String() string
Returns a string representation of the underlying slice.
.IndexOf(matcher func(element T) bool) (error, int)
Calls matcher on each element in the array. For the first element from which matcher returns true, the int index of that element will be returned.
.Size() (error, int)
Returns the int length of the underlying slice.
.Cap() (error, int)
Returns the int capacity of the underlying slice.
.IsEmpty() (error, bool)
Returns true if the underlying slice has a length of 0. Returns an error if it is a nil pointer.
.Last() (error, T)
Returns the value T of the element at the last index. Returns an error if the underlying slice is a nil pointer or list is empty.
.First() (error, T)
Returns the value T of the element at index 0. Returns an error if the underlying slice is a nil pointer or list is empty.
lists.New[T any, R any](array []T) *List[T, R]
Build a *List[T, R] from an array or slice.
lists.NewEmpty[T any, R any]() *List[T, R]
Build an empty *List[T, R] from an array or slice.
ResultTypeSwap[T any, OldR any, NewR any] (list *List[T, OldR]) *List[T, NewR]
Get a new List[T, NewR], in the case where result type was incorrect or a new result type if needed.
.Map(mapper func(value V, key K, index int) R) *lists.List[R, R]
Call mapper for each key value pair, returning an R value which is appended into the returned *lists.List[R, R].
.Reduce(reducer func(accumulator R, value V, key K, index int) R, initial R) R
Calls the reducer function for each key-value pair, passing in accumulator value key and index (index corresonds to the order added to the Map). On the first call to reducer the accumulator value is the initial value. But each subsequent call receives an accumulator that is the returned R value from the previous call to reducer.
.Set(key K, value V) *Map[K, V, R]
Add a key-value pair to the Map. Key will be stored by order added.
.Get(key K) (V, bool)
Returns the V at key. Second value is false if the key was not found, and a zero-value was returned.
.Keys() *lists.List[K, R]
Returns a *lists.List[K, R] of all the keys K added to the Map, in order of addition.
.Values() *lists.List[V, R]
Returns a *lists.List[K, R] of all the values V added to the Map, in order of addition.
.String() string
Returns a string representation of the map - order not yet guaranteed.
maps.New[K comparable, V comparable, R any](nativeMap map[K]V) *Map[K, V, R]
Get a new *Map[K, V, R] from a map[K]V
maps.NewEmpty[K comparable, V comparable, R any]() *Map[K, V, R]
Get a new empty *Map[K, V, R]