Rename Fold to TypeFoldable

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)
-        - [Fold and the Folder trait](./types/operations/fold.md)
+        - [TypeFoldable and the Folder 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,21 +1,21 @@
-# Fold and the Folder trait
+# TypeFoldable and the Folder trait
 
-The [`Fold`] trait permits one to traverse a type or other term in the
+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
 alterations along the way. Folding also allows copying a term from one
 interner to another.
 
-[`Fold`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Fold.html
+[`TypeFoldable`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFoldable.html
 
-To use the [`Fold`] trait, one invokes the [`Fold::fold_with`] method, supplying some
+To use the [`TypeFoldable`] trait, one invokes the [`TypeFoldable::fold_with`] method, supplying some
 "folder" as well as the number of "in scope binders" for that term (typically `0`
 to start):
 
 ```rust,ignore
 let output_ty = input_ty.fold_with(&mut folder, 0);
 ```
 
-[`Fold::fold_with`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Fold.html#tymethod.fold_with
+[`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
 defines a few key callbacks that allow you to substitute different
@@ -26,17 +26,17 @@ folder can substitute a new type in its place.
 
 ## Uses for folders
 
-A common use for `Fold` is to permit a substitution -- that is,
+A common use for `TypeFoldable` is to permit a substitution -- that is,
 replacing generic type parameters with their values.
 
-## From Fold to Folder to SuperFold and back again
+## From TypeFoldable to Folder to SuperFold and back again
 
 The overall flow of folding is like this.
 
-1. [`Fold::fold_with`] is invoked on the outermost term. It recursively
+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 [`Fold::fold_with`] will in turn
+   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
    `SuperFold::super_fold_with`.  This will recursively fold the
@@ -70,18 +70,18 @@ Foo<'a>: for<'b> Bar<'b>
 
 In this case, `Foo<'a>` gets visited with depth 0 and `Bar<'b>` gets visited with depth 1.
 
-## The `Fold::Result` associated type
+## The `TypeFoldable::Result` associated type
 
-The `Fold` trait defines a [`Result`] associated type, indicating the
+The `TypeFoldable` trait defines a [`Result`] associated type, indicating the
 type that will result from folding.
 
-[`Result`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.Fold.html#associatedtype.Result
+[`Result`]: https://rust-lang.github.io/chalk/chalk_ir/fold/trait.TypeFoldable.html#associatedtype.Result
 
-## When to implement the Fold and SuperFold traits
+## When to implement the TypeFoldable and SuperFold traits
 
 Any piece of IR that represents a kind of "term" (e.g., a type, part
-of a type, or a goal, etc) in the logic should implement `Fold`. We
-also implement `Fold` for common collection types like `Vec` as well
+of a type, or a goal, etc) in the logic should implement `TypeFoldable`. We
+also implement `TypeFoldable` for common collection types like `Vec` as well
 as tuples, references, etc.
 
 The `SuperFold` trait should only be implemented for those types that
@@ -90,12 +90,12 @@ lifetimes).
 
 ## Derives
 
-Using the `chalk-derive` crate, you can auto-derive the `Fold` trait.
+Using the `chalk-derive` crate, you can auto-derive the `TypeFoldable` trait.
 There isn't presently a derive for `SuperFold` since it is very rare
-to require it. The derive for `Fold` is a bit cludgy and requires:
+to require it. The derive for `TypeFoldable` is a bit cludgy and requires:
 
-* You must import `Fold` into scope.
-* The type you are deriving `Fold` on must have either:
+* You must import `TypeFoldable` into scope.
+* The type you are deriving `TypeFoldable` on must have either:
   * A type parameter that has a `Interner` bound, like `I: Interner`
   * A type parameter that has a `HasInterner` bound, like `I: HasInterner`
   * The `has_interner(XXX)` attribute.

book/src/what_is_chalk/crates.md

@@ -19,7 +19,7 @@ The following crate is an implementation detail, used internally by `chalk-solve
 
 * The `chalk-engine` crate, which defines the actual engine that solves logical predicate. This
   engine is quite general and not really specific to Rust.
-* The `chalk-derive` crate defines custom derives for the `chalk_ir::fold::Fold` trait and other
+* The `chalk-derive` crate defines custom derives for the `chalk_ir::fold::TypeFoldable` trait and other
   such things.
 
 ## Crates for standalone REPL and testing
@@ -37,11 +37,11 @@ define a kind of "minimal embedding" of chalk.
 
 ## The chalk-solve crate
 
-| The `chalk-solve` crate | |
-|---|--- |
-| Purpose:  | to solve a given goal |
-| Depends on IR:  | chalk-ir and rust-ir   |
-| Context required:  | `RustIrDatabase` |
+| The `chalk-solve` crate |                       |
+| ----------------------- | --------------------- |
+| Purpose:                | to solve a given goal |
+| Depends on IR:          | chalk-ir and rust-ir  |
+| Context required:       | `RustIrDatabase`      |
 
 The `chalk-solve` crate exposes a key type called `Solver`.  This is a
 solver that, given a goal (expressed in chalk-ir) will solve the goal
@@ -60,11 +60,11 @@ provide needed context for the solver -- notably, the solver can ask:
 
 ## The chalk-engine crate
 
-| The `chalk-engine` crate  |   |
-|---|--- |
-| Purpose:  | define the base solving strategy |
-| IR:  | none   |
-| Context required:  | `Context` trait |
+| The `chalk-engine` crate |                                  |
+| ------------------------ | -------------------------------- |
+| Purpose:                 | define the base solving strategy |
+| IR:                      | none                             |
+| Context required:        | `Context` trait                  |
 
 For the purposes of chalk, the `chalk-engine` crate is effectively
 encapsulated by `chalk-solve`.  It defines the base SLG engine. It is

chalk-derive/src/lib.rs

@@ -120,7 +120,7 @@ enum DeriveKind {
 decl_derive!([HasInterner, attributes(has_interner)] => derive_has_interner);
 decl_derive!([Visit, attributes(has_interner)] => derive_visit);
 decl_derive!([SuperVisit, attributes(has_interner)] => derive_super_visit);
-decl_derive!([Fold, attributes(has_interner)] => derive_fold);
+decl_derive!([TypeFoldable, attributes(has_interner)] => derive_type_foldable);
 decl_derive!([Zip, attributes(has_interner)] => derive_zip);
 
 fn derive_has_interner(mut s: synstructure::Structure) -> TokenStream {
@@ -250,11 +250,11 @@ fn derive_zip(mut s: synstructure::Structure) -> TokenStream {
     )
 }
 
-/// Derives Fold for structs and enums for which one of the following is true:
+/// Derives TypeFoldable for structs and enums for which one of the following is true:
 /// - It has a `#[has_interner(TheInterner)]` attribute
 /// - There is a single parameter `T: HasInterner` (does not have to be named `T`)
 /// - There is a single parameter `I: Interner` (does not have to be named `I`)
-fn derive_fold(mut s: synstructure::Structure) -> TokenStream {
+fn derive_type_foldable(mut s: synstructure::Structure) -> TokenStream {
     s.underscore_const(true);
     s.bind_with(|_| synstructure::BindStyle::Move);
 
@@ -265,7 +265,7 @@ fn derive_fold(mut s: synstructure::Structure) -> TokenStream {
         vi.construct(|_, index| {
             let bind = &bindings[index];
             quote! {
-                ::chalk_ir::fold::Fold::fold_with(#bind, folder, outer_binder)?
+                ::chalk_ir::fold::TypeFoldable::fold_with(#bind, folder, outer_binder)?
             }
         })
     });
@@ -277,7 +277,7 @@ fn derive_fold(mut s: synstructure::Structure) -> TokenStream {
         let param = get_generic_param_name(input).unwrap();
         s.add_impl_generic(parse_quote! { _U })
             .add_where_predicate(
-                parse_quote! { #param: ::chalk_ir::fold::Fold<#interner, Result = _U> },
+                parse_quote! { #param: ::chalk_ir::fold::TypeFoldable<#interner, Result = _U> },
             )
             .add_where_predicate(
                 parse_quote! { _U: ::chalk_ir::interner::HasInterner<Interner = #interner> },
@@ -289,7 +289,7 @@ fn derive_fold(mut s: synstructure::Structure) -> TokenStream {
 
     s.add_bounds(synstructure::AddBounds::None);
     s.bound_impl(
-        quote!(::chalk_ir::fold::Fold<#interner>),
+        quote!(::chalk_ir::fold::TypeFoldable<#interner>),
         quote! {
             type Result = #result;
 

chalk-engine/src/lib.rs

@@ -56,7 +56,7 @@
 use std::cmp::min;
 use std::usize;
 
-use chalk_derive::{Fold, HasInterner, Visit};
+use chalk_derive::{HasInterner, TypeFoldable, Visit};
 use chalk_ir::interner::Interner;
 use chalk_ir::{
     AnswerSubst, Canonical, ConstrainedSubst, Constraint, DebruijnIndex, Goal, InEnvironment,
@@ -78,13 +78,13 @@ mod table;
 mod tables;
 
 index_struct! {
-    pub struct TableIndex { // FIXME: pub b/c Fold
+    pub struct TableIndex { // FIXME: pub b/c TypeFoldable
         value: usize,
     }
 }
 
 /// The paper describes these as `A :- D | G`.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, Visit, HasInterner)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit, HasInterner)]
 pub struct ExClause<I: Interner> {
     /// The substitution which, applied to the goal of our table,
     /// would yield A.
@@ -168,7 +168,7 @@ impl TimeStamp {
 ///
 /// trying to solve `?T: Foo` would immediately require solving `?T:
 /// Sized`, and hence would flounder.
-#[derive(Clone, Debug, PartialEq, Eq, Hash, Fold, Visit)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, Visit)]
 pub struct FlounderedSubgoal<I: Interner> {
     /// Literal that floundered.
     pub floundered_literal: Literal<I>,
@@ -209,7 +209,7 @@ pub struct CompleteAnswer<I: Interner> {
 }
 
 /// Either `A` or `~A`, where `A` is a `Env |- Goal`.
-#[derive(Clone, Debug, Fold, Visit)]
+#[derive(Clone, Debug, TypeFoldable, Visit)]
 pub enum Literal<I: Interner> {
     // FIXME: pub b/c fold
     Positive(InEnvironment<Goal<I>>),

chalk-engine/src/normalize_deep.rs

@@ -1,5 +1,5 @@
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::{Fold, Folder};
+use chalk_ir::fold::{Folder, TypeFoldable};
 use chalk_ir::interner::Interner;
 use chalk_ir::*;
 use chalk_solve::infer::InferenceTable;
@@ -21,7 +21,7 @@ impl<I: Interner> DeepNormalizer<'_, I> {
     /// See also `InferenceTable::canonicalize`, which -- during real
     /// processing -- is often used to capture the "current state" of
     /// variables.
-    pub fn normalize_deep<T: Fold<I>>(
+    pub fn normalize_deep<T: TypeFoldable<I>>(
         table: &mut InferenceTable<I>,
         interner: I,
         value: T,

chalk-engine/src/slg/resolvent.rs

@@ -3,7 +3,7 @@ use crate::slg::ResolventOps;
 use crate::{ExClause, Literal, TimeStamp};
 use chalk_ir::cast::Caster;
 use chalk_ir::fold::shift::Shift;
-use chalk_ir::fold::Fold;
+use chalk_ir::fold::TypeFoldable;
 use chalk_ir::interner::{HasInterner, Interner};
 use chalk_ir::zip::{Zip, Zipper};
 use chalk_ir::*;
@@ -708,7 +708,7 @@ impl<'i, I: Interner> Zipper<I> for AnswerSubstitutor<'i, I> {
         pending: &Binders<T>,
     ) -> Fallible<()>
     where
-        T: HasInterner<Interner = I> + Zip<I> + Fold<I, Result = T>,
+        T: HasInterner<Interner = I> + Zip<I> + TypeFoldable<I, Result = T>,
     {
         self.outer_binder.shift_in();
         Zip::zip_with(

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::{Fold, Folder};
+use chalk_ir::fold::{Folder, TypeFoldable};
 use chalk_ir::interner::Interner;
 use chalk_ir::{Canonical, DebruijnIndex, UniverseMap};
 
@@ -35,7 +35,7 @@ pub(crate) struct SelectedSubgoal {
     pub(crate) universe_map: UniverseMap,
 }
 
-impl<I: Interner> Fold<I> for Strand<I> {
+impl<I: Interner> TypeFoldable<I> for Strand<I> {
     type Result = Strand<I>;
     fn fold_with<E>(
         self,

chalk-ir/src/fold.rs

@@ -16,7 +16,7 @@ pub use self::subst::Subst;
 /// some term -- that is, some bit of IR, such as a `Goal` -- with
 /// 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 `Fold` trait which, given a
+/// each bit of IR implements the `TypeFoldable` trait which, given a
 /// `Folder`, will reconstruct itself, invoking the folder's methods
 /// to transform each of the types/lifetimes embedded within.
 ///
@@ -49,7 +49,7 @@ pub use self::subst::Subst;
 ///   that appear in the term being folded (use
 ///   `DefaultPlaceholderFolder` to ignore/forbid these altogether)
 ///
-/// To **apply** a folder, use the `Fold::fold_with` method, like so
+/// To **apply** a folder, use the `TypeFoldable::fold_with` method, like so
 ///
 /// ```rust,ignore
 /// let x = x.fold_with(&mut folder, 0);
@@ -310,11 +310,11 @@ pub trait Folder<I: Interner> {
 /// 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
 /// `T`; well, actually `T::Result`).
-pub trait Fold<I: Interner>: Debug {
+pub trait TypeFoldable<I: Interner>: Debug {
     /// The type of value that will be produced once folding is done.
     /// Typically this is `Self`, unless `Self` contains borrowed
     /// values, in which case owned values are produced (for example,
-    /// one can fold over a `&T` value where `T: Fold`, in which case
+    /// one can fold over a `&T` value where `T: TypeFoldable`, in which case
     /// you get back a `T`, not a `&T`).
     type Result;
 
@@ -333,7 +333,7 @@ pub trait Fold<I: Interner>: Debug {
 /// For types where "fold" invokes a callback on the `Folder`, the
 /// `SuperFold` trait captures the recursive behavior that folds all
 /// the contents of the type.
-pub trait SuperFold<I: Interner>: Fold<I> {
+pub trait SuperFold<I: Interner>: TypeFoldable<I> {
     /// Recursively folds the value.
     fn super_fold_with<E>(
         self,
@@ -345,7 +345,7 @@ pub trait SuperFold<I: Interner>: Fold<I> {
 /// "Folding" a type invokes the `fold_ty` method on the folder; this
 /// usually (in turn) invokes `super_fold_ty` to fold the individual
 /// parts.
-impl<I: Interner> Fold<I> for Ty<I> {
+impl<I: Interner> TypeFoldable<I> for Ty<I> {
     type Result = Ty<I>;
 
     fn fold_with<E>(
@@ -469,7 +469,7 @@ where
 /// "Folding" a lifetime invokes the `fold_lifetime` method on the folder; this
 /// usually (in turn) invokes `super_fold_lifetime` to fold the individual
 /// parts.
-impl<I: Interner> Fold<I> for Lifetime<I> {
+impl<I: Interner> TypeFoldable<I> for Lifetime<I> {
     type Result = Lifetime<I>;
 
     fn fold_with<E>(
@@ -521,7 +521,7 @@ where
 /// "Folding" a const invokes the `fold_const` method on the folder; this
 /// usually (in turn) invokes `super_fold_const` to fold the individual
 /// parts.
-impl<I: Interner> Fold<I> for Const<I> {
+impl<I: Interner> TypeFoldable<I> for Const<I> {
     type Result = Const<I>;
 
     fn fold_with<E>(
@@ -572,7 +572,7 @@ where
 
 /// Folding a goal invokes the `fold_goal` callback (which will, by
 /// default, invoke super-fold).
-impl<I: Interner> Fold<I> for Goal<I> {
+impl<I: Interner> TypeFoldable<I> for Goal<I> {
     type Result = Goal<I>;
 
     fn fold_with<E>(
@@ -604,7 +604,7 @@ impl<I: Interner> SuperFold<I> for Goal<I> {
 /// Folding a program clause invokes the `fold_program_clause`
 /// callback on the folder (which will, by default, invoke the
 /// `super_fold_with` method on the program clause).
-impl<I: Interner> Fold<I> for ProgramClause<I> {
+impl<I: Interner> TypeFoldable<I> for ProgramClause<I> {
     type Result = ProgramClause<I>;
 
     fn fold_with<E>(