A lot of stuff I'm not gonna enumerate

rule fundamentals

src/parse/sourcefile.rs

@@ -1,15 +1,13 @@
 use std::collections::HashSet;
-use std::fs::File;
 use std::iter;
 
-use crate::{enum_parser, Expr, Clause};
+use crate::{enum_parser, expression::{Expr, Clause, Rule}};
 use crate::utils::BoxedIter;
 
 use super::expression::xpr_parser;
 use super::import;
 use super::import::import_parser;
 use super::lexer::Lexeme;
-use super::name;
 use chumsky::{Parser, prelude::*};
 use ordered_float::NotNan;
 
@@ -18,8 +16,7 @@ use ordered_float::NotNan;
 pub enum FileEntry {
     Import(Vec<import::Import>),
     Comment(String),
-    Rule(Vec<Expr>, NotNan<f64>, Vec<Expr>),
-    Export(Vec<Expr>, NotNan<f64>, Vec<Expr>)
+    Rule(Rule, bool)
 }
 
 /// Recursively iterate through all "names" in an expression. It also finds a lot of things that
@@ -70,49 +67,21 @@ pub fn line_parser() -> impl Parser<Lexeme, FileEntry, Error = Simple<Lexeme>> {
             println!("{:?} could not yield an export", s); e
         })
             .ignore_then(rule_parser())
-            .map(|(lhs, prio, rhs)| FileEntry::Export(lhs, prio, rhs)),
+            .map(|(source, prio, target)| FileEntry::Rule(Rule{source, prio, target}, true)),
         // This could match almost anything so it has to go last
-        rule_parser().map(|(lhs, prio, rhs)| FileEntry::Rule(lhs, prio, rhs)),
+        rule_parser().map(|(source, prio, target)| FileEntry::Rule(Rule{source, prio, target}, false)),
     ))
 }
 
 /// Collect all exported names (and a lot of other words) from a file
 pub fn exported_names(src: &Vec<FileEntry>) -> HashSet<&Vec<String>> {
     src.iter().flat_map(|ent| match ent {
-        FileEntry::Export(s, _, d) => Box::new(s.iter().chain(d.iter())) as BoxedIter<&Expr>,
+        FileEntry::Rule(Rule{source, target, ..}, true) =>
+            Box::new(source.iter().chain(target.iter())) as BoxedIter<&Expr>,
         _ => Box::new(iter::empty())
     }).map(find_all_names).flatten().collect()
 }
 
-
-// #[allow(dead_code)]
-/// Collect all operators defined in a file (and some other words)
-fn defined_ops(src: &Vec<FileEntry>, exported_only: bool) -> Vec<&String> {
-    let all_names:HashSet<&Vec<String>> = src.iter().flat_map(|ent| match ent {
-        FileEntry::Rule(s, _, d) =>
-            if exported_only {Box::new(iter::empty()) as BoxedIter<&Expr>}
-            else {Box::new(s.iter().chain(d.iter()))}
-        FileEntry::Export(s, _, d) => Box::new(s.iter().chain(d.iter())),
-        _ => Box::new(iter::empty())
-    }).map(find_all_names).flatten().collect();
-    // Dedupe stage of dubious value; collecting into a hashset may take longer than
-    // handling duplicates would with a file of sensible size.
-    all_names.into_iter()
-        .filter_map(|name|
-            // If it's namespaced, it's imported.
-            if name.len() == 1 && name::is_op(&name[0]) {Some(&name[0])}
-            else {None}
-        ).collect()
-}
-
-// #[allow(dead_code)]
-/// Collect all operators from a file
-pub fn all_ops(src: &Vec<FileEntry>) -> Vec<&String> { defined_ops(src, false) }
-// #[allow(dead_code)]
-/// Collect exported operators from a file (plus some extra)
-pub fn exported_ops(src: &Vec<FileEntry>) -> Vec<&String> { defined_ops(src, true) }
-
-
 /// Summarize all imports from a file in a single list of qualified names 
 pub fn imports<'a, 'b, I>(
     src: I