Отсутствует импорт scala .concurrent.ops

Question

Я пытаюсь запустить действительно старый Scala код для своей игры, но мне не удалось его запустить, так как срок действия некоторых библиотек истек, поэтому они не работают.

import collection.mutable
import scala.concurrent.ops._

/**
 * Put numbers in a NxN board
 * from 1 to N*N
 * scala SayiYerlestirmece N
 */
object SayiYerlestirmece {
  private var current : Int = 0;

  def main(args: Array[String]) {
    var size = 5;
    //if board size is given use.
    if (args.nonEmpty){
       size = Integer.parseInt(args(0));
    }

    var i = 0;
    for (x <- 0 until size ){
      for(y <- 0 until size){
        //run every initial states in parallel.
        spawn{
          val arr = new Array[Int](size * size);
          arr(i) = 1;
          //create initial states
          val initialList :List[Model] = List(new Model(arr,size,x,y));
          solve(initialList);
        }
        i+=1;
      }
    }

  }

  /**
   * solve problem recursively
   * @param modelList - next states
   */
  def solve(modelList: List[Model]){
    modelList.foreach(p => {
       if (p.completed){
         current+=1;
         println(p);
         println(current);
       }
       solve(p.nextStepList());
    });
  }
}

/**
 *
 * @param data - current state of board
 * @param size - size of board 5x5 10x10 etc
 * @param x - current x position on the board
 * @param y - current y position on the board
 */
class Model(data:Array[Int], size:Int, x:Int, y:Int) {
  /**
   * convert multi dimensional x,y index to one dimensional index.
   * @param size - size of board
   * @param x - current x position
   * @param y - current y position
   * @return - corresponding array index
   */
  def xy2Idx(size:Int, x:Int, y:Int): Int = {
    if ( x < 0 || y < 0 || x >= size || y >= size)
      -1
    else
      size * x + y;
  }

  /**
   * convert one dimensional array index to multi dimensional x,y index
   * @param size
   * @param idx
   * @return
   */
  def idx2Xy(size:Int, idx:Int):(Int,Int) = {
    return (idx/size,idx%size);
  }

  /**
   *   Checks whether game is completed or not
   * @return  true if is game completed else false
   */
  def completed() :Boolean = { data(xy2Idx(size,x,y)) == size * size };

  /**
   * Position of next available empty cells.
   * @return - list of index of empty cells.
   */
  def nextStepIdxList():List[Int] = {
    return mutable.MutableList(
      xy2Idx(size,x+3,y),
      xy2Idx(size,x-3,y),
      xy2Idx(size,x,y+3),
      xy2Idx(size,x,y-3),
      xy2Idx(size,x+2,y+2),
      xy2Idx(size,x-2,y+2),
      xy2Idx(size,x+2,y-2),
      xy2Idx(size,x-2,y-2)
    ).filter(p => p > -1 && data(p) == 0).toList; //filter out of bounds and non-empty cells
  }

  /**
   * Next states of board. These are derived from indexes
   * which are returned by nextStepIdxList() function.
   * @return - Next possible states of the board
   */
  def nextStepList():List[Model] = {
    var modelList = mutable.MutableList[Model]()
    nextStepIdxList().foreach( p => {
      val newArr = data.clone();
      newArr(p) = data(xy2Idx(size,x,y)) + 1;
      modelList += new Model(newArr,size,idx2Xy(size,p)._1, idx2Xy(size,p)._2);
    });
    return modelList.sortWith(_.nextStepSize() < _.nextStepSize()).toList;  // sorts board states by least next step size
  }

  /**
   * Available cell count at next step.
   * This value is used to determine next move.
   * @return - Available empty cell count
   */
  def nextStepSize():Int = {
    return nextStepIdxList().size;
  }

  override def toString(): String = {
    val sb = new StringBuilder();
    data.indices.foreach(p =>{
      if (p % size == 0)
        sb.append("\n");
      else
        sb.append(",");
      sb.append(data(p));

    });
    return sb.toString();
  }
}

Когда я запускаю его, он говорит, что import scala.concurrent.ops._ не работает, когда я его удаляю, он не может найти спаун. Когда я добавил другую версию спауна, она не работает. Как я могу запустить этот код?

Answer 1

scala.concurrent.ops._ устарели и заменены на Future на Фьючерсы, обещания и контексты исполнения # 200 в Scala 2.10.0 в 2012 год и полностью удален в 2.11.0. Попробуйте заменить

spawn {
  // expressions
}

на

import concurrent.ExecutionContext.Implicits.global

Future {
  // expressions
}

Кстати, параллелизм и изменяемые коллекции обычно являются комбинацией небезопасно из-за состояния гонки и c.