better State representation in queens

Author: rssh

shared/src/test/scala/gopher/monads/Queens.scala

@@ -16,29 +16,17 @@ class QueensSuite extends FunSuite {
   import scala.concurrent.ExecutionContext.Implicits.global
   given Gopher[Future] = SharedGopherAPI.apply[Future]()
 
-  case class State(
-     busyRows:Set[Int],
-     busyColumns:Set[Int],
-     busyLRDiagonals:Set[Int],
-     busyRLDiagonals:Set[Int],
-     queens: Vector[(Int,Int)]
-  )  {
+  type State = Vector[(Int,Int)]
+     
+  extension(queens:State) {
 
-    def isBusy(i:Int, j:Int): Boolean = 
-      busyRows.contains(i) ||
-      busyColumns.contains(j) ||
-      busyLRDiagonals.contains(i-j) ||
-      busyRLDiagonals.contains(i+j)
+    def isUnderAttack(i:Int, j:Int): Boolean = 
+      queens.exists{ (qi,qj) => 
+        qi == i || qj == j || i-j == qi-qj || i+j == qi+qj
+      }
 
-
     def put(i:Int, j:Int): State =
-      copy( busyRows = busyRows + i,
-            busyColumns = busyColumns + j,
-            busyLRDiagonals = busyLRDiagonals + (i-j),
-            busyRLDiagonals = busyRLDiagonals + (i+j),
-            queens = queens :+ (i,j)
-          )
-
+     queens :+ (i,j) 
 
   }
 
@@ -47,32 +35,31 @@ class QueensSuite extends FunSuite {
   def  putQueen(state:State): ReadChannel[Future,State] =
     val ch = makeChannel[State]()
     async[Future] {
-      val i = state.queens.length
+      val i = state.length
       if i < N then 
-        for{ j <- 0 until N  if !state.isBusy(i,j) } 
+        for{ j <- 0 until N  if !state.isUnderAttack(i,j) } 
           ch.write(state.put(i,j))
       ch.close()
     }
     ch
 
   def solutions(state: State): ReadChannel[Future,State] =
     async[[X] =>> ReadChannel[Future,X]] {
-      if(state.queens.size < N) then
+      if(state.size < N) then
         val nextState = await(putQueen(state))
         await(solutions(nextState))
       else
         state    
     }
 
-  val emptyState = State(Set.empty, Set.empty, Set.empty, Set.empty, Vector.empty)
 
   test("two first solution for 8 queens problem") {
      async[Future] {
-       val r = solutions(emptyState).take(2)
+       val r = solutions(Vector.empty).take(2)
        assert(!r.isEmpty)
-       println(r.map(_.queens))
+       println(r)
      }
   }
 
 
-}
+}