pirates-path example uses until (#218)

Author: keiravillekode

concepts/deques/about.md

@@ -44,13 +44,13 @@ A breadth-first search is the canonical FIFO use:
     <dlist>    :> frontier
     start visited adjoin
     start frontier push-back
-    [ frontier deque-empty? not ] [
+    [ frontier deque-empty? ] [
         frontier pop-front graph at [
             dup visited in? [ drop ] [
                 [ visited adjoin ] [ frontier push-back ] bi
             ] if
         ] each
-    ] while
+    ] until
     visited ;
 ```
 

exercises/concept/factory-failsafe/.docs/introduction.md

@@ -62,5 +62,19 @@ A no-slot error is just `ERROR: name ;` — calling `name` throws an
 empty instance. Tuples defined with `ERROR:` carry a class predicate
 `name?` you can use to test whether a caught error was of that type.
 
+## Reading slots back out
+
+A caught error is just a tuple, so each `ERROR:` slot comes with the
+same auto-generated `slot>>` reader as any other tuple.
+
+```factor
+! DOCTEST: SKIP
+{
+    T{ not-found { path "/a" } }
+    T{ not-found { path "/b" } }
+}
+[ path>> ] map .   ! => { "/a" "/b" }
+```
+
 [kernel]: https://docs.factorcode.org/content/vocab-kernel.html
 [continuations]: https://docs.factorcode.org/content/vocab-continuations.html

exercises/concept/factory-failsafe/.meta/design.md

@@ -27,3 +27,5 @@ handling with `recover`, and defining error classes with `ERROR:`.
 
 - `tuples` — taught in `role-playing-game`.
 - `conditionals` — taught in `cars-assemble`.
+- `higher-order-sequences` — taught in `boutique-bookkeeping`.
+- `combinators` — taught in `joiners-journey`.

exercises/concept/pirates-path/.docs/hints.md

@@ -10,16 +10,16 @@
 
 ## 1. Drain the tide queue
 
-- Start with `<dlist>`, `[ push-back ] each` to fill it, then a
-  `while` loop that pops the front until the deque is empty,
-  accumulating into a `V{ } clone` and converting to an array
-  at the end with `>array`.
+- Start with `<dlist>`, `[ push-back ] each` to fill it, then
+  drain it with an `until` loop (`[ deque-empty? ]` predicate):
+  pop the front into a `V{ } clone`, converting to an array at
+  the end with `>array`.
 
 ## 2. Coves reachable
 
 - Pattern: `HS{ } clone` for `visited`, `<dlist>` for
   `frontier`, mark `start` visited and push it onto the
-  frontier, then loop while the frontier isn't empty: pop the
+  frontier, then loop until the frontier is empty: pop the
   front, look up its neighbours in the chart with `at`, and for
   each unseen neighbour adjoin to `visited` and push-back onto
   the frontier.
@@ -29,8 +29,8 @@
 - Same shape as task 2, but the deque carries `{ cove distance }`
   pairs. When you pop a pair whose cove equals the goal, record
   the distance as the answer and stop. Use a mutable local
-  (`f :> answer!`) and gate the loop on
-  `frontier deque-empty? not answer not and`.
+  (`f :> answer!`) and gate the `until` loop on
+  `frontier deque-empty? answer or`.
 
 ## 4. Gold count
 

exercises/concept/pirates-path/.docs/introduction.md

@@ -50,9 +50,9 @@ candidates from the front, and dedup with a hash-set:
 USING: deques dlists hash-sets sets ;
 
 ! ... visited adjoin and frontier push-back ...
-[ frontier deque-empty? not ] [
+[ frontier deque-empty? ] [
     frontier pop-front ! ... look up neighbours, push unseen ones ...
-] while
+] until
 ```
 
 Older candidates are visited before newer ones — so the search

exercises/concept/pirates-path/.meta/design.md

@@ -51,7 +51,7 @@ neighbour function" pattern from the ground up.
   up neighbours.
 - `locals` — taught in `lasagna-luminary`. `::` and `:>` keep
   the multi-state BFS body readable.
-- `while` — taught in `mixed-juices`. The BFS loop.
+- `until` — taught in `mixed-juices`. The BFS loop.
 
 ## Tasks ramp
 

exercises/concept/pirates-path/.meta/exemplar.factor

@@ -6,21 +6,21 @@ IN: pirates-path
     <dlist> :> q
     items [ q push-back ] each
     V{ } clone
-    [ q deque-empty? not ] [ q pop-front over push ] while
+    [ q deque-empty? ] [ q pop-front over push ] until
     >array ;
 
 :: coves-reachable ( start chart -- coves )
     HS{ } clone :> visited
     <dlist> :> frontier
     start visited adjoin
     start frontier push-back
-    [ frontier deque-empty? not ] [
+    [ frontier deque-empty? ] [
         frontier pop-front chart at [
             dup visited in? [ drop ] [
                 [ visited adjoin ] [ frontier push-back ] bi
             ] if
         ] each
-    ] while
+    ] until
     visited ;
 
 :: hop-count ( start goal chart -- n/f )
@@ -29,7 +29,7 @@ IN: pirates-path
     f :> answer!
     start visited adjoin
     { start 0 } frontier push-back
-    [ frontier deque-empty? not answer not and ] [
+    [ frontier deque-empty? answer or ] [
         frontier pop-front first2 :> ( cove dist )
         cove goal = [ dist answer! ] [
             cove chart at [
@@ -39,7 +39,7 @@ IN: pirates-path
                 ] if
             ] each
         ] if
-    ] while
+    ] until
     answer ;
 
 CONSTANT: gold-distribution H{