moving towards a more Lens like structure

src/main/scala/com/wheaties/choice/Choice.scala

@@ -9,22 +9,11 @@ trait Choice[-Value]{
   protected[choice] def scheme: Predicate1[Value]
   protected[choice] def filter: Predicate1[Value]
 
-  def get[C](collection: C)(implicit traverse: Traverse[Value,C]) = traverse.prune(collection, filter)
+  def get[C](collection: C)(implicit view: View[Value,C]) = view(collection, filter)
 
-  def set[A,C](collection: C, value: A)(implicit traverse: Traverse[Value,C], replace: Replace[Value,A]) =
-    traverse.replace(collection, replace, filter)
+  def set[A,C](collection: C, value: A)(implicit replace: Replace[Value,C,A]) = replace(collection, value, filter)
 
-  //TODO: this needs to handle List[_], Map[_,_] and Map[Key,_] so that we can have our cake and eat it too.
-  def mod[C](collection: C, f: Value => Value)(implicit traverse: Traverse[Value,C]) =
-    traverse.replace(collection, f, filter)
-
-  def partition[C](collection: C)(implicit traverse: Traverse[Value,C]) = traverse.part(collection, filter)
-
-  //def fold[A,B,C](collection: C, init: Value, f: A)(implicit traverse: Traverse[Value,C]) =
-  //  traverse.fold(collection, init, f, filter(scheme))
-
-  //def reduce[A](collection: C, f: A)(implicit traverse: Traverse[Value,C]) =
-  //  traverse.reduce(collection, f, filter(scheme))
+  def mod[C](collection: C, f: Value => Value)(implicit modify: Modify[Value,C]) = modify(collection, f, filter)
 
   def compose[V <: Value](that: Choice[V]) = that andThen this
 
@@ -34,4 +23,4 @@ trait Choice[-Value]{
   }
 }
 
-object Choice extends TraverseImplicits
+object Choice extends ViewImplicits with ReplaceImplicits with ModifyImplicits

src/main/scala/com/wheaties/choice/iteration/Modify.scala

@@ -0,0 +1,17 @@
+package com.wheaties.choice.iteration
+
+import scala.collection.TraversableLike
+import scala.collection.generic._
+
+trait Modify[Elem, Collection] extends ((Collection, Elem => Elem, Elem => Boolean) => Collection)
+
+trait ModifyImplicits{
+  implicit def modTraversable[Elem, Repr <: TraversableLike[Elem, Repr]](implicit cbf: CanBuildFrom[Repr, Elem, Repr]) =
+    new Modify[Elem, Repr] {
+      def apply(coll: Repr, f: Elem => Elem, pred: Elem => Boolean): Repr ={
+        def sub(elem: Elem) = if(pred(elem)) f(elem) else elem
+
+        coll.map(sub)(cbf)
+      }
+    }
+}

src/main/scala/com/wheaties/choice/iteration/Replace.scala

@@ -1,37 +1,55 @@
 package com.wheaties.choice.iteration
 
-//TODO: change to implicit object that creates functions
+import scala.collection.TraversableLike
+import scala.collection.generic._
 
-trait Replace[Elem,+Action] extends (Elem => Elem){
-  def apply(elem: Elem): Elem
-}
+trait Replace[Elem,Collection,Sub] extends ((Collection, Sub, Elem => Boolean) => Collection)
 
