helper functions to create map/slice matcher about its

[youta-t]

Within go language, such helper can ONLY be

func F[T, U any](func(T)U, ...T) []U

or

func F[K comparable, T, U any] (func(T)U, map[K]T) map[K]U

For example, it will be written as

its.Slice(its.ApplyOver(its.EqEq[int], 1, 2, 3)).Match(...)

This may be the most concise expression in go.

But I have little confidence that it make us happy.
My intuition is not touched by that.
It only adds complexness and nerdish bonus, isn't it?

[youta-t]

How'd about this?

	its.SliceForEach(its.EqEq[int], 1, 2, 3).
		Unordered().Match([]int{3, 1, 2}).
		OrError(t)

[youta-t]

How'd about this?

I'm afraid that Unordered will be placed far from its.SliceForEach.
Where should do user's eyes set focus on?

[youta-t]

I have less idea about what to be done with this.
This issue is postponed as backlog.

[youta-t]

func ForItems[T, U, X any, F func(U) Matcher[T], S func(...Matcher[T]) Matcher[X]](
	s S, matcherFactory F, element []U,
) Matcher[X] {
	cancel := itskit.SkipStack()
	defer cancel()

	ret := make([]Matcher[T], len(element))
	for i := range element {
		ret[i] = matcherFactory(element[i])
	}
	return s(ret...)
}

func ForEntries[
	K comparable, T, U, X any, F func(U) Matcher[T], S func(map[K]Matcher[T]) Matcher[X],
](
	s S,
	matcherFactory F,
	entries map[K]U,
) Matcher[X] {
	cancel := itskit.SkipStack()
	defer cancel()

	m := map[K]Matcher[T]{}
	for k := range entries {
		m[k] = matcherFactory(entries[k])
	}

	return s(m)
}

Isn't it nice?

Especially ForItems, it works with not only its.Slice, its.SliceUnordered but also All or Some.

It will be used as its.ForItems(its.Slice, its.EqEq, []int{1, 2, 3}) .

Names can be bikesheddable.