fpgo

package module

Go to main page

Versions in this module

v2

v2.3.2

Jun 2, 2022

v2.3.1

May 26, 2022

v2.3.0

May 19, 2022

v2.2.7

May 17, 2022

Changes in this version

type BufferedChannelQueue

+ func (q *BufferedChannelQueue[T]) Count() int

+ func (q *BufferedChannelQueue[T]) GetChannel() chan T

v2.2.6

May 17, 2022

v2.2.5

May 16, 2022

Changes in this version

type BufferedChannelQueue

+ func (q *BufferedChannelQueue[T]) GetBufferSizeMaximum() int

+ func (q *BufferedChannelQueue[T]) GetFreeNodeHookPoolIntervalDuration() time.Duration

+ func (q *BufferedChannelQueue[T]) GetLoadFromPoolDuration() time.Duration

+ func (q *BufferedChannelQueue[T]) GetNodeHookPoolSize() int

+ func (q *BufferedChannelQueue[T]) IsClosed() bool

v2.2.4

May 15, 2022

Changes in this version

type AskDef

+ func (askSelf *AskDef[T, R]) AskOnceWithTimeout(target ActorHandle[interface{}], timeout time.Duration) (R, error)

v2.2.3

May 15, 2022

Changes in this version

+ type ConcurrentStack struct

+ func NewConcurrentStack(stack Stack[T]) *ConcurrentStack[T]

+ func (q *ConcurrentStack[T]) Pop() (T, error)

+ func (q *ConcurrentStack[T]) Push(val T) error

v2.2.2

May 13, 2022

v2.2.1

May 12, 2022

v2.2.0

May 12, 2022

Changes in this version

+ var ErrQueueIsClosed = errors.New("queue is closed")

+ var ErrQueueIsEmpty = errors.New("queue is empty")

+ var ErrQueueIsFull = errors.New("queue is full")

+ var ErrQueuePutTimeout = errors.New("queue put timeout")

+ var ErrQueueTakeTimeout = errors.New("queue take timeout")

+ var ErrStackIsEmpty = errors.New("stack is empty")

+ var ErrStackIsFull = errors.New("stack is full")

+ type BufferedChannelQueue struct

+ func NewBufferedChannelQueue(channelCapacity int, bufferSizeMaximum int, nodeHookPoolSize int) *BufferedChannelQueue[T]

+ func (q *BufferedChannelQueue[T]) Close()

+ func (q *BufferedChannelQueue[T]) Offer(val T) error

+ func (q *BufferedChannelQueue[T]) Poll() (T, error)

+ func (q *BufferedChannelQueue[T]) Put(val T) error

+ func (q *BufferedChannelQueue[T]) SetBufferSizeMaximum(size int)

+ func (q *BufferedChannelQueue[T]) SetFreeNodeHookPoolIntervalDuration(duration time.Duration)

+ func (q *BufferedChannelQueue[T]) SetLoadFromPoolDuration(duration time.Duration)

+ func (q *BufferedChannelQueue[T]) SetNodeHookPoolSize(size int)

+ func (q *BufferedChannelQueue[T]) Take() (T, error)

+ func (q *BufferedChannelQueue[T]) TakeWithTimeout(timeout time.Duration) (T, error)

+ type ChannelQueue chan T

+ func NewChannelQueue(capacity int) ChannelQueue[T]

+ func (q ChannelQueue[T]) Offer(val T) error

+ func (q ChannelQueue[T]) Poll() (T, error)

+ func (q ChannelQueue[T]) Put(val T) error

+ func (q ChannelQueue[T]) PutWithTimeout(val T, timeout time.Duration) error

+ func (q ChannelQueue[T]) Take() (T, error)

+ func (q ChannelQueue[T]) TakeWithTimeout(timeout time.Duration) (T, error)

+ type ConcurrentQueue struct

+ func NewConcurrentQueue(queue Queue[T]) *ConcurrentQueue[T]

+ func (q *ConcurrentQueue[T]) Offer(val T) error

+ func (q *ConcurrentQueue[T]) Poll() (T, error)

+ func (q *ConcurrentQueue[T]) Put(val T) error

+ func (q *ConcurrentQueue[T]) Take() (T, error)

+ type DoublyListItem struct

+ Next *DoublyListItem[T]

+ Prev *DoublyListItem[T]

+ Val *T

+ func (listItem *DoublyListItem[T]) AddFirst(input *DoublyListItem[T]) *DoublyListItem[T]

+ func (listItem *DoublyListItem[T]) AddLast(input *DoublyListItem[T]) *DoublyListItem[T]

+ func (listItem *DoublyListItem[T]) Count() int

