more interesting demos

demo/kitchen-sink/docs/groovy.groovy

@@ -1,26 +1,41 @@
-//http://groovy.codehaus.org/Concurrency+with+Groovy
+//http://groovy.codehaus.org/Martin+Fowler%27s+closure+examples+in+Groovy
-import java.util.concurrent.atomic.AtomicInteger
 
-def counter = new AtomicInteger()
+class Employee {
-
+    def name, salary
-synchronized out(message) {
+    boolean manager
-    println(message)
+    String toString() { return name }
 }
 
-def th = Thread.start {
+def emps = [new Employee(name:'Guillaume', manager:true, salary:200),
-    for( i in 1..8 ) {
+    new Employee(name:'Graeme', manager:true, salary:200),
-        sleep 30
+    new Employee(name:'Dierk', manager:false, salary:151),
-        out "thread loop $i"
+    new Employee(name:'Bernd', manager:false, salary:50)]
-        counter.incrementAndGet()
+
-    }
+def managers(emps) {
+    emps.findAll { e -> e.isManager() }
 }
 
-for( j in 1..4 ) {
+assert emps[0..1] == managers(emps) // [Guillaume, Graeme]
-    sleep 50
+
-    out "main loop $j"
+def highPaid(emps) {
-    counter.incrementAndGet()
+    threshold = 150
+    emps.findAll { e -> e.salary > threshold }
 }
 
-th.join()
+assert emps[0..2] == highPaid(emps) // [Guillaume, Graeme, Dierk]
 
-assert counter.get() == 12
+def paidMore(amount) {
+    { e -> e.salary > amount}
+}
+def highPaid = paidMore(150)
+
+assert highPaid(emps[0]) // true
+assert emps[0..2] == emps.findAll(highPaid)
+
+def filename = 'test.txt'
+new File(filename).withReader{ reader -> doSomethingWith(reader) }
+
+def readersText
+def doSomethingWith(reader) { readersText = reader.text }
+
+assert new File(filename).text == readersText

demo/kitchen-sink/docs/scala.scala

@@ -1,12 +1,69 @@
-//http://www.scala-lang.org/node/227
+// http://www.scala-lang.org/node/54
-/* Defines a new method 'sort' for array objects */
+
-object implicits extends Application {
+package examples.actors
-  implicit def arrayWrapper[A : ClassManifest](x: Array[A]) =
+
-    new {
+import scala.actors.Actor
-      def sort(p: (A, A) => Boolean) = {
+import scala.actors.Actor._
-        util.Sorting.stableSort(x, p); x
+
+abstract class PingMessage
+case object Start extends PingMessage
+case object SendPing extends PingMessage
+case object Pong extends PingMessage
+
+abstract class PongMessage
+case object Ping extends PongMessage
+case object Stop extends PongMessage
+
+object pingpong extends Application {
+  val pong = new Pong
+  val ping = new Ping(100000, pong)
+  ping.start
+  pong.start
+  ping ! Start
+}
+
+class Ping(count: Int, pong: Actor) extends Actor {
+  def act() {
+    println("Ping: Initializing with count "+count+": "+pong)
+    var pingsLeft = count
+    loop {
+      react {
+        case Start =>
+          println("Ping: starting.")
+          pong ! Ping
+          pingsLeft = pingsLeft - 1
+        case SendPing =>
+          pong ! Ping
+          pingsLeft = pingsLeft - 1
+        case Pong =>
+          if (pingsLeft % 1000 == 0)
+            println("Ping: pong from: "+sender)
+          if (pingsLeft > 0)
+            self ! SendPing
+          else {
+            println("Ping: Stop.")
+            pong ! Stop
+            exit('stop)
+          }
       }
     }
-  val x = Array(2, 3, 1, 4)
+  }
-  println("x = "+ x.sort((x: Int, y: Int) => x < y))
+}
+
+class Pong extends Actor {
+  def act() {
+    var pongCount = 0
+    loop {
+      react {
+        case Ping =>
+          if (pongCount % 1000 == 0)
+            println("Pong: ping "+pongCount+" from "+sender)
+          sender ! Pong
+          pongCount = pongCount + 1
+        case Stop =>
+          println("Pong: Stop.")
+          exit('stop)
+      }
+    }
+  }
 }