sorters

Documentation

Index

• type CompareOption
  • func WithLocale(locale string) CompareOption
  • func WithLocaleTag(localeTag language.Tag) CompareOption
• type Comparison
  • func BoolsComparator(_ ...CompareOption) Comparison[bool]
  • func BoolsPtrComparator(opts ...CompareOption) Comparison[*bool]
  • func BytesComparator(opts ...CompareOption) Comparison[[]byte]
  • func CompoundCriteria[T any](criteria ...Comparison[T]) Comparison[T]
  • func OrderedComparator[T Ordered]() Comparison[T]
  • func OrderedPtrComparator[T Ordered]() Comparison[*T]
  • func Ptr[T any](in Comparison[T]) Comparison[*T]
  • func Reverse[T any](in Comparison[T]) Comparison[T]
  • func ReversePtr[T any](in Comparison[*T]) Comparison[*T]
  • func StringsComparator(opts ...CompareOption) Comparison[string]
  • func StringsPtrComparator(opts ...CompareOption) Comparison[*string]
• type Multi
  • func NewMulti[T any](collection []T, criteria ...Comparison[T]) *Multi[T]
  • func (s Multi[T]) Collection() []T
  • func (s Multi[T]) Len() int
  • func (s *Multi[T]) Less(i, j int) bool
  • func (s *Multi[T]) Sort()
  • func (s *Multi[T]) Swap(i, j int)
• type Ordered

Examples

• Multi.Sort

Types

type CompareOption

type CompareOption func(*compareOptions)

CompareOption sets options for sorting.

func WithLocale

func WithLocale(locale string) CompareOption

WithLocale sets the language specific collation for ordering strings.

func WithLocaleTag

func WithLocaleTag(localeTag language.Tag) CompareOption

WithLocaleTag sets the language specific collation for ordering strings.

type Comparison

type Comparison[T any] func(a, b T) int

func BoolsComparator

func BoolsComparator(_ ...CompareOption) Comparison[bool]

BoolsComparator compare booleans: false < true.

func BoolsPtrComparator

func BoolsPtrComparator(opts ...CompareOption) Comparison[*bool]

BoolsPtrComparator compare pointers to booleans: false < true.

Pointer logic is that nil < !nil , nil == nil. Usual comparison occurs whenever both arguments are not nil.

func BytesComparator

func BytesComparator(opts ...CompareOption) Comparison[[]byte]

BytesComparator builds a comparator for []byte slices, with some collating sequence option.

func CompoundCriteria

func CompoundCriteria[T any](criteria ...Comparison[T]) Comparison[T]

CompoundCriteria compose multiple sorting criteria into a single Comparison[T].

func OrderedComparator

func OrderedComparator[T Ordered]() Comparison[T]

OrderedComparator builds a comparator for any ordered golang type (i.e. numerical types).

func OrderedPtrComparator

func OrderedPtrComparator[T Ordered]() Comparison[*T]

OrderedPtrComparator builds a comparator for pointers to any ordered golang type (i.e. numerical types).

Pointer logic is that nil < !nil , nil == nil. Usual comparison occurs whenever both arguments are not nil.

func Ptr

func Ptr[T any](in Comparison[T]) Comparison[*T]

Ptr makes a comparison over pointers from a comparison over types.

func Reverse

func Reverse[T any](in Comparison[T]) Comparison[T]

Reverse the comparison order.

func ReversePtr

func ReversePtr[T any](in Comparison[*T]) Comparison[*T]

ReversePtr reverses the nil comparison logic for pointer operands: !nil < nil instead of nil < !nil.

The comparison logic for non-nil values is not altered.

func StringsComparator

func StringsComparator(opts ...CompareOption) Comparison[string]

StringsComparator builds a comparator for strings, with some collating sequence option.

func StringsPtrComparator

func StringsPtrComparator(opts ...CompareOption) Comparison[*string]

StringsPtrComparator builds a comparator for pointers to strings, with some collating sequence option.

Pointer logic is that nil < !nil , nil == nil. Usual comparison occurs whenever both arguments are not nil.

type Multi

type Multi[T any] struct {
	// contains filtered or unexported fields
}

func NewMulti

func NewMulti[T any](collection []T, criteria ...Comparison[T]) *Multi[T]

NewMulti produces a sortable object, that supports multiple sorting criteria.

func (Multi[T]) Collection

func (s Multi[T]) Collection() []T

Collection yields the inner collection.

