fpgo

package module

Go to main page

Versions in this module

v1

v1.5.2

Jun 2, 2022

v1.5.1

May 26, 2022

v1.5.0

May 19, 2022

v1.4.6

May 17, 2022

Changes in this version

type BufferedChannelQueue

+ func (q *BufferedChannelQueue) Count() int

+ func (q *BufferedChannelQueue) GetChannel() chan interface{}

v1.4.5

May 17, 2022

v1.4.4

May 16, 2022

Changes in this version

type BufferedChannelQueue

+ func (q *BufferedChannelQueue) GetBufferSizeMaximum() int

+ func (q *BufferedChannelQueue) GetFreeNodeHookPoolIntervalDuration() time.Duration

+ func (q *BufferedChannelQueue) GetLoadFromPoolDuration() time.Duration

+ func (q *BufferedChannelQueue) GetNodeHookPoolSize() int

+ func (q *BufferedChannelQueue) IsClosed() bool

v1.4.3

May 15, 2022

Changes in this version

type AskDef

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

v1.4.2

May 15, 2022

Changes in this version

+ type ConcurrentStack struct

+ func NewConcurrentStack(stack Stack) *ConcurrentStack

+ func (q *ConcurrentStack) Pop() (interface{}, error)

+ func (q *ConcurrentStack) Push(val interface{}) error

v1.4.1

May 13, 2022

v1.4.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

+ func (q *BufferedChannelQueue) Close()

+ func (q *BufferedChannelQueue) Offer(val interface{}) error

+ func (q *BufferedChannelQueue) Poll() (interface{}, error)

+ func (q *BufferedChannelQueue) Put(val interface{}) error

+ func (q *BufferedChannelQueue) SetBufferSizeMaximum(size int)

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

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

+ func (q *BufferedChannelQueue) SetNodeHookPoolSize(size int)

+ func (q *BufferedChannelQueue) Take() (interface{}, error)

+ func (q *BufferedChannelQueue) TakeWithTimeout(timeout time.Duration) (interface{}, error)

+ type ChannelQueue chan interface

+ func (q ChannelQueue) Offer(val interface{}) error

+ func (q ChannelQueue) Poll() (interface{}, error)

+ func (q ChannelQueue) Put(val interface{}) error

+ func (q ChannelQueue) PutWithTimeout(val interface{}, timeout time.Duration) error

+ func (q ChannelQueue) Take() (interface{}, error)

+ func (q ChannelQueue) TakeWithTimeout(timeout time.Duration) (interface{}, error)

+ func NewChannelQueue(capacity int) ChannelQueue

+ type ConcurrentQueue struct

+ func NewConcurrentQueue(queue Queue) *ConcurrentQueue

+ func (q *ConcurrentQueue) Offer(val interface{}) error

+ func (q *ConcurrentQueue) Poll() (interface{}, error)

+ func (q *ConcurrentQueue) Put(val interface{}) error

+ func (q *ConcurrentQueue) Take() (interface{}, error)

+ type DoublyListItem struct

+ Next *DoublyListItem

+ Prev *DoublyListItem

+ Val *interface{}

+ func (listItem *DoublyListItem) AddFirst(input *DoublyListItem) *DoublyListItem

+ func (listItem *DoublyListItem) AddLast(input *DoublyListItem) *DoublyListItem

+ func (listItem *DoublyListItem) Count() int

+ func (listItem *DoublyListItem) First() *DoublyListItem

+ func (listItem *DoublyListItem) Last() *DoublyListItem

+ type LinkedListItem struct

+ Next *LinkedListItem

+ Val *interface{}

+ func (listItem *LinkedListItem) AddLast(input *LinkedListItem) *LinkedListItem

+ func (listItem *LinkedListItem) Count() int

+ func (listItem *LinkedListItem) Last() *LinkedListItem

+ type LinkedListQueue struct

+ func NewLinkedListQueue() *LinkedListQueue

+ func (q *LinkedListQueue) Clear()

+ func (q *LinkedListQueue) ClearNodePool()

+ func (q *LinkedListQueue) Count() int

+ func (q *LinkedListQueue) KeepNodePoolCount(n int)

+ func (q *LinkedListQueue) Offer(val interface{}) error

