151 lines
3.0 KiB
Markdown
151 lines
3.0 KiB
Markdown
# gomap
|
|
|
|
Map functions utilizing basic interfaces, assertions, and ptypes.
|
|
|
|
This code and [ptypes](https://github.com/prequist/ptypes) are both artistic bloat,
|
|
utilised for DX concepts and/or type-evading for operations.
|
|
|
|
## Usage
|
|
|
|
<details closed>
|
|
<summary>Basic Setup</summary>
|
|
|
|
```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)
|
|
}
|
|
```
|
|
|
|
</details>
|
|
|
|
<details close>
|
|
<summary>Filter</summary>
|
|
|
|
```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"
|
|
}
|
|
```
|
|
|
|
</details>
|
|
|
|
<details closed>
|
|
<summary>Boxed</summary>
|
|
|
|
```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
|
|
}
|
|
```
|
|
|
|
</details>
|
|
|
|
<details closed>
|
|
<summary>Using <code>interface{}</code>s</summary>
|
|
|
|
```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
|
|
}
|
|
```
|
|
|
|
</details>
|
|
|
|
## 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
|
|
``` |