type-param-common

type-param-common

Type parameter primitives and commons.

This repository contains type-parameter version of containers and set, iterator, queue, deque, stack implementations.

Suffixed with -param to avoid name overlapping

Wrappers of Go std lib are suffixed with -param

Package descriptions

Wrappers of container of standard

• heap-param
  • STATUS: done. doc comments needs improvement.
• list-param
  • STATUS: done. most of behavior consistent to container/list.
• ring-param
  • STATUS: Half done. Needs good testing.

Heap-param wraps container/heap of standard library. see ./heap.go, ./filterable_heap.go and corresponding test files for example usages.

list-param and ring-param wraps container/list and container/ring respectively.

*Element[T] and *Ring[T] have addtitional methods, Get, Set and Unwrap to replace direct mutation/observation of elementOrRing.Value. Some of their methods are changed their returned value from single ret T to (ret T, ok bool). This second boolean value indicates internal Value was not nil, which means returned ret T is zero value if false.

sync-param

Wrappers of sync.Map and sync.Pool.

slice

Deque[T], Queue[T], Stack[T] and helper functions. It eases pain of write-deque-everywhere.

• Deque
• Queue
• Stack
• Helper functions
  • Useful for unsorted slice.

iterator

Exerimental iterator impl for go.

• STATUS: half done. requires addition of missing tests. add benchmark for performance comparision.

iterator package's main struct is Iterator[T].

type Iterator[T any] struct {
	SeIterator[T]
}

type Nexter[T any] interface {
	Next() (next T, ok bool)
}

// Singly ended iterator.
type SeIterator[T any] interface {
	Nexter[T]
}

Usage example:

package main

import (
	"fmt"
	"strings"

	"github.com/ngicks/type-param-common/iterator"
)

func main() {
	fmt.Println(
		iterator.Fold[iterator.EnumerateEnt[string]](
			iterator.Enumerate[string](
				iterator.
					FromSlice([]string{"foo", "bar", "baz"}).
					Map(func(s string) string { return s + s }).
					Exclude(func(s string) bool { return strings.Contains(s, "az") }).
					MustReverse(),
			),
			func(accumulator map[string]int, next iterator.EnumerateEnt[string]) map[string]int {
				accumulator[next.Next] = next.Count
				return accumulator
			},
			map[string]int{},
		),
	)  // outputs: map[barbar:0 foofoo:1]
}

It requires Singly ended iterator as embeded field. Iterator[T] is thin helper type. Chance to have breaking change (e.g. new field) is low.

Iterator[T] can be created directly from

• slice []T
• listparam.List[T]
• channel <-chan T

var iter iterator.Iterator[string]
iter = iterator.FromSlice(strSlice)
// or
// for size-fixed iterator
iter = iterator.FromFixedList(list)
// for growing iterator
iter = iterator.FromList(list)
// or
iter = iterator.FromChannel(make(chan string))

Input SeIterator[T] can optionally implements interfaces shown below. Those will be used in iterator methods of corresponding name.

type SizeHinter interface {
	SizeHint() int
}

type Reverser[T any] interface {
	Reverse() (rev SeIterator[T], ok bool)
}

type Unwrapper[T any] interface {
	Unwrap() SeIterator[T]
}


// Doubly ended iterator.
type DeIterator[T any] interface {
	Nexter[T]
	NextBacker[T]
}