+ func (q *LinkedListQueue) Peek() (interface{}, error)

+ func (q *LinkedListQueue) Poll() (interface{}, error)

+ func (q *LinkedListQueue) Pop() (interface{}, error)

+ func (q *LinkedListQueue) Push(val interface{}) error

+ func (q *LinkedListQueue) Put(val interface{}) error

+ func (q *LinkedListQueue) Shift() (interface{}, error)

+ func (q *LinkedListQueue) Take() (interface{}, error)

+ func (q *LinkedListQueue) Unshift(val interface{}) error

+ type Queue interface

+ Offer func(val interface{}) error

+ Poll func() (interface{}, error)

+ Put func(val interface{}) error

+ Take func() (interface{}, error)

+ type Stack interface

+ Pop func() (interface{}, error)

+ Push func(val interface{}) error

v1.3.11

Aug 21, 2021

Changes in this version

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

v1.3.10

Aug 16, 2021

Changes in this version

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

v1.3.9

Aug 15, 2021

v1.3.8

Aug 15, 2021

v1.3.7

Aug 15, 2021

Changes in this version

+ type ActorHandle interface

+ Send func(message interface{})

+ type AskDef struct

+ Message interface{}

+ var Ask AskDef

+ func AskNewByOptionsGenerics(message interface{}, ioCh *chan interface{}, timeout *time.Duration) *AskDef

+ func AskNewGenerics(message interface{}, timeout *time.Duration) *AskDef

+ func (askSelf *AskDef) AskChannel(target ActorHandle) (*chan interface{}, *time.Timer)

+ func (askSelf *AskDef) AskOnce(target ActorHandle) interface{}

+ func (askSelf *AskDef) New(message interface{}, timeout *time.Duration) *AskDef

+ func (askSelf *AskDef) NewByOptions(message interface{}, ioCh *chan interface{}, timeout *time.Duration) *AskDef

+ func (askSelf *AskDef) Reply(response interface{})

v1.3.6

Aug 15, 2021

Changes in this version

type ActorDef

+ func (actorSelf *ActorDef) GetID() time.Time

v1.3.5

Aug 14, 2021

Changes in this version

+ type ActorDef struct

+ var Actor ActorDef

+ func (actorSelf *ActorDef) Close()

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

+ func (actorSelf *ActorDef) GetDefault() *ActorDef

+ func (actorSelf *ActorDef) GetParent() *ActorDef

+ func (actorSelf *ActorDef) IsClosed() bool

+ func (actorSelf *ActorDef) New(effect func(*ActorDef, interface{})) *ActorDef

+ func (actorSelf *ActorDef) NewByOptions(effect func(*ActorDef, interface{}), ioCh *chan interface{}, ...) *ActorDef

+ func (actorSelf *ActorDef) Send(message interface{})

+ func (actorSelf *ActorDef) Spawn(effect func(*ActorDef, interface{})) *ActorDef

type HandlerDef

+ func (handlerSelf *HandlerDef) IsClosed() bool

v1.3.4

Jul 18, 2021

v1.3.3

Jul 18, 2021

v1.3.2

Jul 17, 2021

Changes in this version

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

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

+ func IsPtr(obj interface{}) bool

type MaybeDef

+ IsPtr func() bool

type MonadIODef

+ func (monadIOSelf *MonadIODef) Eval() interface{}

v1.3.1

Jul 15, 2021

v1.3.0

Jul 15, 2021

Changes in this version

+ var None = noneDef

+ func CurryParam1ForSlice1(fn func(interface{}, []interface{}) interface{}, a interface{}) func(...interface{}) interface

+ func IsNil(obj interface{}) bool

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

+ func MakeNumericReturnForSliceParamReturnBool1(fn func([]interface{}) bool) func(...interface{}) []interface

v1.2.3

Jul 14, 2021

Changes in this version

+ func MakeNumericReturnForParam1ReturnBool1(fn func(interface{}) bool) func(...interface{}) []interface

+ func MakeNumericReturnForVariadicParamReturnBool1(fn func(...interface{}) bool) func(...interface{}) []interface

type SetDef

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

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

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

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

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

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

+ func (setSelf *SetDef) MapKey(fn TransformerFunctor) *SetDef

