Implement basic iterative deepening

gleam.toml

···
 [dependencies]
 gleam_stdlib = ">= 0.44.0 and < 2.0.0"
 iv = ">= 1.3.2 and < 2.0.0"
+birl = ">= 1.8.0 and < 2.0.0"
 
 [dev-dependencies]
 gleeunit = ">= 1.0.0 and < 2.0.0"

manifest.toml

···
 ]
 
 [requirements]
+birl = { version = ">= 1.8.0 and < 2.0.0" }
 gleam_stdlib = { version = ">= 0.44.0 and < 2.0.0" }
 gleeunit = { version = ">= 1.0.0 and < 2.0.0" }
 iv = { version = ">= 1.3.2 and < 2.0.0" }

src/starfish.gleam

···
+import birl
 import gleam/bool
 import gleam/result
 import starfish/internal/board
···
   move.legal(game)
 }
 
-pub fn search(game: Game, to_depth depth: Int) -> Result(Move, Nil) {
-  search.best_move(game, depth)
+/// Used to determine how long to search positions
+pub type SearchCutoff {
+  /// Search to a specific depth
+  Depth(depth: Int)
+  /// Search for a given number of milliseconds.
+  /// 
+  /// NOTE: The process will usually take slightly longer than the specified time.
+  /// It would be expensive to check the time every millisecond, so it is checked
+  /// periodically. This is usually less than 10ms, but it can be higher than that.
+  Time(milliseconds: Int)
+}
+
+/// Finds the best move for a given position, or returns an error if no moves are
+/// legal (If it's checkmate or stalemate)
+pub fn search(game: Game, until cutoff: SearchCutoff) -> Result(Move, Nil) {
+  let until = case cutoff {
+    Depth(depth:) -> fn(current_depth) { current_depth > depth }
+    Time(milliseconds:) -> {
+      let end_time = birl.monotonic_now() + milliseconds * 1000
+      fn(_) { birl.monotonic_now() >= end_time }
+    }
+  }
+
+  search.best_move(game, until)
 }
 
 pub fn apply_move(game: Game, move: Move) -> Game {

src/starfish/internal/search.gleam

···
 
 const checkmate = -1_000_000
 
-pub fn best_move(game: Game, depth: Int) -> Result(Move, Nil) {
-  use <- bool.guard(depth < 1, Error(Nil))
-  search_top_level(
-    game,
-    hash.new_table(),
-    depth,
-    move.legal(game),
-    None,
-    -infinity,
-  )
+type Until =
+  fn(Int) -> Bool
+
+pub fn best_move(game: Game, until: Until) -> Result(Move, Nil) {
+  use <- bool.guard(until(0), Error(Nil))
+  let legal_moves = move.legal(game)
+  use <- bool.guard(legal_moves == [], Error(Nil))
+  iterative_deepening(game, 1, None, legal_moves, hash.new_table(), until)
+}
+
+fn iterative_deepening(
+  game: Game,
+  depth: Int,
+  best_move: Option(Move),
+  legal_moves: List(Move),
+  cached_positions: hash.Table,
+  until: Until,
+) -> Result(Move, Nil) {
+  use <- bool.guard(until(depth), option.to_result(best_move, Nil))
+
+  let move_result =
+    search_top_level(
+      game,
+      cached_positions,
+      depth,
+      legal_moves,
+      None,
+      -infinity,
+      until,
+    )
+
+  case move_result {
+    Error(_) -> option.to_result(best_move, Nil)
+    Ok(TopLevelSearchResult(best_move:, cached_positions:)) ->
+      iterative_deepening(
+        game,
+        depth + 1,
+        Some(best_move),
+        legal_moves,
+        cached_positions,
+        until,
+      )
+  }
+}
+
+type TopLevelSearchResult {
+  TopLevelSearchResult(best_move: Move, cached_positions: hash.Table)
 }
 
 type SearchResult {
···
     eval: Int,
     cached_positions: hash.Table,
     eval_kind: hash.CacheKind,
+    finished: Bool,
   )
 }
 
···
   legal_moves: List(Move),
   best_move: Option(Move),
   best_eval: Int,
-) -> Result(Move, Nil) {
+  until: Until,
+) -> Result(TopLevelSearchResult, Nil) {
   case legal_moves {
     [] ->
       case best_move {
         None -> Error(Nil)
-        Some(best_move) -> Ok(best_move)
+        Some(best_move) ->
+          Ok(TopLevelSearchResult(best_move:, cached_positions:))
       }
     [move, ..moves] -> {
-      let SearchResult(eval:, cached_positions:, ..) =
+      let SearchResult(eval:, cached_positions:, eval_kind: _, finished:) =
         search(
           move.apply(game, move),
           cached_positions,
···
           -infinity,
           -best_eval,
           0,
+          until,
         )
 
+      use <- bool.guard(!finished, case best_move {
+        None -> Error(Nil)
+        Some(best_move) ->
+          Ok(TopLevelSearchResult(best_move:, cached_positions:))
+      })
+
       let eval = -eval
 
       let #(best_move, best_eval) = case eval > best_eval {
···
         moves,
         best_move,
         best_eval,
+        until,
       )
     }
   }
···
   best_eval: Int,
   best_opponent_move: Int,
   depth_searched: Int,
+  until: Until,
 ) -> SearchResult {
+  use <- bool.guard(
+    until(depth),
+    SearchResult(0, cached_positions, hash.Exact, False),
+  )
+
   // If we have reached fifty moves, the game is already a draw, so there's no
   // point searching further.
   use <- bool.guard(
     game.half_moves >= 50,
-    SearchResult(0, cached_positions, hash.Exact),
+    SearchResult(0, cached_positions, hash.Exact, True),
   )
 
   case
···
       best_opponent_move,
     )
   {
-    Ok(#(eval, eval_kind)) -> SearchResult(eval:, cached_positions:, eval_kind:)
+    Ok(#(eval, eval_kind)) ->
+      SearchResult(eval:, cached_positions:, eval_kind:, finished: True)
     Error(_) ->
       case move.legal(game) {
         // If the game is in a checkmate or stalemate position, the game is over, so
···
               hash.Exact,
               eval,
             )
-          SearchResult(eval:, cached_positions:, eval_kind: hash.Exact)
+          SearchResult(
+            eval:,
+            cached_positions:,
+            eval_kind: hash.Exact,
+            finished: True,
+          )
         }
         moves ->
           case depth {
···
                   hash.Exact,
                   eval,
                 )
-              SearchResult(eval:, cached_positions:, eval_kind: hash.Exact)
+              SearchResult(
+                eval:,
+                cached_positions:,
+                eval_kind: hash.Exact,
+                finished: True,
+              )
             }
             _ -> {
-              let SearchResult(eval:, cached_positions:, eval_kind:) =
+              let SearchResult(eval:, cached_positions:, eval_kind:, finished:) as result =
                 search_loop(
                   game,
                   cached_positions,
···
                   best_opponent_move,
                   depth_searched,
                   hash.Ceiling,
+                  until,
                 )
 
+              use <- bool.guard(!finished, result)
+
               let cached_positions =
                 hash.cache(
                   cached_positions,
···
                   eval,
                 )
 
-              SearchResult(eval:, cached_positions:, eval_kind:)
+              SearchResult(eval:, cached_positions:, eval_kind:, finished:)
             }
           }
       }
