diff --git a/src/halves/cached.rs b/src/halves/cached.rs
index 2f94b29..fb8c14f 100644
--- a/src/halves/cached.rs
+++ b/src/halves/cached.rs
@@ -1,56 +1,36 @@
-use super::{
-    direct::Obs,
-    frozen::{FrozenCons, FrozenProd},
-};
+use super::{direct::Obs, frozen::FrozenWrap};
 use crate::{
     rb::traits::{RbRef, ToRbRef},
-    traits::{Consumer, Observe, Observer, Producer},
+    traits::{Consumer, Observer, Producer},
 };
 use core::{fmt, mem::MaybeUninit, num::NonZeroUsize};
 #[cfg(feature = "std")]
 use std::io;
 
-/// Caching producer of ring buffer.
-pub struct CachingProd<R: RbRef> {
-    frozen: FrozenProd<R>,
+/// Caching wrapper of ring buffer.
+pub struct CachingWrap<R: RbRef, const P: bool, const C: bool> {
+    frozen: FrozenWrap<R, P, C>,
 }
 
-/// Caching consumer of ring buffer.
-pub struct CachingCons<R: RbRef> {
-    frozen: FrozenCons<R>,
-}
+pub type CachingProd<R> = CachingWrap<R, true, false>;
+pub type CachingCons<R> = CachingWrap<R, false, true>;
 
-impl<R: RbRef> CachingProd<R> {
+impl<R: RbRef, const P: bool, const C: bool> CachingWrap<R, P, C> {
     /// # Safety
     ///
     /// There must be no more than one consumer wrapper.
-    pub unsafe fn new(ref_: R) -> Self {
+    pub unsafe fn new(rb: R) -> Self {
         Self {
-            frozen: FrozenProd::new(ref_),
+            frozen: FrozenWrap::new(rb),
         }
     }
-}
-impl<R: RbRef> ToRbRef for CachingProd<R> {
-    type RbRef = R;
 
-    fn rb_ref(&self) -> &R {
-        self.frozen.rb_ref()
-    }
-    fn into_rb_ref(self) -> R {
-        self.frozen.into_rb_ref()
-    }
-}
-impl<R: RbRef> CachingCons<R> {
-    /// # Safety
-    ///
-    /// There must be no more than one consumer wrapper.
-    pub unsafe fn new(ref_: R) -> Self {
-        Self {
-            frozen: FrozenCons::new(ref_),
-        }
+    pub fn observe(&self) -> Obs<R> {
+        self.frozen.observe()
     }
 }
-impl<R: RbRef> ToRbRef for CachingCons<R> {
+
+impl<R: RbRef, const P: bool, const C: bool> ToRbRef for CachingWrap<R, P, C> {
     type RbRef = R;
 
     fn rb_ref(&self) -> &R {
@@ -61,30 +41,7 @@ impl<R: RbRef> ToRbRef for CachingCons<R> {
     }
 }
 
-impl<R: RbRef> Observer for CachingProd<R> {
-    type Item = <R::Target as Observer>::Item;
-
-    #[inline]
-    fn capacity(&self) -> NonZeroUsize {
-        self.frozen.capacity()
-    }
-
-    #[inline]
-    fn read_index(&self) -> usize {
-        self.frozen.fetch();
-        self.frozen.read_index()
-    }
-    #[inline]
-    fn write_index(&self) -> usize {
-        self.frozen.write_index()
-    }
-
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>]) {
-        self.frozen.unsafe_slices(start, end)
-    }
-}
-
-impl<R: RbRef> Observer for CachingCons<R> {
+impl<R: RbRef, const P: bool, const C: bool> Observer for CachingWrap<R, P, C> {
     type Item = <R::Target as Observer>::Item;
 
     #[inline]
@@ -94,11 +51,16 @@ impl<R: RbRef> Observer for CachingCons<R> {
 
     #[inline]
     fn read_index(&self) -> usize {
+        if P {
+            self.frozen.fetch();
+        }
         self.frozen.read_index()
     }
     #[inline]
     fn write_index(&self) -> usize {
-        self.frozen.fetch();
+        if C {
+            self.frozen.fetch();
+        }
         self.frozen.write_index()
     }
 
@@ -175,16 +137,3 @@ where
         <Self as Consumer>::read(self, buf)
     }
 }
-
-impl<R: RbRef> Observe for CachingProd<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        self.frozen.observe()
-    }
-}
-impl<R: RbRef> Observe for CachingCons<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        self.frozen.observe()
-    }
-}
diff --git a/src/halves/direct.rs b/src/halves/direct.rs
index 908a015..6338649 100644
--- a/src/halves/direct.rs
+++ b/src/halves/direct.rs
@@ -1,65 +1,42 @@
 use crate::{
     rb::traits::{RbRef, ToRbRef},
-    traits::{consumer::Consumer, observer::Observe, producer::Producer, Observer},
+    traits::{consumer::Consumer, producer::Producer, Observer},
 };
 use core::{fmt, mem::MaybeUninit, num::NonZeroUsize};
 #[cfg(feature = "std")]
 use std::io;
 
-/// Observer of ring buffer.
-#[derive(Clone)]
-pub struct Obs<R: RbRef> {
+pub struct Wrap<R: RbRef, const P: bool, const C: bool> {
     rb: R,
 }
+
+/// Observer of ring buffer.
+pub type Obs<R> = Wrap<R, false, false>;
 /// Producer of ring buffer.
-pub struct Prod<R: RbRef> {
-    rb: R,
-}
+pub type Prod<R> = Wrap<R, true, false>;
 /// Consumer of ring buffer.
-pub struct Cons<R: RbRef> {
-    rb: R,
-}
+pub type Cons<R> = Wrap<R, false, true>;
 
-impl<R: RbRef> Obs<R> {
-    pub fn new(rb: R) -> Self {
-        Self { rb }
-    }
-}
-impl<R: RbRef> Prod<R> {
-    /// # Safety
-    ///
-    /// There must be no more than one consumer wrapper.
-    pub unsafe fn new(rb: R) -> Self {
-        Self { rb }
+impl<R: RbRef> Clone for Obs<R> {
+    fn clone(&self) -> Self {
+        Self { rb: self.rb.clone() }
     }
 }
-impl<R: RbRef> Cons<R> {
+
+impl<R: RbRef, const P: bool, const C: bool> Wrap<R, P, C> {
     /// # Safety
     ///
-    /// There must be no more than one consumer wrapper.
+    /// There must be no more than one wrapper with the same parameter being `true`.
     pub unsafe fn new(rb: R) -> Self {
         Self { rb }
     }
-}
-impl<R: RbRef> ToRbRef for Obs<R> {
-    type RbRef = R;
-    fn rb_ref(&self) -> &R {
-        &self.rb
-    }
-    fn into_rb_ref(self) -> R {
-        self.rb
-    }
-}
-impl<R: RbRef> ToRbRef for Prod<R> {
-    type RbRef = R;
-    fn rb_ref(&self) -> &R {
-        &self.rb
-    }
-    fn into_rb_ref(self) -> R {
-        self.rb
+
+    pub fn observe(&self) -> Obs<R> {
+        Obs { rb: self.rb.clone() }
     }
 }
-impl<R: RbRef> ToRbRef for Cons<R> {
+
+impl<R: RbRef, const P: bool, const C: bool> ToRbRef for Wrap<R, P, C> {
     type RbRef = R;
     fn rb_ref(&self) -> &R {
         &self.rb
@@ -69,7 +46,7 @@ impl<R: RbRef> ToRbRef for Cons<R> {
     }
 }
 
-impl<R: RbRef> Observer for Obs<R> {
+impl<R: RbRef, const P: bool, const C: bool> Observer for Wrap<R, P, C> {
     type Item = <R::Target as Observer>::Item;
 
     #[inline]
@@ -85,49 +62,7 @@ impl<R: RbRef> Observer for Obs<R> {
         self.rb().write_index()
     }
     #[inline]
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
-        self.rb().unsafe_slices(start, end)
-    }
-}
-
-impl<R: RbRef> Observer for Prod<R> {
-    type Item = <R::Target as Observer>::Item;
-
-    #[inline]
-    fn capacity(&self) -> NonZeroUsize {
-        self.rb().capacity()
-    }
-    #[inline]
-    fn read_index(&self) -> usize {
-        self.rb().read_index()
-    }
-    #[inline]
-    fn write_index(&self) -> usize {
-        self.rb().write_index()
-    }
-    #[inline]
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
-        self.rb().unsafe_slices(start, end)
-    }
-}
-
-impl<R: RbRef> Observer for Cons<R> {
-    type Item = <R::Target as Observer>::Item;
-
-    #[inline]
-    fn capacity(&self) -> NonZeroUsize {
-        self.rb().capacity()
-    }
-    #[inline]
-    fn read_index(&self) -> usize {
-        self.rb().read_index()
-    }
-    #[inline]
-    fn write_index(&self) -> usize {
-        self.rb().write_index()
-    }
-    #[inline]
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [core::mem::MaybeUninit<Self::Item>]) {
+    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>]) {
         self.rb().unsafe_slices(start, end)
     }
 }
@@ -176,22 +111,3 @@ where
         <Self as Consumer>::read(self, buf)
     }
 }
-
-impl<R: RbRef> Observe for Obs<R> {
-    type Obs = Self;
-    fn observe(&self) -> Self::Obs {
-        self.clone()
-    }
-}
-impl<R: RbRef> Observe for Prod<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        Obs::new(self.rb.clone())
-    }
-}
-impl<R: RbRef> Observe for Cons<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        Obs::new(self.rb.clone())
-    }
-}
diff --git a/src/halves/frozen.rs b/src/halves/frozen.rs
index 83111ea..014c1a7 100644
--- a/src/halves/frozen.rs
+++ b/src/halves/frozen.rs
@@ -1,9 +1,9 @@
 #![allow(dead_code)]
 
