circle

package module

Go to main page

Versions in this module

v1

v1.1.2

May 4, 2021

v1.1.1

Jul 28, 2020

Changes in this version

+ type ExecutorFactory func(Iterator) (Executor, error)

v1.1.0

Jul 25, 2020

Changes in this version

+ var ErrInvalidConsumer = errors.New("invalid consumer")

+ type ConsumeExecutor interface

+ ConsumeExecute func() error

+ func NewConsumeExecutor(f Consumer, it Iterator) ConsumeExecutor

+ type Consumer interface

+ Apply func(x interface{}) error

+ func NewConsumer(f interface{}) (Consumer, error)

+ func NewEitherConsumer(f, g interface{}) (Consumer, error)

+ func NewMaybeConsumer(f interface{}, g func() error) (Consumer, error)

+ func NewTupleConsumer(f interface{}) (Consumer, error)

type Either

+ Consume func(f, g Consumer) error

type Maybe

+ Consume func(f, g Consumer) error

type Stream

+ Consume func(f Consumer, opt ...StreamOption) error

type StreamBuilder

+ Consume func(f interface{}, opt ...StreamOption) error

+ EitherConsume func(f, g interface{}, opt ...StreamOption) error

+ MaybeConsume func(f interface{}, g func() error, opt ...StreamOption) error

+ TupleConsume func(f interface{}, opt ...StreamOption) error

v1.0.1

Jul 23, 2020

Changes in this version

+ var ErrApply = errors.New("apply error")

+ var ErrCannotCreateIterator = errors.New("cannot create iterator")

+ var ErrCannotCreateStream = errors.New("cannot create stream")

+ var ErrEOI = errors.New("EOI")

+ var ErrInvalidAggregateExecutor = errors.New("invalid aggregate executor")

+ var ErrInvalidAggregator = errors.New("invalid aggregator")

+ var ErrInvalidComparator = errors.New("invalid comparator")

+ var ErrInvalidFilter = errors.New("invalid filter")

+ var ErrInvalidMapper = errors.New("invalid mapper")

+ type AggregateExecutorType int

+ const LAggregateExecutorType

+ const RAggregateExecutorType

+ const UnknownAggregateExecutorType

+ type AggregateType int

+ const LAggregateType

+ const RAggregateType

+ const UnknownAggregateType

+ type Aggregator interface

+ Apply func(x, y interface{}) (interface{}, error)

+ Type func() AggregatorType

+ func NewAggregator(f interface{}) (Aggregator, error)

+ type AggregatorType int

+ const LeftAggregatorType

+ const PerfectAggregatorType

+ const RightAggregatorType

+ const UnknownAggregatorType

+ type Comparator interface

+ Apply func(x, y interface{}) (bool, error)

+ func NewComparator(f interface{}) (Comparator, error)

+ type Either interface

+ GetOrElse func(v interface{}) interface{}

+ IsLeft func() bool

+ IsRight func() bool

+ Left func() (interface{}, bool)

+ Map func(f Mapper) Either

+ Right func() (interface{}, bool)

+ ToMaybe func() Maybe

+ func NewLeft(v interface{}) Either

+ func NewRight(v interface{}) Either

+ type Executor interface

+ Execute func() (Iterator, error)

+ func NewAggregateExecutor(f Aggregator, it Iterator, iv interface{}, opt ...ExecutorOption) (Executor, error)

+ func NewCompareExecutor(f Comparator, it Iterator) Executor

+ func NewFilterExecutor(f Filter, it Iterator) Executor

+ func NewFlatExecutor(it Iterator) Executor

+ func NewMapExecutor(f Mapper, it Iterator) Executor

+ type ExecutorOption func(Executor)

+ func WithAggregateExecutorType(t AggregateExecutorType) ExecutorOption

+ type Filter interface

+ Apply func(v interface{}) (bool, error)

+ func NewFilter(f interface{}) (Filter, error)

+ func NewTupleFilter(f interface{}) (Filter, error)

+ type Iterator interface

+ Channel func() IteratorChannel

+ ChannelWithContext func(ctx context.Context) IteratorChannel

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

+ func NewIterator(v interface{}) (Iterator, error)

+ type IteratorChannel interface

+ C func() <-chan interface{}

+ Err func() error

+ type IteratorFunc func() (interface{}, error)

+ type Mapper interface

+ Apply func(v interface{}) (interface{}, error)

+ func NewEitherMapper(f interface{}) (Mapper, error)

+ func NewMapper(f interface{}) (Mapper, error)

+ func NewMaybeMapper(f interface{}) (Mapper, error)

+ func NewTupleMapper(f interface{}) (Mapper, error)

+ type Maybe interface

+ Filter func(f Filter) Maybe

+ Get func() (interface{}, bool)

+ GetOrElse func(v interface{}) interface{}

+ IsNothing func() bool

+ Map func(f Mapper) Maybe

+ OrElse func(v Maybe) Maybe

+ func NewJust(v interface{}) Maybe

+ func NewNothing() Maybe

+ type Stream interface

+ Aggregate func(f Aggregator, iv interface{}, opt ...StreamOption) Stream

+ Filter func(f Filter, opt ...StreamOption) Stream

+ Flat func(opt ...StreamOption) Stream

+ Map func(f Mapper, opt ...StreamOption) Stream

+ Sort func(f Comparator, opt ...StreamOption) Stream

+ func NewStream(it Iterator) Stream

+ type StreamBuilder interface

+ Aggregate func(f, iv interface{}, opt ...StreamOption) StreamBuilder

+ EitherMap func(f interface{}, opt ...StreamOption) StreamBuilder

+ Filter func(f interface{}, opt ...StreamOption) StreamBuilder

+ Flat func(opt ...StreamOption) StreamBuilder

+ Map func(f interface{}, opt ...StreamOption) StreamBuilder

+ MaybeMap func(f interface{}, opt ...StreamOption) StreamBuilder

+ Sort func(f interface{}, opt ...StreamOption) StreamBuilder

+ TupleFilter func(f interface{}, opt ...StreamOption) StreamBuilder

+ TupleMap func(f interface{}, opt ...StreamOption) StreamBuilder

+ func NewStreamBuilder(it Iterator) StreamBuilder

+ type StreamConfig struct

+ Aggregate StreamConfigAggregate

+ NodeID string

+ func (s *StreamConfig) Apply(opt ...StreamOption)

+ type StreamConfigAggregate struct

+ Type AggregateExecutorType

+ type StreamFactory func(Stream) (Stream, error)

+ type StreamNode interface

+ Err func() error

+ ID func() string

+ func NewErrStreamNode(err error, nid string) StreamNode

+ func NewStreamNode(executor Executor, nid string) StreamNode

+ type StreamNodeFactory func(Iterator) StreamNode

+ type StreamNodeIterator struct

+ func (s *StreamNodeIterator) Channel() IteratorChannel

+ func (s *StreamNodeIterator) ChannelWithContext(ctx context.Context) IteratorChannel

+ func (s *StreamNodeIterator) ID() string

+ func (s *StreamNodeIterator) Next() (interface{}, error)

+ type StreamOption func(*StreamConfig)

+ func WithAggregateType(t AggregateType) StreamOption

+ func WithNodeID(nid string) StreamOption

+ type Tuple interface

+ Get func(i int) (interface{}, bool)

+ Size func() int

+ func NewTuple(v ...interface{}) Tuple

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