Index: TODO =================================================================== diff -u -r537b7cd99b6bc0a28b0f73c2691e08b8bd319147 -r3397af1d1bd4eee19e5a2d059e54fc98195b1cc8 --- TODO (.../TODO) (revision 537b7cd99b6bc0a28b0f73c2691e08b8bd319147) +++ TODO (.../TODO) (revision 3397af1d1bd4eee19e5a2d059e54fc98195b1cc8) @@ -3942,6 +3942,8 @@ - allow slot "initialize" method to be protected (handled similarly to "init") +- extended regression tests for yield +- implemented "next" for ruby-like enumerators (each needs still more work) ======================================================================== TODO: Index: tests/tcl86.test =================================================================== diff -u -r6779e85f10d288b4171bc2c5d9ca1fab2a87c727 -r3397af1d1bd4eee19e5a2d059e54fc98195b1cc8 --- tests/tcl86.test (.../tcl86.test) (revision 6779e85f10d288b4171bc2c5d9ca1fab2a87c727) +++ tests/tcl86.test (.../tcl86.test) (revision 3397af1d1bd4eee19e5a2d059e54fc98195b1cc8) @@ -36,6 +36,170 @@ } # +# Test coroutine / yield +# +nx::Test case enumerator1 { + + # + # enumerator with yield in a single class + # + nx::Class create Enumerator { + :property members:0..n + :public method yielder {} { + yield [info coroutine] + foreach m ${:members} { + yield $m + } + return -level 2 -code break + } + :public method next {} {${:coro}} + :method init {} { + :require namespace + set :coro [coroutine [self]::coro [self] yielder] + } + } + + # + # Some application class using the enumerator (just used for easy + # testing) + # + nx::Class create Foo { + :public method sum {} { + set sum 0 + set e [Enumerator new -members {1 2 3}] + while 1 { + incr sum [$e next] + } + return $sum + } + :create f1 + } + + ? {f1 sum} 6 +} + + +nx::Test case enumerator2 { + + # + # Define separate classes for Yielder and Enumerator + # + nx::Class create Yielder { + :property {block ";"} + :variable continuation "" + + # + # make apply available as a method + # + :public alias apply ::apply + + # + # The method "yielder" is the working horse for next. We need this + # since the interface of Tcl's coroutines is based on a separate + # cmd for continuation in the coroutine. The block can be + # configured by application classes. + # + :public method yielder {} { + yield [info coroutine] + eval ${:block} + return -level 2 -code break + } + + # + # The method "next" simply forwards to the continuation + # + :public method next {} {${:continuation}} + + # + # The method "each" is based on the method "next" and applies the + # value returned by next to the lambda expression + # + :public method each {var body} { + while 1 { + set value [:next] + #[self] apply [list $var $body] $value + :apply [list $var $body] $value + #uplevel [list [self] apply [list $var $body] $value] + #uplevel [list [self] apply [list $var $body] $value] + } + } + + # + # When a yielder is generated, we create automatically a coroutine + # for it. The coroutine is placed under the current object, this + # ensures simple cleanup (but is most probably not the fastest + # variant, since we have to require a namespace). + # + :method init {} { + :require namespace + set :continuation [coroutine [self]::coro [self] yielder] + } + } + + # + # The class "Enumerator" provides some application logic for the + # class "Yielder". We use here a list of elements as base + # representation. + # + nx::Class create Enumerator -superclass Yielder { + :property members:0..n + :property {block { + foreach m ${:members} { + yield $m + } + }} + } + + puts stderr ===0 + set e [Enumerator new -members {1 2 3}] + while 1 { + puts stderr [$e next] + } + + puts stderr ===1 + set e [Enumerator new -members {a be bu}] + $e each x {puts x=$x} + puts stderr ===2 + + # + # Some application class using the enumerator (just used for easy + # testing) + # + nx::Class create Foo { + + # test Enumerator.next + :public method sum {} { + set sum 0 + set e [Enumerator new -members {1 2 3}] + while 1 { incr sum [$e next] } + return $sum + } + + :public method set {var} { + set :$var + } + + # test Enumerator.each + :public method concat {} { + set ::string "-" + set e [Enumerator new -members {a be bu}] + # For the time being, we seem just able to address gobal + # variables in the each body. TODO: this is not desired. + $e each x { + append ::string $x- + } + #puts stderr vars=[:info vars] + return $::string + } + + :create f1 + } + + ? {f1 sum} 6 + ? {f1 concat} "-a-be-bu-" +} + +# # apply # nx::Test case apply { @@ -48,10 +212,10 @@ set :delta 100 # Define a standard map function based on apply - :public method map {lambda list} { + :public method map {lambda values} { set result {} - foreach item $list { - lappend result [:apply $lambda $item] + foreach value $values { + lappend result [:apply $lambda $value] } return $result }