core of Gopher API. Given instance of Gopher[F] need for using most of Gopher operations.
+core of Gopher API. Given instance of Gopher[F] need for using most of Gopher operations.
+Gopher is a framework, which implements CSP (Communication Sequence Process). +Process here - scala units of execution (i.e. functions, blok of code, etc). +Communication channels represented by [gopher.Channel]
+[gopher.Channel]
+[gopher#select]
+ReadChannel: Interface providing asynchronous reading API.
+ReadChannel: Interface providing asynchronous reading API.
+Organize waiting for read/write from multiple async channels
+Organize waiting for read/write from multiple async channels
+Gopher[F] provide a function select of this type.
Helper namespace for Select.Fold return value
+Helper namespace for Select.Fold return value
+[Select.fold]
+Result of select.forever: apply method accept partial pseudofunction which evalueated forever.
Result of select.forever: apply method accept partial pseudofunction which evalueated forever.
Select group is a virtual 'lock' object. +Readers and writers are grouped into select groups. When +event about avaiability to read or to write is arrived and +no current event group members is running, than run of one of the members +is triggered. +I.e. only one from group can run.
+Select group is a virtual 'lock' object. +Readers and writers are grouped into select groups. When +event about avaiability to read or to write is arrived and +no current event group members is running, than run of one of the members +is triggered. +I.e. only one from group can run.
+Note, that application develeper usually not work with SelectGroup directly,
+it is created internally by select pseudostatement.
[gopher.Select]
+[gopher.select]
+Shared gopehr api, which is initialized by platofrm part, +Primary used for cross-platforming test, you shoul initialize one of platform API +behind and then run tests.
+Shared gopehr api, which is initialized by platofrm part, +Primary used for cross-platforming test, you shoul initialize one of platform API +behind and then run tests.
+Time API, simular to one in golang standard library.
+Time API, simular to one in golang standard library.
+gopherApi#time
+Channel, where messages can be exprited.
+Channel, where messages can be exprited.
+Create Read/Write channel.
+Create Read/Write channel.
+[gopher.Channel]
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
core of Gopher API. Given instance of Gopher[F] need for using most of Gopher operations.
+Gopher is a framework, which implements CSP (Communication Sequence Process). +Process here - scala units of execution (i.e. functions, blok of code, etc). +Communication channels represented by [gopher.Channel]
+[gopher.Channel]
+[gopher#select]
+Create Read/Write channel.
+Create Read/Write channel.
+[gopher.Channel]
+set logging function, which output internal diagnostics and errors from spawned processes.
+set logging function, which output internal diagnostics and errors from spawned processes.
+Monad which control asynchronic execution. +The main is scheduling: i.e. ability to submit monadic expression to scheduler +and know that this monadic expression will be evaluated.
+Monad which control asynchronic execution. +The main is scheduling: i.e. ability to submit monadic expression to scheduler +and know that this monadic expression will be evaluated.
+Create channel where you can write only one element.
+Create channel where you can write only one element.
+[gopher.Channel]
+Create a select statement, which used for choosing one action from a set of potentially concurrent asynchronics events. +[@see gopher.Select]
+Create a select statement, which used for choosing one action from a set of potentially concurrent asynchronics events. +[@see gopher.Select]
+Monad which control asynchronic execution. +The main is scheduling: i.e. ability to submit monadic expression to scheduler +and know that this monadic expression will be evaluated.
+Monad which control asynchronic execution. +The main is scheduling: i.e. ability to submit monadic expression to scheduler +and know that this monadic expression will be evaluated.
+Create channel where you can write only one element.
+Create channel where you can write only one element.
+[gopher.Channel]
+Create a select statement, which used for choosing one action from a set of potentially concurrent asynchronics events. +[@see gopher.Select]
+Create a select statement, which used for choosing one action from a set of potentially concurrent asynchronics events. +[@see gopher.Select]
+channel which emit value of a in loop and never close
+channel, which will emit all elements from 'c' and then close.
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
ReadChannel: Interface providing asynchronous reading API.
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Organize waiting for read/write from multiple async channels
+Gopher[F] provide a function select of this type.
run forever expression in pf, return
run forever expression in pf, return
wait until some channels from the list in pf .
wait until some channels from the list in pf .
async{
+....
+select {
+ case vx:xChannel.read => doSomethingWithX
+ case vy:yChannel.write if (vy == valueToWrite) => doSomethingAfterWrite(vy)
+ case t: Time.after if (t == 1.minute) => processTimeout
+}
+...
+}
+return value in Select.Fold which means that we should stop folding
+Helper namespace for Select.Fold return value
+[Select.fold]
+return value in Select.Fold which means that we should stop folding
+return value in Select.Fold which means that we should stop folding
+Result of select.forever: apply method accept partial pseudofunction which evalueated forever.
Select group is a virtual 'lock' object. +Readers and writers are grouped into select groups. When +event about avaiability to read or to write is arrived and +no current event group members is running, than run of one of the members +is triggered. +I.e. only one from group can run.
+Note, that application develeper usually not work with SelectGroup directly,
+it is created internally by select pseudostatement.
[gopher.Select]
+[gopher.select]
+FluentDSL for user SelectGroup without macroses.
+FluentDSL for user SelectGroup without macroses.
+SelectGroup.onRead(input){ x => println(x) }
+ .onRead(endSignal){ () => done=true }
+FluentDSL for user SelectGroup without macroses.
+FluentDSL for user SelectGroup without macroses.
+SelectGroup.onWrite(input){ x => println(x) }
+ .onWrite(endSignal){ () => done=true }
+instance of select group created for call of select. +0 - free +1 - now processes +2 - expired
+instance of select group created for call of select. +0 - free +1 - now processes +2 - expired
+Shared gopehr api, which is initialized by platofrm part, +Primary used for cross-platforming test, you shoul initialize one of platform API +behind and then run tests.
+Task, which can be cancelled.
+Used in selector shugar for specyfying tineout.
+Used in selector shugar for specyfying tineout.
+select{
+ ......
+ case t: Time.after if t > expr => doSomething
+}
+is a sugar for to selectGroup.{..}.setTimeout(expr, t=>doSomething)
+Select
+return channl on which event will be delivered after duration
return channl on which event will be delivered after duration
ticker which hold channel with expirable tick messages and iterface to stop one.
+Time API, simular to one in golang standard library.
+gopherApi#time
+ticker which hold channel with expirable tick messages and iterface to stop one.
+ticker which hold channel with expirable tick messages and iterface to stop one.
+type for using in select paterns.
type for using in select paterns.
[gopher.Select]
+return channel, then after duration ellapses, send signal to this channel.
return channel, then after duration ellapses, send signal to this channel.
return future which will be filled after time will ellapse.
+return future which will be filled after time will ellapse.
+create ticker with given duration between ticks.
create ticker with given duration between ticks.
[gopher.Time.Ticker]
+synonim for await(asleep(duration)). Should be used inside async block.
synonim for await(asleep(duration)). Should be used inside async block.
create ticker. When somebody read this ticker, than one receive duration +messages. When nobody reading - messages are expired.
+create ticker. When somebody read this ticker, than one receive duration +messages. When nobody reading - messages are expired.
+Channel, where messages can be exprited.
+Input, which reed from the first channel, and after first channel is closed - from second
+Input, which reed from the first channel, and after first channel is closed - from second
+can be created with 'append' operator.
+ val x = read(x|y)
+Object, which can be expired +(usually - reader or writer in SelectGroup) +Usage protocol is next: +capture +if A inside is used, call markUsed and use A +if A inside is unused for some reason -- call markFree
+Object, which can be expired +(usually - reader or writer in SelectGroup) +Usage protocol is next: +capture +if A inside is used, call markUsed and use A +if A inside is unused for some reason -- call markFree
+Input, which combine two other inputs.
+Input, which combine two other inputs.
+can be created with '|' operator.
+ val x = read(x|y)
+Input, which reed from the first channel, and after first channel is closed - from second
+can be created with 'append' operator.
+ val x = read(x|y)
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Object, which can be expired +(usually - reader or writer in SelectGroup) +Usage protocol is next: +capture +if A inside is used, call markUsed and use A +if A inside is unused for some reason -- call markFree
+called when reader/writer can become no more available for some reason
+called when reader/writer can become no more available for some reason
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+Called when we can't use captured function (i.e. get function but ).
+Called when we can't use captured function (i.e. get function but ).
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
ticker which hold channel with expirable tick messages and iterface to stop one.
+ticker which hold channel with expirable tick messages and iterface to stop one.
+type for using in select paterns.
type for using in select paterns.
[gopher.Select]
+return channel, then after duration ellapses, send signal to this channel.
return channel, then after duration ellapses, send signal to this channel.
return future which will be filled after time will ellapse.
+return future which will be filled after time will ellapse.
+create ticker with given duration between ticks.
create ticker with given duration between ticks.
[gopher.Time.Ticker]
+synonim for await(asleep(duration)). Should be used inside async block.
synonim for await(asleep(duration)). Should be used inside async block.
create ticker. When somebody read this ticker, than one receive duration +messages. When nobody reading - messages are expired.
+create ticker. When somebody read this ticker, than one receive duration +messages. When nobody reading - messages are expired.
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Can be called only insed wrapper fun, +set current inUse be closed, if n +precondition: inUse.get !== null +return: true, if bith x and y are closed
+Input, which combine two other inputs.
+can be created with '|' operator.
+ val x = read(x|y)
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
called when reader/writer can become no more available for some reason
+called when reader/writer can become no more available for some reason
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+Called when we can't use captured function (i.e. get function but ).
+Called when we can't use captured function (i.e. get function but ).
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+Special type which is used in select statement.
+Special type which is used in select statement.
+[gopher.Select]
+Synonim for read.
+Synonim for read.
+read value and return future with
+read value and return future with
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+async version of read. Immediatly return future, which will contains result of read or failur with StreamClosedException +in case of stream is closed.
+return F which contains sequence from first n elements.
return F which contains sequence from first n elements.
run code each time when new object is arriced. +until end of stream is not reached
+run code each time when new object is arriced. +until end of stream is not reached
+read value and return
+read value and return
+should be called inside async block.
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+blocked read: if currently not element available - wait for one. +Can be used only inside async block. +If stream is closed and no values to read left in the stream - throws StreamClosedException
+take first n elements.
+should be called inside async block.
take first n elements.
+should be called inside async block.
called when reader/writer can become no more available for some reason
+called when reader/writer can become no more available for some reason
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+capture object, and after this we can or use one (markUsed will be called) or abandon (markFree)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+if this object is expired and should be deleted from queue +(for example: when reader is belong to select group and some other action in this select group was performed)
+Called when we can't use captured function (i.e. get function but ).
+Called when we can't use captured function (i.e. get function but ).
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+Called when we submitt to task executor readFunction and now is safe to make exprire all other readers/writers in the +same select group
+map over result of checked evaluation of A
map over result of checked evaluation of A
synonym for flatMapTry +needed for processing awaits inside mapTry.
+synonym for flatMapTry +needed for processing awaits inside mapTry.
+restore fa, ie if fa sucessful - return fa, +otherwise apply fx to received error.
+restore fa, ie if fa sucessful - return fa, +otherwise apply fx to received error.
+try to evaluate async operation and wrap successful or failed result into F.
try to evaluate async operation and wrap successful or failed result into F.
try to evaluate synchonious operation and wrap successful or failed result into F.
try to evaluate synchonious operation and wrap successful or failed result into F.
ensure that action will run before getting value from fa
ensure that action will run before getting value from fa
async shift of withAction.
async shift of withAction.
This method is substituted instead withAction, when we use await inside withAction argument.
return result of fa after completition of action.
return result of fa after completition of action.