mirror of gomap just cuz

bfu4 99026bd939 (filter): add integer for filter test 1 month ago
.gitignore 19e0735f77 initial commit 2 months ago
LICENSE 19e0735f77 initial commit 2 months ago
README.md b455a5af11 (feat): filter tests, docs, list#Mappable() 1 month ago
box_list.go 19e0735f77 initial commit 2 months ago
callable.go ff2649abd3 feat: slice support 2 months ago
filter.go b6e3ff169b (feat): filter function, list#Mappable() 1 month ago
filter_test.go 99026bd939 (filter): add integer for filter test 1 month ago
go.mod 19e0735f77 initial commit 2 months ago
go.sum 19e0735f77 initial commit 2 months ago
handles.go ff2649abd3 feat: slice support 2 months ago
iterator.go 0679424204 (iterator): utilise a pointer to avoid copying of array elements 2 months ago
iterator_test.go 19e0735f77 initial commit 2 months ago
list.go b6e3ff169b (feat): filter function, list#Mappable() 1 month ago
map.go b455a5af11 (feat): filter tests, docs, list#Mappable() 1 month ago
map_test.go b455a5af11 (feat): filter tests, docs, list#Mappable() 1 month ago
remap.go ff2649abd3 feat: slice support 2 months ago
slice.go ff2649abd3 feat: slice support 2 months ago
slice_test.go b455a5af11 (feat): filter tests, docs, list#Mappable() 1 month ago

README.md

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 ```go 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 ```go 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 ```go 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 ```go 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 (Monterey, M1)

map_test.go

goos: darwin
goarch: arm64
pkg: github.com/prequist/gomap
BenchmarkPlain-8                12474228               100.0 ns/op
BenchmarkBox-8                    759380              1523 ns/op
BenchmarkString-8                4029303               277.8 ns/op
BenchmarkBoxedString-8            782708              1501 ns/op
BenchmarkAdd-8                  17820822                94.33 ns/op

iterator_test.go

BenchmarkIteratorNext-8         1000000000               0.5661 ns/op

filter_test.go

BenchmarkFilter
BenchmarkFilter/Filter
BenchmarkFilter/Filter-8         	1000000000	          0.0000009 ns/op