+ func (listItem *DoublyListItem[T]) First() *DoublyListItem[T]

+ func (listItem *DoublyListItem[T]) Last() *DoublyListItem[T]

+ type LinkedListItem struct

+ Next *LinkedListItem[T]

+ Val *T

+ func (listItem *LinkedListItem[T]) AddLast(input *LinkedListItem[T]) *LinkedListItem[T]

+ func (listItem *LinkedListItem[T]) Count() int

+ func (listItem *LinkedListItem[T]) Last() *LinkedListItem[T]

+ type LinkedListQueue struct

+ func NewLinkedListQueue() *LinkedListQueue[T]

+ func (q *LinkedListQueue[T]) Clear()

+ func (q *LinkedListQueue[T]) ClearNodePool()

+ func (q *LinkedListQueue[T]) Count() int

+ func (q *LinkedListQueue[T]) KeepNodePoolCount(n int)

+ func (q *LinkedListQueue[T]) Offer(val T) error

+ func (q *LinkedListQueue[T]) Peek() (T, error)

+ func (q *LinkedListQueue[T]) Poll() (T, error)

+ func (q *LinkedListQueue[T]) Pop() (T, error)

+ func (q *LinkedListQueue[T]) Push(val T) error

+ func (q *LinkedListQueue[T]) Put(val T) error

+ func (q *LinkedListQueue[T]) Shift() (T, error)

+ func (q *LinkedListQueue[T]) Take() (T, error)

+ func (q *LinkedListQueue[T]) Unshift(val T) error

+ type Queue interface

+ Offer func(val T) error

+ Poll func() (T, error)

+ Put func(val T) error

+ Take func() (T, error)

+ type Stack interface

+ Pop func() (T, error)

+ Push func(val T) error

v2.1.1

May 7, 2022

Changes in this version

+ var ErrActorAskTimeout = fmt.Errorf("ErrActorAskTimeout")

+ var ErrConversionNil = errors.New("<nil>")

+ var ErrConversionSizeOverflow = errors.New("size overflow")

+ var ErrConversionUnsupported = errors.New("unsupported")

+ var Maybe someDef[interface{}]

+ var None = noneDef

+ func CompareToOrdered(a, b T) int

+ func Compose(fnList ...func(...T) []T) func(...T) []T

+ func ComposeInterface(fnList ...func(...interface{}) []interface{}) func(...interface{}) []interface

+ func Concat(mine []T, slices ...[]T) []T

+ func CurryParam1(fn func(A, ...T) R, a A) func(...T) R

+ func CurryParam1ForSlice1(fn func(A, []T) R, a A) func(...T) R

+ func CurryParam2(fn func(A, B, ...T) R, a A, b B) func(...T) R

+ func CurryParam3(fn func(A, B, C, ...T) R, a A, b B, c C) func(...T) R

+ func CurryParam4(fn func(A, B, C, D, ...T) R, a A, b B, c C, d D) func(...T) R

+ func CurryParam5(fn func(A, B, C, D, E, ...T) R, a A, b B, c C, d D, e E) func(...T) R

+ func CurryParam6(fn func(A, B, C, D, E, F, ...T) R, a A, b B, c C, d D, e E, f F) func(...T) R

+ func Dedupe(list ...T) []T

+ func Difference(arrList ...[]T) []T

+ func Distinct(list ...T) []T

+ func DistinctForInterface(list ...interface{}) []interface

+ func DistinctRandom(list ...T) []T

+ func Drop(count int, list ...T) []T

+ func DropEq(num T, list ...T) []T

+ func DropLast(count int, list ...T) []T

+ func DropWhile(f Predicate[T], list ...T) []T

+ func DuplicateMap(input map[T]R) map[T]R

+ func DuplicateMapForInterface(input map[interface{}]R) map[interface{}]R

+ func DuplicateSlice(list []T) []T

+ func Either(value interface{}, patterns ...Pattern) interface

+ func Every(f Predicate[T], list ...T) bool

+ func Exists(input T, list ...T) bool

+ func ExistsForInterface(input interface{}, list ...interface{}) bool

+ func Filter(fn func(T, int) bool, input ...T) []T

+ func Flatten(list ...[]T) []T

+ func GroupBy(grouper TransformerFunctor[T, R], list ...T) map[R][]T

+ func Head(list ...T) T

+ func Intersection(inputList ...[]T) []T

+ func IntersectionForInterface(inputList ...[]interface{}) []interface

+ func IntersectionMapByKey(inputList ...map[T]R) map[T]R

+ func IntersectionMapByKeyForInterface(inputList ...map[interface{}]R) map[interface{}]R

