improve definitions naming

compiler-core/src/analyse.rs

···
     GLEAM_CORE_PACKAGE_NAME,
     ast::{
         self, Arg, BitArrayOption, CustomType, Definition, DefinitionLocation, Function,
-        GroupedStatements, Import, ModuleConstant, Publicity, RecordConstructor,
+        GroupedDefinitions, Import, ModuleConstant, Publicity, RecordConstructor,
         RecordConstructorArg, SrcSpan, Statement, TypeAlias, TypeAst, TypeAstConstructor,
         TypeAstFn, TypeAstHole, TypeAstTuple, TypeAstVar, TypedDefinition, TypedExpr,
         TypedFunction, TypedModule, UntypedArg, UntypedCustomType, UntypedFunction, UntypedImport,
···
         }
         .build();
 
-        let statements = GroupedStatements::new(module.into_iter_statements(self.target));
-        let statements_count = statements.len();
+        let definitions = GroupedDefinitions::new(module.into_iter_definitions(self.target));
+        let definitions_count = definitions.len();
 
         // Register any modules, types, and values being imported
         // We process imports first so that anything imported can be referenced
         // anywhere in the module.
-        let mut env = Importer::run(self.origin, env, &statements.imports, &mut self.problems);
+        let mut env = Importer::run(self.origin, env, &definitions.imports, &mut self.problems);
 
         // Register types so they can be used in constructors and functions
         // earlier in the module.