+ func (setSelf *SetDef) MapValue(fn TransformerFunctor) *SetDef

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

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

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

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

type StreamDef

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

+ type StreamSetDef struct

+ var StreamSet StreamSetDef

+ func NewStreamSet() *StreamSetDef

+ func StreamSetFrom(list ...interface{}) *StreamSetDef

+ func StreamSetFromArray(list []interface{}) *StreamSetDef

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

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

+ func StreamSetFromMap(theMap map[interface{}]*StreamDef) *StreamSetDef

+ func (streamSetSelf *StreamSetDef) Clone() *StreamSetDef

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

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

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

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

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

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

v1.2.2

Jul 13, 2021

Changes in this version

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

+ func DuplicateMap(input map[interface{}]interface{}) map[interface{}]interface

+ type SetDef map[interface{}]interface

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

+ func (setSelf *SetDef) Clone() *SetDef

+ func (setSelf *SetDef) Contains(input interface{}) bool

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

+ func (setSelf *SetDef) IsSubset(input *SetDef) bool

+ func (setSelf *SetDef) IsSuperset(input *SetDef) bool

+ func (setSelf *SetDef) Map(fn TransformerFunctor) *SetDef

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

+ func (setSelf *SetDef) Remove(input ...interface{}) *SetDef

+ func (setSelf *SetDef) Size() int

+ func (setSelf *SetDef) ToArray() []interface{}

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

+ func SetFrom(list ...interface{}) *SetDef

+ func SetFromArray(list []interface{}) *SetDef

+ func SetFromArrayInterface(list []interface{}) *SetDef

+ func SetFromInterface(list ...interface{}) *SetDef

+ func SetFromMap(theMap map[interface{}]interface{}) *SetDef

type StreamDef

+ func (streamSelf *StreamDef) Clone() *StreamDef

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

+ func (streamSelf *StreamDef) FilterNotNil() *StreamDef

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

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

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

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

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

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

+ func (streamSelf *StreamDef) Reverse() *StreamDef

v1.2.1

Jul 12, 2021

Changes in this version

+ func CurryParam1(fn func(interface{}, ...interface{}) interface{}, a interface{}) func(...interface{}) interface

+ func CurryParam2(fn func(interface{}, interface{}, ...interface{}) interface{}, a interface{}, ...) func(...interface{}) interface

+ func CurryParam3(fn func(interface{}, interface{}, interface{}, ...interface{}) interface{}, ...) func(...interface{}) interface

+ func CurryParam4(...) func(...interface{}) interface

+ func CurryParam5(...) func(...interface{}) interface

+ func CurryParam6(...) func(...interface{}) interface

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

+ func Difference(arrList ...[]interface{}) []interface

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

+ func Drop(count int, list ...interface{}) []interface

+ func DropEq(num interface{}, list ...interface{}) []interface

+ func DropLast(count int, list ...interface{}) []interface

+ func DropWhile(f Predicate, list ...interface{}) []interface

+ func DuplicateSlice(list []interface{}) []interface

+ func Every(f Predicate, list ...interface{}) bool

+ func Exists(num interface{}, list ...interface{}) bool

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

+ func GroupBy(grouper TransformerFunctor, list ...interface{}) map[interface{}][]interface

+ func Head(list ...interface{}) interface

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

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

+ func IsDistinct(list ...interface{}) bool

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

+ func IsEqualMap(map1, map2 map[interface{}]interface{}) bool

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

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

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

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

+ func IsZero(v interface{}) bool

+ func Keys(m map[interface{}]interface{}) []interface

+ func MakeNumericReturnForBool1(fn func(...interface{}) bool) func(...interface{}) []interface

+ func MakeVariadicParam1(fn func(interface{}) interface{}) func(...interface{}) interface

+ func MakeVariadicParam2(fn func(interface{}, interface{}) interface{}) func(...interface{}) interface

+ func MakeVariadicParam3(fn func(interface{}, interface{}, interface{}) interface{}) func(...interface{}) interface

+ func MakeVariadicParam4(fn func(interface{}, interface{}, interface{}, interface{}) interface{}) func(...interface{}) interface

+ func MakeVariadicParam5(...) func(...interface{}) interface

+ func MakeVariadicParam6(...) func(...interface{}) interface