+ func IsDistinct(list ...T) bool

+ func IsEqual(list1, list2 []T) bool

+ func IsEqualMap(map1, map2 map[T]R) bool

+ func IsNeg(v T) bool

+ func IsNil(obj interface{}) bool

+ func IsPos(v T) bool

+ func IsPtr(obj interface{}) bool

+ func IsSubset(list1, list2 []T) bool

+ func IsSubsetForInterface(list1, list2 []interface{}) bool

+ func IsSubsetMapByKey(item1, item2 map[T]R) bool

+ func IsSubsetMapByKeyForInterface(item1, item2 map[interface{}]R) bool

+ func IsSuperset(list1, list2 []T) bool

+ func IsSupersetForInterface(list1, list2 []interface{}) bool

+ func IsSupersetMapByKey(item1, item2 map[T]R) bool

+ func IsSupersetMapByKeyForInterface(item1, item2 map[interface{}]R) bool

+ func IsZero(v T) bool

+ func Keys(m map[T]R) []T

+ func KeysForInterface(m map[interface{}]R) []interface

+ func Kind(obj interface{}) reflect.Kind

+ func MakeNumericReturnForParam1ReturnBool1(fn func(T) bool) func(...T) []R

+ func MakeNumericReturnForSliceParamReturnBool1(fn func([]T) bool) func(...T) []R

+ func MakeNumericReturnForVariadicParamReturnBool1(fn func(...T) bool) func(...T) []R

+ func MakeVariadicParam1(fn func(T) []R) func(...T) []R

+ func MakeVariadicParam2(fn func(T, T) []R) func(...T) []R

+ func MakeVariadicParam3(fn func(T, T, T) []R) func(...T) []R

+ func MakeVariadicParam4(fn func(T, T, T, T) []R) func(...T) []R

+ func MakeVariadicParam5(fn func(T, T, T, T, T) []R) func(...T) []R

+ func MakeVariadicParam6(fn func(T, T, T, T, T, T) []R) func(...T) []R

+ func MakeVariadicReturn1(fn func(...T) R) func(...T) []R

+ func MakeVariadicReturn2(fn func(...T) (R, R)) func(...T) []R

+ func MakeVariadicReturn3(fn func(...T) (R, R, R)) func(...T) []R

+ func MakeVariadicReturn4(fn func(...T) (R, R, R, R)) func(...T) []R

+ func MakeVariadicReturn5(fn func(...T) (R, R, R, R, R)) func(...T) []R

+ func MakeVariadicReturn6(fn func(...T) (R, R, R, R, R, R)) func(...T) []R

+ func Map(fn TransformerFunctor[T, R], values ...T) []R

+ func MapIndexed(fn func(T, int) R, values ...T) []R

+ func MatchCompType(compType CompType, value CompData) bool

+ func MatchCompTypeRef(compType CompType, value *CompData) bool

+ func Max(list ...T) T

+ func Merge(map1, map2 map[T]R) map[T]R

+ func MergeForInterface(map1, map2 map[interface{}]R) map[interface{}]R

+ func Min(list ...T) T

+ func MinMax(list ...T) (T, T)

+ func Minus(set1, set2 []T) []T

+ func MinusForInterface(set1, set2 []interface{}) []interface

+ func MinusMapByKey(set1, set2 map[T]R) map[T]R

+ func PMap(f TransformerFunctor[T, R], option *PMapOption, list ...T) []R

+ func Partition(predicate Predicate[T], list ...T) [][]T

+ func Pipe(fnList ...func(...T) []T) func(...T) []T

+ func PipeInterface(fnList ...func(...interface{}) []interface{}) func(...interface{}) []interface

+ func Prepend(element T, list []T) []T

+ func PtrOf(v T) *T

+ func Range(lower, higher T, hops ...T) []T

+ func Reduce(fn ReducerFunctor[T, R], memo R, input ...T) R

+ func ReduceIndexed(fn func(R, T, int) R, memo R, input ...T) R

+ func Reject(fn func(T, int) bool, input ...T) []T

+ func Reverse(list ...T) []T

+ func SliceOf(args ...T) []T

+ func SliceToMap(defaultValue R, input ...T) map[T]R

+ func SliceToMapForInterface(defaultValue R, input ...interface{}) map[interface{}]R

+ func Some(f Predicate[T], list ...T) bool

+ func Sort(fn Comparator[T], input []T)

+ func SortBySortDescriptors(sortDescriptors []SortDescriptor[T], input []T)

+ func SortOrdered(ascending bool, input ...T) []T

+ func SortOrderedAscending(input ...T) []T

