added tests for fold

Author: rssh

README.md

@@ -107,7 +107,7 @@ val s = goScope{
 
 ## Channels
 
-You can look on the channel as on classic blocked queue with fixed size. Different execution flows can exchange messages via channels.
+Inside go blocks, you can look on the channel as on classic blocked queue with fixed size. Different execution flows can exchange messages via channels.
 
 
      val channel = gopherApi.makeChannel[Int];

notes/0.99.7.markdown

@@ -7,5 +7,6 @@
   be readed at https://github.com/rssh/notes/blob/master/2016_03_05_see-ma-no-vars.md )
 - akka 2.4.2, scala-2.11.8
 - channels by defaults now unbuffered. (as in Go)
+- implemented fold over input
 
 

src/main/scala/gopher/channels/Input.scala

@@ -318,10 +318,26 @@ trait Input[A]
 
   }
 
+  /**
+   * async incarnation of fold. Fold return future, which successed when channel is closed.
+   *Operations withing fold applyed on result on each other, starting with s0.
+   *```
+   * val fsum = ch.afold(0){ (s, n) => s+n }
+   *```
+   * Here in fsum will be future with value: sum of all elements in channel until one has been closed.
+   **/
+  def afold[S,B](s0:S)(f:(S,A)=>S): Future[S] = macro InputMacro.afoldImpl[A,S]
 
+  /**
+   * fold opeations, available inside async bloc.
+   *```
+   * go {
+   *   val sum = ch.fold(0){ (s,n) => s+n }
+   * }
+   *```
+   */
   def fold[S,B](s0:S)(f:(S,A)=>S): S = macro InputMacro.foldImpl[A,S]
 
-  def afold[S,B](s0:S)(f:(S,A)=>S): Future[S] = macro InputMacro.afoldImpl[A,S]
 
 
   def afoldSync[S,B](s0:S)(f:(S,A)=>S): Future[S] =

src/test/scala/gopher/channels/InputOpsSuite.scala

@@ -221,6 +221,15 @@ class InputOpsSuite extends FunSuite with AsyncAssertions {
       w.await(timeout(10 seconds), dismissals(2))
   }
 
+  test("Input afold on stream with 'N' elements inside ") {
+      val ch = gopherApi.makeChannel[Int]()
+      val f = ch.afold(0)((s,e)=>s+1)
+      val ar = ch.awriteAll(1 to 10)
+      ar.onComplete{ case _ => ch.close() }
+      val r = Await.result(f,10 seconds) 
+      assert(r==10)
+  }
+
   test("forech with mapped closed stream") {
     def one(i:Int) = {
       val w = new Waiter
@@ -257,6 +266,29 @@ class InputOpsSuite extends FunSuite with AsyncAssertions {
       w.await(timeout(10 seconds), dismissals(2))
   }
 
+/*
+  test("channel fold with async operation inside") {
+      val ch1 = gopherApi.makeChannel[Int](10) 
+      val ch2 = gopherApi.makeChannel[Int](10) 
+      val fs = go {
+        val sum = ch1.fold(0){ (s,n) =>
+                    val n1 = ch2.read
+                    //s+(n1+n2) -- stack overflow in 2.11.8 compiler. TODO: submit bug
+                    s+(n+n1)
+                  }
+        sum
+      }
+      go {
+       ch1.writeAll(1 to 10)
+       ch2.writeAll(1 to 10)
+       ch1.close()
+      }
+      val r = Await.result(fs, 10 seconds)
+      assert(r==110)
+  }
+*/
+
+
   test("append for finite stream") {
       val w = new Waiter
       val ch1 = gopherApi.makeChannel[Int](10)