remove eval

changelog.md

@@ -38,7 +38,6 @@ This version is not yet released. If you are reading this on the website, then t
 - Add experimental [inline macros](https://www.uiua.org/docs/experimental#inline-macros)
   - Deprecate the experimental `stringify` and `signature` modifiers in favor of inline code macros
 - Add experimental [`binary`](https://uiua.org/docs/binary) function, which encodes and decodes arrays into a compact binary representation
-- Add experimental [`eval`](https://uiua.org/docs/eval) function, which evaluates a string as code at compile time
 - Remove the previously deprecated experimental `coordinate ⟔` function
 - Remove the previously deprecated experimental `struct` modifier
 - Remove the previously deprecated `setinv` and `setund` modifiers

src/compile/mod.rs

@@ -106,7 +106,7 @@ impl Default for Compiler {
             print_diagnostics: false,
             comptime: true,
             pre_eval_mode: PreEvalMode::default(),
-            macro_env: Uiua::default().comptime(),
+            macro_env: Uiua::default(),
         }
     }
 }
@@ -247,7 +247,7 @@ impl Compiler {
     /// Create a new compiler with a custom backend for `comptime` code
     pub fn with_backend(backend: impl IntoSysBackend) -> Self {
         Self {
-            macro_env: Uiua::with_backend(backend.into_sys_backend()).comptime(),
+            macro_env: Uiua::with_backend(backend.into_sys_backend()),
             ..Self::default()
         }
     }

src/primitive/defs.rs

@@ -3458,29 +3458,6 @@ primitive!(
     ///   : ⍜⊜□⍚(⊂@,)∈" \n". repr # add commas
     ///   : &p ⍜▽∵⋅@-=@¯.        # replace negate glyphs with minus signs
     (1, Repr, Misc, "repr"),
-    /// Evalute a string as code at compile time
-    ///
-    /// The first argument is a list of arguments to pass to the code.
-    /// The second argument is the string to evaluate.
-    /// If the code returns a single value, it will simply be pushed to the stack.
-    /// If the code returns multiple values, they will collected into a list of boxes.
-    ///
-    /// [eval] can only be called in a compile-time context.
-    /// ex! # Experimental!
-    ///   : eval {1 2} "+"
-    /// The simplest way to do this is to use [comptime].
-    /// ex: # Experimental!
-    ///   : comptime(eval {1 2} "+")
-    /// [eval] is probably more useful in code macros.
-    /// ex: # Experimental!
-    ///   : F! ←^ eval{1 2}⊢
-    ///   : F!+
-    /// ex: # Experimental!
-    ///   : F! ←^ eval{}⊢
-    ///   : F!"+1" 5
-    ///
-    /// [eval] is still very experimental and may be buggy.
-    (2, Eval, Misc, "eval"),
     /// Encode an image into a byte array with the specified format
     ///
     /// The first argument is the format, and the second is the image.

src/primitive/mod.rs

@@ -33,7 +33,7 @@ use crate::{
     lex::{AsciiToken, SUBSCRIPT_DIGITS},
     sys::*,
     value::*,
-    Compiler, FunctionId, Ops, Shape, Signature, Uiua, UiuaErrorKind, UiuaResult,
+    FunctionId, Ops, Shape, Signature, Uiua, UiuaErrorKind, UiuaResult,
 };
 
 /// Categories of primitives
@@ -529,7 +529,7 @@ impl Primitive {
             self,
             (Off | Backward | Above | Around)
                 | (Tuples | Choose | Permute)
-                | (Or | Chunks | Base | Fft | Case | Layout | Binary | Eval)
+                | (Or | Chunks | Base | Fft | Case | Layout | Binary)
                 | (Astar | Triangle)
                 | (Derivative | Integral)
                 | Sys(Ffi | MemCopy | MemFree | TlsListen)
@@ -819,39 +819,6 @@ impl Primitive {
                 env.push(val.box_depth(0));
             }
             Primitive::Repr => env.monadic_ref(Value::representation)?,
-            Primitive::Eval => {
-                if !env.rt.is_comptime {
-                    return Err(env.error("eval cannot be called outside a compile-time context"));
-                }
-                let args = env.pop(1)?;
-                let code = env.pop(2)?.as_string(env, "eval expects a string")?;
-                let stack = env.take_stack();
-                for arg in args.into_rows().rev() {
-                    env.push(arg.unboxed());
-                }
-
-                let mut comp = Compiler::with_backend(env.rt.backend.clone());
-                comp.asm.spans = env.asm.spans.clone();
-                comp.asm.inputs = env.asm.inputs.clone();
-                let res = (|| -> UiuaResult {
-                    comp.load_str(&code)?;
-                    env.run_compiler(&mut comp)?;
-                    env.asm.spans = comp.asm.spans;
-                    env.asm.inputs = comp.asm.inputs;
-                    Ok(())
-                })();
-
-                let results = env.take_stack();
-                for val in stack.into_iter().rev() {
-                    env.push(val);
-                }
-                env.push(if results.len() == 1 {
-                    results.into_iter().next().unwrap()
-                } else {
-                    Array::from_iter(results.into_iter().map(Boxed)).into()
-                });
-                res?;
-            }
             Primitive::Parse => env.monadic_ref_env(Value::parse_num)?,
             Primitive::Utf8 => env.monadic_ref_env(Value::utf8)?,
             Primitive::Graphemes => env.monadic_ref_env(Value::graphemes)?,

src/run.rs

@@ -59,8 +59,6 @@ pub(crate) struct Runtime {
     pub(crate) execution_start: f64,
     /// The recursion limit
     recursion_limit: usize,
-    /// Whether this is a compile-time runtime
-    pub(crate) is_comptime: bool,
     /// Whether the program was interrupted
     pub(crate) interrupted: Option<Arc<dyn Fn() -> bool + Send + Sync>>,
     /// Whether to print the time taken to execute each instruction
@@ -201,7 +199,6 @@ impl Default for Runtime {
             cli_file_path: PathBuf::new(),
             execution_limit: None,
             execution_start: 0.0,
-            is_comptime: false,
             #[cfg(debug_assertions)]
             recursion_limit: 20,
             #[cfg(not(debug_assertions))]
@@ -244,11 +241,6 @@ impl Uiua {
     pub fn build(self) -> Assembly {
         self.asm
     }
-    /// Make this a compile-time runtime
-    pub(crate) fn comptime(mut self) -> Self {
-        self.rt.is_comptime = true;
-        self
-    }
     /// Get a reference to the system backend
     pub fn backend(&self) -> &dyn SysBackend {
         &*self.rt.backend
@@ -1441,7 +1433,6 @@ impl Uiua {
                 interrupted: self.rt.interrupted.clone(),
                 output_comments: HashMap::new(),
                 memo: self.rt.memo.clone(),
-                is_comptime: self.rt.is_comptime,
                 unevaluated_constants: HashMap::new(),
                 test_results: Vec::new(),
                 reports: Vec::new(),

todo.md

@@ -4,6 +4,7 @@
 The next version of Uiua
 
 - Stabilize `backward`, `case`
+- Compile-time code string evaluation
 - `do` function pack
 - Allow for multi-value constant bindings
 - Animated WEBP support? (`&webp`)