+ func SortOrderedDescending(input ...T) []T

+ func SortSlice(fn Comparator[T], input ...T) []T

+ func SortedListBySortDescriptors(sortDescriptors []SortDescriptor[T], input ...T) []T

+ func SplitEvery(size int, list ...T) [][]T

+ func Tail(list ...T) []T

+ func Take(count int, list ...T) []T

+ func TakeLast(count int, list ...T) []T

+ func Trampoline(fn func(...T) ([]T, bool, error), input ...T) ([]T, error)

+ func Union(arrList ...[]T) []T

+ func UniqBy(identify TransformerFunctor[T, R], list ...T) []T

+ func Values(m map[T]R) []R

+ func ValuesForInterface(m map[interface{}]R) []R

+ func Zip(list1 []T, list2 []R) map[T]R

+ type ActorDef struct

+ var Actor ActorDef[interface{}]

+ func ActorNewByOptionsGenerics(effect func(*ActorDef[T], T), ioCh *chan T, context map[string]interface{}) *ActorDef[T]

+ func ActorNewGenerics(effect func(*ActorDef[T], T)) *ActorDef[T]

+ func (actorSelf *ActorDef[T]) Close()

+ func (actorSelf *ActorDef[T]) GetChild(id time.Time) *ActorDef[T]

+ func (actorSelf *ActorDef[T]) GetDefault() *ActorDef[interface{}]

+ func (actorSelf *ActorDef[T]) GetID() time.Time

+ func (actorSelf *ActorDef[T]) GetParent() *ActorDef[T]

+ func (actorSelf *ActorDef[T]) IsClosed() bool

+ func (actorSelf *ActorDef[T]) New(effect func(*ActorDef[T], T)) *ActorDef[T]

+ func (actorSelf *ActorDef[T]) NewByOptions(effect func(*ActorDef[T], T), ioCh *chan T, context map[string]interface{}) *ActorDef[T]

+ func (actorSelf *ActorDef[T]) Send(message T)

+ func (actorSelf *ActorDef[T]) Spawn(effect func(*ActorDef[T], T)) *ActorDef[T]

+ type ActorHandle interface

+ Send func(message T)

+ type AskDef struct

+ Message T

+ var Ask AskDef[interface{}, interface{}]

+ func AskNewByOptionsGenerics(message T, ioCh *chan R) *AskDef[T, R]

+ func AskNewGenerics(message T) *AskDef[T, R]

+ func (askSelf *AskDef[T, R]) AskChannel(target ActorHandle[interface{}]) *chan R

+ func (askSelf *AskDef[T, R]) AskOnce(target ActorHandle[interface{}], timeout *time.Duration) (R, error)

+ func (askSelf *AskDef[T, R]) New(message T) *AskDef[T, R]

+ func (askSelf *AskDef[T, R]) NewByOptions(message T, ioCh *chan R) *AskDef[T, R]

+ func (askSelf *AskDef[T, R]) Reply(response R)

+ type AtomBool struct

+ func (atomBoolSelf *AtomBool) Get() bool

+ func (atomBoolSelf *AtomBool) Set(value bool)

+ type CompData struct

+ func NewCompData(compType CompType, value ...interface{}) *CompData

+ type CompType interface

+ Matches func(value ...interface{}) bool

+ func DefProduct(kinds ...reflect.Kind) CompType

+ func DefSum(compTypes ...CompType) CompType

+ type CompTypePatternDef struct

+ func (patternSelf CompTypePatternDef) Apply(value interface{}) interface{}

+ func (patternSelf CompTypePatternDef) Matches(value interface{}) bool

+ type Comparable interface

+ CompareTo func(T) int

+ type ComparableOrdered struct

+ Val T

+ func NewComparableOrdered(val T) ComparableOrdered[T]

+ func (obj ComparableOrdered[T]) CompareTo(input interface{}) int

+ type ComparableString struct

+ Val string

+ func NewComparableString(val string) ComparableString

+ func (obj ComparableString) CompareTo(input interface{}) int

+ type Comparator func(T, T) bool

+ type CorDef struct

+ var Cor CorDef[interface{}]

+ func CorNewGenerics(effect func()) *CorDef[T]

+ func (corSelf *CorDef[T]) DoNotation(effect func(*CorDef[T]) T) T

+ func (corSelf *CorDef[T]) IsDone() bool

+ func (corSelf *CorDef[T]) IsStarted() bool

+ func (corSelf *CorDef[T]) New(effect func()) *CorDef[interface{}]

+ func (corSelf *CorDef[T]) NewAndStart(effect func()) *CorDef[T]