-use super::direct::{Cons, Obs, Prod};
+use super::direct::Obs;
 use crate::{
     rb::traits::{RbRef, ToRbRef},
-    traits::{Consumer, Observe, Observer, Producer},
+    traits::{Consumer, Observer, Producer},
 };
 use core::{
     cell::Cell,
@@ -15,11 +15,7 @@ use core::{
 #[cfg(feature = "std")]
 use std::io;
 
-/// Frozen read end of some ring buffer.
-///
-/// A free space of removed items is not visible for an opposite write end until [`Self::commit`]/[`Self::sync`] is called or `Self` is dropped.
-/// Items inserted by an opposite write end is not visible for `Self` until [`Self::sync`] is called.
-pub struct FrozenCons<R: RbRef> {
+pub struct FrozenWrap<R: RbRef, const P: bool, const C: bool> {
     rb: R,
     read: Cell<usize>,
     write: Cell<usize>,
@@ -29,83 +25,15 @@ pub struct FrozenCons<R: RbRef> {
 ///
 /// Inserted items is not visible for an opposite write end until [`Self::commit`]/[`Self::sync`] is called or `Self` is dropped.
 /// A free space of items removed by an opposite write end is not visible for `Self` until [`Self::sync`] is called.
-pub struct FrozenProd<R: RbRef> {
-    rb: R,
-    read: Cell<usize>,
-    write: Cell<usize>,
-}
-
-impl<R: RbRef> Observer for FrozenCons<R> {
-    type Item = <R::Target as Observer>::Item;
-
-    #[inline]
-    fn capacity(&self) -> NonZeroUsize {
-        self.rb().capacity()
-    }
-
-    #[inline]
-    fn read_index(&self) -> usize {
-        self.read.get()
-    }
-    #[inline]
-    fn write_index(&self) -> usize {
-        self.write.get()
-    }
-
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>]) {
-        self.rb().unsafe_slices(start, end)
-    }
-}
-
-impl<R: RbRef> Observer for FrozenProd<R> {
-    type Item = <R::Target as Observer>::Item;
-
-    #[inline]
-    fn capacity(&self) -> NonZeroUsize {
-        self.rb().capacity()
-    }
+pub type FrozenProd<R> = FrozenWrap<R, true, false>;
 
-    #[inline]
-    fn read_index(&self) -> usize {
-        self.read.get()
-    }
-    #[inline]
-    fn write_index(&self) -> usize {
-        self.write.get()
-    }
-
-    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>]) {
-        self.rb().unsafe_slices(start, end)
-    }
-}
-
-impl<R: RbRef> Consumer for FrozenCons<R> {
-    #[inline]
-    unsafe fn set_read_index(&self, value: usize) {
-        self.read.set(value);
-    }
-}
-
-impl<R: RbRef> Producer for FrozenProd<R> {
-    #[inline]
-    unsafe fn set_write_index(&self, value: usize) {
-        self.write.set(value);
-    }
-}
-
-impl<R: RbRef> Drop for FrozenCons<R> {
-    fn drop(&mut self) {
-        self.commit();
-    }
-}
-
-impl<R: RbRef> Drop for FrozenProd<R> {
-    fn drop(&mut self) {
-        self.commit();
-    }
-}
+/// Frozen read end of some ring buffer.
+///
+/// A free space of removed items is not visible for an opposite write end until [`Self::commit`]/[`Self::sync`] is called or `Self` is dropped.
+/// Items inserted by an opposite write end is not visible for `Self` until [`Self::sync`] is called.
+pub type FrozenCons<R> = FrozenWrap<R, false, true>;
 
-impl<R: RbRef> FrozenCons<R> {
+impl<R: RbRef, const P: bool, const C: bool> FrozenWrap<R, P, C> {
     /// Create new ring buffer cache.
     ///
     /// # Safety
@@ -118,26 +46,13 @@ impl<R: RbRef> FrozenCons<R> {
             rb,
         }
     }
-    /// Commit and destroy `Self` returning underlying consumer.
-    pub fn release(self) -> Cons<R> {
-        unsafe { Cons::new(self.into_rb_ref()) }
-    }
 
-    /// Commit changes to the ring buffer.
-    pub fn commit(&self) {
-        unsafe { self.rb().set_read_index(self.read.get()) }
-    }
-    /// Fetch changes from the ring buffer.
-    pub fn fetch(&self) {
-        self.write.set(self.rb().write_index());
-    }
-    /// Commit changes to and fetch updates from the ring buffer.
-    pub fn sync(&self) {
-        self.commit();
-        self.fetch();
+    pub fn observe(&self) -> Obs<R> {
+        unsafe { Obs::new(self.rb.clone()) }
     }
 }
-impl<R: RbRef> ToRbRef for FrozenCons<R> {
+
+impl<R: RbRef, const P: bool, const C: bool> ToRbRef for FrozenWrap<R, P, C> {
     type RbRef = R;
 
     fn rb_ref(&self) -> &R {
@@ -150,38 +65,37 @@ impl<R: RbRef> ToRbRef for FrozenCons<R> {
     }
 }
 
-impl<R: RbRef> FrozenProd<R> {
-    /// Create new ring buffer cache.
-    ///
-    /// # Safety
-    ///
-    /// There must be only one instance containing the same ring buffer reference.
-    pub unsafe fn new(rb: R) -> Self {
-        Self {
-            read: Cell::new(rb.deref().read_index()),
-            write: Cell::new(rb.deref().write_index()),
-            rb,
-        }
-    }
-    /// Commit and destroy `Self` returning underlying producer.
-    pub fn release(self) -> Prod<R> {
-        unsafe { Prod::new(self.into_rb_ref()) }
-    }
-
+impl<R: RbRef, const P: bool, const C: bool> FrozenWrap<R, P, C> {
     /// Commit changes to the ring buffer.
     pub fn commit(&self) {
-        unsafe { self.rb().set_write_index(self.write.get()) }
+        unsafe {
+            if P {
+                self.rb().set_write_index(self.write.get());
+            }
+            if C {
+                self.rb().set_read_index(self.read.get());
+            }
+        }
     }
+
     /// Fetch changes from the ring buffer.
     pub fn fetch(&self) {
-        self.read.set(self.rb().read_index());
+        if P {
+            self.read.set(self.rb().read_index());
+        }
+        if C {
+            self.write.set(self.rb().write_index());
+        }
     }
+
     /// Commit changes to and fetch updates from the ring buffer.
     pub fn sync(&self) {
         self.commit();
         self.fetch();
     }
+}
 
+impl<R: RbRef> FrozenProd<R> {
     /// Discard new items pushed since last sync.
     pub fn discard(&mut self) {
         let last_tail = self.rb().write_index();
@@ -192,16 +106,46 @@ impl<R: RbRef> FrozenProd<R> {
         self.write.set(last_tail);
     }
 }
-impl<R: RbRef> ToRbRef for FrozenProd<R> {
-    type RbRef = R;
 
-    fn rb_ref(&self) -> &R {
-        &self.rb
+impl<R: RbRef, const P: bool, const C: bool> Observer for FrozenWrap<R, P, C> {
+    type Item = <R::Target as Observer>::Item;
+
+    #[inline]
+    fn capacity(&self) -> NonZeroUsize {
+        self.rb().capacity()
     }
-    fn into_rb_ref(self) -> R {
+
+    #[inline]
+    fn read_index(&self) -> usize {
+        self.read.get()
+    }
+    #[inline]
+    fn write_index(&self) -> usize {
+        self.write.get()
+    }
+
+    unsafe fn unsafe_slices(&self, start: usize, end: usize) -> (&mut [MaybeUninit<Self::Item>], &mut [MaybeUninit<Self::Item>]) {
+        self.rb().unsafe_slices(start, end)
+    }
+}
+
+impl<R: RbRef> Producer for FrozenProd<R> {
+    #[inline]
+    unsafe fn set_write_index(&self, value: usize) {
+        self.write.set(value);
+    }
+}
+
+impl<R: RbRef> Consumer for FrozenCons<R> {
+    #[inline]
+    unsafe fn set_read_index(&self, value: usize) {
+        self.read.set(value);
+    }
+}
+
+impl<R: RbRef, const P: bool, const C: bool> Drop for FrozenWrap<R, P, C> {
+    fn drop(&mut self) {
         self.commit();
-        let this = ManuallyDrop::new(self);
-        unsafe { ptr::read(&this.rb) }
     }
 }
 
@@ -236,16 +180,3 @@ where
         <Self as Consumer>::read(self, buf)
     }
 }
-
-impl<R: RbRef> Observe for FrozenCons<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        Obs::new(self.rb.clone())
-    }
-}
-impl<R: RbRef> Observe for FrozenProd<R> {
-    type Obs = Obs<R>;
-    fn observe(&self) -> Self::Obs {
-        Obs::new(self.rb.clone())
-    }
-}
diff --git a/src/tests/basic.rs b/src/tests/basic.rs
index dfe6520..9f19cb1 100644
--- a/src/tests/basic.rs
+++ b/src/tests/basic.rs
@@ -1,8 +1,5 @@
 use super::Rb;
-use crate::{
-    storage::Static,
-    traits::{observer::Observe, *},
-};
+use crate::{storage::Static, traits::*};
 
 fn indices(this: impl Observer) -> (usize, usize) {
     (this.read_index(), this.write_index())
diff --git a/src/traits/mod.rs b/src/traits/mod.rs
index f743399..0398c8c 100644
--- a/src/traits/mod.rs
+++ b/src/traits/mod.rs
@@ -6,7 +6,7 @@ mod split;
 mod utils;
 
 pub use consumer::Consumer;
-pub use observer::{Observe, Observer};
+pub use observer::Observer;
 pub use producer::Producer;
 pub use ring_buffer::RingBuffer;
 pub use split::{Split, SplitRef};
diff --git a/src/traits/observer.rs b/src/traits/observer.rs
index 18723e7..56742fe 100644
--- a/src/traits/observer.rs
+++ b/src/traits/observer.rs
@@ -46,8 +46,3 @@ pub trait Observer: Sized {
         self.vacant_len() == 0
     }
 }
-
-pub trait Observe {
-    type Obs: Observer;
-    fn observe(&self) -> Self::Obs;
-}