Named FauxGaux because this isn't very idiomatic.
This is for learning purposes and the hell of it. Please do not actually use in a project.
This probably has an awful memory profile; don't look at it.
I have given minimal thought to error handling. As such, there is none.
go get github.com/Shrugs/fauxgaux
Takes a function. This function must accept one argument of arbitrary type and return one argument of arbitrary type.
nums := &[]int{1, 2, 3, 4}
nums = Chain(nums).Map(func(i int) int {
return i + 1
}).ConvertInt()
fmt.Println(nums)
// [2 3 4 5]
words := &[]string{"Hello", "What's up", "Howdy"}
words = Chain(words).Map(func(s string) string {
return strings.Join([]string{s, "World!"}, " ")
}).ConvertString()
fmt.Println(words)
// [Hello World! What's up World! Howdy World!]
Same as map, but creates a worker goroutine for each element in the slice. Uses sync.WaitGroup
to wait for all elements before continuing the chain.
// in series, function would sleep for 5 seconds
// with ParallelMap, only sleeps for 1
nums := &[]int{0, 1, 2, 3, 4}
newNums := Chain(nums).ParallelMap(func(i int) int {
time.Sleep(time.Second)
return i
}).ConvertInt()
// ok github.com/Shrugs/fauxgaux 1.007s
Takes a function and an accumulator. Function must accept the accumulator and the current object (using the correct types, naturally) and return the accumulator (with type unchanged).
User must instantiate accumulator to some value.
people := &[]*Person{
&Person{"Matt", 20},
&Person{"Ben", 19},
}
totalAge := fauxgaux.Chain(people).Map(func(p *Person) int {
return p.Age
}).Reduce(func(i int, num int) int {
i += num
return i
}, 0).(int)
fmt.Println(totalAge)
// 39
nums := &[]int{1, 2, 3, 4, 5}
sum := Chain(nums).Reduce(func(i int, num int) int {
i += num
return i
}, 0).(int)
fmt.Println(sum)
// 15
Same as Map, but does not replace the values of the chained slice; it only modifies them in memory. As such, the function passed must only accept one argument of the correct type.
type Person struct {
Name string
Age int
}
people := &[]*Person{
&Person{"Matt", 20},
&Person{"Ben", 19},
&Person{"Sam", 21},
}
fauxgaux.Chain(people).Each(func(p *Person) {
p.Name = "test"
})
for _, p := range *people {
fmt.Println(p.Name)
}
// test test test
Filters the slice based on a conditional function. Function should accept one argument of the correct type and return a bool indicating whether or not to keep the element in the slice.
nums := &[]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
evenSum := fauxgaux.Chain(nums).Filter(func(i int) bool {
return math.Mod(float64(i), 2) == 0
}).Reduce(func(sum, num int) int {
sum += num
return sum
}, 0).(int)
fmt.Println(evenSum)
// 30