make VariableSubsSlice an alias

cli/src/repl/eval.rs

@@ -647,8 +647,8 @@ fn unpack_single_element_tag_union(subs: &Subs, tags: UnionTags) -> (&TagName, &
     let (tag_name_index, payload_vars_index) = tags.iter_all().next().unwrap();
 
     let tag_name = &subs[tag_name_index];
-    let subs_slice = subs[payload_vars_index].as_subs_slice();
+    let subs_slice = subs[payload_vars_index];
-    let payload_vars = subs.get_subs_slice(*subs_slice);
+    let payload_vars = subs.get_subs_slice(subs_slice);
 
     (tag_name, payload_vars)
 }
@@ -661,14 +661,14 @@ fn unpack_two_element_tag_union(
     let (tag_name_index, payload_vars_index) = it.next().unwrap();
 
     let tag_name1 = &subs[tag_name_index];
-    let subs_slice = subs[payload_vars_index].as_subs_slice();
+    let subs_slice = subs[payload_vars_index];
-    let payload_vars1 = subs.get_subs_slice(*subs_slice);
+    let payload_vars1 = subs.get_subs_slice(subs_slice);
 
     let (tag_name_index, payload_vars_index) = it.next().unwrap();
 
     let tag_name2 = &subs[tag_name_index];
-    let subs_slice = subs[payload_vars_index].as_subs_slice();
+    let subs_slice = subs[payload_vars_index];
-    let payload_vars2 = subs.get_subs_slice(*subs_slice);
+    let payload_vars2 = subs.get_subs_slice(subs_slice);
 
     (tag_name1, payload_vars1, tag_name2, payload_vars2)
 }

compiler/solve/src/solve.rs

@@ -906,7 +906,7 @@ fn alias_to_var<'a>(
     }
 
     AliasVariables {
-        variables_start: new_variables.slice.start,
+        variables_start: new_variables.start,
         type_variables_len: type_arguments.len() as _,
         all_variables_len: length as _,
     }
@@ -1501,7 +1501,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
     macro_rules! var_slice {
         ($variable_subs_slice:expr) => {{
             let slice = $variable_subs_slice;
-            &subs.variables[slice.slice.start as usize..][..slice.slice.length as usize]
+            &subs.variables[slice.indices()]
         }};
     }
 
@@ -1570,7 +1570,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
                     let ext_var = *ext_var;
 
                     for slice_index in tags.variables() {
-                        let slice = subs.variable_slices[slice_index.start as usize];
+                        let slice = subs.variable_slices[slice_index.index as usize];
                         stack.extend(var_slice!(slice));
                     }
 
