Rename Folder to TypeFolder

Author: eggyal

book/src/SUMMARY.md

@@ -12,7 +12,7 @@
         - [Application types](./types/rust_types/application_ty.md)
     - [Rust lifetimes](./types/rust_lifetimes.md)
     - [Operations](./types/operations.md)
-        - [TypeFoldable and the Folder trait](./types/operations/fold.md)
+        - [TypeFoldable and the TypeFolder trait](./types/operations/fold.md)
 - [Lowering Rust IR to logic](./clauses.md)
     - [Goals and clauses](./clauses/goals_and_clauses.md)
     - [Type equality and unification](./clauses/type_equality.md)

book/src/types/operations/fold.md

@@ -1,4 +1,4 @@
-# TypeFoldable and the Folder trait
+# TypeFoldable and the TypeFolder trait
 
 The [`TypeFoldable`] trait permits one to traverse a type or other term in the
 chalk-ir and make a copy of it, possibly making small substitutions or
@@ -17,39 +17,39 @@ let output_ty = input_ty.fold_with(&mut folder, 0);
 
 [`TypeFoldable::fold_with`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFoldable.html#tymethod.fold_with
 
-The folder is some instance of the [`Folder`] trait. This trait
+The folder is some instance of the [`TypeFolder`] trait. This trait
 defines a few key callbacks that allow you to substitute different
 values as the fold proceeds. For example, when a type is folded, the
 folder can substitute a new type in its place.
 
-[`Folder`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Folder.html
+[`TypeFolder`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFolder.html
 
 ## Uses for folders
 
 A common use for `TypeFoldable` is to permit a substitution -- that is,
 replacing generic type parameters with their values.
 
-## From TypeFoldable to Folder to TypeSuperFoldable and back again
+## From TypeFoldable to TypeFolder to TypeSuperFoldable and back again
 
 The overall flow of folding is like this.
 
 1. [`TypeFoldable::fold_with`] is invoked on the outermost term. It recursively
    walks the term.
 2. For those sorts of terms (types, lifetimes, goals, program clauses) that have
-   callbacks in the [`Folder`] trait, invoking [`TypeFoldable::fold_with`] will in turn
-   invoke the corresponding method on the [`Folder`] trait, such as `Folder::fold_ty`.
-3. The default implementation of `Folder::fold_ty`, in turn, invokes
+   callbacks in the [`TypeFolder`] trait, invoking [`TypeFoldable::fold_with`] will in turn
+   invoke the corresponding method on the [`TypeFolder`] trait, such as `TypeFolder::fold_ty`.
+3. The default implementation of `TypeFolder::fold_ty`, in turn, invokes
    `TypeSuperFoldable::super_fold_with`.  This will recursively fold the
    contents of the type. In some cases, the `super_fold_with`
-   implementation invokes more specialized methods on [`Folder`], such
-   as [`Folder::fold_free_var_ty`], which makes it easier to write
+   implementation invokes more specialized methods on [`TypeFolder`], such
+   as [`TypeFolder::fold_free_var_ty`], which makes it easier to write
    folders that just intercept *certain* types.
 
-[`Folder::fold_free_var_ty`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Folder.html#method.fold_free_var_ty
+[`TypeFolder::fold_free_var_ty`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFolder.html#method.fold_free_var_ty
 
 Thus, as a user, you can customize folding by:
 
-* Defining your own `Folder` type
+* Defining your own `TypeFolder` type
 * Implementing the appropriate methods to "intercept" types/lifetimes/etc at the right level of
   detail
 * In those methods, if you find a case where you would prefer not to
@@ -58,7 +58,7 @@ Thus, as a user, you can customize folding by:
 
 ## The `binders` argument
 
-Each callback in the [`Folder`] trait takes a `binders` argument. This indicates
+Each callback in the [`TypeFolder`] trait takes a `binders` argument. This indicates
 the number of binders that we have traversed during folding, which is relevant for De Bruijn indices.
 So e.g. a bound variable with depth 1, if invoked with a `binders` value of 1, indicates something that was bound to something external to the fold.
 
@@ -85,7 +85,7 @@ also implement `TypeFoldable` for common collection types like `Vec` as well
 as tuples, references, etc.
 
 The `TypeSuperFoldable` trait should only be implemented for those types that
-have a callback defined on the `Folder` trait (e.g., types and
+have a callback defined on the `TypeFolder` trait (e.g., types and
 lifetimes).
 
 ## Derives

chalk-derive/src/lib.rs

@@ -299,7 +299,7 @@ fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
 
             fn fold_with<E>(
                 self,
-                folder: &mut dyn ::chalk_ir::fold::Folder < #interner, Error = E >,
+                folder: &mut dyn ::chalk_ir::fold::TypeFolder < #interner, Error = E >,
                 outer_binder: ::chalk_ir::DebruijnIndex,
             ) -> ::std::result::Result<Self::Result, E> {
                 Ok(match self { #body })

chalk-engine/src/normalize_deep.rs

@@ -1,5 +1,5 @@
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Folder, TypeFoldable};
+use chalk_ir::fold::{TypeFoldable, TypeFolder};
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_solve::infer::InferenceTable;
@@ -35,10 +35,10 @@ impl<I: Interner> DeepNormalizer<'_, I> {
     }
 }
 
-impl<I: Interner> Folder<I> for DeepNormalizer<'_, I> {
+impl<I: Interner> TypeFolder<I> for DeepNormalizer<'_, I> {
     type Error = NoSolution;
 
-    fn as_dyn(&mut self) -> &mut dyn Folder<I, Error = Self::Error> {
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<I, Error = Self::Error> {
         self
     }
 

chalk-engine/src/strand.rs

@@ -3,7 +3,7 @@ use crate::{ExClause, TableIndex, TimeStamp};
 use std::fmt::Debug;
 
 use chalk_derive::HasInterner;
-use chalk_ir::fold::{Folder, TypeFoldable};
+use chalk_ir::fold::{TypeFoldable, TypeFolder};
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, DebruijnIndex, UniverseMap};
 
@@ -39,7 +39,7 @@ impl<I: Interner> TypeFoldable<I> for Strand<I> {
     type Result = Strand<I>;
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         Ok(Strand {

chalk-ir/src/fold.rs

@@ -17,7 +17,7 @@ pub use self::subst::Subst;
 /// certain changes applied. The idea is that it contains methods that
 /// let you swap types/lifetimes for new types/lifetimes; meanwhile,
 /// each bit of IR implements the `TypeFoldable` trait which, given a
-/// `Folder`, will reconstruct itself, invoking the folder's methods
+/// `TypeFolder`, will reconstruct itself, invoking the folder's methods
 /// to transform each of the types/lifetimes embedded within.
 ///
 /// # Usage patterns
@@ -29,14 +29,14 @@ pub use self::subst::Subst;
 /// more often, just free existential variables) that appear within
 /// the term.
 ///
-/// For this reason, the `Folder` trait extends two other traits that
+/// For this reason, the `TypeFolder` trait extends two other traits that
 /// contain methods that are invoked when just those particular
 ///
 /// In particular, folders can intercept references to free variables
 /// (either existentially or universally quantified) and replace them
 /// with other types/lifetimes as appropriate.
 ///
-/// To create a folder `F`, one never implements `Folder` directly, but instead
+/// To create a folder `F`, one never implements `TypeFolder` directly, but instead
 /// implements one of each of these three sub-traits:
 ///
 /// - `FreeVarFolder` -- folds `BoundVar` instances that appear free
@@ -54,19 +54,19 @@ pub use self::subst::Subst;
 /// ```rust,ignore
 /// let x = x.fold_with(&mut folder, 0);
 /// ```
-pub trait Folder<I: Interner> {
+pub trait TypeFolder<I: Interner> {
     /// The type this folder returns when folding fails. This is
     /// commonly [`NoSolution`].
     type Error;
 
     /// Creates a `dyn` value from this folder. Unfortunately, this
-    /// must be added manually to each impl of Folder; it permits the
-    /// default implements below to create a `&mut dyn Folder` from
+    /// must be added manually to each impl of TypeFolder; it permits the
+    /// default implements below to create a `&mut dyn TypeFolder` from
     /// `Self` without knowing what `Self` is (by invoking this
-    /// method). Effectively, this limits impls of `Folder` to types
+    /// method). Effectively, this limits impls of `TypeFolder` to types
     /// for which we are able to create a dyn value (i.e., not `[T]`
     /// types).
-    fn as_dyn(&mut self) -> &mut dyn Folder<I, Error = Self::Error>;
+    fn as_dyn(&mut self) -> &mut dyn TypeFolder<I, Error = Self::Error>;
 
     /// Top-level callback: invoked for each `Ty<I>` that is
     /// encountered when folding. By default, invokes
@@ -305,7 +305,7 @@ pub trait Folder<I: Interner> {
     fn interner(&self) -> I;
 }
 
-/// Applies the given `Folder` to a value, producing a folded result
+/// Applies the given `TypeFolder` to a value, producing a folded result
 /// of type `Self::Result`. The result type is typically the same as
 /// the source type, but in some cases we convert from borrowed
 /// to owned as well (e.g., the folder for `&T` will fold to a fresh
@@ -325,19 +325,19 @@ pub trait TypeFoldable<I: Interner>: Debug {
     /// constructs.
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E>;
 }
 
-/// For types where "fold" invokes a callback on the `Folder`, the
+/// For types where "fold" invokes a callback on the `TypeFolder`, the
 /// `TypeSuperFoldable` trait captures the recursive behavior that folds all
 /// the contents of the type.
 pub trait TypeSuperFoldable<I: Interner>: TypeFoldable<I> {
     /// Recursively folds the value.
     fn super_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E>;
 }
@@ -350,7 +350,7 @@ impl<I: Interner> TypeFoldable<I> for Ty<I> {
 
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         folder.fold_ty(self, outer_binder)
@@ -364,7 +364,7 @@ where
 {
     fn super_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Ty<I>, E> {
         let interner = folder.interner();
@@ -474,7 +474,7 @@ impl<I: Interner> TypeFoldable<I> for Lifetime<I> {
 
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         folder.fold_lifetime(self, outer_binder)
@@ -487,7 +487,7 @@ where
 {
     fn super_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Lifetime<I>, E> {
         let interner = folder.interner();
@@ -526,7 +526,7 @@ impl<I: Interner> TypeFoldable<I> for Const<I> {
 
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         folder.fold_const(self, outer_binder)
@@ -539,7 +539,7 @@ where
 {
     fn super_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Const<I>, E> {
         let interner = folder.interner();
@@ -577,7 +577,7 @@ impl<I: Interner> TypeFoldable<I> for Goal<I> {
 
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         folder.fold_goal(self, outer_binder)
@@ -588,7 +588,7 @@ impl<I: Interner> TypeFoldable<I> for Goal<I> {
 impl<I: Interner> TypeSuperFoldable<I> for Goal<I> {
     fn super_fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         let interner = folder.interner();
@@ -609,7 +609,7 @@ impl<I: Interner> TypeFoldable<I> for ProgramClause<I> {
 
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         folder.fold_program_clause(self, outer_binder)

chalk-ir/src/fold/binder_impls.rs

@@ -9,7 +9,7 @@ impl<I: Interner> TypeFoldable<I> for FnPointer<I> {
     type Result = FnPointer<I>;
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         let FnPointer {
@@ -38,7 +38,7 @@ where
     type Result = Binders<T::Result>;
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         let Binders {
@@ -62,7 +62,7 @@ where
     type Result = Canonical<T::Result>;
     fn fold_with<E>(
         self,
-        folder: &mut dyn Folder<I, Error = E>,
+        folder: &mut dyn TypeFolder<I, Error = E>,
         outer_binder: DebruijnIndex,
     ) -> Result<Self::Result, E> {
         let Canonical {