func (Multi[T]) Len

func (s Multi[T]) Len() int

Len implements the sort.Interface

func (*Multi[T]) Less

func (s *Multi[T]) Less(i, j int) bool

Less implements the sort.Interface

func (*Multi[T]) Sort

func (s *Multi[T]) Sort()

Sort the inner collection. This is a shorthand for sort.Sort(s).

Example

package main

import (
	"encoding/json"
	"fmt"

	"github.com/fredbi/go-patterns/sorters"
	"github.com/go-openapi/swag"
)

type SampleUser struct {
	ID        string   `json:"id"`
	FirstName *string  `json:"first_name,omitempty"`
	LastName  string   `json:"last_name"`
	Age       *float64 `json:"age,omitempty"`
}

func main() {
	// builds a sortable collection with multiple sorting criteria.

	s := sorters.NewMulti[SampleUser](
		sampleUsers(),
		// order by:
		// * LastName ASC
		// * FirstName ASC
		// * Age ASC
		// * ID DESC
		func(a, b SampleUser) int {
			// Alternatively, we may use WithLocaleTag(language.French) to specify the collating sequence.
			return sorters.StringsComparator(sorters.WithLocale("fr"))(a.LastName, b.LastName)
		},
		func(a, b SampleUser) int {
			// Pointer logic is that nil < !nil , nil == nil. Usual comparison occurs whenever
			// both arguments are not nil
			return sorters.StringsPtrComparator(sorters.WithLocale("fr"))(a.FirstName, b.FirstName)
		},
		func(a, b SampleUser) int {
			// Ordered are go numerical types
			return sorters.OrderedPtrComparator[float64]()(a.Age, b.Age)
		},
		func(a, b SampleUser) int {
			return sorters.Reverse(
				// The default string comparison operates here (no language collation)
				sorters.StringsComparator(),
			)(a.ID, b.ID)
		},
	)

	// alternatively, we can call the sort package: sort.Sort(s)
	s.Sort()

	jazon, err := json.MarshalIndent(s.Collection(), "", " ")
	if err != nil {
		fmt.Printf("error: %v\n", err)
	}

	fmt.Println(string(jazon))

}

func sampleUsers() []SampleUser {
	return []SampleUser{
		{
			ID:        "1",
			FirstName: swag.String("Fred"),
			LastName:  "B.",
			Age:       swag.Float64(49),
		},
		{
			ID:        "4",
			FirstName: swag.String("Fred"),
			LastName:  "B.",
			Age:       swag.Float64(49),
		},
		{
			ID:        "10",
			FirstName: swag.String("Fred"),
			LastName:  "B.",
			Age:       swag.Float64(25),
		},
		{
			ID:       "5",
			LastName: "L.",
			Age:      swag.Float64(45),
		},
		{
			ID:        "0",
			FirstName: swag.String("Enzo"),
			LastName:  "L.",
		},
		{
			ID:        "2",
			FirstName: swag.String("Fred"),
			LastName:  "B.",
			Age:       swag.Float64(49),
		},
		{
			ID:        "5",
			FirstName: swag.String("Thomas"),
			LastName:  "B.",
			Age:       swag.Float64(13),
		},
		{
			ID:        "2",
			FirstName: swag.String("Mathieu"),
			LastName:  "B.",
			Age:       swag.Float64(15),
		},
	}
}

Output:

[
 {
  "id": "10",
  "first_name": "Fred",
  "last_name": "B.",
  "age": 25
 },
 {
  "id": "4",
  "first_name": "Fred",
  "last_name": "B.",
  "age": 49
 },
 {
  "id": "2",
  "first_name": "Fred",
  "last_name": "B.",
  "age": 49
 },
 {
  "id": "1",
  "first_name": "Fred",
  "last_name": "B.",
  "age": 49
 },
 {
  "id": "2",
  "first_name": "Mathieu",
  "last_name": "B.",
  "age": 15
 },
 {
  "id": "5",
  "first_name": "Thomas",
  "last_name": "B.",
  "age": 13
 },
 {
  "id": "5",
  "last_name": "L.",
  "age": 45
 },
 {
  "id": "0",
  "first_name": "Enzo",
  "last_name": "L."
 }
]

func (*Multi[T]) Swap

func (s *Multi[T]) Swap(i, j int)

Swap implements the sort.Interface

type Ordered

type Ordered = constraints.Ordered

Ordered defines all ordered types (see https://go.dev/ref/spec)