From d9c8cff1dbf851d32218fc919da22ef880d25b78 Mon Sep 17 00:00:00 2001
From: timofey <tim@ongoteam.yaconnect.com>
Date: Tue, 23 May 2023 13:28:32 +0000
Subject: [PATCH] rename classes to instances

---
 book-monads                                   |  2 +-
 src/flow/traversible/unbalanced.rs            | 16 ++++++----
 src/func.rs                                   | 22 +++++++------
 src/func/controlflow.rs                       |  8 ++---
 src/func/{classes.rs => instances.rs}         |  8 ++---
 .../{classes => instances}/composition.rs     | 30 ++++++++---------
 src/func/{classes => instances}/effect.rs     | 22 ++++++-------
 src/func/{classes => instances}/future.rs     | 22 ++++++-------
 src/func/{classes => instances}/lazy.rs       | 24 +++++++-------
 src/func/{classes => instances}/option.rs     | 28 ++++++++--------
 src/func/{classes => instances}/overload.rs   | 32 +++++++++----------
 src/func/{classes => instances}/result.rs     | 32 +++++++++----------
 src/func/{classes => instances}/solo.rs       | 24 +++++++-------
 src/func/{classes => instances}/stackless.rs  | 22 ++++++-------
 src/func/{classes => instances}/tryfuture.rs  | 28 ++++++++--------
 src/rstd/tracing.rs                           |  6 ++--
 src/rstd/tracing/traceable.rs                 | 12 ++++---
 src/rstd/tracing/traced.rs                    |  2 +-
 src/testing.rs                                |  4 +--
 src/testing/counted.rs                        | 12 +++----
 src/testing/traced.rs                         |  4 +--
 21 files changed, 184 insertions(+), 176 deletions(-)
 rename src/func/{classes.rs => instances.rs} (67%)
 rename src/func/{classes => instances}/composition.rs (90%)
 rename src/func/{classes => instances}/effect.rs (87%)
 rename src/func/{classes => instances}/future.rs (89%)
 rename src/func/{classes => instances}/lazy.rs (86%)
 rename src/func/{classes => instances}/option.rs (87%)
 rename src/func/{classes => instances}/overload.rs (89%)
 rename src/func/{classes => instances}/result.rs (89%)
 rename src/func/{classes => instances}/solo.rs (84%)
 rename src/func/{classes => instances}/stackless.rs (95%)
 rename src/func/{classes => instances}/tryfuture.rs (89%)

diff --git a/book-monads b/book-monads
index 80aa72c..f1dd33d 160000
--- a/book-monads
+++ b/book-monads
@@ -1 +1 @@
-Subproject commit 80aa72c60ecd0ac605041d22df2ea6a66178c5be
+Subproject commit f1dd33d61f7d1ce9c1d428ff0d75fb3efb2bb340
diff --git a/src/flow/traversible/unbalanced.rs b/src/flow/traversible/unbalanced.rs
index a42c44f..691a7d5 100644
--- a/src/flow/traversible/unbalanced.rs
+++ b/src/flow/traversible/unbalanced.rs
@@ -55,13 +55,15 @@ where
     }
 }
 
-impl<'a, A: 'a + Display> Display for UnbalancedReference<'a, classes::solo::SoloClass, A> {
+impl<'a, A: 'a + Display> Display for UnbalancedReference<'a, instances::solo::SoloInstance, A> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_fmt(format_args!("{}", self.0()))
     }
 }
 