+ func MakeVariadicReturn1(fn func(...interface{}) interface{}) func(...interface{}) []interface

+ func MakeVariadicReturn2(fn func(...interface{}) (interface{}, interface{})) func(...interface{}) []interface

+ func MakeVariadicReturn3(fn func(...interface{}) (interface{}, interface{}, interface{})) func(...interface{}) []interface

+ func MakeVariadicReturn4(fn func(...interface{}) (interface{}, interface{}, interface{}, interface{})) func(...interface{}) []interface

+ func MakeVariadicReturn5(...) func(...interface{}) []interface

+ func MakeVariadicReturn6(...) func(...interface{}) []interface

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

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

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

+ func PMap(f TransformerFunctor, option *PMapOption, list ...interface{}) []interface

+ func Partition(predicate Predicate, list ...interface{}) [][]interface

+ func Prepend(element interface{}, list []interface{}) []interface

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

+ func Set(list []interface{}) []interface

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

+ func Some(f Predicate, list ...interface{}) bool

+ func SplitEvery(size int, list ...interface{}) [][]interface

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

+ func Take(count int, list ...interface{}) []interface

+ func TakeLast(count int, list ...interface{}) []interface

+ func Trampoline(fn func(...interface{}) ([]interface{}, bool, error), input ...interface{}) ([]interface{}, error)

+ func Union(arrList ...[]interface{}) []interface

+ func UniqBy(identify TransformerFunctor, list ...interface{}) []interface

+ func Values(m map[interface{}]interface{}) []interface

+ func Zip(list1 []interface{}, list2 []interface{}) map[interface{}]interface

+ type PMapOption struct

+ FixedPool int

+ RandomOrder bool

+ type PredicateErr func(interface{}, int) (bool, error)

+ type ReducerFunctor func(interface{}, interface{}) interface

v1.2.0

Jul 8, 2021

Changes in this version

+ func Concat(mine []interface{}, slices ...[]interface{}) []interface

+ func Filter(fn func(interface{}, int) bool, input ...interface{}) []interface

+ func Map(fn TransformerFunctor, values ...interface{}) []interface

+ func MapIndexed(fn func(interface{}, int) interface{}, values ...interface{}) []interface

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

+ func Reduce(fn func(interface{}, interface{}) interface{}, memo interface{}, ...) interface

+ func ReduceIndexed(fn func(interface{}, interface{}, int) interface{}, memo interface{}, ...) interface

+ func Reject(fn func(interface{}, int) bool, input ...interface{}) []interface

+ func Sort(fn Comparator, input []interface{})

+ func SortBySortDescriptors(sortDescriptors []SortDescriptor, input []interface{})

+ func SortSlice(fn Comparator, input ...interface{}) []interface

+ func SortedListBySortDescriptors(sortDescriptors []SortDescriptor, input ...interface{}) []interface

+ type Comparable interface

+ CompareTo func(interface{}) int

+ type Comparator func(interface{}, interface{}) bool

+ type FieldSortDescriptor struct

+ func NewFieldSortDescriptor(fieldName string, ascending bool) FieldSortDescriptor

+ func (descriptor FieldSortDescriptor) GetFieldName() string

+ func (descriptor FieldSortDescriptor) SetFieldName(val string)

+ func (descriptor FieldSortDescriptor) TransformedBy() TransformerFunctor

+ type Predicate func(interface{}) bool

+ type SimpleSortDescriptor struct

+ func NewSimpleSortDescriptor(transformFn TransformerFunctor, ascending bool) SimpleSortDescriptor

+ func (descriptor SimpleSortDescriptor) IsAscending() bool

+ func (descriptor SimpleSortDescriptor) SetAscending(val bool)

+ func (descriptor SimpleSortDescriptor) TransformedBy() TransformerFunctor

+ type SortDescriptor interface

+ IsAscending func() bool

+ SetAscending func(bool)

+ TransformedBy func() TransformerFunctor

+ type SortDescriptorsBuilder []SortDescriptor

+ func NewSortDescriptorsBuilder() SortDescriptorsBuilder

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

+ func (builder SortDescriptorsBuilder) Sort(input []interface{})

