coroutine


HOME

coroutine

NAME
SYNOPSIS
DESCRIPTION
EXAMPLES
SEE ALSO
KEYWORDS

___________________________

NAME

coroutine, yield, yieldto − Create and produce values from coroutines

SYNOPSIS

coroutine name command ?arg...?
yield
?value?
yieldto
command ?arg...? │
name
?value...? │ ___________________________

DESCRIPTION

The coroutine command creates a new coroutine context (with associated command) named name and executes that context by calling command, passing in the other remaining arguments without further interpretation. Once command returns normally or with an exception (e.g., an error) the coroutine context name is deleted.

Within the context, values may be generated as results by using the yield command; if no value is supplied, the empty string is used. When that is called, the context will suspend execution and the coroutine command will return the argument to yield. The execution of the context can then be resumed by calling the context command, optionally passing in the single value to use as the result of the yield call that caused the context to be suspended. If the coroutine context never yields and instead returns conventionally, the result of the coroutine command will be the result of the evaluation of the context.

The coroutine may also suspend its execution by use of the yieldto │ command, which instead of returning, cedes execution to some command │ called command (resolved in the context of the coroutine) and to which │ any number of arguments may be passed. Since every coroutine has a │ context command, yieldto can be used to transfer control directly from │ one coroutine to another (this is only advisable if the two coroutines │ are expecting this to happen) but any command may be the target. If a │ coroutine is suspended by this mechanism, the coroutine processing can │ be resumed by calling the context command optionally passing in an │ arbitrary number of arguments. The return value of the yieldto call │ will be the list of arguments passed to the context command; it is up │ to the caller to decide what to do with those values. │

The recommended way of writing a version of yield that allows │ resumption with multiple arguments is by using yieldto and the return │ command, like this: │

proc yieldm {value} { │
yieldto
return -level 0 $value │
} │

The coroutine can also be deleted by destroying the command name, and the name of the current coroutine can be retrieved by using info coroutine. If there are deletion traces on variables in the coroutine’s implementation, they will fire at the point when the coroutine is explicitly deleted (or, naturally, if the command returns conventionally).

At the point when command is called, the current namespace will be the global namespace and there will be no stack frames above it (in the sense of upvar and uplevel). However, which command to call will be determined in the namespace that the coroutine command was called from.

EXAMPLES

This example shows a coroutine that will produce an infinite sequence of even values, and a loop that consumes the first ten of them.

proc allNumbers {} {
yield

set i 0
while 1 {
yield
$i
incr i 2
}
}
coroutine
nextNumber allNumbers
for {set i 0} {$i < 10} {incr i} {
puts "received [nextNumber]"
}
rename nextNumber {}

In this example, the coroutine acts to add up the arguments passed to it.

coroutine accumulator apply {{} {
set x 0
while 1 {
incr x [yield $x]
}
}}
for {set i 0} {$i < 10} {incr i} {
puts "$i -> [accumulator $i]"
}

This example demonstrates the use of coroutines to implement the classic Sieve of Eratosthenes algorithm for finding prime numbers. Note the creation of coroutines inside a coroutine.

proc filterByFactor {source n} {
yield
[info coroutine]
while 1 {
set x [$source]
if {$x % $n} {
yield
$x
}
}
}
coroutine
allNumbers apply {{} {while 1 {yield [incr x]}}}
coroutine
eratosthenes apply {c {
yield

while 1 {
set n [$c]
yield
$n
set c [coroutine prime$n filterByFactor $c $n]
}
}} allNumbers
for {set i 1} {$i <= 20} {incr i} {
puts "prime#$i = [eratosthenes]"
}

This example shows how a value can be passed around a group of three │ coroutines that yield to each other: │

proc juggler {name target {value ""}} { │
if {$value eq ""} { │
set value [yield [info coroutine]] │
} │
while {$value ne ""} { │
puts "$name : $value" │
set value [string range $value 0 end-1] │
lassign [yieldto $target $value] value │
} │
} │
coroutine
j1 juggler Larry [ │
coroutine
j2 juggler Curly [ │
coroutine
j3 juggler Moe j1]] "Nyuck!Nyuck!Nyuck!" │

DETAILED SEMANTICS
This example demonstrates that coroutines start from the global namespace, and that command resolution happens before the coroutine stack is created.

proc report {where level} {
# Where was the caller called from?
set ns [uplevel 2 {namespace current}]
yield
"made $where $level context=$ns name=[info coroutine]"
}
proc example {} {
report outer [info level]
}
namespace eval demo {
proc example {} {
report inner [info level]
}
proc makeExample {} {
puts "making from [info level]"
puts [coroutine coroEg example]
}
makeExample
}

Which produces the output below. In particular, we can see that stack manipulation has occurred (comparing the levels from the first and second line) and that the parent level in the coroutine is the global namespace. We can also see that coroutine names are local to the current namespace if not qualified, and that coroutines may yield at depth (e.g., in called procedures).

making from 2
made inner 1 context=:: name=::demo::coroEg

SEE ALSO

apply(n), info(1), proc(5), return(n)

KEYWORDS

coroutine, generator







Opportunity


Personal Opportunity - Free software gives you access to billions of dollars of software at no cost. Use this software for your business, personal use or to develop a profitable skill. Access to source code provides access to a level of capabilities/information that companies protect though copyrights. Open source is a core component of the Internet and it is available to you. Leverage the billions of dollars in resources and capabilities to build a career, establish a business or change the world. The potential is endless for those who understand the opportunity.

Business Opportunity - Goldman Sachs, IBM and countless large corporations are leveraging open source to reduce costs, develop products and increase their bottom lines. Learn what these companies know about open source and how open source can give you the advantage.





Free Software


Free Software provides computer programs and capabilities at no cost but more importantly, it provides the freedom to run, edit, contribute to, and share the software. The importance of free software is a matter of access, not price. Software at no cost is a benefit but ownership rights to the software and source code is far more significant.


Free Office Software - The Libre Office suite provides top desktop productivity tools for free. This includes, a word processor, spreadsheet, presentation engine, drawing and flowcharting, database and math applications. Libre Office is available for Linux or Windows.





Free Books


The Free Books Library is a collection of thousands of the most popular public domain books in an online readable format. The collection includes great classical literature and more recent works where the U.S. copyright has expired. These books are yours to read and use without restrictions.


Source Code - Want to change a program or know how it works? Open Source provides the source code for its programs so that anyone can use, modify or learn how to write those programs themselves. Visit the GNU source code repositories to download the source.





Education


Study at Harvard, Stanford or MIT - Open edX provides free online courses from Harvard, MIT, Columbia, UC Berkeley and other top Universities. Hundreds of courses for almost all major subjects and course levels. Open edx also offers some paid courses and selected certifications.


Linux Manual Pages - A man or manual page is a form of software documentation found on Linux/Unix operating systems. Topics covered include computer programs (including library and system calls), formal standards and conventions, and even abstract concepts.