+ func (corSelf *CorDef[T]) Start()

+ func (corSelf *CorDef[T]) StartWithVal(in T)

+ func (corSelf *CorDef[T]) YieldFrom(target *CorDef[T], in T) T

+ func (corSelf *CorDef[T]) YieldFromIO(target *MonadIODef[T]) T

+ func (corSelf *CorDef[T]) YieldRef(out T) T

+ type CorOp struct

+ type CurryDef struct

+ func CurryNew(...) *CurryDef[interface{}, interface{}]

+ func CurryNewGenerics(fn func(c *CurryDef[T, R], args ...T) R) *CurryDef[T, R]

+ func (currySelf *CurryDef[T, R]) Call(args ...T) *CurryDef[T, R]

+ func (currySelf *CurryDef[T, R]) IsDone() bool

+ func (currySelf *CurryDef[T, R]) MarkDone()

+ func (currySelf *CurryDef[T, R]) Result() R

+ type EqualPatternDef struct

+ func (patternSelf EqualPatternDef) Apply(value interface{}) interface{}

+ func (patternSelf EqualPatternDef) Matches(value interface{}) bool

+ type FieldSortDescriptor struct

+ func NewFieldSortDescriptor(fieldName string, ascending bool) FieldSortDescriptor[T]

+ func (descriptor FieldSortDescriptor[T]) GetFieldName() string

+ func (descriptor FieldSortDescriptor[T]) SetFieldName(val string)

+ func (descriptor FieldSortDescriptor[T]) TransformedBy() TransformerFunctor[T, Comparable[interface{}]]

+ type HandlerDef struct

+ var Handler HandlerDef

+ func (handlerSelf *HandlerDef) Close()

+ func (handlerSelf *HandlerDef) GetDefault() *HandlerDef

+ func (handlerSelf *HandlerDef) New() *HandlerDef

+ func (handlerSelf *HandlerDef) NewByCh(ioCh *chan func()) *HandlerDef

+ func (handlerSelf *HandlerDef) Post(fn func())

+ type KindPatternDef struct

+ func (patternSelf KindPatternDef) Apply(value interface{}) interface{}

+ func (patternSelf KindPatternDef) Matches(value interface{}) bool

+ type MapSetDef map[T]R

+ func SetFrom(list ...T) *MapSetDef[T, R]

+ func SetFromArray(list []T) *MapSetDef[T, R]

+ func SetFromMap(theMap map[T]R) *MapSetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) Add(input ...T) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) AsMap() map[T]R

+ func (mapSetSelf *MapSetDef[T, R]) AsMapSet() *MapSetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) Clone() SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) ContainsKey(input T) bool

+ func (mapSetSelf *MapSetDef[T, R]) ContainsValue(input R) bool

+ func (mapSetSelf *MapSetDef[T, R]) Get(key T) R

+ func (mapSetSelf *MapSetDef[T, R]) Intersection(input SetDef[T, R]) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) IsSubsetByKey(input SetDef[T, R]) bool

+ func (mapSetSelf *MapSetDef[T, R]) IsSupersetByKey(input SetDef[T, R]) bool

+ func (mapSetSelf *MapSetDef[T, R]) Keys() []T

+ func (mapSetSelf *MapSetDef[T, R]) MapKey(fn TransformerFunctor[T, T]) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) MapValue(fn TransformerFunctor[R, R]) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) Minus(input SetDef[T, R]) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) RemoveKeys(input ...T) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) RemoveValues(input ...R) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) Set(key T, value R)

+ func (mapSetSelf *MapSetDef[T, R]) Size() int

+ func (mapSetSelf *MapSetDef[T, R]) Union(input SetDef[T, R]) SetDef[T, R]

+ func (mapSetSelf *MapSetDef[T, R]) Values() []R

+ type MaybeDef interface

+ Clone func() MaybeDef[T]

+ FlatMap func(fn func(T) MaybeDef[T]) MaybeDef[T]

+ IsKind func(t reflect.Kind) bool

+ IsNil func() bool

+ IsPresent func() bool

+ IsPtr func() bool

+ IsType func(t reflect.Type) bool

+ IsValid func() bool

+ Just func(in interface{}) MaybeDef[interface{}]

+ Kind func() reflect.Kind

+ Let func(fn func())

+ Or func(or T) T

+ ToBool func() (bool, error)

+ ToFloat32 func() (float32, error)

+ ToFloat64 func() (float64, error)

+ ToInt func() (int, error)

+ ToInt32 func() (int32, error)

+ ToInt64 func() (int64, error)

+ ToMaybe func() MaybeDef[T]

+ ToPtr func() *T

+ ToString func() string