+ func (builder SortDescriptorsBuilder) ThenWith(input ...SortDescriptor) SortDescriptorsBuilder

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

+ func (builder SortDescriptorsBuilder) ThenWithTransformerFunctor(transformFn TransformerFunctor, ascending bool) SortDescriptorsBuilder

+ func (builder SortDescriptorsBuilder) ToSortedList(input ...interface{}) []interface{}

type StreamDef

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

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

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

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

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

+ type Transformer interface

+ TransformedBy func() TransformerFunctor

+ type TransformerFunctor func(interface{}) interface

v1.1.3

Jun 20, 2018

Changes in this version

+ func SliceOf(args ...interface{}) []interface

v1.1.2

Jun 20, 2018

v1.1.1

Jun 18, 2018

Changes in this version

type MaybeDef

+ func (self MaybeDef) Clone() MaybeDef

+ func (self MaybeDef) CloneTo(dest interface{}) MaybeDef

v1.1.0

Jun 18, 2018

Changes in this version

type CorDef

+ func (self *CorDef) StartWithVal(in interface{})

type MaybeDef

+ func (self MaybeDef) IsValid() bool

+ func (self MaybeDef) ToPtr() *interface{}

v1.0.0

Jun 16, 2018

Changes in this version

+ func Compose(fnList ...fnObj) fnObj

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

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

+ func MatchCompType(compType CompType, value CompData) bool

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

+ func PtrOf(v interface{}) *interface

+ type AtomBool struct

+ func (self *AtomBool) Get() bool

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

+ type CompData struct

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

