The syntax is of course attractive (coming from Rust), and I'd love to replace more of my posix scripts with something saner. I struggle understanding whether the utility of having language literals for IP addresses, IP prefixes, and AS numbers is worth it though [0]. It seems like the confusion added by having custom built-ins like this for one particular domain, in addition to the unclear scoping (what could later also deserve being a language literal), combined with special-case errors as famous in e.g. the YAML Norway problem, makes it seem like such features are better left as some general extension / macro / library capability.

Nix is a language with built-in support for URI literals typed as strings [1], which is a source of confusion and edge-cases, and I believe the feature is now discouraged in general use.

[0] https://roto.docs.nlnetlabs.nl/en/stable/reference/language_...

[1] https://nix.dev/manual/nix/2.34/language/string-literals

Very cool! I have been working on scripting in Rust recently on a Lua project [1].

When you made Roto what kind of workloads were you optimizing for? How are you guys benchmarking performance?

I ran a quick benchmark based on my recent work (Used AI for the code here): ``` fn sum_scalar(n: u64) -> u64 { let total = 0; let i = 0; while i < n { total = total + i; i = i + 1; } total }

  fn sum_list(xs: List[u64]) -> u64 {
      let total = 0;
      for x in xs { total = total + x; }
      total
  }

Rust benchmark.rs ```

  use std::time::Instant;
  use roto::{List, Runtime};

  fn main() {
      let rt = Runtime::new();
      let mut pkg = rt.compile("bench.roto").unwrap();
      let sum_list   = pkg.get_function::<fn(List<u64>) -> u64>("sum_list").unwrap();

      let n = 1024;
      let iters = 50_000;
      let xs: List<u64> = (0..n).collect();

      let t = Instant::now();
      for _ in 0..iters { sum_scalar.call(n); }          // adds 0..n with a counter
      let scalar = t.elapsed();

      let t = Instant::now();
      for _ in 0..iters { sum_list.call(xs.clone()); }   // adds the SAME 0..n from a List
      let list = t.elapsed();

      println!("sum_scalar (counter):   {scalar:?}");
      println!("sum_list   (List[u64]): {list:?}");
      println!("-> {:.0}x slower", list.as_secs_f64() / scalar.as_secs_f64());
  }

  Output:
  sum_scalar (counter):   28.56ms
  sum_list   (List[u64]): 590.48ms
  -> 21x slower

Does anyone know if the Roto runtime is serde-able?

A big problem I encountered in using Lua in Rust for my game engine was that I wasn't able to serde the Lua runtime such that I can snapshot a game session and save it in a file, and retrieve it in another context.