bfu 8bee0afdc7 | ||
---|---|---|
.gitignore | ||
LICENSE | ||
README.md | ||
box_list.go | ||
callable.go | ||
filter.go | ||
filter_test.go | ||
go.mod | ||
go.sum | ||
handles.go | ||
iterator.go | ||
iterator_test.go | ||
list.go | ||
map.go | ||
map_test.go | ||
remap.go | ||
slice.go | ||
slice_test.go |
gomap
Map functions utilizing basic interfaces, assertions, and ptypes.
This code and ptypes are both artistic bloat, utilised for DX concepts and/or type-evading for operations.
Usage
Basic Setup
import (
"github.com/prequist/gomap"
)
func Showcase() {
// gomap.Transformer
transformer := func(i interface{}) interface{} {
// type assert the interface and add 1.
return i.(int) + 1
}
// Create a new list
list := gomap.New(1, 2, 3, 4)
mappable := gomap.MappableList{list}
// The outcome.
outcome := mappable.Map(transformer)
// For predefined slices, we can use this flow:
slice := []int{1, 2, 3, 4, 5}
list = gomap.New(slice)
mappable = gomap.MappableList{list}
outcome := mappable.Map(transformer)
}
Filter
import (
"github.com/prequist/gomap"
"strings"
)
func Showcase() {
e := gomap.New("a", "b", "c", "ab", "d")
predicate := func(i interface{}) bool {
if str, ok := i.(string) {
return strings.Contains(str, "a")
}
return false
}
// Get the mappable list
mappable := e.Mappable()
// Apply the predicate, return the filtered list as a variable
mappable = e.Filter(predicate) // "a", "ab"
}
Boxed
import (
"github.com/prequist/gomap"
"github.com/prequist/ptypes"
)
func MakeBoxedAndConvert() []int {
e := gomap.NewBoxed(1, 2, 3, 4, 5)
mappable := e.Mappable()
mappable.Map(func(v interface{}) interface{} {
ib := v.(ptypes.Box).IntBox()
return ptypes.FromInt(*ib.Int() + 2)
})
arr := make([]int, len(e.Items()))
for index, vi := range e.Items() {
arr[index] = *vi.(ptypes.Box).IntBox().Int()
}
return arr
}
Using interface{}
s
import (
"github.com/prequist/gomap"
"github.com/prequist/ptypes"
)
func MakeAndConvert() []int {
e := gomap.New(1, 2, 3, 4, 5)
mappable := e.Mappable()
mappable.Map(func(v interface{}) interface{} {
return v.(int) + 1
})
arr := make([]int, len(e.Items()))
for index, vi := range e.Items() {
arr[index] = vi.(int)
}
return arr
}
Benchmarks
These are probably a bit bloat over time, however, they're not horrendous (compared to other) implementations.
On Mac OSX (Big Sur, M1)
map_test.go
goos: darwin
goarch: arm64
pkg: git.tcp.direct/bfu/gomap
BenchmarkPlain-8 5423301 221.0 ns/op
BenchmarkBox-8 937978 1240 ns/op
BenchmarkString-8 3070027 394.6 ns/op
BenchmarkBoxedString-8 762390 1489 ns/op
BenchmarkAdd-8 27079604 52.38 ns/op
iterator_test.go
BenchmarkIteratorNext-8 1000000000 0.7843 ns/op
filter_test.go
BenchmarkFilter
BenchmarkFilter/Filter
BenchmarkFilter/Filter-8 1000000000 0.0000008 ns/op