-impl<'a, A: 'a + Display> Display for UnbalancedReference<'a, classes::result::ResultClass<()>, A> {
+impl<'a, A: 'a + Display> Display
+    for UnbalancedReference<'a, instances::result::ResultInstance<()>, A>
+{
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self.0() {
             Ok(node) => f.write_fmt(format_args!("{}", node)),
@@ -179,7 +181,7 @@ mod tests {
 
     #[test]
     fn test_simple_slices() {
-        let ctr: Rc<UnbalancedConstructor<classes::result::ResultClass<()>, _>> =
+        let ctr: Rc<UnbalancedConstructor<instances::result::ResultInstance<()>, _>> =
             UnbalancedConstructor::rc(Box::new(|node| Box::new(move || Ok(node.clone()))));
         let mut rng = rand::thread_rng();
         let t_set = ctr.from_slice(&mut rng, &[0]);
@@ -212,7 +214,7 @@ mod tests {
     #[ignore]
     #[test]
     fn test_random_slices() {
-        let ctr: Rc<UnbalancedConstructor<classes::result::ResultClass<()>, _>> =
+        let ctr: Rc<UnbalancedConstructor<instances::result::ResultInstance<()>, _>> =
             UnbalancedConstructor::rc(Box::new(|node| Box::new(move || Ok(node.clone()))));
         let mut rng = rand::thread_rng();
         for _ in 0..1000 {
@@ -254,8 +256,10 @@ mod tests {
         }
     }
 
-    type TracedMonad =
-        classes::composition::CompositionClass<TracedClass, classes::result::ResultClass<()>>;
+    type TracedMonad = instances::composition::CompositionInstance<
+        TracedInstance,
+        instances::result::ResultInstance<()>,
+    >;
 
     #[ignore]
     #[test]
diff --git a/src/func.rs b/src/func.rs
index 4769470..0475f85 100644
--- a/src/func.rs
+++ b/src/func.rs
@@ -8,11 +8,11 @@
 //! * <https://hackage.haskell.org/package/base-4.18.0.0/docs/Control-Monad.html>
 
 mod applicative_select;
-pub mod classes;
 pub mod clone_func;
 mod controlflow;
 pub mod copy_func;
 pub mod derivations;
+pub mod instances;
 #[cfg(test)]
 pub mod test_suite;
 #[cfg(test)]
@@ -23,8 +23,10 @@ pub use std::ops::ControlFlow;
 pub use radn_derive::{CovariantFunctor, SharedFunctor};
 
 pub use self::applicative_select::{ApplicativeSelect, Selected};
-use self::controlflow::{BindableMut, ControlFlowClass};
+use self::controlflow::{BindableMut, ControlFlowInstance};
 pub use self::controlflow::{Iterative, IterativeWrapped};
+#[cfg(doc)]
+use self::instances::stackless::StacklessInstance;
 
 /// Part of Haskell's `Functor f` responsible for having `f a`.
 ///
@@ -42,13 +44,13 @@ pub trait WeakFunctor {
 /// ```compile_fail
 /// use radn_rs::func::*;
 ///
-/// struct VecClass;
+/// struct VecInstance;
 ///
-/// impl WeakFunctor for VecClass {
+/// impl WeakFunctor for VecInstance {
 ///     type F<'a, A> = Vec<A>;
 /// }
 ///
-/// impl Functor for VecClass {
+/// impl Functor for VecInstance {
 ///     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
 ///         fa.into_iter().map(f).collect()
 ///     }
@@ -61,13 +63,13 @@ pub trait WeakFunctor {
 /// ```
 /// use radn_rs::func::clone_func::*;
 ///
-/// struct VecClass;
+/// struct VecInstance;
 ///
-/// impl CloneWeakFunctor for VecClass {
+/// impl CloneWeakFunctor for VecInstance {
 ///     type ClF<'a, A: Clone> = Vec<A>;
 /// }
 ///
-/// impl CloneFunctor for VecClass {
+/// impl CloneFunctor for VecInstance {
 ///     fn clone_fmap<'a, A: 'a + Clone, B: 'a + Clone>(
 ///         f: impl 'a + Fn(A) -> B,
 ///         fa: Self::ClF<'a, A>,
@@ -182,7 +184,7 @@ pub trait Monad: Applicative {
 
     /// Included for optimisation and clarity.
     /// Generally, [`Monad::bind`] should be enough implement it.
-    /// See [`classes::stackless::StacklessClass::iterate`] for a generic, though less-than ideal, blanket implementation.
+    /// See [`StacklessInstance::iterate`] for a generic, though less-than ideal, blanket implementation.
     /// On practice, you generally shouldn't be using [`Monad::bind`]/[`Pure::pure`]/[`Functor::fmap`] here.
     fn iterate<'a, B: 'a>(f: impl Iterative<'a, T = Self, B = B>) -> Self::F<'a, B>
     where
@@ -256,7 +258,7 @@ pub trait LocalFunctor: WeakFunctor {
     where
         Self: 'a,
     {
-        Self::stuff::<_, ControlFlowClass<A>>(state)
+        Self::stuff::<_, ControlFlowInstance<A>>(state)
     }
 
     /// Stuff wrapped result into another functor.
diff --git a/src/func/controlflow.rs b/src/func/controlflow.rs
index e3752d1..0a162ea 100644
--- a/src/func/controlflow.rs
+++ b/src/func/controlflow.rs
@@ -2,15 +2,15 @@ use std::marker::PhantomData;
 
 use super::*;
 
-pub struct ControlFlowClass<C>(ControlFlow<(), C>);
+pub struct ControlFlowInstance<C>(ControlFlow<(), C>);
 
-impl<C> WeakFunctor for ControlFlowClass<C> {
+impl<C> WeakFunctor for ControlFlowInstance<C> {
     type F<'a, A: 'a> =  ControlFlow<A, C>
     where
         Self: 'a;
 }
 
-impl<C> Functor for ControlFlowClass<C> {
+impl<C> Functor for ControlFlowInstance<C> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -22,7 +22,7 @@ impl<C> Functor for ControlFlowClass<C> {
     }
 }
 
-impl<C> Pure for ControlFlowClass<C> {
+impl<C> Pure for ControlFlowInstance<C> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
diff --git a/src/func/classes.rs b/src/func/instances.rs
similarity index 67%
rename from src/func/classes.rs
rename to src/func/instances.rs
index 0094bd6..02ae552 100644
--- a/src/func/classes.rs
+++ b/src/func/instances.rs
@@ -1,6 +1,6 @@
-//! Implementation of some basic classes (in Haskell's meaning of a class).
+//! Implementation of some basic instances (in Haskell's meaning of a instances).
 //!
-//! To get an understanding of what classes are about, see [`option`].
+//! To get an understanding of what instances are about, see [`option`].
 //!
 //! For [`MonadFail<E>`] examples, see [`result`][^research].
 //!
@@ -12,9 +12,9 @@
 //!
 //! For combining monads, see [`composition`][^research].
 //!
-//! [^production]: classes expected to be used in production.
+//! [^production]: instances expected to be used in production.
 //!
-//! [^research]: classes used for research purposes to enhance the abstract interfaces.
+//! [^research]: instances used for research purposes to enhance the abstract interfaces.
 
 #[cfg(doc)]
 use crate::func::*;
diff --git a/src/func/classes/composition.rs b/src/func/instances/composition.rs
similarity index 90%
rename from src/func/classes/composition.rs
rename to src/func/instances/composition.rs
index c99549e..32b9f3f 100644
--- a/src/func/classes/composition.rs
+++ b/src/func/instances/composition.rs
@@ -1,12 +1,12 @@
 use crate::func::*;
 
-pub struct CompositionClass<U, V>(U, V);
+pub struct CompositionInstance<U, V>(U, V);
 
-impl<U: WeakFunctor, V: WeakFunctor> WeakFunctor for CompositionClass<U, V> {
+impl<U: WeakFunctor, V: WeakFunctor> WeakFunctor for CompositionInstance<U, V> {
     type F<'a, A: 'a> = U::F<'a, V::F<'a, A>> where Self: 'a;
 }
 
-impl<U: Functor, V: Functor> Functor for CompositionClass<U, V> {
+impl<U: Functor, V: Functor> Functor for CompositionInstance<U, V> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -29,7 +29,7 @@ impl<U: Functor, V: Functor> Functor for CompositionClass<U, V> {
     }
 }
 
-impl<U: Pure, V: Pure> Pure for CompositionClass<U, V> {
+impl<U: Pure, V: Pure> Pure for CompositionInstance<U, V> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -38,7 +38,7 @@ impl<U: Pure, V: Pure> Pure for CompositionClass<U, V> {
     }
 }
 
-impl<U: ApplicativeLA2, V: ApplicativeSeq> ApplicativeSeq for CompositionClass<U, V> {
+impl<U: ApplicativeLA2, V: ApplicativeSeq> ApplicativeSeq for CompositionInstance<U, V> {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -50,7 +50,7 @@ impl<U: ApplicativeLA2, V: ApplicativeSeq> ApplicativeSeq for CompositionClass<U
     }
 }
 
-impl<U: ApplicativeLA2, V: ApplicativeLA2> ApplicativeLA2 for CompositionClass<U, V> {
+impl<U: ApplicativeLA2, V: ApplicativeLA2> ApplicativeLA2 for CompositionInstance<U, V> {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -63,7 +63,7 @@ impl<U: ApplicativeLA2, V: ApplicativeLA2> ApplicativeLA2 for CompositionClass<U
     }
 }
 
-impl<U: ApplicativeTuple, V: ApplicativeTuple> ApplicativeTuple for CompositionClass<U, V> {
+impl<U: ApplicativeTuple, V: ApplicativeTuple> ApplicativeTuple for CompositionInstance<U, V> {
     fn tuple<'a, A: 'a, B: 'a>(fab: (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -72,7 +72,7 @@ impl<U: ApplicativeTuple, V: ApplicativeTuple> ApplicativeTuple for CompositionC
     }
 }
 
-impl<U: ApplicativeSelect, V: Functor> ApplicativeSelect for CompositionClass<U, V> {
+impl<U: ApplicativeSelect, V: Functor> ApplicativeSelect for CompositionInstance<U, V> {
     fn select<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
@@ -92,7 +92,7 @@ impl<U: ApplicativeSelect, V: Functor> ApplicativeSelect for CompositionClass<U,
     }
 }
 
-impl<U: Applicative, V: Applicative> Applicative for CompositionClass<U, V> {
+impl<U: Applicative, V: Applicative> Applicative for CompositionInstance<U, V> {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -108,7 +108,7 @@ impl<U: Applicative, V: Applicative> Applicative for CompositionClass<U, V> {
     }
 }
 
-impl<U: Monad, V: Monad + LocalFunctor> Monad for CompositionClass<U, V> {
+impl<U: Monad, V: Monad + LocalFunctor> Monad for CompositionInstance<U, V> {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -141,7 +141,7 @@ impl<
         'a,
         U: 'a + Monad,
         V: 'a + Monad + LocalFunctor,
-        F: Iterative<'a, T = CompositionClass<U, V>>,
+        F: Iterative<'a, T = CompositionInstance<U, V>>,
     > Iterative<'a> for ComposedIterative<F>
 {
     type B = <V as WeakFunctor>::F<'a, F::B>;
@@ -159,7 +159,7 @@ impl<
     }
 }
 
-impl<E, U: Monad, V: Fail<E> + LocalFunctor> Fail<E> for CompositionClass<U, V> {
+impl<E, U: Monad, V: Fail<E> + LocalFunctor> Fail<E> for CompositionInstance<U, V> {
     fn fail<'a, A: 'a>(e: E) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -169,7 +169,7 @@ impl<E, U: Monad, V: Fail<E> + LocalFunctor> Fail<E> for CompositionClass<U, V>
     }
 }
 
-impl<U: LocalFunctor + Functor, V: LocalFunctor> LocalFunctor for CompositionClass<U, V> {
+impl<U: LocalFunctor + Functor, V: LocalFunctor> LocalFunctor for CompositionInstance<U, V> {
     fn unstuff<'a, A: 'a, B: 'a>(
         state: Self::F<'a, ControlFlow<B, A>>,
     ) -> ControlFlow<Self::F<'a, B>, A>
@@ -187,7 +187,7 @@ impl<U: LocalFunctor + Functor, V: LocalFunctor> LocalFunctor for CompositionCla
     }
 }
 
-impl<U: SharedFunctor + Functor, V: SharedFunctor> SharedFunctor for CompositionClass<U, V> {
+impl<U: SharedFunctor + Functor, V: SharedFunctor> SharedFunctor for CompositionInstance<U, V> {
     type Shared<'a, A: 'a + Clone> = U::Shared<'a, V::Shared<'a, A>>
     where
         Self: 'a;
@@ -208,7 +208,7 @@ impl<U: SharedFunctor + Functor, V: SharedFunctor> SharedFunctor for Composition
 }
 
 impl<U: CovariantFunctor + Functor, V: CovariantFunctor> CovariantFunctor
-    for CompositionClass<U, V>
+    for CompositionInstance<U, V>
 {
     fn variate<'a: 'b, 'b, A: 'a>(fa: Self::F<'a, A>) -> Self::F<'b, A>
     where
diff --git a/src/func/classes/effect.rs b/src/func/instances/effect.rs
similarity index 87%
rename from src/func/classes/effect.rs
rename to src/func/instances/effect.rs
index 2a3c0bc..37823b7 100644
--- a/src/func/classes/effect.rs
+++ b/src/func/instances/effect.rs
@@ -24,15 +24,15 @@ impl<A, E: Effect> WithEffect<A, E> {
 }
 
 #[derive(SharedFunctor, CovariantFunctor)]
-pub struct EffectClass<E>(E);
+pub struct EffectInstance<E>(E);
 
-impl<E> WeakFunctor for EffectClass<E> {
+impl<E> WeakFunctor for EffectInstance<E> {
     type F<'a, A: 'a> = WithEffect<A, E>
     where
         Self: 'a;
 }
 
-impl<E> Functor for EffectClass<E> {
+impl<E> Functor for EffectInstance<E> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -55,7 +55,7 @@ impl<E> Functor for EffectClass<E> {
     }
 }
 
-impl<E: Effect> Pure for EffectClass<E> {
+impl<E: Effect> Pure for EffectInstance<E> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -67,7 +67,7 @@ impl<E: Effect> Pure for EffectClass<E> {
     }
 }
 
-impl<E: Effect> ApplicativeSeq for EffectClass<E> {
+impl<E: Effect> ApplicativeSeq for EffectInstance<E> {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -82,7 +82,7 @@ impl<E: Effect> ApplicativeSeq for EffectClass<E> {
     }
 }
 
-impl<E: Effect> ApplicativeLA2 for EffectClass<E> {
+impl<E: Effect> ApplicativeLA2 for EffectInstance<E> {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -98,7 +98,7 @@ impl<E: Effect> ApplicativeLA2 for EffectClass<E> {
     }
 }
 
-impl<E: Effect> ApplicativeTuple for EffectClass<E> {
+impl<E: Effect> ApplicativeTuple for EffectInstance<E> {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -110,9 +110,9 @@ impl<E: Effect> ApplicativeTuple for EffectClass<E> {
     }
 }
 
-impl<E: Effect> ApplicativeSelect for EffectClass<E> {}
+impl<E: Effect> ApplicativeSelect for EffectInstance<E> {}
 
-impl<E: Effect> Applicative for EffectClass<E> {
+impl<E: Effect> Applicative for EffectInstance<E> {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -136,7 +136,7 @@ impl<E: Effect> Applicative for EffectClass<E> {
     }
 }
 
-impl<E: Effect> Monad for EffectClass<E> {
+impl<E: Effect> Monad for EffectInstance<E> {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -171,7 +171,7 @@ impl<E: Effect> Monad for EffectClass<E> {
     }
 }
 
-impl<E> LocalFunctor for EffectClass<E> {
+impl<E> LocalFunctor for EffectInstance<E> {
     fn stuff<'a, A: 'a, T: 'a + Pure>(fa: Self::F<'a, T::F<'a, A>>) -> T::F<'a, Self::F<'a, A>>
     where
         Self: 'a,
diff --git a/src/func/classes/future.rs b/src/func/instances/future.rs
similarity index 89%
rename from src/func/classes/future.rs
rename to src/func/instances/future.rs
index c0ecef3..1086a6d 100644
--- a/src/func/classes/future.rs
+++ b/src/func/instances/future.rs
@@ -13,13 +13,13 @@ use futures::{
 use crate::func::*;
 
 #[derive(CovariantFunctor)]
-pub struct FutureClass;
+pub struct FutureInstance;
 
-impl WeakFunctor for FutureClass {
+impl WeakFunctor for FutureInstance {
     type F<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = A>>>;
 }
 
-impl Functor for FutureClass {
+impl Functor for FutureInstance {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
         Box::pin(async { f(fa.await) })
     }
@@ -32,13 +32,13 @@ impl Functor for FutureClass {
     }
 }
 
-impl Pure for FutureClass {
+impl Pure for FutureInstance {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
         Box::pin(async { a })
     }
 }
 
-impl ApplicativeSeq for FutureClass {
+impl ApplicativeSeq for FutureInstance {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -50,7 +50,7 @@ impl ApplicativeSeq for FutureClass {
     }
 }
 
-impl ApplicativeLA2 for FutureClass {
+impl ApplicativeLA2 for FutureInstance {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -63,7 +63,7 @@ impl ApplicativeLA2 for FutureClass {
     }
 }
 
-impl ApplicativeTuple for FutureClass {
+impl ApplicativeTuple for FutureInstance {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -72,7 +72,7 @@ impl ApplicativeTuple for FutureClass {
     }
 }
 
-impl ApplicativeSelect for FutureClass {
+impl ApplicativeSelect for FutureInstance {
     fn select<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
@@ -90,7 +90,7 @@ impl ApplicativeSelect for FutureClass {
     }
 }
 
-impl Applicative for FutureClass {
+impl Applicative for FutureInstance {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
         Box::pin(async { join!(fa, fb).1 })
     }
@@ -100,7 +100,7 @@ impl Applicative for FutureClass {
     }
 }
 
-impl Monad for FutureClass {
+impl Monad for FutureInstance {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -127,7 +127,7 @@ impl Monad for FutureClass {
     }
 }
 
-impl SharedFunctor for FutureClass {
+impl SharedFunctor for FutureInstance {
     type Shared<'a, A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = A>>>>
     where
         Self: 'a;
diff --git a/src/func/classes/lazy.rs b/src/func/instances/lazy.rs
similarity index 86%
rename from src/func/classes/lazy.rs
rename to src/func/instances/lazy.rs
index 76ddc88..2de51b4 100644
--- a/src/func/classes/lazy.rs
+++ b/src/func/instances/lazy.rs
@@ -2,7 +2,7 @@
 //! Wrapped value is just a box pointing to the constructor function.
 //!
 //! Due to semantical laziness,
-//! [`LazyClass::replace`] and [`LazyClass::discard_first`]/[`LazyClass::discard_second`]
+//! [`LazyInstance::replace`] and [`LazyInstance::discard_first`]/[`LazyInstance::discard_second`]
 //! actually fully cancel the "unnecessary" computation.
 //!
 //! For stackless execution see [`super::stackless`].
@@ -12,13 +12,13 @@ use std::{cell::RefCell, rc::Rc};
 use crate::func::*;
 
 #[derive(CovariantFunctor)]
-pub struct LazyClass;
+pub struct LazyInstance;
 
-impl WeakFunctor for LazyClass {
+impl WeakFunctor for LazyInstance {
     type F<'a, A: 'a> = Box<dyn 'a + FnOnce() -> A>;
 }
 
-impl Functor for LazyClass {
+impl Functor for LazyInstance {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
         Box::new(|| f(fa()))
     }
@@ -34,13 +34,13 @@ impl Functor for LazyClass {
     }
 }
 
-impl Pure for LazyClass {
+impl Pure for LazyInstance {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
         Box::new(|| a)
     }
 }
 
-impl ApplicativeSeq for LazyClass {
+impl ApplicativeSeq for LazyInstance {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -49,7 +49,7 @@ impl ApplicativeSeq for LazyClass {
     }
 }
 
-impl ApplicativeLA2 for LazyClass {
+impl ApplicativeLA2 for LazyInstance {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -59,7 +59,7 @@ impl ApplicativeLA2 for LazyClass {
     }
 }
 
-impl ApplicativeTuple for LazyClass {
+impl ApplicativeTuple for LazyInstance {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -68,9 +68,9 @@ impl ApplicativeTuple for LazyClass {
     }
 }
 
-impl ApplicativeSelect for LazyClass {}
+impl ApplicativeSelect for LazyInstance {}
 
-impl Applicative for LazyClass {
+impl Applicative for LazyInstance {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
         drop(fa);
         fb
@@ -82,7 +82,7 @@ impl Applicative for LazyClass {
     }
 }
 
-impl Monad for LazyClass {
+impl Monad for LazyInstance {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -116,7 +116,7 @@ fn unshare<'a, A: 'a + Clone>(shared: &mut Option<Box<dyn 'a + FnOnce() -> A>>)
     a
 }
 
-impl SharedFunctor for LazyClass {
+impl SharedFunctor for LazyInstance {
     type Shared<'a, A: 'a + Clone> = Rc<RefCell<Option<Box<dyn 'a + FnOnce() -> A>>>>
     where
         Self: 'a;
diff --git a/src/func/classes/option.rs b/src/func/instances/option.rs
similarity index 87%
rename from src/func/classes/option.rs
rename to src/func/instances/option.rs
index 3ac2df7..f70cf02 100644
--- a/src/func/classes/option.rs
+++ b/src/func/instances/option.rs
@@ -2,7 +2,7 @@
 //!
 //! If any of the input values are [`None`], you can expect the output to be [`None`] as well.
 //! That includes
-//! [`OptionClass::replace`] and [`OptionClass::discard_first`]/[`OptionClass::discard_second`],
+//! [`OptionInstance::replace`] and [`OptionInstance::discard_first`]/[`OptionInstance::discard_second`],
 //! even if the value of the option would be ignored.
 //!
 //! For [`Result<A, E>`] alternative see [`super::result`]
@@ -10,13 +10,13 @@
 use crate::func::*;
 
 #[derive(SharedFunctor, CovariantFunctor)]
-pub struct OptionClass;
+pub struct OptionInstance;
 
-impl WeakFunctor for OptionClass {
+impl WeakFunctor for OptionInstance {
     type F<'a, A: 'a> = Option<A>;
 }
 
-impl Functor for OptionClass {
+impl Functor for OptionInstance {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
         fa.map(f)
     }
@@ -38,13 +38,13 @@ impl Functor for OptionClass {
     }
 }
 
-impl Pure for OptionClass {
+impl Pure for OptionInstance {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
         Some(a)
     }
 }
 
-impl ApplicativeSeq for OptionClass {
+impl ApplicativeSeq for OptionInstance {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -53,7 +53,7 @@ impl ApplicativeSeq for OptionClass {
     }
 }
 
-impl ApplicativeLA2 for OptionClass {
+impl ApplicativeLA2 for OptionInstance {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -63,7 +63,7 @@ impl ApplicativeLA2 for OptionClass {
     }
 }
 
-impl ApplicativeTuple for OptionClass {
+impl ApplicativeTuple for OptionInstance {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -72,9 +72,9 @@ impl ApplicativeTuple for OptionClass {
     }
 }
 
-impl ApplicativeSelect for OptionClass {}
+impl ApplicativeSelect for OptionInstance {}
 
-impl Applicative for OptionClass {
+impl Applicative for OptionInstance {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
         fa?;
         fb
@@ -86,7 +86,7 @@ impl Applicative for OptionClass {
     }
 }
 
-impl Monad for OptionClass {
+impl Monad for OptionInstance {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -111,7 +111,7 @@ impl Monad for OptionClass {
     }
 }
 
-impl LocalFunctor for OptionClass {
+impl LocalFunctor for OptionInstance {
     fn unstuff<'a, A: 'a, B: 'a>(
         state: Self::F<'a, ControlFlow<B, A>>,
     ) -> ControlFlow<Self::F<'a, B>, A>
@@ -136,7 +136,7 @@ impl LocalFunctor for OptionClass {
     }
 }
 
-impl Fail<()> for OptionClass {
+impl Fail<()> for OptionInstance {
     fn fail<'a, A: 'a>(_e: ()) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -149,7 +149,7 @@ impl Fail<()> for OptionClass {
 mod option_tests {
     use super::{test_suite, tests, Functor};
 
-    use super::OptionClass as T;
+    use super::OptionInstance as T;
 
     impl tests::Eqr for T {
         fn eqr<'a, A: PartialEq + std::fmt::Debug + 'a>(
diff --git a/src/func/classes/overload.rs b/src/func/instances/overload.rs
similarity index 89%
rename from src/func/classes/overload.rs
rename to src/func/instances/overload.rs
index d3caad9..afe7cfc 100644
--- a/src/func/classes/overload.rs
+++ b/src/func/instances/overload.rs
@@ -2,7 +2,7 @@ use std::marker::PhantomData;
 
 use crate::func::*;
 
-pub struct OverloadClass<T, O>(T, O);
+pub struct OverloadInstance<T, O>(T, O);
 
 pub trait DeriveWeakFunctor {}
 impl<O: DeriveFunctor> DeriveWeakFunctor for O {}
@@ -12,13 +12,13 @@ pub trait DeriveApplicative {}
 impl<O: DeriveMonad> DeriveApplicative for O {}
 pub trait DeriveMonad {}
 
-impl<T: WeakFunctor, O: DeriveWeakFunctor> WeakFunctor for OverloadClass<T, O> {
+impl<T: WeakFunctor, O: DeriveWeakFunctor> WeakFunctor for OverloadInstance<T, O> {
     type F<'a, A: 'a> = T::F<'a, A>
     where
         Self: 'a;
 }
 
-impl<T: Functor, O: DeriveFunctor> Functor for OverloadClass<T, O> {
+impl<T: Functor, O: DeriveFunctor> Functor for OverloadInstance<T, O> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -41,7 +41,7 @@ impl<T: Functor, O: DeriveFunctor> Functor for OverloadClass<T, O> {
     }
 }
 
-impl<T: Pure, O: DeriveApplicative> Pure for OverloadClass<T, O> {
+impl<T: Pure, O: DeriveApplicative> Pure for OverloadInstance<T, O> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -50,7 +50,7 @@ impl<T: Pure, O: DeriveApplicative> Pure for OverloadClass<T, O> {
     }
 }
 
-impl<T: ApplicativeSeq, O: DeriveApplicative> ApplicativeSeq for OverloadClass<T, O> {
+impl<T: ApplicativeSeq, O: DeriveApplicative> ApplicativeSeq for OverloadInstance<T, O> {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -62,7 +62,7 @@ impl<T: ApplicativeSeq, O: DeriveApplicative> ApplicativeSeq for OverloadClass<T
     }
 }
 
-impl<T: ApplicativeLA2, O: DeriveApplicative> ApplicativeLA2 for OverloadClass<T, O> {
+impl<T: ApplicativeLA2, O: DeriveApplicative> ApplicativeLA2 for OverloadInstance<T, O> {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -75,7 +75,7 @@ impl<T: ApplicativeLA2, O: DeriveApplicative> ApplicativeLA2 for OverloadClass<T
     }
 }
 
-impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeTuple for OverloadClass<T, O> {
+impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeTuple for OverloadInstance<T, O> {
     fn tuple<'a, A: 'a, B: 'a>(fab: (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -84,9 +84,9 @@ impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeTuple for OverloadCla
     }
 }
 
-impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeSelect for OverloadClass<T, O> {}
+impl<T: ApplicativeTuple, O: DeriveApplicative> ApplicativeSelect for OverloadInstance<T, O> {}
 
-impl<T: Applicative, O: DeriveApplicative> Applicative for OverloadClass<T, O> {
+impl<T: Applicative, O: DeriveApplicative> Applicative for OverloadInstance<T, O> {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -110,7 +110,7 @@ impl<F, O> OverloadIterative<F, O> {
     }
 }
 
-impl<'a, T: 'a + Monad, O: 'a + DeriveMonad, F: Iterative<'a, T = OverloadClass<T, O>>>
+impl<'a, T: 'a + Monad, O: 'a + DeriveMonad, F: Iterative<'a, T = OverloadInstance<T, O>>>
     Iterative<'a> for OverloadIterative<F, O>
 {
     type B = F::B;
@@ -128,7 +128,7 @@ impl<'a, T: 'a + Monad, O: 'a + DeriveMonad, F: Iterative<'a, T = OverloadClass<
     }
 }
 
-impl<T: Monad, O: DeriveMonad> Monad for OverloadClass<T, O> {
+impl<T: Monad, O: DeriveMonad> Monad for OverloadInstance<T, O> {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -159,7 +159,7 @@ pub struct DeriveFail<Ex>(Ex);
 
 impl<Ex> DeriveMonad for DeriveFail<Ex> {}
 
-impl<E, Ex, T: MonadFail<Result<E, Ex>>> Fail<E> for OverloadClass<T, DeriveFail<Ex>> {
+impl<E, Ex, T: MonadFail<Result<E, Ex>>> Fail<E> for OverloadInstance<T, DeriveFail<Ex>> {
     fn fail<'a, A: 'a>(e: E) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -172,7 +172,7 @@ impl<E, Ex, T: MonadFail<Result<E, Ex>>> Fail<E> for OverloadClass<T, DeriveFail
 struct DeriveFailAny<Ex, Fallible>(Ex, Fallible);
 
 impl<Ex, Fallible: MonadFailAny> MonadFailAny for DeriveFailAny<Ex, Fallible> {
-    type W<E> = OverloadClass<Fallible::W<Result<E, Ex>>, DeriveFail<Ex>>;
+    type W<E> = OverloadInstance<Fallible::W<Result<E, Ex>>, DeriveFail<Ex>>;
 
     type T = Fallible::W<Ex>;
 
@@ -240,7 +240,7 @@ impl<Ex, Fallible: MonadFailAny> MonadFailAny for DeriveFailAny<Ex, Fallible> {
     }
 }
 
-impl<T: SharedFunctor, O: DeriveWeakFunctor> SharedFunctor for OverloadClass<T, O> {
+impl<T: SharedFunctor, O: DeriveWeakFunctor> SharedFunctor for OverloadInstance<T, O> {
     type Shared<'a, A: 'a + Clone> = T::Shared<'a, A>
     where
         Self: 'a;
@@ -260,7 +260,7 @@ impl<T: SharedFunctor, O: DeriveWeakFunctor> SharedFunctor for OverloadClass<T,
     }
 }
 
-impl<T: CovariantFunctor, O: DeriveWeakFunctor> CovariantFunctor for OverloadClass<T, O> {
+impl<T: CovariantFunctor, O: DeriveWeakFunctor> CovariantFunctor for OverloadInstance<T, O> {
     fn variate<'a: 'b, 'b, A: 'a>(fa: Self::F<'a, A>) -> Self::F<'b, A>
     where
         Self: 'a,
@@ -269,4 +269,4 @@ impl<T: CovariantFunctor, O: DeriveWeakFunctor> CovariantFunctor for OverloadCla
     }
 }
 
-pub type EmbedFail<T, Ex> = OverloadClass<T, DeriveFail<Ex>>;
+pub type EmbedFail<T, Ex> = OverloadInstance<T, DeriveFail<Ex>>;
diff --git a/src/func/classes/result.rs b/src/func/instances/result.rs
similarity index 89%
rename from src/func/classes/result.rs
rename to src/func/instances/result.rs
index b4ae158..60637fc 100644
--- a/src/func/classes/result.rs
+++ b/src/func/instances/result.rs
@@ -2,7 +2,7 @@
 //!
 //! If any of the input values are [`Err`], you can expect the output to be [`Err`] as well.
 //! That includes
-//! [`ResultClass::replace`] and [`ResultClass::discard_first`]/[`ResultClass::discard_second`],
+//! [`ResultInstance::replace`] and [`ResultInstance::discard_first`]/[`ResultInstance::discard_second`],
 //! even if the value of the option would be ignored.
 //!
 //! For [`Option<A>`] alternative see [`super::option`]
@@ -10,13 +10,13 @@
 use crate::func::*;
 
 #[derive(SharedFunctor, CovariantFunctor)]
-pub struct ResultClass<E>(E);
+pub struct ResultInstance<E>(E);
 
-impl<E> WeakFunctor for ResultClass<E> {
+impl<E> WeakFunctor for ResultInstance<E> {
     type F<'a, A: 'a> = Result<A, E> where Self: 'a;
 }
 
-impl<E> Functor for ResultClass<E> {
+impl<E> Functor for ResultInstance<E> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -41,7 +41,7 @@ impl<E> Functor for ResultClass<E> {
     }
 }
 
-impl<E> Pure for ResultClass<E> {
+impl<E> Pure for ResultInstance<E> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -50,7 +50,7 @@ impl<E> Pure for ResultClass<E> {
     }
 }
 
-impl<E> ApplicativeSeq for ResultClass<E> {
+impl<E> ApplicativeSeq for ResultInstance<E> {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -62,7 +62,7 @@ impl<E> ApplicativeSeq for ResultClass<E> {
     }
 }
 
-impl<E> ApplicativeLA2 for ResultClass<E> {
+impl<E> ApplicativeLA2 for ResultInstance<E> {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -75,7 +75,7 @@ impl<E> ApplicativeLA2 for ResultClass<E> {
     }
 }
 
-impl<E> ApplicativeTuple for ResultClass<E> {
+impl<E> ApplicativeTuple for ResultInstance<E> {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -84,9 +84,9 @@ impl<E> ApplicativeTuple for ResultClass<E> {
     }
 }
 
-impl<E> ApplicativeSelect for ResultClass<E> {}
+impl<E> ApplicativeSelect for ResultInstance<E> {}
 
-impl<E> Applicative for ResultClass<E> {
+impl<E> Applicative for ResultInstance<E> {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -104,7 +104,7 @@ impl<E> Applicative for ResultClass<E> {
     }
 }
 
-impl<E> Monad for ResultClass<E> {
+impl<E> Monad for ResultInstance<E> {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -135,7 +135,7 @@ impl<E> Monad for ResultClass<E> {
     }
 }
 
-impl<E> LocalFunctor for ResultClass<E> {
+impl<E> LocalFunctor for ResultInstance<E> {
     fn unstuff<'a, A: 'a, B: 'a>(
         state: Self::F<'a, ControlFlow<B, A>>,
     ) -> ControlFlow<Self::F<'a, B>, A>
@@ -160,7 +160,7 @@ impl<E> LocalFunctor for ResultClass<E> {
     }
 }
 
-impl<E> Fail<E> for ResultClass<E> {
+impl<E> Fail<E> for ResultInstance<E> {
     fn fail<'a, A: 'a>(e: E) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -185,9 +185,9 @@ impl<'a, A: 'a, E0: 'a> ResultExt<'a, A, E0> for Result<A, E0> {
 }
 
 impl MonadFailAny for ResultFailAny {
-    type W<E> = ResultClass<E>;
+    type W<E> = ResultInstance<E>;
 
-    type T = classes::solo::SoloClass;
+    type T = instances::solo::SoloInstance;
 
     fn map_err<'a, A: 'a, E0: 'a, E1: 'a>(
         wa: <Self::W<E0> as WeakFunctor>::F<'a, A>,
@@ -254,7 +254,7 @@ impl MonadFailAny for ResultFailAny {
 pub struct ResultFailOver<T: Monad>(T);
 
 impl<T: Monad> MonadFailAny for ResultFailOver<T> {
-    type W<E> = super::composition::CompositionClass<T, ResultClass<E>>;
+    type W<E> = super::composition::CompositionInstance<T, ResultInstance<E>>;
 
     type T = T;
 
diff --git a/src/func/classes/solo.rs b/src/func/instances/solo.rs
similarity index 84%
rename from src/func/classes/solo.rs
rename to src/func/instances/solo.rs
index 97bf8ca..8641e48 100644
--- a/src/func/classes/solo.rs
+++ b/src/func/instances/solo.rs
@@ -5,13 +5,13 @@
 use crate::func::*;
 
 #[derive(SharedFunctor, CovariantFunctor)]
-pub struct SoloClass;
+pub struct SoloInstance;
 
-impl WeakFunctor for SoloClass {
+impl WeakFunctor for SoloInstance {
     type F<'a, A: 'a> = A;
 }
 
-impl Functor for SoloClass {
+impl Functor for SoloInstance {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B> {
         f(fa)
     }
@@ -26,13 +26,13 @@ impl Functor for SoloClass {
     }
 }
 
-impl Pure for SoloClass {
+impl Pure for SoloInstance {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
         a
     }
 }
 
-impl ApplicativeSeq for SoloClass {
+impl ApplicativeSeq for SoloInstance {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -41,7 +41,7 @@ impl ApplicativeSeq for SoloClass {
     }
 }
 
-impl ApplicativeLA2 for SoloClass {
+impl ApplicativeLA2 for SoloInstance {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -51,7 +51,7 @@ impl ApplicativeLA2 for SoloClass {
     }
 }
 
-impl ApplicativeTuple for SoloClass {
+impl ApplicativeTuple for SoloInstance {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -60,9 +60,9 @@ impl ApplicativeTuple for SoloClass {
     }
 }
 
-impl ApplicativeSelect for SoloClass {}
+impl ApplicativeSelect for SoloInstance {}
 
-impl Applicative for SoloClass {
+impl Applicative for SoloInstance {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B> {
         drop(fa);
         fb
@@ -74,7 +74,7 @@ impl Applicative for SoloClass {
     }
 }
 
-impl Monad for SoloClass {
+impl Monad for SoloInstance {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -99,7 +99,7 @@ impl Monad for SoloClass {
     }
 }
 
-impl LocalFunctor for SoloClass {
+impl LocalFunctor for SoloInstance {
     fn unstuff<'a, A: 'a, B: 'a>(
         state: Self::F<'a, ControlFlow<B, A>>,
     ) -> ControlFlow<Self::F<'a, B>, A>
@@ -117,7 +117,7 @@ impl LocalFunctor for SoloClass {
     }
 }
 
-impl Fail<std::convert::Infallible> for SoloClass {
+impl Fail<std::convert::Infallible> for SoloInstance {
     fn fail<'a, A: 'a>(e: std::convert::Infallible) -> Self::F<'a, A>
     where
         Self: 'a,
diff --git a/src/func/classes/stackless.rs b/src/func/instances/stackless.rs
similarity index 95%
rename from src/func/classes/stackless.rs
rename to src/func/instances/stackless.rs
index 64a7bfe..7ae2e90 100644
--- a/src/func/classes/stackless.rs
+++ b/src/func/instances/stackless.rs
@@ -117,13 +117,13 @@ impl<'a, A: 'a> From<A> for Stackless<'a, A> {
     }
 }
 
-pub struct StacklessClass;
+pub struct StacklessInstance;
 
-impl WeakFunctor for StacklessClass {
+impl WeakFunctor for StacklessInstance {
     type F<'a, A: 'a> = Stackless<'a, A>;
 }
 
-impl Functor for StacklessClass {
+impl Functor for StacklessInstance {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -147,13 +147,13 @@ impl Functor for StacklessClass {
     }
 }
 
-impl Pure for StacklessClass {
+impl Pure for StacklessInstance {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A> {
         Stackless::from(a)
     }
 }
 
-impl ApplicativeSeq for StacklessClass {
+impl ApplicativeSeq for StacklessInstance {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -165,7 +165,7 @@ impl ApplicativeSeq for StacklessClass {
     }
 }
 
-impl ApplicativeLA2 for StacklessClass {
+impl ApplicativeLA2 for StacklessInstance {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -178,7 +178,7 @@ impl ApplicativeLA2 for StacklessClass {
     }
 }
 
-impl ApplicativeTuple for StacklessClass {
+impl ApplicativeTuple for StacklessInstance {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -187,9 +187,9 @@ impl ApplicativeTuple for StacklessClass {
     }
 }
 
-impl ApplicativeSelect for StacklessClass {}
+impl ApplicativeSelect for StacklessInstance {}
 
-impl Applicative for StacklessClass {
+impl Applicative for StacklessInstance {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -215,7 +215,7 @@ impl Applicative for StacklessClass {
     }
 }
 
-impl Monad for StacklessClass {
+impl Monad for StacklessInstance {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -263,7 +263,7 @@ impl Monad for StacklessClass {
 mod stackless_test {
     use super::{test_suite, tests, Stackless};
 
-    use super::StacklessClass as T;
+    use super::StacklessInstance as T;
 
     impl tests::Eqr for T {
         fn eqr<'a, A: PartialEq + std::fmt::Debug + 'a>(
diff --git a/src/func/classes/tryfuture.rs b/src/func/instances/tryfuture.rs
similarity index 89%
rename from src/func/classes/tryfuture.rs
rename to src/func/instances/tryfuture.rs
index 0bbcb57..d2a91e9 100644
--- a/src/func/classes/tryfuture.rs
+++ b/src/func/instances/tryfuture.rs
@@ -8,13 +8,13 @@ use futures::{
 use crate::func::*;
 
 #[derive(CovariantFunctor)]
-pub struct TryFutureClass<E>(E);
+pub struct TryFutureInstance<E>(E);
 
-impl<E> WeakFunctor for TryFutureClass<E> {
+impl<E> WeakFunctor for TryFutureInstance<E> {
     type F<'a, A: 'a> = Pin<Box<dyn 'a + Future<Output = Result<A, E>>>> where Self: 'a;
 }
 
-impl<E> Functor for TryFutureClass<E> {
+impl<E> Functor for TryFutureInstance<E> {
     fn fmap<'a, A: 'a, B: 'a>(f: impl 'a + FnOnce(A) -> B, fa: Self::F<'a, A>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -33,7 +33,7 @@ impl<E> Functor for TryFutureClass<E> {
     }
 }
 
-impl<E> Pure for TryFutureClass<E> {
+impl<E> Pure for TryFutureInstance<E> {
     fn pure<'a, A: 'a>(a: A) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -42,7 +42,7 @@ impl<E> Pure for TryFutureClass<E> {
     }
 }
 
-impl<E> ApplicativeSeq for TryFutureClass<E> {
+impl<E> ApplicativeSeq for TryFutureInstance<E> {
     fn seq<'a, A: 'a, B: 'a>(
         ff: Self::F<'a, impl 'a + FnOnce(A) -> B>,
         fa: Self::F<'a, A>,
@@ -57,7 +57,7 @@ impl<E> ApplicativeSeq for TryFutureClass<E> {
     }
 }
 
-impl<E> ApplicativeLA2 for TryFutureClass<E> {
+impl<E> ApplicativeLA2 for TryFutureInstance<E> {
     fn la2<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(A, B) -> C,
         fa: Self::F<'a, A>,
@@ -73,7 +73,7 @@ impl<E> ApplicativeLA2 for TryFutureClass<E> {
     }
 }
 
-impl<E> ApplicativeTuple for TryFutureClass<E> {
+impl<E> ApplicativeTuple for TryFutureInstance<E> {
     fn tuple<'a, A: 'a, B: 'a>((fa, fb): (Self::F<'a, A>, Self::F<'a, B>)) -> Self::F<'a, (A, B)>
     where
         Self: 'a,
@@ -82,7 +82,7 @@ impl<E> ApplicativeTuple for TryFutureClass<E> {
     }
 }
 
-impl<E> ApplicativeSelect for TryFutureClass<E> {
+impl<E> ApplicativeSelect for TryFutureInstance<E> {
     fn select<'a, A: 'a, B: 'a, C: 'a>(
         f: impl 'a + FnOnce(Selected<'a, A, B, Self>) -> C,
         fa: Self::F<'a, A>,
@@ -102,7 +102,7 @@ impl<E> ApplicativeSelect for TryFutureClass<E> {
     }
 }
 
-impl<E> Applicative for TryFutureClass<E> {
+impl<E> Applicative for TryFutureInstance<E> {
     fn discard_first<'a, A: 'a, B: 'a>(fa: Self::F<'a, A>, fb: Self::F<'a, B>) -> Self::F<'a, B>
     where
         Self: 'a,
@@ -118,7 +118,7 @@ impl<E> Applicative for TryFutureClass<E> {
     }
 }
 
-impl<E> Monad for TryFutureClass<E> {
+impl<E> Monad for TryFutureInstance<E> {
     fn bind<'a, A: 'a, B: 'a>(
         fa: Self::F<'a, A>,
         f: impl 'a + FnOnce(A) -> Self::F<'a, B>,
@@ -151,7 +151,7 @@ impl<E> Monad for TryFutureClass<E> {
     }
 }
 
-impl<E: Clone> SharedFunctor for TryFutureClass<E> {
+impl<E: Clone> SharedFunctor for TryFutureInstance<E> {
     type Shared<'a, A: 'a + Clone> = Shared<Pin<Box<dyn 'a + Future<Output = Result<A, E>>>>>
     where
         Self: 'a;
@@ -171,7 +171,7 @@ impl<E: Clone> SharedFunctor for TryFutureClass<E> {
     }
 }
 
-impl<E> Fail<E> for TryFutureClass<E> {
+impl<E> Fail<E> for TryFutureInstance<E> {
     fn fail<'a, A: 'a>(e: E) -> Self::F<'a, A>
     where
         Self: 'a,
@@ -184,9 +184,9 @@ impl<E> Fail<E> for TryFutureClass<E> {
 pub struct FutureFailAny;
 
 impl MonadFailAny for FutureFailAny {
-    type W<E> = TryFutureClass<E>;
+    type W<E> = TryFutureInstance<E>;
 
-    type T = classes::future::FutureClass;
+    type T = instances::future::FutureInstance;
 
     fn map_err<'a, A: 'a, E0: 'a, E1: 'a>(
         wa: <Self::W<E0> as WeakFunctor>::F<'a, A>,
diff --git a/src/rstd/tracing.rs b/src/rstd/tracing.rs
index becc9ad..aebba60 100644
--- a/src/rstd/tracing.rs
+++ b/src/rstd/tracing.rs
@@ -22,9 +22,9 @@ pub use self::traced::*;
 pub struct TracedDiagnostic;
 
 /// Implementation of [`Monad`] for [Traced] objects.
-pub type TracedClass = classes::effect::EffectClass<TraceBox>;
+pub type TracedInstance = instances::effect::EffectInstance<TraceBox>;
 
-impl classes::effect::Effect for TraceBox {
+impl instances::effect::Effect for TraceBox {
     fn e_pure() -> Self {
         TraceBox::pure()
     }
@@ -86,7 +86,7 @@ impl<A> Traced<A> {
     }
 }
 
-impl Diagnostic<TracedClass> for TracedDiagnostic {
+impl Diagnostic<TracedInstance> for TracedDiagnostic {
     fn after<'a: 'b, 'b, A>(fa: Traced<A>, event: impl FnOnce() -> String) -> Traced<A> {
         fa.after(TraceBox::event(event()))
     }
diff --git a/src/rstd/tracing/traceable.rs b/src/rstd/tracing/traceable.rs
index 6bdcef5..a8a2515 100644
--- a/src/rstd/tracing/traceable.rs
+++ b/src/rstd/tracing/traceable.rs
@@ -6,15 +6,15 @@ struct TracedResolver<'a, Ctx: 'a + Context> {
     resolver: Rc<dyn Resolver<'a, Ctx>>,
 }
 
-impl<'a, Ctx: 'a + Context<T = TracedClass>> TracedResolver<'a, Ctx> {
+impl<'a, Ctx: 'a + Context<T = TracedInstance>> TracedResolver<'a, Ctx> {
     fn wrap(resolver: Rc<dyn Resolver<'a, Ctx>>) -> Rc<dyn Resolver<'a, Ctx>> {
         Rc::new(Self { resolver })
     }
 }
 
-impl<'a, Ctx: 'a + Context<T = TracedClass>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
+impl<'a, Ctx: 'a + Context<T = TracedInstance>> Resolver<'a, Ctx> for TracedResolver<'a, Ctx> {
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, Ctx> {
-        TracedClass::fmap(
+        TracedInstance::fmap(
             |resolved| {
                 let (src, resolver) = resolved?;
                 let delayed: Rc<dyn Resolver<'a, Ctx>> = Rc::new(TracedResolver { resolver });
@@ -27,7 +27,9 @@ impl<'a, Ctx: 'a + Context<T = TracedClass>> Resolver<'a, Ctx> for TracedResolve
 }
 
 /// Extension trait to trace the evaluation flow.
-pub trait Traceable<'a, Ctx: 'a + Context<T = TracedClass>>: Mentionable<'a, Ctx> + Sized {
+pub trait Traceable<'a, Ctx: 'a + Context<T = TracedInstance>>:
+    Mentionable<'a, Ctx> + Sized
+{
     /// Re-cast the value, adding an extra[^extra]
     /// note ([`RenderedCommon::Resolution`]) to the trace on each resolution.
     ///
@@ -36,7 +38,7 @@ pub trait Traceable<'a, Ctx: 'a + Context<T = TracedClass>>: Mentionable<'a, Ctx
     fn trace(self: Rc<Self>) -> CastResult<'a, Ctx, Self>;
 }
 
-impl<'a, Ctx: 'a + Context<T = TracedClass>, A: Mentionable<'a, Ctx>> Traceable<'a, Ctx> for A
+impl<'a, Ctx: 'a + Context<T = TracedInstance>, A: Mentionable<'a, Ctx>> Traceable<'a, Ctx> for A
 where
     Ctx::LookupError<'a>: From<CastError<'a>>,
 {
diff --git a/src/rstd/tracing/traced.rs b/src/rstd/tracing/traced.rs
index 45d8511..5268bf9 100644
--- a/src/rstd/tracing/traced.rs
+++ b/src/rstd/tracing/traced.rs
@@ -3,4 +3,4 @@ use super::*;
 /// Wrapper containing the value and the corresponding execution trace.
 ///
 /// For what the trace contains, see its rendered form, [`RenderedAny`].
-pub type Traced<A> = classes::effect::WithEffect<A, TraceBox>;
+pub type Traced<A> = instances::effect::WithEffect<A, TraceBox>;
diff --git a/src/testing.rs b/src/testing.rs
index d82c4a4..3bf99bb 100644
--- a/src/testing.rs
+++ b/src/testing.rs
@@ -67,9 +67,9 @@ impl<'a> Display for TestLookupError<'a> {
 impl<'a> Error for TestLookupError<'a> {}
 
 impl Context for TestContextPlain {
-    type T = classes::solo::SoloClass;
+    type T = instances::solo::SoloInstance;
 
-    type Fallible = classes::result::ResultFailAny;
+    type Fallible = instances::result::ResultFailAny;
 
     type D = NoDiagnostic;
 
diff --git a/src/testing/counted.rs b/src/testing/counted.rs
index 511ffad..71d8903 100644
--- a/src/testing/counted.rs
+++ b/src/testing/counted.rs
@@ -9,9 +9,9 @@ use super::*;
 pub struct TestContextCounted;
 
 impl Context for TestContextCounted {
-    type T = CountedClass;
+    type T = CountedInstance;
 
-    type Fallible = classes::result::ResultFailOver<Self::T>;
+    type Fallible = instances::result::ResultFailOver<Self::T>;
 
     type D = NoDiagnostic;
 
@@ -22,9 +22,9 @@ impl Context for TestContextCounted {
     }
 }
 
-pub type CountedClass = classes::effect::EffectClass<usize>;
+pub type CountedInstance = instances::effect::EffectInstance<usize>;
 
-impl classes::effect::Effect for usize {
+impl instances::effect::Effect for usize {
     fn e_pure() -> Self {
         0
     }
@@ -38,7 +38,7 @@ impl classes::effect::Effect for usize {
     }
 }
 
-pub type Counted<A> = classes::effect::WithEffect<A, usize>;
+pub type Counted<A> = instances::effect::WithEffect<A, usize>;
 
 impl<A> Counted<A> {
     fn add(self, n: usize) -> Self {
@@ -67,7 +67,7 @@ impl<'a> CountedResolver<'a> {
 
 impl<'a> Resolver<'a, TestContextCounted> for CountedResolver<'a> {
     fn resolve(self: Rc<Self>, address: Address) -> HashResolution<'a, TestContextCounted> {
-        CountedClass::fmap(
+        CountedInstance::fmap(
             |resolved| {
                 let (src, resolver) = resolved?;
                 let delayed: Rc<dyn Resolver<'a, TestContextCounted>> =
diff --git a/src/testing/traced.rs b/src/testing/traced.rs
index 094484f..31fccd2 100644
--- a/src/testing/traced.rs
+++ b/src/testing/traced.rs
@@ -6,9 +6,9 @@ use super::*;
 pub struct TestContextTraced;
 
 impl Context for TestContextTraced {
-    type T = TracedClass;
+    type T = TracedInstance;
 
-    type Fallible = classes::result::ResultFailOver<Self::T>;
+    type Fallible = instances::result::ResultFailOver<Self::T>;
 
     type D = TracedDiagnostic;