*** empty log message ***
authorClaus Gittinger <cg@exept.de>
Thu, 25 Jul 2002 20:10:54 +0200
changeset 1072 7e2d41c7b33a
parent 1071 0f74a3bb42a7
child 1073 1b0886e40a5a
*** empty log message ***
LazyValue.st
--- a/LazyValue.st	Thu Jul 25 16:38:51 2002 +0200
+++ b/LazyValue.st	Thu Jul 25 20:10:54 2002 +0200
@@ -190,53 +190,180 @@
         l := l cdr.
     ].
                                                         [exEnd]
+"
+!
+
+examples2
+"
+    Attention: for the examples below to work,
+    you have to enable the Parsers AllowLazyValueExtension and
+    the parsers AllowFunctionCallSyntaxForBlockEvaluation.
+    (set the corresponding classVariables in Parser to true).
+
+      Parser classVarAt:#AllowSTXSyntaxExtensions put:true.
+      Parser classVarAt:#AllowLazyValueExtension put:true.
+      Parser classVarAt:#AllowFunctionCallSyntaxForBlockEvaluation put:true.
+
+    notice that this is just syntactic sugar: the 'FOO(arg)' notation is
+    the same as 'FOO value:arg', and !!block is the same as 'LazyValue block:block'.
+    BTW: the # is the binary Cons-message.
+                                                        [exBegin]
+    |x|
+
+    x := !![ Transcript flash. 1234 ].
+    Delay waitForSeconds:4.
+    Transcript showCR:x printString
+                                                        [exEnd]
+
+  listFrom:n - an infinite list of integers starting with n
+                                                        [exBegin]
+    |GEN infiniteList|
+
+    GEN := [:n | n # !![ GEN( n+1) ] ].
+
+    infiniteList := GEN(1).
+    1 to:10 do:[:i |
+        Transcript showCR:infiniteList car.
+        infiniteList := infiniteList cdr.
+    ].
+                                                        [exEnd]
+
+  filterOdd:l - an infinite list filtering odd numbers from another list
+                                                        [exBegin]
+    |GEN infiniteList GENOdd infiniteOdd|
+
+    GEN := [:n | n # !![ GEN(n+1) ] ].
+
+    infiniteList := GEN(1).
+
+    GENOdd := [:l |
+                        |lR el|
+
+                        lR := l.
+                        [ 
+                            el := lR car. 
+                            lR := lR cdr. 
+                            el odd 
+                        ] whileFalse:[].
+                        el # !![ GENOdd(lR) ]
+                   ].
+
+    infiniteOdd := GENOdd(infiniteList).
+
+    1 to:10 do:[:i |
+        Transcript showCR:infiniteOdd car.
+        infiniteOdd := infiniteOdd cdr.
+    ].
+                                                        [exEnd]
+
+  powersOf:n - an infinite list of powers of n
+                                                        [exBegin]
+    |GENPowersOf infiniteListOfPowers|
+
+    GENPowersOf := [:base |
+                   |powersOfBase|
+
+                   powersOfBase := [:n | n # !![powersOfBase(n*base)]].
+                   powersOfBase(1)
+                ].
+
+    infiniteListOfPowers := GENPowersOf(2).
+    1 to:10 do:[:i |
+        Transcript showCR:infiniteListOfPowers car.
+        infiniteListOfPowers := infiniteListOfPowers cdr.
+    ].
+                                                        [exEnd]
+
+  merge2:a _:b - merge 2 lists.
+  the genODD and genEVEN setup is just for testing.
+                                                        [exBegin]
+    |GENMerge2 l GEN infiniteList GENFILTER GENOdd infiniteOdd GENEven infiniteEven GENMerge|
+
+    GEN := [:n | n # !![GEN(n+1)] ].
+
+    infiniteList := GEN(1).
+
+    GENFILTER := [:l :filter|
+                        |lR el|
+
+                        lR := l.
+                        [ el := lR car. lR := lR cdr. filter(el) ] whileFalse:[].
+                        el # !![ GENFILTER(lR. filter) ] 
+              ].
+
+    GENOdd := [:l | GENFILTER(l. [:el | el odd])].
+    infiniteOdd := GENOdd(infiniteList).
+
+    GENEven := [:l | GENFILTER(l. [:el | el even])].
+    infiniteEven := GENEven value:infiniteList.
+
+    GENMerge2 := [:a :b |
+                   |nextA nextB|
+
+                   nextA := a car.
+                   nextB := b car.
+
+                   nextA < nextB ifTrue:[
+                       nextA # !![ GENMerge2(a cdr . b)]
+                   ] ifFalse:[
+                       nextB # !![ GENMerge2(a . b cdr)]
+                   ].
+                ].
+
+    l := GENMerge2(infiniteOdd .infiniteEven).
+    1 to:10 do:[:i |
+        Transcript showCR:l car.
+        l := l cdr.
+    ].
+                                                        [exEnd]
+
+  powersOf2 - generate 2^i for all i >= 0
+                                                        [exBegin]
+    |l GENPowersOf powersOf2|
+
+    GENPowersOf := [:base |
+                   |powersOfBase|
+
+                   powersOfBase := [:n | n # !![powersOfBase value:n*base] ].
+                   powersOfBase value:1.
+                ].
+
+    powersOf2 := GENPowersOf value:2.
+
+    1 to:10 do:[:i |
+        Transcript showCR:powersOf2 car.
+        powersOf2 := powersOf2 cdr.
+    ].
+                                                        [exEnd]
 
   genPoly - generate 2^i + 3^j + 5^k for all i,j,k
-  not finished.
+  unfinished.
                                                         [exBegin]
-    |genMerge2 l gen genPowersOf infiniteList powersOf2 powersOf3 powersOf5|
+    |GENPowersOf genMerge2 l gen  infiniteList powersOf2 powersOf3 powersOf5
+     genAdd genMerge3|
 
-    gen := [:n |
-                        Cons 
-                            car:n 
-                            cdr:( LazyValue block:[gen value:n+1] )
-                   ].
+    gen := [:n | Cons car:n cdr:( !![gen value:n+1] ) ].
 
     infiniteList := gen value:1.
 
-    genPowersOf := [:base |
+    GENPowersOf := [:base |
                    |powersOfBase|
 
-                   powersOfBase :=
-                       [:n |
-                            Cons 
-                                car:n 
-                                cdr:( LazyValue block:[powersOfBase value:n*base] )
-                       ].
-                   powersOfBase value:1.
+                   powersOfBase := [:n | n # !![powersOfBase value:n*base] ].
+                   powersOfBase(1).
                 ].
 
-    powersOf2 := genPowersOf value:2.
-    powersOf3 := genPowersOf value:3.
-    powersOf5 := genPowersOf value:5.
-
-    genAdd := [:n :l |
-                   |gen|
+    powersOf2 := GENPowersOf(2).     '2^i' for all i
+    powersOf3 := GENPowersOf(3).     '3^j' for all j
+    powersOf5 := GENPowersOf(5).     '5^k' for all k
 
-                   gen := [:l |
-                               Cons 
-                                   car:(car l) * n 
-                                   cdr:( LazyValue block:[gen value:(l cdr)] )
-                          ].
-                   gen value:l
-              ].
+    genMerge3 := [:a :b :c|
+                   |min nextA nextB nextC rA rB rC|
 
-    genMerge2 := [:a :b |
-                   |min nextA nextB rA rB|
-
-                   rA := a.
-                   rB := b.
-                   nextA := rA car.
+                   nextA := a car.
+                   nextB := b car.
+                   nextC := c car.
+                
                    [ (nextB := rB car) = nextA ] whileTrue:[ rB := rB cdr ].
 
                    nextA < nextB ifTrue:[
@@ -251,10 +378,14 @@
 
                    Cons 
                        car:min 
-                       cdr:( LazyValue block:[genMerge2 value:rA value:rB] )
+                       cdr:!![genMerge2 value:rA value:rB] 
                 ].
 
-    l := genMerge2 value:powersOf2 value:powersOf3 value:powersOf5.
+    genMerge3 := [:a :b :c|
+                   genMerge2(genMerge2(a . b) . c).
+                ].
+
+    l := genMerge3 value:powersOf2 value:powersOf3 value:powersOf5.
     1 to:10 do:[:i |
         Transcript showCR:l car.
         l := l cdr.
@@ -339,6 +470,6 @@
 !LazyValue class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic2/LazyValue.st,v 1.2 2002-07-25 14:38:51 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic2/LazyValue.st,v 1.3 2002-07-25 18:10:54 cg Exp $'
 ! !
 LazyValue initialize!