@@ -1586,7 +1586,7 @@ fn instantiate_rigids_help(subs: &mut Subs, max_rank: Rank, initial: Variable) {
                     let rec_var = *rec_var;
 
                     for slice_index in tags.variables() {
-                        let slice = subs.variable_slices[slice_index.start as usize];
+                        let slice = subs.variable_slices[slice_index.index as usize];
                         stack.extend(var_slice!(slice));
                     }
 
@@ -1736,7 +1736,7 @@ fn deep_copy_var_help(
                         RecordFields {
                             length: fields.length,
                             field_names_start: fields.field_names_start,
-                            variables_start: new_variables.slice.start,
+                            variables_start: new_variables.start,
                             field_types_start: fields.field_types_start,
                         }
                     };
@@ -1844,7 +1844,7 @@ fn deep_copy_var_help(
             }
 
             let new_arguments = AliasVariables {
-                variables_start: new_variables.slice.start,
+                variables_start: new_variables.start,
                 ..arguments
             };
 

compiler/types/src/pretty_print.rs

@@ -504,24 +504,14 @@ fn write_flat_type(env: &Env, flat_type: &FlatType, subs: &Subs, buf: &mut Strin
     use crate::subs::FlatType::*;
 
     match flat_type {
-        Apply(symbol, args) => write_apply(
+        Apply(symbol, args) => {
-            env,
+            write_apply(env, *symbol, subs.get_subs_slice(*args), subs, buf, parens)
-            *symbol,
+        }
-            subs.get_subs_slice(*args.as_subs_slice()),
-            subs,
-            buf,
-            parens,
-        ),
         EmptyRecord => buf.push_str(EMPTY_RECORD),
         EmptyTagUnion => buf.push_str(EMPTY_TAG_UNION),
-        Func(args, _closure, ret) => write_fn(
+        Func(args, _closure, ret) => {
-            env,
+            write_fn(env, subs.get_subs_slice(*args), *ret, subs, buf, parens)
-            subs.get_subs_slice(*args.as_subs_slice()),
+        }
-            *ret,
-            subs,
-            buf,
-            parens,
-        ),
         Record(fields, ext_var) => {
             use crate::types::{gather_fields, RecordStructure};
 
@@ -640,7 +630,7 @@ pub fn chase_ext_tag_union<'a>(
         Content::Structure(TagUnion(tags, ext_var)) => {
             for (name_index, slice_index) in tags.iter_all() {
                 let subs_slice = subs[slice_index];
-                let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
+                let slice = subs.get_subs_slice(subs_slice);
                 let tag_name = subs[name_index].clone();
 
                 fields.push((tag_name, slice.to_vec()));
@@ -652,7 +642,7 @@ pub fn chase_ext_tag_union<'a>(
         Content::Structure(RecursiveTagUnion(_, tags, ext_var)) => {
             for (name_index, slice_index) in tags.iter_all() {
                 let subs_slice = subs[slice_index];
-                let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
+                let slice = subs.get_subs_slice(subs_slice);
                 let tag_name = subs[name_index].clone();
 
                 fields.push((tag_name, slice.to_vec()));

compiler/types/src/solved_types.rs

@@ -299,7 +299,7 @@ impl SolvedType {
             Apply(symbol, args) => {
                 let mut new_args = Vec::with_capacity(args.len());
 
-                for var in subs.get_subs_slice(*args.as_subs_slice()) {
+                for var in subs.get_subs_slice(*args) {
                     new_args.push(Self::from_var_help(subs, recursion_vars, *var));
                 }
 
@@ -308,7 +308,7 @@ impl SolvedType {
             Func(args, closure, ret) => {
                 let mut new_args = Vec::with_capacity(args.len());
 
-                for var in subs.get_subs_slice(*args.as_subs_slice()) {
+                for var in subs.get_subs_slice(*args) {
                     new_args.push(Self::from_var_help(subs, recursion_vars, *var));
                 }
 

compiler/types/src/subs.rs

@@ -367,7 +367,7 @@ fn subs_fmt_content(this: &Content, subs: &Subs, f: &mut fmt::Formatter) -> fmt:
         } => write!(f, "Recursion({:?}, {:?})", structure, opt_name),
         Content::Structure(flat_type) => subs_fmt_flat_type(flat_type, subs, f),
         Content::Alias(name, arguments, actual) => {
-            let slice = subs.get_subs_slice(*arguments.variables().as_subs_slice());
+            let slice = subs.get_subs_slice(arguments.variables());
 
             write!(f, "Alias({:?}, {:?}, {:?})", name, slice, actual)
         }
@@ -386,12 +386,12 @@ impl<'a> fmt::Debug for SubsFmtFlatType<'a> {
 fn subs_fmt_flat_type(this: &FlatType, subs: &Subs, f: &mut fmt::Formatter) -> fmt::Result {
     match this {
         FlatType::Apply(name, arguments) => {
-            let slice = subs.get_subs_slice(*arguments.as_subs_slice());
+            let slice = subs.get_subs_slice(*arguments);
 
             write!(f, "Apply({:?}, {:?})", name, slice)
         }
         FlatType::Func(arguments, lambda_set, result) => {
-            let slice = subs.get_subs_slice(*arguments.as_subs_slice());
+            let slice = subs.get_subs_slice(*arguments);
             write!(f, "Func({:?}, {:?}, {:?})", slice, lambda_set, result)
         }
         FlatType::Record(fields, ext) => {
@@ -1425,9 +1425,7 @@ pub struct AliasVariables {
 
 impl AliasVariables {
     pub const fn variables(&self) -> VariableSubsSlice {
-        VariableSubsSlice {
+        SubsSlice::new(self.variables_start, self.all_variables_len)
-            slice: SubsSlice::new(self.variables_start, self.all_variables_len),
-        }
     }
 
     pub const fn len(&self) -> usize {
@@ -1555,34 +1553,9 @@ pub enum Builtin {
     EmptyRecord,
 }
 
-#[derive(Clone, Copy, Debug, Default)]
+pub type VariableSubsSlice = SubsSlice<Variable>;
-pub struct VariableSubsSlice {
-    pub slice: SubsSlice<Variable>,
-}
 
 impl VariableSubsSlice {
-    pub fn len(&self) -> usize {
-        self.slice.len()
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    pub fn as_subs_slice(&self) -> &SubsSlice<Variable> {
-        &self.slice
-    }
-
-    pub fn new(start: u32, length: u16) -> Self {
-        Self {
-            slice: SubsSlice::new(start, length),
-        }
-    }
-
-    pub fn indices(&self) -> std::ops::Range<usize> {
-        self.slice.indices()
-    }
-
     /// Reserve space for `length` variables in the subs.variables array
     ///
     /// This is useful when we know how many variables e.g. a loop will produce,
@@ -1614,16 +1587,6 @@ impl VariableSubsSlice {
     }
 }
 
-impl IntoIterator for VariableSubsSlice {
-    type Item = SubsIndex<Variable>;
-
-    type IntoIter = <SubsSlice<Variable> as IntoIterator>::IntoIter;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.slice.into_iter()
-    }
-}
-
 #[derive(Clone, Copy, Debug, Default)]
 pub struct UnionTags {
     length: u16,
@@ -1637,7 +1600,7 @@ impl UnionTags {
             return false;
         }
 
-        let slice = subs.variable_slices[self.variables_start as usize].slice;
+        let slice = subs.variable_slices[self.variables_start as usize];
         slice.length == 1
     }
 
@@ -1764,7 +1727,9 @@ impl UnionTags {
     ) -> impl Iterator<Item = (&TagName, &[Variable])> + 'a {
         let (it, _) = crate::types::gather_tags_unsorted_iter(subs, *self, ext);
 
-        it.map(move |(label, slice)| (label, subs.get_subs_slice(*slice.as_subs_slice())))
+        let f = move |(label, slice): (_, SubsSlice<Variable>)| (label, subs.get_subs_slice(slice));
+
+        it.map(f)
     }
 
     pub fn unsorted_iterator_and_ext<'a>(
@@ -1774,10 +1739,9 @@ impl UnionTags {
     ) -> (impl Iterator<Item = (&TagName, &[Variable])> + 'a, Variable) {
         let (it, ext) = crate::types::gather_tags_unsorted_iter(subs, *self, ext);
 
-        (
+        let f = move |(label, slice): (_, SubsSlice<Variable>)| (label, subs.get_subs_slice(slice));
-            it.map(move |(label, slice)| (label, subs.get_subs_slice(*slice.as_subs_slice()))),
+
-            ext,
+        (it.map(f), ext)
-        )
     }
 
     #[inline(always)]
@@ -1792,7 +1756,7 @@ impl UnionTags {
                     let tag_name: &TagName = &subs[i1];
                     let subs_slice = subs[i2];
 
-                    let slice = subs.get_subs_slice(*subs_slice.as_subs_slice());
+                    let slice = subs.get_subs_slice(subs_slice);
 
                     (tag_name.clone(), slice)
                 })),
@@ -1903,9 +1867,7 @@ impl RecordFields {
     }
 
     pub const fn variables(&self) -> VariableSubsSlice {
-        let slice = SubsSlice::new(self.variables_start, self.length);
+        SubsSlice::new(self.variables_start, self.length)
-
-        VariableSubsSlice { slice }
     }
 
     pub fn iter_variables(&self) -> impl Iterator<Item = SubsIndex<Variable>> {
@@ -2081,16 +2043,13 @@ fn occurs(
                 new_seen.insert(root_var);
 
                 match flat_type {
-                    Apply(_, args) => short_circuit(
+                    Apply(_, args) => {
-                        subs,
+                        short_circuit(subs, root_var, &new_seen, subs.get_subs_slice(*args).iter())
-                        root_var,
+                    }
-                        &new_seen,
-                        subs.get_subs_slice(*args.as_subs_slice()).iter(),
-                    ),
                     Func(arg_vars, closure_var, ret_var) => {
                         let it = once(ret_var)
                             .chain(once(closure_var))
-                            .chain(subs.get_subs_slice(*arg_vars.as_subs_slice()).iter());
+                            .chain(subs.get_subs_slice(*arg_vars).iter());
                         short_circuit(subs, root_var, &new_seen, it)
                     }
                     Record(vars_by_field, ext_var) => {
@@ -2798,10 +2757,8 @@ fn restore_help(subs: &mut Subs, initial: Variable) {
     let variable_slices = &subs.variable_slices;
 
     let variables = &subs.variables;
-    let var_slice = |variable_subs_slice: VariableSubsSlice| {
+    let var_slice =
-        &variables[variable_subs_slice.slice.start as usize..]
+        |variable_subs_slice: VariableSubsSlice| &variables[variable_subs_slice.indices()];
-            [..variable_subs_slice.slice.length as usize]
-    };
 
     while let Some(var) = stack.pop() {
         let desc = &mut subs.utable.probe_value_ref_mut(var).value;
@@ -3082,7 +3039,7 @@ impl StorageSubs {
         offsets: &StorageSubsOffsets,
         mut slice: VariableSubsSlice,
     ) -> VariableSubsSlice {
-        slice.slice.start += offsets.variables;
+        slice.start += offsets.variables;
 
         slice
     }

compiler/types/src/types.rs

@@ -1765,7 +1765,7 @@ pub fn gather_tags_slices(
     let (it, ext) = gather_tags_unsorted_iter(subs, other_fields, var);
 
     let mut result: Vec<_> = it
-        .map(|(ref_label, field)| (ref_label.clone(), field))
+        .map(|(ref_label, field): (_, VariableSubsSlice)| (ref_label.clone(), field))
         .collect();
 
     result.sort_by(|(a, _), (b, _)| a.cmp(b));
@@ -1777,11 +1777,8 @@ pub fn gather_tags(subs: &Subs, other_fields: UnionTags, var: Variable) -> TagUn
     let (it, ext) = gather_tags_unsorted_iter(subs, other_fields, var);
 
     let mut result: Vec<_> = it
-        .map(|(ref_label, field)| {
+        .map(|(ref_label, field): (_, VariableSubsSlice)| {
-            (
+            (ref_label.clone(), subs.get_subs_slice(field))
-                ref_label.clone(),
-                subs.get_subs_slice(*field.as_subs_slice()),
-            )
         })
         .collect();
 

compiler/unify/src/unify.rs

@@ -842,7 +842,7 @@ fn unify_shared_tags_new(
                 all_fields = merge_sorted(
                     all_fields,
                     other1.into_iter().map(|(field_name, subs_slice)| {
-                        let vec = subs.get_subs_slice(*subs_slice.as_subs_slice()).to_vec();
+                        let vec = subs.get_subs_slice(subs_slice).to_vec();
 
                         (field_name, vec)
                     }),
@@ -851,7 +851,7 @@ fn unify_shared_tags_new(
                 all_fields = merge_sorted(
                     all_fields,
                     other2.into_iter().map(|(field_name, subs_slice)| {
-                        let vec = subs.get_subs_slice(*subs_slice.as_subs_slice()).to_vec();
+                        let vec = subs.get_subs_slice(subs_slice).to_vec();
 
                         (field_name, vec)
                     }),
@@ -969,8 +969,7 @@ fn unify_flat_type(
         }
 
         (Apply(l_symbol, l_args), Apply(r_symbol, r_args)) if l_symbol == r_symbol => {
-            let problems =
+            let problems = unify_zip_slices(subs, pool, *l_args, *r_args);
-                unify_zip_slices(subs, pool, *l_args.as_subs_slice(), *r_args.as_subs_slice());
 
             if problems.is_empty() {
                 merge(subs, ctx, Structure(Apply(*r_symbol, *r_args)))
@@ -981,8 +980,7 @@ fn unify_flat_type(
         (Func(l_args, l_closure, l_ret), Func(r_args, r_closure, r_ret))
             if l_args.len() == r_args.len() =>
         {
-            let arg_problems =
+            let arg_problems = unify_zip_slices(subs, pool, *l_args, *r_args);
-                unify_zip_slices(subs, pool, *l_args.as_subs_slice(), *r_args.as_subs_slice());
             let ret_problems = unify_pool(subs, pool, *l_ret, *r_ret);
             let closure_problems = unify_pool(subs, pool, *l_closure, *r_closure);