+ Type func() reflect.Type

+ Unwrap func() T

+ UnwrapInterface func() interface{}

+ func CloneTo(maybeSelf MaybeDef[T], dest T) MaybeDef[T]

+ func JustGenerics(in T) MaybeDef[T]

+ type MonadIODef struct

+ var MonadIO MonadIODef[interface{}]

+ func MonadIOJustGenerics(in T) *MonadIODef[T]

+ func MonadIONewGenerics(effect func() T) *MonadIODef[T]

+ func (monadIOSelf *MonadIODef[T]) Eval() T

+ func (monadIOSelf *MonadIODef[T]) FlatMap(fn func(T) *MonadIODef[T]) *MonadIODef[T]

+ func (monadIOSelf *MonadIODef[T]) New(effect func() T) *MonadIODef[T]

+ func (monadIOSelf *MonadIODef[T]) ObserveOn(h *HandlerDef) *MonadIODef[T]

+ func (monadIOSelf *MonadIODef[T]) Subscribe(s Subscription[T]) *Subscription[T]

+ func (monadIOSelf *MonadIODef[T]) SubscribeOn(h *HandlerDef) *MonadIODef[T]

+ func (monadIOSelf MonadIODef[T]) Just(in interface{}) *MonadIODef[interface{}]

+ type NilTypeDef struct

+ var NilType NilTypeDef

+ func (typeSelf NilTypeDef) Matches(value ...interface{}) bool

+ type Numeric interface

+ type Ordered interface

+ type OtherwisePatternDef struct

+ func (patternSelf OtherwisePatternDef) Apply(value interface{}) interface{}

+ func (patternSelf OtherwisePatternDef) Matches(value interface{}) bool

+ type PMapOption struct

+ FixedPool int

+ RandomOrder bool

+ type Pattern interface

+ Apply func(interface{}) interface{}

+ Matches func(value interface{}) bool

+ func InCaseOfEqual(value interface{}, effect fnObj) Pattern

+ func InCaseOfKind(kind reflect.Kind, effect fnObj) Pattern

+ func InCaseOfRegex(pattern string, effect fnObj) Pattern

+ func InCaseOfSumType(compType CompType, effect fnObj) Pattern

+ func Otherwise(effect fnObj) Pattern

+ type PatternMatching struct

+ func DefPattern(patterns ...Pattern) PatternMatching

+ func (patternMatchingSelf PatternMatching) MatchFor(inValue interface{}) interface{}

+ type Predicate func(T) bool

+ type PredicateErr func(T, int) (bool, error)

+ type ProductType struct

+ func (typeSelf ProductType) Matches(value ...interface{}) bool

+ type PublisherDef struct

+ var Publisher PublisherDef[interface{}]

+ func PublisherNewGenerics() *PublisherDef[T]

+ func (publisherSelf *PublisherDef[T]) Map(fn func(T) T) *PublisherDef[T]

+ func (publisherSelf *PublisherDef[T]) New() *PublisherDef[interface{}]

+ func (publisherSelf *PublisherDef[T]) Publish(result T)

+ func (publisherSelf *PublisherDef[T]) Subscribe(sub Subscription[T]) *Subscription[T]

+ func (publisherSelf *PublisherDef[T]) SubscribeOn(h *HandlerDef) *PublisherDef[T]

+ func (publisherSelf *PublisherDef[T]) Unsubscribe(s *Subscription[T])

+ type ReducerFunctor func(R, T) R

+ type RegexPatternDef struct

+ func (patternSelf RegexPatternDef) Apply(value interface{}) interface{}

+ func (patternSelf RegexPatternDef) Matches(value interface{}) bool

+ type SetDef interface

+ Add func(input ...T) SetDef[T, R]

+ AsMap func() map[T]R

+ AsMapSet func() *MapSetDef[T, R]

+ Clone func() SetDef[T, R]

+ ContainsKey func(input T) bool

+ ContainsValue func(input R) bool

+ Get func(key T) R

+ Intersection func(input SetDef[T, R]) SetDef[T, R]

+ IsSubsetByKey func(input SetDef[T, R]) bool

+ IsSupersetByKey func(input SetDef[T, R]) bool

+ Keys func() []T

+ MapKey func(fn TransformerFunctor[T, T]) SetDef[T, R]

+ MapValue func(fn TransformerFunctor[R, R]) SetDef[T, R]

+ Minus func(input SetDef[T, R]) SetDef[T, R]

+ RemoveKeys func(input ...T) SetDef[T, R]

+ RemoveValues func(input ...R) SetDef[T, R]

+ Set func(key T, value R)

+ Size func() int

