Documentation
¶
Overview ¶
Package fslice implements a set of methods for operating on slices in a Functional Programming way.
Index ¶
- type EveryFunction
- type FilterFunction
- type Fslice
- func (fs Fslice[T]) Every(fn EveryFunction[T]) bool
- func (fs Fslice[T]) Filter(fn FilterFunction[T]) Fslice[T]
- func (fs Fslice[T]) Includes(x T) bool
- func (fs Fslice[T]) Map(fn MapFunction[T]) Fslice[T]
- func (fs Fslice[T]) Reduce(fn ReduceFunction[T], seed T) T
- func (fs Fslice[T]) Some(fn SomeFunction[T]) bool
- func (fs Fslice[T]) Sort(fn SortFunction[T]) Fslice[T]
- func (fs Fslice[T]) ToSlice() []T
- type MapFunction
- type MethodSet
- type ReduceFunction
- type SomeFunction
- type SortFunction
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type EveryFunction ¶
type EveryFunction[T comparable] func(v T, i int, arr []T) bool
EveryFunction operates on an element of a slice and returns true or false
type FilterFunction ¶
type Fslice ¶
type Fslice[T comparable] []T
Fslice is a slice with helpful methods in the Functional Programming style
func (Fslice[T]) Every ¶
func (fs Fslice[T]) Every(fn EveryFunction[T]) bool
Every returns true if its EveryFunction returns true for every element
Example ¶
package main
import (
"fmt"
"github.com/sean9999/GoFunctional/fslice"
)
func main() {
// is every element of this slice even?
inputSlice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12}
isEven := func(v int, _ int, _ []int) bool {
return (v%2 == 0)
}
answer := fslice.From(inputSlice).Every(isEven)
fmt.Println(answer)
}
Output: false
func (Fslice[T]) Filter ¶
func (fs Fslice[T]) Filter(fn FilterFunction[T]) Fslice[T]
Filter takes a function that operates on every element of the slice and returns only those elements of the slice for which the function returned true
Example ¶
package main
import (
"fmt"
"strings"
"github.com/sean9999/GoFunctional/fslice"
)
func main() {
// only give me the even numbers
numbers := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
onlyEven := func(n int, i int, arr []int) bool {
return (n%2 == 0)
}
filteredNumbers := fslice.From(numbers).Filter(onlyEven).ToSlice()
// remove SHOUTCASE words
inputSlice := []string{"all", "your", "BASE", "are", "belong", "to", "US"}
noShouting := func(word string, _ int, _ []string) bool {
upperCaseWord := strings.ToUpper(word)
return (word != upperCaseWord)
}
wordsWithoutShouting := fslice.From(inputSlice).Filter(noShouting).ToSlice()
fmt.Println(filteredNumbers)
fmt.Println(wordsWithoutShouting)
}
Output: [2 4 6 8] [all your are belong to]
func (Fslice[T]) Map ¶
func (fs Fslice[T]) Map(fn MapFunction[T]) Fslice[T]
Map takes a MapFunction and returns a new Slice with the same number of elements, those elements being of the same type
Example ¶
package main
import (
"fmt"
"strings"
"github.com/sean9999/GoFunctional/fslice"
)
func main() {
// square the numbers
squared := func(n int, _ int, _ []int) int {
return n * n
}
squares := fslice.From([]int{1, 2, 3, 4, 5}).Map(squared).ToSlice()
// convert every other word to SHOUTCASE
lowerBase := []string{"all", "your", "base", "are", "belong", "to", "us"}
shoutCaseEveryOther := func(word string, i int, _ []string) string {
if i%2 == 1 {
word = strings.ToUpper(word)
}
return word
}
shoutyBase := fslice.From(lowerBase).Map(shoutCaseEveryOther).ToSlice()
fmt.Println(squares)
fmt.Println(shoutyBase)
}
Output: [1 4 9 16 25] [all YOUR base ARE belong TO us]
func (Fslice[T]) Reduce ¶
func (fs Fslice[T]) Reduce(fn ReduceFunction[T], seed T) T
Reduce takes a ReduceFunction and a seed, which is the initial value fed into the user-supplied ReduceFunction
// BUG(sean9999): Seed value should be optional and should not be strictly typed // see: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce#edge_cases
func (Fslice[T]) Some ¶
func (fs Fslice[T]) Some(fn SomeFunction[T]) bool
Some takes a function that operates on as many elements of the slice as it takes to get a return value of true. It returns true in that case and false otherwise
Example ¶
package main
import (
"fmt"
"github.com/sean9999/GoFunctional/fslice"
)
func main() {
// at least one of these numbers is a multiple of 3
inputSlice := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11}
isMultipleOf3 := func(v int, _ int, _ []int) bool {
return (v%3 == 0 && v >= 3)
}
result := fslice.From(inputSlice).Some(isMultipleOf3)
fmt.Println(result)
}
Output: true
func (Fslice[T]) Sort ¶
func (fs Fslice[T]) Sort(fn SortFunction[T]) Fslice[T]
Sort takes a SortFunction and returns a slice, sorted
type MapFunction ¶
type MapFunction[T comparable] func(v T, i int, arr []T) T
MapFunction operates on every element of a Slice and returns an element of the same type. It is passed into Fslice.Map
type MethodSet ¶
type MethodSet[T comparable] interface { Map(MapFunction[T]) Fslice[T] Filter(FilterFunction[T]) Fslice[T] Some(SomeFunction[T]) bool Every(EveryFunction[T]) bool Includes(T) bool Reduce(ReduceFunction[T], T) T Sort(SortFunction[T]) Fslice[T] ToSlice() []T }
MethodSet is the interface Fslice implements
func From ¶
func From[T comparable](inputSlice []T) MethodSet[T]
From is a constructor. It wraps an existing slice returning an Fslice[T] satisfying MethodSet[T]
type ReduceFunction ¶
type ReduceFunction[T comparable] func(a T, b T) T
ReduceFunction operates on all elements, feeding the value of one iteration into the next
type SomeFunction ¶
type SortFunction ¶
type SortFunction[T comparable] func(a, b T) int
SortFunction compares two values from the slice and returns a negative value if (a > b), else positive or zero. Note that while Javascript makes a distinction between positive and zero values, Go does not. Go only asks if (a > b), and never asks if (a == b).
Source Files