feat(web): add async solver worker

src/app/wordle_simulation.rs

@@ -1,5 +1,6 @@
 use std::{env::args, path::Path};
 
+use indicatif::ProgressBar;
 use wordle_solver::{game::Game, solver::Solver, word_list::WordList};
 
 pub fn do_simulation(valid_words: WordList, target_words: WordList, opener: Option<&str>) -> u64 {
@@ -24,14 +25,16 @@ pub fn do_simulation(valid_words: WordList, target_words: WordList, opener: Opti
     }
 
     loop {
-        let best_word = solver
+        let bar = ProgressBar::new(0);
-            .evaluate_all_words()
+        let best_words = solver
-            .unwrap()
+            .evaluate_all_words_async(move |i, n| {
-            .first()
+                bar.set_position(i as u64);
-            .unwrap()
+                bar.set_length(n as u64);
-            .word
+            })
-            .clone();
+            .wait()
-        println!("{}", solver.best_word_format(5));
+            .unwrap();
+        let best_word = best_words.first().unwrap().word.clone();
+        println!("{}", Solver::best_word_format(best_words, 5));
 
         match game.guess(&best_word) {
             Ok(pat) => {

src/app/wordle_solver.rs

@@ -39,9 +39,11 @@ pub fn main() -> io::Result<()> {
         io::stdin().read_line(&mut buf)?;
         let pat_str = buf.trim_ascii().to_ascii_lowercase();
 
-        solver.apply_guess(Pattern::try_new(&guess, pat_from_str(&pat_str)).unwrap());
+        solver
-        solver.evaluate_all_words();
+            .apply_guess(Pattern::try_new(&guess, pat_from_str(&pat_str)).unwrap())
+            .unwrap();
+        let best_words = solver.evaluate_all_words().unwrap();
         println!("\n{}\n", solver.tabular_format());
-        println!("{}", solver.best_word_format(10));
+        println!("{}", Solver::best_word_format(best_words, 10));
     }
 }

src/lib/pattern.rs

@@ -8,7 +8,7 @@ pub enum CharStatus {
     GREEN,
 }
 
-#[derive(Debug, PartialEq, Eq, Hash)]
+#[derive(Debug, PartialEq, Eq, Hash, Clone)]
 pub struct Pattern {
     chars: Vec<char>,
     stats: Vec<CharStatus>,

src/lib/solver.rs

@@ -1,3 +1,8 @@
+use std::sync::{
+    atomic::{AtomicUsize, Ordering},
+    mpsc, Arc,
+};
+
 use crate::pattern::Pattern;
 use indicatif::ParallelProgressIterator;
 use rayon::iter::{ParallelBridge, ParallelIterator};
@@ -7,16 +12,29 @@ use crate::word_list::WordList;
 use derive_more::Display;
 use tabular::{Row, Table};
 
+#[derive(Clone)]
 pub struct Guess {
     pub pattern: Pattern,
     pub information_gained: f64,
 }
 
+#[derive(Clone)]
 pub struct Solver {
     valid_words: WordList,
     possible_solutions: WordList,
     guesses: Vec<Guess>,
-    best_words: Vec<WordStats>,
+}
+
+pub struct SolverJob {
+    receiver: mpsc::Receiver<Result<Vec<WordStats>, String>>,
+}
+
+impl SolverJob {
+    pub fn wait(self) -> Result<Vec<WordStats>, String> {
+        self.receiver
+            .recv()
+            .map_err(|_| "calculation task cancelled".to_string())?
+    }
 }
 
 #[derive(Display, Clone)]
@@ -40,7 +58,6 @@ impl Solver {
             valid_words: word_list.clone(),
             possible_solutions: word_list,
             guesses: vec![],
-            best_words: vec![],
         }
     }
 
@@ -49,7 +66,6 @@ impl Solver {
             valid_words,
             possible_solutions,
             guesses: vec![],
-            best_words: vec![],
         }
     }
 
@@ -59,7 +75,7 @@ impl Solver {
             - new_possible_solutions.equal_likelieness_entropy();
 
         if new_possible_solutions.len() == 0 {
-            return Err("Solution space is empty".to_string());
+            return Err("Applying this guess would empty the solution space!".to_string());
         }
 
         self.possible_solutions = new_possible_solutions;
@@ -99,8 +115,44 @@ impl Solver {
         })
     }
 
+    pub fn evaluate_all_words_async<F>(&self, progress: F) -> SolverJob
+    where
+        F: Fn(usize, usize) + Send + Sync + 'static,
+    {
+        let solver_locked = (*self).clone();
+
+        let (tx, rc) = mpsc::channel();
+
+        let completed = Arc::new(AtomicUsize::new(0));
+
+        rayon::spawn_fifo(move || {
+            let mut result = solver_locked
+                .valid_words
+                .words()
+                .par_bridge()
+                .map(|w| {
+                    let r = solver_locked.evaluate_word(w);
+                    let completed = completed.fetch_add(1, Ordering::Relaxed) + 1;
+                    progress(completed, solver_locked.valid_words.len());
+                    r
+                })
+                .collect::<Result<Vec<WordStats>, String>>();
+
+            if let Ok(result) = &mut result {
+                result.sort_by(|a, b| {
+                    a.expected_score_after_guess
+                        .total_cmp(&b.expected_score_after_guess)
+                });
+            }
+
+            let _ = tx.send(result);
+        });
+
+        SolverJob { receiver: rc }
+    }
+
     pub fn evaluate_all_words(&mut self) -> Result<Vec<WordStats>, String> {
-        self.best_words = self
+        let mut best_words: Vec<WordStats> = self
             .valid_words
             .words()
             .par_bridge()
@@ -108,15 +160,15 @@ impl Solver {
             .map(|w| self.evaluate_word(w))
             .collect::<Result<_, String>>()?;
 
-        self.best_words.sort_by(|a, b| {
+        best_words.sort_by(|a, b| {
             a.expected_score_after_guess
                 .total_cmp(&b.expected_score_after_guess)
         });
 
-        Ok(self.best_words.clone())
+        Ok(best_words)
     }
 
-    pub fn best_word_format(&self, n: usize) -> String {
+    pub fn best_word_format(best_words: Vec<WordStats>, n: usize) -> String {
         let mut table = Table::new("#{:<} {:>} | {:<} {:<} {:<}");
 
         table.add_row(
@@ -127,7 +179,7 @@ impl Solver {
                 .with_cell("E[I]")
                 .with_cell("E[score]"),
         );
-        for (i, ws) in self.best_words.iter().take(n).enumerate() {
+        for (i, ws) in best_words.iter().take(n).enumerate() {
             table.add_row(
                 Row::new()
                     .with_cell(i + 1)

web/src/App.svelte

@@ -1,33 +1,50 @@
 <script lang="ts">
-    import { Color, Solver } from "wordle-solver";
+    import { Color } from "wordle-solver";
-  import WordleLine from "./components/WordleLine.svelte"
+    import WordleLine from "./components/WordleLine.svelte";
+    import { solver_guess } from "./solver/solver.ts";
 
-  let guesses = $state([{
+    let guesses = $state([
+        {
             letters: ["", "", "", "", ""],
-    colors: [Color.GREY, Color.GREY, Color.GREY, Color.GREY, Color.GREY]
+            colors: [
-  }]);
+                Color.GREY,
+                Color.GREY,
+                Color.GREY,
+                Color.GREY,
+                Color.GREY,
+            ],
+        },
+    ]);
+
+    let infos_gained: (Promise<number> | null)[] = $state([null]);
 
     let cursor = $state(0);
 
-  let solver = Solver.new();
-
-  let info_gained = $state(solver.guess_infos());
-  let solution_space = $state(solver.solution_space());
-  let solution_space_uncertainty = $state(solver.solution_space_uncertainty());
-
     function handleKey(event: KeyboardEvent) {
         if (event.key === "Enter") {
-      cursor = 0;
             const guess = guesses[guesses.length - 1];
 
-      solver.guess(guess.letters.join(""), guess.colors)
+            if (guess.letters.join("").length != 5) {
-      solution_space = solver.solution_space();
+                return;
-      solution_space_uncertainty = solver.solution_space_uncertainty();
+            }
-      info_gained = solver.guess_infos();
+
+            infos_gained[infos_gained.length - 1] = solver_guess(
+                guess.letters,
+                guess.colors,
+            );
+            infos_gained.push(null);
+
+            cursor = 0;
 
             guesses.push({
                 letters: ["", "", "", "", ""],
-        colors: [Color.GREY, Color.GREY, Color.GREY, Color.GREY, Color.GREY]
+                colors: [
+                    Color.GREY,
+                    Color.GREY,
+                    Color.GREY,
+                    Color.GREY,
+                    Color.GREY,
+                ],
             });
         }
     }
@@ -35,30 +52,29 @@
 
 <svelte:window onkeydown={handleKey} />
 
-<div class="min-h-screen bg-zinc-950 text-zinc-100 flex items-center justify-center">
+<div
+    class="min-h-screen bg-zinc-950 text-zinc-100 flex items-center justify-center"
+>
     <div class="text-center">
-		<h1 class="mb-6 text-3xl font-bold">
+        <h1 class="mb-6 text-3xl font-bold">Wordle Solver</h1>
-			Wordle Solver
-		</h1>
 
-    <p class="mt-4 text-sm text-zinc-500">
+        <p class="mt-4 text-sm text-zinc-500">SolutionSpace</p>
-      Solution-space: {solution_space} · {solution_space_uncertainty.toFixed(2)}bits
-    </p>
 
         <div class="mt-4 flex flex-col gap-2">
             {#each guesses as g, i (g)}
-        <WordleLine active={i === guesses.length-1}
+                <WordleLine
+                    active={i === guesses.length - 1}
                     bind:cursor
                     bind:letters={guesses[i].letters}
                     bind:colors={guesses[i].colors}
-                    info_gained={i < info_gained.length ? info_gained[i] : null}
+                    info_gained={infos_gained[i]}
                 />
             {/each}
         </div>
 
-
         <p class="mt-4 text-sm text-zinc-500">
-        Type letters · ← → navigate · Space cycle color · Backspace delete · Enter apply
+            Type letters · ← → navigate · Space cycle color · Backspace delete ·
+            Enter apply
         </p>
     </div>
 </div>

web/src/components/SolverOutput.svelte

@@ -0,0 +1,2 @@
+<script lang="ts">
+</script>

web/src/components/WordleLine.svelte

@@ -1,11 +1,19 @@
 <script lang="ts">
     import { Color } from "wordle-solver";
 
-    let { active=false,
+    let {
+        active = false,
         cursor = $bindable(0),
         letters = $bindable(["", "", "", "", ""]),
-          colors=$bindable([Color.GREY, Color.GREY, Color.GREY, Color.GREY, Color.GREY]),
+        colors = $bindable([
-          info_gained=null } = $props();
+            Color.GREY,
+            Color.GREY,
+            Color.GREY,
+            Color.GREY,
+            Color.GREY,
+        ]),
+        info_gained = null,
+    } = $props();
 
     function handleKey(event: KeyboardEvent) {
         if (!active) {
@@ -65,7 +73,25 @@
             {letter}
         </div>
     {/each}
-  <span class="w-12 text-sm text-zinc-500 self-center">{
+    <span
-    (info_gained !== null) ? info_gained.toFixed(2) + "bits" : '↵'
+        class="w-12 text-sm text-zinc-500 self-center flex items-center justify-center"
-  }</span>
+    >
+        {#if info_gained === null}
+            ↵
+        {:else}
+            {#await info_gained}
+                <div
+                    class="size-3 animate-spin rounded-full border-2 border-gray-300 border-t-gray-700"
+                ></div>
+            {:then i}
+                {i.toFixed(2)}
+            {:catch e}
+                <span
+                    title={e}
+                    class="lex size-4 items-center justify-center rounded-full border border-red-500 text-[10px] font-bold text-red-500"
+                    >!</span
+                >
+            {/await}
+        {/if}
+    </span>
 </div>

web/src/solver/solver.ts

@@ -0,0 +1,48 @@
+import type { Color } from "wordle-solver";
+import SolverWorker from "./worker?worker";
+import type { SolverRequest, SolverResponse } from "./types";
+
+let solver_worker = new SolverWorker();
+
+let msg_id = 0;
+
+const pending = new Map<number, {
+  resolve: (value: unknown) => void;
+  reject: (error: unknown) => void;
+}>();
+
+export function solver_guess(word: string[], colors: Color[]): Promise<number> {
+  const id = msg_id++;
+
+  return new Promise((resolve, reject) => {
+    pending.set(id, { resolve, reject });
+
+    const r: SolverRequest = {
+      type: "guess",
+      id: id,
+      input: { word: word, colors: colors },
+    };
+    
+    solver_worker.postMessage(JSON.parse(JSON.stringify(r)));
+  });
+}
+
+
+solver_worker.onmessage = (event: MessageEvent<SolverResponse>) => {
+  let res = event.data;
+  const pendingRequest = pending.get(res.id);
+
+  if (!pendingRequest) {
+    return;
+  }
+
+  pending.delete(res.id);
+  
+  if (res.error) {
+    pendingRequest.reject(res.result);
+  } else if (res.type == "guess") {
+    pendingRequest.resolve(res.result.info_gained);
+  } else if (event.type == "evaluate_words") {
+    pendingRequest.resolve(res.result.stats);
+  }
+};

web/src/solver/types.ts

@@ -0,0 +1,44 @@
+import { Color } from "wordle-solver";
+
+export type SolverRequest =
+  | {
+    type: "guess",
+    id: number,
+    input: Guess
+  }
+  | {
+    type: "evaluate_words",
+    id: number,
+    input: EvaluateWords
+  };
+
+export type SolverResponse =
+  | {
+    type: "guess",
+    id: number,
+    error: boolean,
+    result: GuessResult | string
+  }
+  | {
+    type: "evaluate_words",
+    id: number,
+    error: boolean,
+    result: EvaluateWordsResult | string
+  };
+
+export type Guess = {
+  word: string[],
+  colors: Color[]
+};
+export type GuessResult = {
+  info_gained: number,
+};
+export type EvaluateWords = {
+  n: number,
+};
+export type WordStats = {
+  word: string,
+};
+export type EvaluateWordsResult = {
+  stats: WordStats[]
+};

web/src/solver/worker.ts

@@ -0,0 +1,54 @@
+import { Solver } from "wordle-solver";
+import type { SolverRequest, SolverResponse } from "./types";
+
+
+let solver = Solver.new();
+
+self.onmessage = (event: MessageEvent<SolverRequest>) => {
+  const request = event.data;
+
+  switch (request.type) {
+    case "guess": {
+      try {
+        solver.guess(request.input.word.join(""), request.input.colors);
+        const infos = solver.guess_infos();
+
+        const response: SolverResponse = {
+          type: "guess",
+          id: request.id,
+          error: false,
+          result: { info_gained: infos[infos.length - 1] }
+        };
+
+        self.setTimeout(() => {
+          self.postMessage(JSON.parse(JSON.stringify(response)));
+        }, 1000);
+      } catch (e) {
+        const response: SolverResponse = {
+          type: "guess",
+          id: request.id,
+          error: true,
+          result: e,
+        };
+
+        self.setTimeout(() => {
+          self.postMessage(JSON.parse(JSON.stringify(response)));
+        }, 1000);
+      }
+
+
+      break;
+    };
+    case "evaluate_words": {
+      const response: SolverResponse = {
+        type: "evaluate_words",
+        id: request.id,
+        error: true,
+        result: "Not implemented"
+      };
+
+      self.postMessage(JSON.parse(JSON.stringify(response)));
+      break;
+    };
+  }
+};