-        for t in &statements.custom_types {
-            if let Err(error) = self.register_types_from_custom_type(t, &mut env) {
+        for type_ in &definitions.custom_types {
+            if let Err(error) = self.register_types_from_custom_type(type_, &mut env) {
                 return self.all_errors(error);
             }
         }
 
-        let sorted_aliases = match sorted_type_aliases(&statements.type_aliases) {
-            Ok(it) => it,
+        let sorted_aliases = match sorted_type_aliases(&definitions.type_aliases) {
+            Ok(sorted_aliases) => sorted_aliases,
             Err(error) => return self.all_errors(error),
         };
-        for t in sorted_aliases {
-            self.register_type_alias(t, &mut env);
+        for type_alias in sorted_aliases {
+            self.register_type_alias(type_alias, &mut env);
         }
 
-        for f in &statements.functions {
-            self.register_value_from_function(f, &mut env);
+        for function in &definitions.functions {
+            self.register_value_from_function(function, &mut env);
         }
 
         // Infer the types of each statement in the module
-        let mut typed_statements = Vec::with_capacity(statements_count);
-        for i in statements.imports {
-            optionally_push(&mut typed_statements, self.analyse_import(i, &env));
+        let mut typed_definitions = Vec::with_capacity(definitions_count);
+        for import in definitions.imports {
+            optionally_push(&mut typed_definitions, self.analyse_import(import, &env));
         }
-        for t in statements.custom_types {
-            optionally_push(&mut typed_statements, self.analyse_custom_type(t, &mut env));
+        for type_ in definitions.custom_types {
+            optionally_push(
+                &mut typed_definitions,
+                self.analyse_custom_type(type_, &mut env),
+            );
         }
-        for t in statements.type_aliases {
-            typed_statements.push(analyse_type_alias(t, &mut env));
+        for type_alias in definitions.type_aliases {
+            typed_definitions.push(analyse_type_alias(type_alias, &mut env));
         }
 
-        // Sort functions and constants into dependency order for inference. Definitions that do
-        // not depend on other definitions are inferred first, then ones that depend
-        // on those, etc.
+        // Sort functions and constants into dependency order for inference.
+        // Definitions that do not depend on other definitions are inferred
+        // first, then ones that depend on those, etc.
         let definition_groups =
-            match into_dependency_order(statements.functions, statements.constants) {
-                Ok(it) => it,
+            match into_dependency_order(definitions.functions, definitions.constants) {
+                Ok(definition_groups) => definition_groups,
                 Err(error) => return self.all_errors(error),
             };
         let mut working_group = vec![];
 
         for group in definition_groups {
-            // A group may have multiple functions that depend on each other through
-            // mutual recursion.
+            // A group may have multiple functions that depend on each other
+            // through mutual recursion.
 
             for definition in group {
-                let def = match definition {
-                    CallGraphNode::Function(f) => self.infer_function(f, &mut env),
-                    CallGraphNode::ModuleConstant(c) => self.infer_module_constant(c, &mut env),
+                let definition = match definition {
+                    CallGraphNode::Function(function) => self.infer_function(function, &mut env),
+                    CallGraphNode::ModuleConstant(constant) => {
+                        self.infer_module_constant(constant, &mut env)
+                    }
                 };
-                working_group.push(def);
+                working_group.push(definition);
             }
 
             // Now that the entire group has been inferred, generalise their types.
             for inferred in working_group.drain(..) {
-                typed_statements.push(generalise_statement(inferred, &self.module_name, &mut env));
+                typed_definitions.push(generalise_definition(
+                    inferred,
+                    &self.module_name,
+                    &mut env,
+                ));
             }
         }
 
···
         let module = ast::Module {
             documentation: documentation.clone(),
             name: self.module_name.clone(),
-            definitions: typed_statements,
+            definitions: typed_definitions,
             names: type_names,
             unused_definition_positions,
             type_info: ModuleInterface {
···
     }
 }
 
-fn generalise_statement(
-    s: TypedDefinition,
+fn generalise_definition(
+    definition: TypedDefinition,
     module_name: &EcoString,
     environment: &mut Environment<'_>,
 ) -> TypedDefinition {
-    match s {
+    match definition {
         Definition::Function(function) => generalise_function(function, environment, module_name),
         Definition::ModuleConstant(constant) => {
             generalise_module_constant(constant, environment, module_name)
         }
-        statement @ (Definition::TypeAlias(TypeAlias { .. })
+        definition @ (Definition::TypeAlias(TypeAlias { .. })
         | Definition::CustomType(CustomType { .. })
-        | Definition::Import(Import { .. })) => statement,
+        | Definition::Import(Import { .. })) => definition,
     }
 }
 

compiler-core/src/ast.rs

···
 pub type UntypedModule = Module<(), TargetedDefinition>;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Module<Info, Statements> {
+pub struct Module<Info, Definitions> {
     pub name: EcoString,
     pub documentation: Vec<EcoString>,
     pub type_info: Info,
-    pub definitions: Vec<Statements>,
+    pub definitions: Vec<Definitions>,
     pub names: Names,
     /// The source byte locations of definition that are unused.
     /// This is used in code generation to know when definitions can be safely omitted.
     pub unused_definition_positions: HashSet<u32>,
 }
 
-impl<Info, Statements> Module<Info, Statements> {
+impl<Info, Definitions> Module<Info, Definitions> {
     pub fn erlang_name(&self) -> EcoString {
         module_erlang_name(&self.name)
     }
···
     pub fn find_node(&self, byte_index: u32) -> Option<Located<'_>> {
         self.definitions
             .iter()
-            .find_map(|statement| statement.find_node(byte_index))
+            .find_map(|definition| definition.find_node(byte_index))
     }
 
     pub fn find_statement(&self, byte_index: u32) -> Option<&TypedStatement> {
···
 
 impl UntypedModule {
     pub fn dependencies(&self, target: Target) -> Vec<(EcoString, SrcSpan)> {
-        self.iter_statements(target)
-            .flat_map(|s| match s {
+        self.iter_definitions(target)
+            .flat_map(|definition| match definition {
                 Definition::Import(Import {
                     module, location, ..
                 }) => Some((module.clone(), *location)),
···
             .collect()
     }
 
-    pub fn iter_statements(&self, target: Target) -> impl Iterator<Item = &UntypedDefinition> {
+    pub fn iter_definitions(&self, target: Target) -> impl Iterator<Item = &UntypedDefinition> {
         self.definitions
             .iter()
-            .filter(move |def| def.is_for(target))
-            .map(|def| &def.definition)
+            .filter(move |definition| definition.is_for(target))
+            .map(|definition| &definition.definition)
     }
 
-    pub fn into_iter_statements(self, target: Target) -> impl Iterator<Item = UntypedDefinition> {
+    pub fn into_iter_definitions(self, target: Target) -> impl Iterator<Item = UntypedDefinition> {
         self.definitions
             .into_iter()
-            .filter(move |def| def.is_for(target))
-            .map(|def| def.definition)
+            .filter(move |definition| definition.is_for(target))
+            .map(|definition| definition.definition)
     }
 }
 
···
 }
 
 #[derive(Debug, Default)]
-pub struct GroupedStatements {
+pub struct GroupedDefinitions {
     pub functions: Vec<UntypedFunction>,
     pub constants: Vec<UntypedModuleConstant>,
     pub custom_types: Vec<UntypedCustomType>,
···
     pub type_aliases: Vec<UntypedTypeAlias>,
 }
 
-impl GroupedStatements {
-    pub fn new(statements: impl IntoIterator<Item = UntypedDefinition>) -> Self {
+impl GroupedDefinitions {
+    pub fn new(definitions: impl IntoIterator<Item = UntypedDefinition>) -> Self {
         let mut this = Self::default();
 
-        for statement in statements {
-            this.add(statement)
+        for definition in definitions {
+            this.add(definition)
         }
 
         this
···
 
     fn add(&mut self, statement: UntypedDefinition) {
         match statement {
-            Definition::Import(i) => self.imports.push(i),
-            Definition::Function(f) => self.functions.push(f),
-            Definition::TypeAlias(t) => self.type_aliases.push(t),
-            Definition::CustomType(c) => self.custom_types.push(c),
-            Definition::ModuleConstant(c) => self.constants.push(c),
+            Definition::Import(import) => self.imports.push(import),
+            Definition::Function(function) => self.functions.push(function),
+            Definition::TypeAlias(type_alias) => self.type_aliases.push(type_alias),
+            Definition::CustomType(custom_type) => self.custom_types.push(custom_type),
+            Definition::ModuleConstant(constant) => self.constants.push(constant),
         }
     }
 }

compiler-core/src/ast/visit.rs

···
 where
     V: Visit<'a> + ?Sized,
 {
-    for def in &module.definitions {
-        v.visit_typed_definition(def);
+    for definition in &module.definitions {
+        v.visit_typed_definition(definition);
     }
 }
 

compiler-core/src/ast_folder.rs

···
 #[allow(dead_code)]
 pub trait UntypedModuleFolder: TypeAstFolder + UntypedExprFolder {
     /// You probably don't want to override this method.
-    fn fold_module(&mut self, mut m: UntypedModule) -> UntypedModule {
-        m.definitions = m
+    fn fold_module(&mut self, mut module: UntypedModule) -> UntypedModule {
+        module.definitions = module
             .definitions
             .into_iter()
-            .map(|d| {
-                let TargetedDefinition { definition, target } = d;
+            .map(|definition| {
+                let TargetedDefinition { definition, target } = definition;
                 match definition {
-                    Definition::Function(f) => {
-                        let f = self.fold_function_definition(f, target);
-                        let definition = self.walk_function_definition(f);
+                    Definition::Function(function) => {
+                        let function = self.fold_function_definition(function, target);
+                        let definition = self.walk_function_definition(function);
                         TargetedDefinition { definition, target }
                     }
 
-                    Definition::TypeAlias(a) => {
-                        let a = self.fold_type_alias(a, target);
-                        let definition = self.walk_type_alias(a);
+                    Definition::TypeAlias(type_alias) => {
+                        let type_alias = self.fold_type_alias(type_alias, target);
+                        let definition = self.walk_type_alias(type_alias);
                         TargetedDefinition { definition, target }
                     }
 
-                    Definition::CustomType(t) => {
-                        let t = self.fold_custom_type(t, target);
-                        let definition = self.walk_custom_type(t);
+                    Definition::CustomType(custom_type) => {
+                        let custom_type = self.fold_custom_type(custom_type, target);
+                        let definition = self.walk_custom_type(custom_type);
                         TargetedDefinition { definition, target }
                     }
 
-                    Definition::Import(i) => {
-                        let i = self.fold_import(i, target);
-                        let definition = self.walk_import(i);
+                    Definition::Import(import) => {
+                        let import = self.fold_import(import, target);
+                        let definition = self.walk_import(import);
                         TargetedDefinition { definition, target }
                     }
 
-                    Definition::ModuleConstant(c) => {
-                        let c = self.fold_module_constant(c, target);
-                        let definition = self.walk_module_constant(c);
+                    Definition::ModuleConstant(constant) => {
+                        let constant = self.fold_module_constant(constant, target);
+                        let definition = self.walk_module_constant(constant);
                         TargetedDefinition { definition, target }
                     }
                 }
             })
             .collect();
-        m
+        module
     }
 
     /// You probably don't want to override this method.
     fn walk_function_definition(&mut self, mut function: UntypedFunction) -> UntypedDefinition {
-        function.body = function.body.mapped(|s| self.fold_statement(s));
+        function.body = function
+            .body
+            .mapped(|statement| self.fold_statement(statement));
         function.return_annotation = function
             .return_annotation
             .map(|type_| self.fold_type(type_));

compiler-core/src/build.rs

···
 
         self.ast.type_info.documentation = self.ast.documentation.clone();
 
-        // Order statements to avoid misassociating doc comments after the
+        // Order definitions to avoid misassociating doc comments after the
         // order has changed during compilation.
-        let mut statements: Vec<_> = self.ast.definitions.iter_mut().collect();
-        statements.sort_by(|a, b| a.location().start.cmp(&b.location().start));
+        let mut definitions: Vec<_> = self.ast.definitions.iter_mut().collect();
+        definitions.sort_by(|a, b| a.location().start.cmp(&b.location().start));
 
         // Doc Comments
         let mut doc_comments = self.extra.doc_comments.iter().peekable();
-        for statement in &mut statements {
+        for definition in &mut definitions {
             let (docs_start, docs): (u32, Vec<&str>) = doc_comments_before(
                 &mut doc_comments,
                 &self.extra,
-                statement.location().start,
+                definition.location().start,
                 &self.code,
             );
             if !docs.is_empty() {
                 let doc = docs.join("\n").into();
-                statement.put_doc((docs_start, doc));
+                definition.put_doc((docs_start, doc));
             }
 
-            if let Definition::CustomType(CustomType { constructors, .. }) = statement {
+            if let Definition::CustomType(CustomType { constructors, .. }) = definition {
                 for constructor in constructors {
                     let (docs_start, docs): (u32, Vec<&str>) = doc_comments_before(
                         &mut doc_comments,

compiler-core/src/docs.rs

···
             .ast
             .definitions
             .iter()
-            .filter_map(|statement| printer.type_definition(&source_links, statement))
+            .filter_map(|definition| printer.type_definition(&source_links, definition))
             .sorted()
             .collect();
 
···
             .ast
             .definitions
             .iter()
-            .filter_map(|statement| printer.value(&source_links, statement))
+            .filter_map(|definition| printer.value(&source_links, definition))
             .sorted()
             .collect();
 

compiler-core/src/docs/tests.rs

···
         .definitions
         .iter()
         .filter_map(
-            |statement: &crate::ast::Definition<
+            |definition: &crate::ast::Definition<
                 std::sync::Arc<type_::Type>,
                 crate::ast::TypedExpr,
                 EcoString,
                 EcoString,
-            >| printer.type_definition(&source_links, statement),
+            >| printer.type_definition(&source_links, definition),
         )
         .sorted()
         .collect_vec();
···
     let values = module
         .definitions
         .iter()
-        .filter_map(|statement| printer.value(&source_links, statement))
+        .filter_map(|definition| printer.value(&source_links, definition))
         .sorted()
         .collect_vec();
 

compiler-core/src/erlang.rs

···
     module
         .definitions
         .iter()
-        .filter_map(|s| match s {
+        .filter_map(|definition| match definition {
             Definition::CustomType(CustomType {
                 publicity: Publicity::Public,
                 constructors,
···
     // would result in an error as it tries to reference this private function.
     let overridden_publicity = find_private_functions_referenced_in_importable_constants(module);
 
-    for s in &module.definitions {
+    for definition in &module.definitions {
         register_imports_and_exports(
-            s,
+            definition,
             &mut exports,
             &mut type_exports,
             &mut type_defs,
···
 }
 
 fn register_imports_and_exports(
-    s: &TypedDefinition,
+    definition: &TypedDefinition,
     exports: &mut Vec<Document<'_>>,
     type_exports: &mut Vec<Document<'_>>,
     type_defs: &mut Vec<Document<'_>>,
···
     unused_definition_positions: &HashSet<u32>,
 ) {
     // Do not generate any code for unused items
-    if unused_definition_positions.contains(&s.location().start) {
+    if unused_definition_positions.contains(&definition.location().start) {
         return;
     }
 
-    match s {
+    match definition {
         Definition::Function(Function {
             publicity,
             name: Some((_, name)),
···
             } else {
                 let constructors = constructors
                     .iter()
-                    .map(|c| {
-                        let name = atom_string(to_snake_case(&c.name));
-                        if c.arguments.is_empty() {
+                    .map(|constructor| {
+                        let name = atom_string(to_snake_case(&constructor.name));
+                        if constructor.arguments.is_empty() {
                             name
                         } else {
                             let type_printer = TypePrinter::new(module_name);
-                            let args = c.arguments.iter().map(|a| type_printer.print(&a.type_));
+                            let args = constructor
+                                .arguments
+                                .iter()
+                                .map(|argument| type_printer.print(&argument.type_));
                             tuple(std::iter::once(name).chain(args))
                         }
                     })
···
             .nest(INDENT);
             let type_printer = TypePrinter::new(module_name);
             let params = join(
-                typed_parameters.iter().map(|a| type_printer.print(a)),
+                typed_parameters
+                    .iter()
+                    .map(|type_| type_printer.print(type_)),
                 ", ".to_doc(),
             );
             let doc = if *opaque { "-opaque " } else { "-type " }
···
 ) -> im::HashSet<EcoString> {
     let mut overridden_publicity = im::HashSet::new();
 
-    for def in module.definitions.iter() {
-        if let Definition::ModuleConstant(c) = def {
-            if c.publicity.is_importable() {
-                find_referenced_private_functions(&c.value, &mut overridden_publicity)
+    for definition in module.definitions.iter() {
+        if let Definition::ModuleConstant(constant) = definition {
+            if constant.publicity.is_importable() {
+                find_referenced_private_functions(&constant.value, &mut overridden_publicity)
             }
         }
     }

compiler-core/src/javascript.rs

···
             self.module
                 .definitions
                 .iter()
-                .flat_map(|s| self.statement(s)),
+                .flat_map(|definition| self.definition(definition)),
         );
 
         // Two lines between each statement
···
         imports.register_module(path, [], [member]);
     }
 
-    pub fn statement(&mut self, statement: &'a TypedDefinition) -> Option<Output<'a>> {
-        match statement {
+    pub fn definition(&mut self, definition: &'a TypedDefinition) -> Option<Output<'a>> {
+        match definition {
             Definition::TypeAlias(TypeAlias { .. }) => None,
 
             // Handled in collect_imports
···
         self.module
             .definitions
             .iter()
-            .flat_map(|statement| match statement {
+            .flat_map(|definition| match definition {
                 // If a custom type is unused then we don't need to generate code for it
                 Definition::CustomType(CustomType { location, .. })
                     if self
···
     fn collect_imports(&mut self) -> Imports<'a> {
         let mut imports = Imports::new();
 
-        for statement in &self.module.definitions {
-            match statement {
+        for definition in &self.module.definitions {
+            match definition {
                 Definition::Import(Import {
                     module,
                     as_name,
···
     }
 
     fn register_module_definitions_in_scope(&mut self) {
-        for statement in self.module.definitions.iter() {
-            match statement {
+        for definition in self.module.definitions.iter() {
+            match definition {
                 Definition::ModuleConstant(ModuleConstant { name, .. }) => {
                     self.register_in_scope(name)
                 }

compiler-core/src/javascript/typescript.rs

···
             .module
             .definitions
             .iter()
-            .flat_map(|s| self.statement(s));
+            .flat_map(|definition| self.definition(definition));
 
         // Two lines between each statement
         let mut statements: Vec<_> =
···
         }
     }
 
-    fn statement(&mut self, statement: &'a TypedDefinition) -> Vec<Output<'a>> {
-        match statement {
+    fn definition(&mut self, definition: &'a TypedDefinition) -> Vec<Output<'a>> {
+        match definition {
             Definition::TypeAlias(TypeAlias {
                 alias,
                 publicity,

compiler-core/src/language_server/code_action.rs

···
     ) -> Option<&'a Import<EcoString>> {
         let mut matching_import = None;
 
-        for def in &self.module.ast.definitions {
-            if let ast::Definition::Import(import) = def {
+        for definition in &self.module.ast.definitions {
+            if let ast::Definition::Import(import) = definition {
                 let imported = if layer.is_value() {
                     &import.unqualified_values
                 } else {
···
                 .ast
                 .definitions
                 .iter()
-                .find_map(|def| match def {
+                .find_map(|definition| match definition {
                     ast::Definition::Import(import) if import.module == *module_name => import
                         .unqualified_values
                         .iter()
···
                 .ast
                 .definitions
                 .iter()
-                .find_map(|def| match def {
+                .find_map(|definition| match definition {
                     ast::Definition::Import(import) => {
                         if let Some(ty) = import
                             .unqualified_types

compiler-core/src/language_server/completer.rs

···
 
             // Find the function that the cursor is in and push completions for
             // its arguments and local variables.
-            if let Some(fun) = self.module.ast.definitions.iter().find_map(|d| match d {
-                Definition::Function(f) if f.full_location().contains(cursor) => Some(f),
-                _ => None,
-            }) {
+            if let Some(function) =
+                self.module
+                    .ast
+                    .definitions
+                    .iter()
+                    .find_map(|definition| match definition {
+                        Definition::Function(function)
+                            if function.full_location().contains(cursor) =>
+                        {
+                            Some(function)
+                        }
+                        _ => None,
+                    })
+            {
                 completions.extend(
-                    LocalCompletion::new(mod_name, insert_range, cursor).fn_completions(fun),
+                    LocalCompletion::new(mod_name, insert_range, cursor).fn_completions(function),
                 );
             }
 

compiler-core/src/language_server/engine.rs

···
     ast: &TypedModule,
     hex_deps: &HashSet<EcoString>,
 ) -> Option<String> {
-    let package_name = ast.definitions.iter().find_map(|def| match def {
-        Definition::Import(p) if p.module == module_name && hex_deps.contains(&p.package) => {
-            Some(&p.package)
-        }
-        _ => None,
-    })?;
+    let package_name = ast
+        .definitions
+        .iter()
+        .find_map(|definition| match definition {
+            Definition::Import(import)
+                if import.module == module_name && hex_deps.contains(&import.package) =>
+            {
+                Some(&import.package)
+            }
+            _ => None,
+        })?;
 
     Some(format_hexdocs_link_section(
         package_name,