-class Substitute[Elem](value: Elem) extends Replace[Elem,Elem]{
-  def apply(elem: Elem) = value
-}
+//TODO: Missing mutable...
+trait ReplaceImplicits{
+  implicit def repTraversable[Elem, Repr <: TraversableLike[Elem, Repr]](implicit cbf: CanBuildFrom[Repr, Elem, Repr]) =
+    new Replace[Elem, Repr, Elem] {
+      def apply(coll: Repr, value: Elem, pred: Elem => Boolean): Repr ={
+        def sub(elem: Elem) = if(pred(elem)) value else elem
 
-class SubIterable[Elem,To,I[To] <: Iterable[Elem]](value: I[To]) extends Replace[Elem,I[To]]{
-  private val iter = value.iterator
+        coll.map(sub)(cbf)
+      }
+    }
 
-  def apply(elem: Elem) = if(iter hasNext) iter next () else elem
-}
+  implicit def repTraversable[Elem, Array[_]] = new Replace[Elem, Array[Elem], Elem] {
+    def apply(coll: Array[Elem], value: Elem, pred: Elem => Boolean): Array[Elem] ={
+      def sub(elem: Elem) = if(pred(elem)) value else elem
 
-class SubStream[Elem,To,S[To] <: Stream[Elem]](var value: S[To]) extends Replace[Elem,S[To]]{
-  def apply(elem: Elem) = value match{
-    case head #:: tail => value = tail; head
-    case _ => elem
+      coll map sub
+    }
   }
-}
 
-class SubArray[Elem : ClassManifest, To, A[To] <: Array[Elem]](value: A[To]) extends Replace[Elem,A[To]]{
-  private val iter = value.iterator
-
-  def apply(elem: Elem) = if(iter hasNext) iter next () else elem
-}
-
-class SubKeys[Key, To, Value, C[To] <: Iterable[Key]](value: C[To])
-    extends Replace[(Key,Value),C[To]]{
-  private val iter = value.iterator
-
-  def apply(elem: (Key,Value)) = if(iter hasNext) (iter next (), elem._2) else elem
+  implicit def repTraversableSub[Elem, Sub <: Elem, Repr <: TraversableLike[Elem, Repr], From <: TraversableLike[Sub, From]](implicit cbf: CanBuildFrom[Repr, Elem, Repr])=
+    new Replace[Elem, Repr, From] {
+      def apply(coll: Repr, value: From, pred: Elem => Boolean): Repr ={
+        val iter = value.toIterator
+        def sub(elem: Elem) = if(pred(elem) && iter.hasNext) iter next () else elem
+
+        coll.map(sub)(cbf)
+      }
+    }
+
+  implicit def repTraversableArray[Elem, Sub <: Elem, Repr <: TraversableLike[Elem, Repr], Array[_]](implicit cbf: CanBuildFrom[Repr, Elem, Repr]) =
+    new Replace[Elem, Repr, Array[Sub]] {
+      def apply(coll: Repr, value: Array[Sub], pred: Elem => Boolean): Repr ={
+        val iter = value.toIterator
+        def sub(elem: Elem) = if(pred(elem) && iter.hasNext) iter next () else elem
+
+        coll.map(sub)(cbf)
+      }
+    }
+
+  implicit def repArraySub[Elem, Sub <: Elem, Array[_]] = new Replace[Elem, Array[Elem], Array[Sub]] {
+    def apply(coll: Array[Elem], value: Array[Sub], pred: Elem => Boolean): Array[Elem] ={
+      val iter = value.toIterator
+      def sub(elem: Elem) = if(pred(elem) && iter.hasNext) iter next () else elem
+
+      coll map sub
+    }
+  }
 }

src/main/scala/com/wheaties/choice/iteration/View.scala

@@ -0,0 +1,17 @@
+package com.wheaties.choice.iteration
+
+import scala.collection.TraversableLike
+
+trait View[Elem,Collection] extends ((Collection, Elem => Boolean) => Collection)
+
+trait ViewImplicits{
+  implicit def viewTraversable[Elem, Repr <: TraversableLike[Elem, Repr]] = new View[Elem, Repr] {
+    def apply(coll: Repr, pred: Elem => Boolean): Repr = coll filter pred
+  }
+
+  implicit def viewArray[Elem, Array[_]] = new View[Elem, Array[Elem]] {
+    def apply(array: Array[Elem], pred: Elem => Boolean): Array[Elem] = array filter pred
+  }
+
+  //implicit def viewArray[Elem, Repr <: ArrayLike[Elem, Repr]]
+}

src/main/scala/com/wheaties/predicate/Predicate.scala

@@ -1,6 +1,5 @@
 package com.wheaties.predicate
 
 package object predicate{
-  def not(value: Boolean) = !value
   implicit def sugarIs[A](value: A) = new{ def is(pred: A => Boolean) = pred(value) }
 }