+ func NewCompDataVal(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 (self CompTypePatternDef) Apply(value *interface{}) *interface{}

+ func (self CompTypePatternDef) Matches(value *interface{}) bool

+ type CorDef struct

+ var Cor CorDef

+ func (self *CorDef) DoNotation(effect func(*CorDef) *interface{}) *interface{}

+ func (self *CorDef) IsDone() bool

+ func (self *CorDef) IsStarted() bool

+ func (self *CorDef) New(effect func()) *CorDef

+ func (self *CorDef) NewAndStart(effect func()) *CorDef

+ func (self *CorDef) Start()

+ func (self *CorDef) StartWithRef(in *interface{})

+ func (self *CorDef) Yield() *interface{}

+ func (self *CorDef) YieldFrom(target *CorDef, in *interface{}) *interface{}

+ func (self *CorDef) YieldFromIO(target *MonadIODef) *interface{}

+ func (self *CorDef) YieldRef(out *interface{}) *interface{}

+ type CorOp struct

+ type CurryDef struct

+ var Curry CurryDef

+ func (self *CurryDef) Call(args ...*interface{}) *CurryDef

+ func (self *CurryDef) IsDone() bool

+ func (self *CurryDef) MarkDone()

+ func (self *CurryDef) New(fn func(c *CurryDef, args ...*interface{}) *interface{}) *CurryDef

+ func (self *CurryDef) Result() *interface{}

+ type EqualPatternDef struct

+ func (self EqualPatternDef) Apply(value *interface{}) *interface{}

+ func (self EqualPatternDef) Matches(value *interface{}) bool

+ type HandlerDef struct

+ var Handler HandlerDef

+ func (self *HandlerDef) Close()

+ func (self *HandlerDef) GetDefault() *HandlerDef

+ func (self *HandlerDef) New() *HandlerDef

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

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

+ type KindPatternDef struct

+ func (self KindPatternDef) Apply(value *interface{}) *interface{}

+ func (self KindPatternDef) Matches(value *interface{}) bool

+ type MaybeDef struct

+ var Maybe MaybeDef

+ func (self MaybeDef) FlatMap(fn func(*interface{}) *MaybeDef) *MaybeDef

+ func (self MaybeDef) IsKind(t reflect.Kind) bool

+ func (self MaybeDef) IsNil() bool

+ func (self MaybeDef) IsPresent() bool

+ func (self MaybeDef) IsType(t reflect.Type) bool

+ func (self MaybeDef) Just(in *interface{}) MaybeDef

+ func (self MaybeDef) JustVal(in interface{}) MaybeDef

+ func (self MaybeDef) Kind() reflect.Kind

+ func (self MaybeDef) Let(fn func())

+ func (self MaybeDef) Or(or *interface{}) *interface{}

+ func (self MaybeDef) OrVal(or interface{}) *interface{}

+ func (self MaybeDef) Ref() *interface{}

+ func (self MaybeDef) ToBool() (bool, error)

+ func (self MaybeDef) ToFloat32() (float32, error)

+ func (self MaybeDef) ToFloat64() (float64, error)

+ func (self MaybeDef) ToInt() (int, error)

+ func (self MaybeDef) ToInt32() (int32, error)

+ func (self MaybeDef) ToInt64() (int64, error)

+ func (self MaybeDef) ToMaybe() MaybeDef

+ func (self MaybeDef) ToString() string

+ func (self MaybeDef) Type() reflect.Type

+ func (self MaybeDef) Unwrap() interface{}

+ type MonadIODef struct

+ var MonadIO MonadIODef

+ func (self *MonadIODef) FlatMap(fn func(*interface{}) *MonadIODef) *MonadIODef

+ func (self *MonadIODef) New(effect func() *interface{}) *MonadIODef

+ func (self *MonadIODef) ObserveOn(h *HandlerDef) *MonadIODef

+ func (self *MonadIODef) Subscribe(s Subscription) *Subscription

+ func (self *MonadIODef) SubscribeOn(h *HandlerDef) *MonadIODef

+ func (self MonadIODef) Just(in *interface{}) *MonadIODef

+ func (self MonadIODef) JustVal(in interface{}) *MonadIODef

+ type NilTypeDef struct

+ var NilType NilTypeDef

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

+ type OtherwisePatternDef struct

+ func (self OtherwisePatternDef) Apply(value *interface{}) *interface{}

+ func (self OtherwisePatternDef) Matches(value *interface{}) 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 (self PatternMatching) MatchFor(value *interface{}) *interface{}

+ type ProductType struct

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

+ type PublisherDef struct

+ var Publisher PublisherDef

+ func (self *PublisherDef) Map(fn func(*interface{}) *interface{}) *PublisherDef

+ func (self *PublisherDef) New() *PublisherDef

+ func (self *PublisherDef) Publish(result *interface{})

+ func (self *PublisherDef) Subscribe(sub Subscription) *Subscription

+ func (self *PublisherDef) SubscribeOn(h *HandlerDef) *PublisherDef

+ func (self *PublisherDef) Unsubscribe(s *Subscription)

+ type RegexPatternDef struct

+ func (self RegexPatternDef) Apply(value *interface{}) *interface{}

+ func (self RegexPatternDef) Matches(value *interface{}) bool

+ type StreamDef struct

+ var Stream StreamDef

+ func (self *StreamDef) Append(item *interface{}) *StreamDef

+ func (self *StreamDef) Distinct() *StreamDef

+ func (self *StreamDef) Extend(stream *StreamDef) *StreamDef

+ func (self *StreamDef) Filter(fn func(int) bool) *StreamDef

+ func (self *StreamDef) FromArray(list []*interface{}) *StreamDef

+ func (self *StreamDef) FromArrayBool(old []bool) *StreamDef

+ func (self *StreamDef) FromArrayFloat32(old []float32) *StreamDef

+ func (self *StreamDef) FromArrayFloat64(old []float64) *StreamDef

+ func (self *StreamDef) FromArrayInt(old []int) *StreamDef

+ func (self *StreamDef) FromArrayInt32(old []int32) *StreamDef

+ func (self *StreamDef) FromArrayInt64(old []int64) *StreamDef

+ func (self *StreamDef) FromArrayMaybe(old []MaybeDef) *StreamDef

+ func (self *StreamDef) FromArrayString(old []string) *StreamDef

+ func (self *StreamDef) Get(i int) *interface{}

+ func (self *StreamDef) Len() int

+ func (self *StreamDef) Map(fn func(int) *interface{}) *StreamDef

+ func (self *StreamDef) Remove(index int) *StreamDef

+ func (self *StreamDef) Sort(fn func(i, j int) bool) *StreamDef

+ func (self *StreamDef) ToArray() []*interface{}

+ type Subscription struct

+ OnNext func(*interface{})

+ type SumType struct

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

Other modules containing this package

github.com/TeaEntityLab/fpGo/v2

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