···
   best_opponent_move: Int,
   depth_searched: Int,
   eval_kind: hash.CacheKind,
+  until: Until,
 ) -> SearchResult {
   case moves {
-    [] -> SearchResult(eval: best_eval, cached_positions:, eval_kind:)
+    [] ->
+      SearchResult(
+        eval: best_eval,
+        cached_positions:,
+        eval_kind:,
+        finished: True,
+      )
     [move, ..moves] -> {
       // Evaluate the position for the opponent. The negative of the opponent's
       // eval is our eval.
-      let SearchResult(eval:, cached_positions:, eval_kind: search_kind) =
+      let SearchResult(
+        eval:,
+        cached_positions:,
+        eval_kind: search_kind,
+        finished:,
+      ) as result =
         search(
           move.apply(game, move),
           cached_positions,
···
           -best_opponent_move,
           -best_eval,
           depth_searched + 1,
+          until,
         )
+
+      use <- bool.guard(!finished, result)
 
       let eval = -eval
 
       use <- bool.guard(
         eval >= best_opponent_move,
-        SearchResult(best_opponent_move, cached_positions, hash.Floor),
+        SearchResult(
+          best_opponent_move,
+          cached_positions,
+          hash.Floor,
+          finished: True,
+        ),
       )
 
       let #(best_eval, eval_kind) = case eval > best_eval {
···
         best_opponent_move,
         depth_searched,
         eval_kind,
+        until,
       )
     }
   }

test/starfish_test.gleam

···
   let assert Ok(move) =
     starfish.search(
       starfish.from_fen("8/2p5/3p4/KP5r/1R3p1k/8/4P1P1/8 w - - 0 1"),
-      to_depth: 5,
+      until: starfish.Depth(5),
     )
   // b4f4
   assert move == move.Capture(from: 25, to: 29)