+ Union func(input SetDef[T, R]) SetDef[T, R]

+ Values func() []R

+ type SetForInterfaceDef map[interface{}]interface

+ func (setSelf *SetForInterfaceDef) Add(input ...interface{}) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) Clone() *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) ContainsKey(input interface{}) bool

+ func (setSelf *SetForInterfaceDef) ContainsValue(input interface{}) bool

+ func (setSelf *SetForInterfaceDef) Get(key interface{}) interface{}

+ func (setSelf *SetForInterfaceDef) Intersection(input *SetForInterfaceDef) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) IsSubsetByKey(input *SetForInterfaceDef) bool

+ func (setSelf *SetForInterfaceDef) IsSupersetByKey(input *SetForInterfaceDef) bool

+ func (setSelf *SetForInterfaceDef) Keys() []interface{}

+ func (setSelf *SetForInterfaceDef) MapKey(fn TransformerFunctor[interface{}, interface{}]) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) MapValue(fn TransformerFunctor[interface{}, interface{}]) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) Minus(input *SetForInterfaceDef) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) RemoveKeys(input ...interface{}) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) RemoveValues(input ...interface{}) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) Set(key interface{}, value interface{})

+ func (setSelf *SetForInterfaceDef) Size() int

+ func (setSelf *SetForInterfaceDef) Union(input *SetForInterfaceDef) *SetForInterfaceDef

+ func (setSelf *SetForInterfaceDef) Values() []interface{}

+ var Set SetForInterfaceDef

+ func SetForInterfaceFrom(list ...interface{}) *SetForInterfaceDef

+ func SetForInterfaceFromArray(list []interface{}) *SetForInterfaceDef

+ func SetForInterfaceFromMap(theMap map[interface{}]interface{}) *SetForInterfaceDef

+ type SimpleSortDescriptor struct

+ func NewSimpleSortDescriptor(transformFn TransformerFunctor[T, Comparable[interface{}]], ascending bool) SimpleSortDescriptor[T]

+ func (descriptor SimpleSortDescriptor[T]) IsAscending() bool

+ func (descriptor SimpleSortDescriptor[T]) SetAscending(val bool)

+ func (descriptor SimpleSortDescriptor[T]) TransformedBy() TransformerFunctor[T, Comparable[interface{}]]

+ type SortDescriptor interface

+ IsAscending func() bool

+ SetAscending func(bool)

+ type SortDescriptorsBuilder []SortDescriptor[T]

+ func NewSortDescriptorsBuilder() SortDescriptorsBuilder[T]

+ func (builder SortDescriptorsBuilder[T]) GetSortDescriptors() []SortDescriptor[T]

+ func (builder SortDescriptorsBuilder[T]) Sort(input []T)

+ func (builder SortDescriptorsBuilder[T]) ThenWith(input ...SortDescriptor[T]) SortDescriptorsBuilder[T]

+ func (builder SortDescriptorsBuilder[T]) ThenWithFieldName(fieldName string, ascending bool) SortDescriptorsBuilder[T]

+ func (builder SortDescriptorsBuilder[T]) ThenWithTransformerFunctor(transformFn TransformerFunctor[T, Comparable[interface{}]], ascending bool) SortDescriptorsBuilder[T]

+ func (builder SortDescriptorsBuilder[T]) ToSortedList(input ...T) []T

+ type StreamDef []T

+ func StreamFrom(list ...T) *StreamDef[T]

+ func StreamFromArray(list []T) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Append(item ...T) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Clone() *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Concat(slices ...[]T) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Contains(input T) bool

+ func (streamSelf *StreamDef[T]) Distinct() *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Extend(streams ...*StreamDef[T]) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Filter(fn func(T, int) bool) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) FilterNotNil() *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Get(i int) T

+ func (streamSelf *StreamDef[T]) Intersection(input *StreamDef[T]) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) IsSubset(input *StreamDef[T]) bool

+ func (streamSelf *StreamDef[T]) IsSuperset(input *StreamDef[T]) bool

+ func (streamSelf *StreamDef[T]) Len() int

+ func (streamSelf *StreamDef[T]) Map(fn func(T, int) T) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Minus(input *StreamDef[T]) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Reject(fn func(T, int) bool) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Remove(index int) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) RemoveItem(input ...T) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Reverse() *StreamDef[T]

+ func (streamSelf *StreamDef[T]) Sort(fn Comparator[T]) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) SortByIndex(fn func(a, b int) bool) *StreamDef[T]

+ func (streamSelf *StreamDef[T]) ToArray() []T

+ type StreamForInterfaceDef []interface

