remove astar

Author: kaikalii

changelog.md

@@ -35,6 +35,7 @@ This version is not yet released. If you are reading this on the website, then t
   - This allows filling from the left instead of the right
 - Add experimental [`bytes`](https://uiua.org/docs/bytes) function for encoding and decoding byte arrays
 - Remove previously deprecated `around ’`
+- Remove previously deprecated `astar`
 ### Interpreter
 - Improve pretty-printed array layout
   - High-rank arrays take up less vertical space and more horizontal space

site/primitives.json

@@ -371,13 +371,6 @@
     "class": "Misc",
     "description": "Throw an error if a condition is not met"
   },
-  "astar": {
-    "outputs": 2,
-    "modifier_args": 3,
-    "class": "Algorithm",
-    "description": "Find shortest paths in a graph",
-    "deprecated": true
-  },
   "atangent": {
     "glyph": "∠",
     "args": 2,

src/check.rs

@@ -208,7 +208,7 @@ impl VirtualEnv {
                 self.handle_args_outputs(1, parts.len().saturating_sub(1))
             }
             Node::Unpack { count, .. } => self.handle_args_outputs(1, *count),
-            Node::Mod(Astar, args, _) | Node::ImplMod(AstarFirst, args, _) => {
+            Node::ImplMod(Astar, args, _) | Node::ImplMod(AstarFirst, args, _) => {
                 self.pop();
                 let [neighbors, heuristic, is_goal] = get_args(args)?;
                 let has_costs = neighbors.outputs() == 2;

src/compile/modifier.rs

@@ -279,24 +279,14 @@ impl Compiler {
                 let span = self.add_span(modifier.span.clone());
                 Ok(Node::CustomInverse(cust.into(), span))
             }
-            Modifier::Primitive(Primitive::Astar) if pack.branches.len() == 2 => {
-                self.handle_primitive_deprecation(Primitive::Astar, &modifier.span);
-                self.handle_primitive_experimental(Primitive::Astar, &modifier.span);
-                let mut args = EcoVec::with_capacity(3);
-                for branch in pack.lexical_order().cloned() {
-                    args.push(self.word_sig(branch.map(Word::Func))?);
-                }
-                let span = self.add_span(modifier.span.clone());
-                Ok(Node::Mod(Primitive::Path, args, span))
-            }
             Modifier::Primitive(Primitive::Path) if pack.branches.len() == 3 => {
                 let mut args = EcoVec::with_capacity(3);
                 for branch in pack.lexical_order().cloned() {
                     args.push(self.word_sig(branch.map(Word::Func))?);
                 }
                 args.make_mut().swap(1, 2);
                 let span = self.add_span(modifier.span.clone());
-                Ok(Node::Mod(Primitive::Astar, args, span))
+                Ok(Node::ImplMod(ImplPrimitive::Astar, args, span))
             }
             m if m.args() >= 2 => {
                 let new = Modified {

src/compile/optimize.rs

@@ -293,15 +293,15 @@ opt!(
         ImplMod(PathPop, args.clone(), *span)
     ),
     (
-        [Mod(Astar, args, span), Prim(First, _)],
+        [ImplMod(Astar, args, span), Prim(First, _)],
         ImplMod(AstarFirst, args.clone(), *span)
     ),
     (
-        [Mod(Astar, args, span), Push(n), Prim(Take, _)],
+        [ImplMod(Astar, args, span), Push(n), Prim(Take, _)],
         [Push(n.clone()), ImplMod(AstarTake, args.clone(), *span)]
     ),
     (
-        [Mod(Astar, args, span), Prim(Pop, _)],
+        [ImplMod(Astar, args, span), Prim(Pop, _)],
         ImplMod(AstarPop, args.clone(), *span)
     ),
 );
@@ -328,7 +328,7 @@ impl Optimization for PathOpt {
                 let node = Mod(Fill, eco_vec![get_fill.clone(), inner], *fill_span);
                 Some((2, node))
             }
-            [Mod(Astar, args, span), Mod(Fill, fill_args, fill_span), ..] => {
+            [ImplMod(Astar, args, span), Mod(Fill, fill_args, fill_span), ..] => {
                 let [get_fill, filled] = fill_args.as_slice() else {
                     return None;
                 };

src/primitive/defs.rs

@@ -2939,10 +2939,6 @@ primitive!(
     ///   : ▽⟜≡▽0.5
     ///   : ⌵⍜°⍉≡fft .
     (1, Fft, Algorithm, "fft", { experimental: true }),
-    /// Find shortest paths in a graph
-    ///
-    /// [astar] is deprecated. Use [path] instead.
-    ((2)[3], Astar, Algorithm, "astar"),
     /// Find the shortest path between two things
     ///
     /// Expects 2 functions and at least 1 value.
@@ -3546,6 +3542,7 @@ impl_primitive!(
     (1, ReplaceRand, Impure),
     (2, ReplaceRand2, Impure),
     (1, CountUnique),
+    ((2)[3], Astar),
     ((2)[3], AstarFirst),
     ((1)[3], AstarPop),
     ((1)[3], AstarTake),

src/primitive/mod.rs

@@ -313,6 +313,7 @@ impl fmt::Display for ImplPrimitive {
             MatchPattern => write!(f, "pattern match"),
             MatchLe => write!(f, "match ≤"),
             MatchGe => write!(f, "match ≥"),
+            Astar => write!(f, "{Path}"),
             AstarFirst => write!(f, "{First}{Astar}"),
             AstarTake => write!(f, "{Take}…{Astar}"),
             AstarPop => write!(f, "{Pop}{Astar}"),
@@ -554,7 +555,6 @@ impl Primitive {
             ),
             Trace => format!("use subscripted {} instead", Stack.format()),
             Windows => format!("use {} {} instead", Stencil.format(), Identity.format()),
-            Astar => format!("use {} instead", Path.format()),
             Over => format!("use {With} or {Below} instead"),
             _ => return None,
         })
@@ -1185,10 +1185,6 @@ impl Primitive {
                 })?;
             }
             Primitive::Dump => dump(ops, env, false)?,
-            Primitive::Astar => {
-                let [neighbors, heuristic, is_goal] = get_ops(ops, env)?;
-                path::path(neighbors, is_goal, Some(heuristic), env)?;
-            }
             Primitive::Path => {
                 let [neighbors, is_goal] = get_ops(ops, env)?;
                 path::path(neighbors, is_goal, None, env)?;
@@ -1883,6 +1879,10 @@ impl ImplPrimitive {
                 env.insert_stack(outputs, kept)?;
                 env.push_all(temp);
             }
+            ImplPrimitive::Astar => {
+                let [neighbors, heuristic, is_goal] = get_ops(ops, env)?;
+                path::path(neighbors, is_goal, Some(heuristic), env)?;
+            }
             ImplPrimitive::UndoPartition1 => groups::undo_partition_part1(ops, env)?,
             ImplPrimitive::UndoGroup1 => groups::undo_group_part1(ops, env)?,
             ImplPrimitive::ReduceContent => reduce::reduce_content(ops, env)?,