add enum Variants list binding

Author: kaikalii

changelog.md

@@ -15,8 +15,9 @@ This version is not yet released. If you are reading this on the website, then t
 - **Breaking Change** - [`dip ⊙`](https://uiua.org/docs/dip) and [`on ⟜`](https://uiua.org/docs/on) function packs no longer apply their modifier to the leftmost function
   - This change makes most usecases of these function packs cleaner, as `A⊙(B|C)` changes to `⊙(A|B|C)` and likewise for [`on ⟜`](https://uiua.org/docs/on)
 - **Breaking Change** - The FFI function API has been changed considerably, read more in the documentation for [`&ffi`](https://uiua.org/docs/&ffi), [`&memcpy`](https://uiua.org/docs/&memcpy), and [`&memset`](https://uiua.org/docs/&memset)
-- [`parse ⋕`](https://uiua.org/docs/parse) can be subscripted to parse strings in different bases
+- Add [`parse ⋕`](https://uiua.org/docs/parse) subscripts to parse strings in different bases
 - Allow for private [modules](https://uiua.org/tutorial/modules#private-scoped-modules), [imports](https://uiua.org/tutorial/modules#private-imports), and [data definitions](https://uiua.org/tutorial/datadefs#visibility)
+- Modules containing data definition variants now contains a `Variants` binding that lists their names
 - Add array pack syntactic sugar. This lets you write code like `[⊃(+|×)]` as `⊃[+|×]`.
 - Subscripts can now be typed with `,` instead of `__`s
 - Add numeric subscripts for [`keep ▽`](https://uiua.org/docs/keep) to keep along a number of dimensions

site/text/data_defs.md

@@ -223,6 +223,16 @@ If you have a lot of variants, you can put more than one on a single line.
 └─╴
 ```
 
+A module that contains variants has a `Variants` binding that lists their names.
+
+```uiua
+┌─╴IpAddr
+  |V₄ [A B C D]
+  |V₆ [A B C D E F]
+└─╴
+IpAddr~Variants
+```
+
 ## Structs of Arrays
 
 There is a well-known optimization for lower-level languages called "structs of arrays". It is a design pattern where instead of making a list of similar data structures, you make a single structure with a list for each field. This makes code faster by making data take up less memory and therefore making CPU cache misses less likely.

src/compile/binding.rs

@@ -611,7 +611,7 @@ impl Compiler {
     }
     fn analyze_macro_body(
         &mut self,
-        macro_name: &str,
+        mac_name: &str,
         words: &[Sp<Word>],
         mut code_macro: bool,
         recursive: &mut bool,
@@ -623,24 +623,22 @@ impl Compiler {
             let mut name_local = None;
             match &word.value {
                 Word::Strand(items) => {
-                    self.analyze_macro_body(macro_name, items, code_macro, recursive, loc)
+                    self.analyze_macro_body(mac_name, items, code_macro, recursive, loc)
                 }
                 Word::Array(arr) => {
-                    if self.analyze_macro_items(macro_name, &arr.lines, code_macro, recursive, loc)
-                    {
+                    if self.analyze_macro_items(mac_name, &arr.lines, code_macro, recursive, loc) {
                         return;
                     }
                 }
                 Word::Func(func) => {
-                    if self.analyze_macro_items(macro_name, &func.lines, code_macro, recursive, loc)
-                    {
+                    if self.analyze_macro_items(mac_name, &func.lines, code_macro, recursive, loc) {
                         return;
                     }
                 }
                 Word::Pack(pack) => {
                     for branch in &pack.branches {
                         if self.analyze_macro_items(
-                            macro_name,
+                            mac_name,
                             &branch.value.lines,
                             code_macro,
                             recursive,
@@ -684,7 +682,7 @@ impl Compiler {
                             if let Err(e) = self.in_scope(ScopeKind::AllInModule, move |comp| {
                                 comp.scope.names.extend(names);
                                 comp.analyze_macro_body(
-                                    macro_name,
+                                    mac_name,
                                     &m.operands,
                                     false,
                                     recursive,
@@ -698,7 +696,7 @@ impl Compiler {
                             // Name errors are ignored in code macros
                             let error_count = self.errors.len();
                             self.analyze_macro_body(
-                                macro_name,
+                                mac_name,
                                 &m.operands,
                                 code_macro,
                                 recursive,
@@ -709,14 +707,13 @@ impl Compiler {
                             }
                         }
                     } else {
-                        self.analyze_macro_body(macro_name, &m.operands, code_macro, recursive, loc)
+                        self.analyze_macro_body(mac_name, &m.operands, code_macro, recursive, loc)
                     }
                 }
                 _ => {}
             }
             if let Some((nm, name_span, local)) = name_local {
-                if nm.value == macro_name
-                    && path_locals.as_ref().is_none_or(|(pl, _)| pl.is_empty())
+                if nm.value == mac_name && path_locals.as_ref().is_none_or(|(pl, _)| pl.is_empty())
                 {
                     *recursive = true;
                 }

src/compile/data.rs

@@ -278,8 +278,9 @@ impl Compiler {
         let mut variant_index = 0;
         if data.variant {
             let module_scope = self.higher_scopes.last_mut().unwrap_or(&mut self.scope);
-            variant_index = module_scope.data_variants;
-            module_scope.data_variants += 1;
+            variant_index = module_scope.data_variants.len();
+            let name = data.name.as_ref().unwrap().value.clone();
+            module_scope.data_variants.insert(name);
         }
 
         // Make getters
@@ -574,6 +575,26 @@ impl Compiler {
         Ok(())
     }
     pub(super) fn end_enum(&mut self) -> UiuaResult {
+        // Add Variants binding
+        if !self.scope.data_variants.is_empty()
+            && !self.scope.names.get("Variants").is_some_and(|ln| ln.public)
+        {
+            let index = self.next_global;
+            self.next_global += 1;
+            let local = LocalName {
+                index,
+                public: true,
+            };
+            let value = take(&mut self.scope.data_variants)
+                .into_iter()
+                .map(|s| Boxed(s.chars().collect()))
+                .collect();
+            let meta = BindingMeta {
+                comment: Some("Names of the data variants of the module".into()),
+                ..Default::default()
+            };
+            self.compile_bind_const("Variants".into(), local, Some(value), 0, meta);
+        }
         Ok(())
     }
 }

src/compile/mod.rs

@@ -21,7 +21,7 @@ use std::{
 };
 
 use ecow::{eco_vec, EcoString, EcoVec};
-use indexmap::IndexMap;
+use indexmap::{IndexMap, IndexSet};
 use serde::{Deserialize, Serialize};
 
 use crate::{
@@ -217,8 +217,8 @@ pub(crate) struct Scope {
     names: LocalNames,
     /// Whether the scope has a data def defined
     has_data_def: bool,
-    /// Number of named data variants
-    data_variants: usize,
+    /// Names of data variants
+    data_variants: IndexSet<EcoString>,
     /// Whether to allow experimental features
     pub experimental: bool,
     /// Whether an error has been emitted for experimental features
@@ -266,7 +266,7 @@ impl Default for Scope {
             comment: None,
             names: IndexMap::new(),
             has_data_def: false,
-            data_variants: 0,
+            data_variants: IndexSet::new(),
             experimental: false,
             experimental_error: false,
             fill_sig_error: false,
@@ -812,9 +812,9 @@ impl Compiler {
         span: usize,
         meta: BindingMeta,
     ) {
-        let span = self.get_span(span).clone().code().unwrap();
+        let span = self.get_span(span).clone().code();
         self.asm
-            .add_binding_at(local, BindingKind::Const(value), Some(span), meta);
+            .add_binding_at(local, BindingKind::Const(value), span, meta);
         self.scope.names.insert(name, local);
     }
     /// Import a module

tests/data_defs.ua

@@ -25,6 +25,13 @@
 └─╴
 ⍤⤙≍ 5 Foo~Bar~a Foo~Bar 5
 
+┌─╴Foo
+  |Bar
+  |Baz {A B}
+  |Uiua [C]
+└─╴
+⍤⤙≍ {"Bar" "Baz" "Uiua"} Foo~Variants
+
 ┌─╴S
   ~ {A B C}
   PopA  ← ˜⊙∘⍜A(˜⊙∘⍜⇌°⊂)

todo.md

@@ -4,8 +4,6 @@
 - LSP optimizations
   - Fix rename
   - Fix goto references
-- `Variants` field for module
-- Don't serialize sortedness flags
 - Sided `join`
 - `table` subscripts for rank selection
 - Mixed subscripts