+ func (streamSelf *StreamForInterfaceDef) Append(item ...interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Clone() *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Concat(slices ...[]interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Contains(input interface{}) bool

+ func (streamSelf *StreamForInterfaceDef) Distinct() *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Extend(streams ...*StreamForInterfaceDef) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Filter(fn func(interface{}, int) bool) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FilterNotNil() *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) From(list ...interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArray(list []interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayBool(old []bool) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayByte(old []byte) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayFloat32(old []float32) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayFloat64(old []float64) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayInt(old []int) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayInt16(old []int16) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayInt32(old []int32) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayInt64(old []int64) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayInt8(old []int8) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayMaybe(old []MaybeDef[interface{}]) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) FromArrayString(old []string) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Get(i int) interface{}

+ func (streamSelf *StreamForInterfaceDef) Intersection(input *StreamForInterfaceDef) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) IsSubset(input *StreamForInterfaceDef) bool

+ func (streamSelf *StreamForInterfaceDef) IsSuperset(input *StreamForInterfaceDef) bool

+ func (streamSelf *StreamForInterfaceDef) Len() int

+ func (streamSelf *StreamForInterfaceDef) Map(fn func(interface{}, int) interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Minus(input *StreamForInterfaceDef) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Reject(fn func(interface{}, int) bool) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Remove(index int) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) RemoveItem(input ...interface{}) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Reverse() *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) Sort(fn Comparator[interface{}]) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) SortByIndex(fn func(a, b int) bool) *StreamForInterfaceDef

+ func (streamSelf *StreamForInterfaceDef) ToArray() []interface{}

+ var StreamForInterface StreamForInterfaceDef

+ type StreamSetDef struct

+ func NewStreamSet() *StreamSetDef[T, R]

+ func StreamSetFrom(list ...T) *StreamSetDef[T, R]

+ func StreamSetFromArray(list []T) *StreamSetDef[T, R]

+ func StreamSetFromMap(theMap map[T]*StreamDef[R]) *StreamSetDef[T, R]

+ func (streamSetSelf *StreamSetDef[T, R]) Clone() *StreamSetDef[T, R]

+ func (streamSetSelf *StreamSetDef[T, R]) Intersection(input *StreamSetDef[T, R]) *StreamSetDef[T, R]

+ func (streamSetSelf *StreamSetDef[T, R]) MinusStreams(input *StreamSetDef[T, R]) *StreamSetDef[T, R]

+ func (streamSetSelf *StreamSetDef[T, R]) Union(input *StreamSetDef[T, R]) *StreamSetDef[T, R]

+ type StreamSetForInterfaceDef struct

+ var StreamSetForInterface StreamSetForInterfaceDef

+ func NewStreamSetForInterface() *StreamSetForInterfaceDef

+ func StreamSetForInterfaceFrom(list ...interface{}) *StreamSetForInterfaceDef

+ func StreamSetForInterfaceFromArray(list []interface{}) *StreamSetForInterfaceDef

+ func StreamSetForInterfaceFromMap(theMap map[interface{}]*StreamForInterfaceDef) *StreamSetForInterfaceDef

+ func StreamSetFromArrayInterface(list []interface{}) *StreamSetForInterfaceDef

+ func StreamSetFromInterface(list ...interface{}) *StreamSetForInterfaceDef

+ func (streamSetSelf *StreamSetForInterfaceDef) Clone() *StreamSetForInterfaceDef

+ func (streamSetSelf *StreamSetForInterfaceDef) Intersection(input *StreamSetForInterfaceDef) *StreamSetForInterfaceDef

+ func (streamSetSelf *StreamSetForInterfaceDef) IsSubsetByKey(input *StreamSetForInterfaceDef) bool

+ func (streamSetSelf *StreamSetForInterfaceDef) IsSupersetByKey(input *StreamSetForInterfaceDef) bool

+ func (streamSetSelf *StreamSetForInterfaceDef) Minus(input *StreamSetForInterfaceDef) *StreamSetForInterfaceDef

+ func (streamSetSelf *StreamSetForInterfaceDef) MinusStreams(input *StreamSetForInterfaceDef) *StreamSetForInterfaceDef

+ func (streamSetSelf *StreamSetForInterfaceDef) Union(input *StreamSetForInterfaceDef) *StreamSetForInterfaceDef

+ type Subscription struct

+ OnNext func(T)

+ type SumType struct

+ func (typeSelf SumType) Matches(value ...interface{}) bool

+ type Transformer interface

+ TransformedBy func() TransformerFunctor[T, R]

+ type TransformerFunctor func(T) R

Other modules containing this package

github.com/TeaEntityLab/fpGo

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