slices

package

Go to main page

Versions in this module

v0

v0.1.5

Jul 18, 2022

Changes in this version

+ func CompareSliceIndex(i int) Comparator[[]A]

+ func CompareSlicePairwise() Comparator[[]A]

+ func EqualSliceIndex(i int) Equaler[[]A]

+ func EqualSlicePairwise() Equaler[[]A]

v0.1.4

Jul 18, 2022

Changes in this version

+ func SortOrd(xs []A) []A

+ func SortOrdered(xs []A) []A

v0.1.3

Jul 18, 2022

Changes in this version

+ func GroupComparable(xs []A) map[A][]A

+ func SortOnOrd(projection F1[A, B], xs []A) []A

+ func SortOnOrdered(projection F1[A, B], xs []A) []A

v0.1.2

Jul 18, 2022

Changes in this version

+ func GroupConsecutive(xs []A) [][]A

+ func GroupConsecutiveBy(g F2[A, A, bool], xs []A) [][]A

+ func GroupOn(projection func(A) B, xs []A) map[B][]A

+ func IndexBy(equal Equaler[T], s []T, e T) int

+ func IndexComparable(s []T, e T) int

+ func IndexEq(s []T, e T) int

v0.1.1

Jul 18, 2022

Changes in this version

+ func ComparePairBy(fst Comparator[A], snd Comparator[B]) Comparator[*Pair[A, B]]

+ func ComparePairOrd() Comparator[*Pair[A, B]]

+ func ComparePairOrdered() Comparator[*Pair[A, B]]

+ func CompareSliceIndexBy(i int, compare Comparator[A]) Comparator[[]A]

+ func CompareSliceIndexOrd(i int) Comparator[[]A]

+ func CompareSliceIndexOrdered(i int) Comparator[[]A]

+ func CompareSlicePairwiseBy(compare Comparator[A]) Comparator[[]A]

+ func CompareSlicePairwiseOrd() Comparator[[]A]

+ func CompareSlicePairwiseOrdered() Comparator[[]A]

+ func EqualPairBy(fst Equaler[A], snd Equaler[B]) Equaler[*Pair[A, B]]

+ func EqualPairComparable() Equaler[*Pair[A, B]]

+ func EqualPairEq() Equaler[*Pair[A, B]]

+ func EqualSliceIndexBy(i int, equal Equaler[A]) Equaler[[]A]

+ func EqualSliceIndexComparable(i int) Equaler[[]A]

+ func EqualSliceIndexEq(i int) Equaler[[]A]

+ func EqualSlicePairwiseBy(equal Equaler[A]) Equaler[[]A]

+ func EqualSlicePairwiseComparable() Equaler[[]A]

+ func EqualSlicePairwiseEq() Equaler[[]A]

v0.1.0

Jul 17, 2022

v0.0.9

Jul 17, 2022

Changes in this version

+ func All(f F1[A, bool], xs []A) bool

+ func And(xs []bool) bool

+ func Any(f F1[A, bool], xs []A) bool

+ func Append(xs []A, ys []A) []A

+ func Break(pred F1[A, bool], xs []A) *Pair[[]A, []A]

+ func CompareBy(comparisons ...Comparator[A]) Comparator[A]

+ func CompareBys(comparisons []Comparator[A]) Comparator[A]

+ func ComparePair(p1 *Pair[A, B], p2 *Pair[A, B]) Ordering

+ func CompareSlice(compare Comparator[A]) Comparator[[]A]

+ func CompareSliceHelper(compare Comparator[A], xs []A, ys []A) Ordering

+ func Concat(xss [][]A) []A

+ func ConcatMap(f F1[A, []B], xs []A) []B

+ func Cons(a A, xs []A) []A

+ func Drop(count int, xs []A) []A

+ func DropWhile(pred F1[A, bool], xs []A) []A

+ func EqualBy(comparisons ...Equaler[A]) Equaler[A]

+ func EqualBys(comparisons []Equaler[A]) Equaler[A]

+ func EqualPair(p1 *Pair[A, B], p2 *Pair[A, B]) bool

+ func EqualSlice(compare F2[A, A, bool]) F2[[]A, []A, bool]

+ func EqualSliceHelper(compare F2[A, A, bool], xs []A, ys []A) bool

+ func Filter(f F1[A, bool], xs []A) []A

+ func Find(pred F1[A, bool], xs []A) *pkg.Maybe[A]

+ func Foldl(combine F2[B, A, B], base B, xs []A) B

+ func Foldr(combine F2[A, B, B], base B, xs []A) B

+ func Group(xs []A) [][]A

+ func GroupBy(g F2[A, A, bool], xs []A) [][]A

+ func Insert(a A, xs []A) []A

+ func Intercalate(sep []A, xss [][]A) []A

+ func Intersperse(sep A, xs []A) []A

+ func Iterate(count int, f F1[A, A], start A) []A

+ func Length(xs []A) int

+ func Map(f F1[A, B], xs []A) []B

+ func MapAccumL(accum F2[S, A, *Pair[S, B]], s S, xs []A) *Pair[S, []B]

+ func MapAccumR(accum F2[S, A, *Pair[S, B]], s S, xs []A) *Pair[S, []B]

+ func Maximum(xs []A) *pkg.Maybe[A]

+ func MaximumBy(f Comparator[A], xs []A) *pkg.Maybe[A]

+ func Merge(xs []A, ys []A, compare Comparator[A]) []A

+ func MergeSortWithComparator(compare Comparator[A], xs []A) []A

+ func Minimum(xs []A) *pkg.Maybe[A]

+ func MinimumBy(f Comparator[A], xs []A) *pkg.Maybe[A]

+ func Null(xs []A) bool

+ func Or(xs []bool) bool

+ func Partition(predicate F1[A, bool], xs []A) *Pair[[]A, []A]

+ func Product(xs []A) A

+ func Range(start A, stop A, step A) []A

+ func Replicate(count int, a A) []A

+ func Reverse(xs []A) []A

+ func Scanl(combine F2[B, A, B], base B, xs []A) []B

+ func Scanl1(combine F2[A, A, A], xs []A) []A

+ func Scanr(combine F2[A, B, B], base B, xs []A) []B

+ func Scanr1(combine F2[A, A, A], xs []A) []A

+ func Singleton(a A) []A

+ func Sort(xs []A) []A

+ func SortBy(compare Comparator[A], xs []A) []A

+ func SortOn(projection F1[A, B], xs []A) []A

+ func SortOnBy(projection F1[A, B], compare Comparator[B], xs []A) []A

+ func Span(pred F1[A, bool], xs []A) *Pair[[]A, []A]

+ func SplitAt(count int, xs []A) *Pair[[]A, []A]

+ func Sum(xs []A) A

+ func Take(count int, xs []A) []A

+ func TakeWhile(pred F1[A, bool], xs []A) []A

+ func Uncons(xs []A) *pkg.Maybe[*Pair[A, []A]]

+ func Unfoldr(f F1[B, *pkg.Maybe[*Pair[A, B]]], b B) []A

+ func Unzip(xs []*Pair[A, B]) *Pair[[]A, []B]

+ func Zip(xs []A, ys []B) []*Pair[A, B]

+ func ZipWith(f F2[A, B, C], xs []A, ys []B) []C

+ type SliceEq []A

+ func (xs SliceEq[A]) Equal(ys SliceEq[A]) bool

+ type SliceOrd []A

+ func (xs SliceOrd[A]) Compare(ys SliceOrd[A]) Ordering

+ func (xs SliceOrd[A]) Equal(ys SliceOrd[A]) bool

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL