diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
index cf08c7e..f3a589a 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
@@ -58,7 +58,8 @@ impl ParsedBundle {
         }
         *mutability = FieldMutability::None;
         colon_token.get_or_insert(Token![:](ident.span()));
-        errors.unwrap_or_default(HdlAttr::parse_and_take_attr(attrs))
+        let options = errors.unwrap_or_default(HdlAttr::parse_and_take_attr(attrs));
+        options
     }
     fn parse(item: ItemStruct) -> syn::Result<Self> {
         let ItemStruct {
@@ -685,7 +686,7 @@ impl ToTokens for ParsedBundle {
                     let __retval = #mask_type_match_variant_ident {
                         #(#match_variant_body_fields)*
                     };
-                    ::fayalite::intern::Interned::into_inner(::fayalite::intern::Intern::intern_sized(__retval))
+                    ::fayalite::intern::Interned::<_>::into_inner(::fayalite::intern::Intern::intern_sized(__retval))
                 }
             }
             #[automatically_derived]
@@ -760,7 +761,7 @@ impl ToTokens for ParsedBundle {
                     let __retval = #match_variant_ident {
                         #(#match_variant_body_fields)*
                     };
-                    ::fayalite::intern::Interned::into_inner(::fayalite::intern::Intern::intern_sized(__retval))
+                    ::fayalite::intern::Interned::<_>::into_inner(::fayalite::intern::Intern::intern_sized(__retval))
                 }
             }
         }
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
index 1d16177..adddd74 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
@@ -600,7 +600,7 @@ impl ToTokens for ParsedEnum {
                 static_generics.split_for_impl();
             let static_type_body_variants =
                 Vec::from_iter(variants.iter().map(|ParsedVariant { ident, field, .. }| {
-                    if field.is_some() {
+                    if let Some(_) = field {
                         quote_spanned! {span=>
                             #ident: ::fayalite::ty::StaticType::TYPE,
                         }
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs b/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
index e36f68e..e7561fe 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_type_common.rs
@@ -1410,7 +1410,7 @@ impl ParseTypes<Path> for ParsedType {
         let mut args = None;
         let segments = Punctuated::from_iter(segments.pairs_mut().map_pair_value_mut(|segment| {
             let PathSegment { ident, arguments } = segment;
-            if args.is_some() {
+            if let Some(_) = args {
                 parser
                     .errors()
                     .error(&ident, "associated types/consts are not yet implemented");
@@ -1594,7 +1594,7 @@ impl ParseTypes<Path> for ParsedConstGenericType {
         let mut args = None;
         let segments = Punctuated::from_iter(segments.pairs_mut().map_pair_value_mut(|segment| {
             let PathSegment { ident, arguments } = segment;
-            if args.is_some() {
+            if let Some(_) = args {
                 parser
                     .errors()
                     .error(&ident, "associated types/consts are not yet implemented");
@@ -2718,7 +2718,7 @@ impl ParsedGenerics {
                             type Output = #next_target #next_type_generics;
 
                             fn index(&self, #param_token: #index_type) -> &Self::Output {
-                                ::fayalite::intern::Interned::into_inner(
+                                ::fayalite::intern::Interned::<_>::into_inner(
                                     ::fayalite::intern::Intern::intern_sized(#output_expr),
                                 )
                             }
@@ -2778,7 +2778,7 @@ impl ParsedGenerics {
                                 type Output = #next_target #next_target_args;
 
                                 fn index(&self, #param_token: #param_ident) -> &Self::Output {
-                                    ::fayalite::intern::Interned::into_inner(
+                                    ::fayalite::intern::Interned::<_>::into_inner(
                                         ::fayalite::intern::Intern::intern_sized(#output_expr),
                                     )
                                 }
@@ -2848,7 +2848,7 @@ impl ParsedGenerics {
                             type Output = #next_target #next_target_args;
 
                             fn index(&self, #param_token: __Param) -> &Self::Output {
-                                ::fayalite::intern::Interned::into_inner(
+                                ::fayalite::intern::Interned::<_>::into_inner(
                                     ::fayalite::intern::Intern::intern_sized(#output_expr),
                                 )
                             }
@@ -3554,7 +3554,7 @@ impl SplitForImpl for Generics {
         Self::TypeGenerics<'_>,
         Self::WhereClause<'_>,
     ) {
-        Generics::split_for_impl(self)
+        Generics::split_for_impl(&self)
     }
 }
 
diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs
index a3aea79..d543322 100644
--- a/crates/fayalite/src/array.rs
+++ b/crates/fayalite/src/array.rs
@@ -187,7 +187,7 @@ impl<T: Type, Len: Size> TypeWithDeref for ArrayType<T, Len> {
         let base = Expr::as_dyn_array(*this);
         let base_ty = Expr::ty(base);
         let retval = Vec::from_iter((0..base_ty.len()).map(|i| ArrayIndex::new(base, i).to_expr()));
-        Interned::into_inner(Intern::intern_sized(
+        Interned::<_>::into_inner(Intern::intern_sized(
             Len::ArrayMatch::<T>::try_from(retval)
                 .ok()
                 .expect("unreachable"),
@@ -202,7 +202,7 @@ impl<T: Type> Index<T> for ArrayWithoutGenerics {
     type Output = ArrayWithoutLen<T>;
 
     fn index(&self, element: T) -> &Self::Output {
-        Interned::into_inner(Intern::intern_sized(ArrayWithoutLen { element }))
+        Interned::<_>::into_inner(Intern::intern_sized(ArrayWithoutLen { element }))
     }
 }
 
@@ -215,6 +215,6 @@ impl<T: Type, L: SizeType> Index<L> for ArrayWithoutLen<T> {
     type Output = ArrayType<T, L::Size>;
 
     fn index(&self, len: L) -> &Self::Output {
-        Interned::into_inner(Intern::intern_sized(ArrayType::new(self.element, len)))
+        Interned::<_>::into_inner(Intern::intern_sized(ArrayType::new(self.element, len)))
     }
 }
diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs
index b338322..95c87f9 100644
--- a/crates/fayalite/src/bundle.rs
+++ b/crates/fayalite/src/bundle.rs
@@ -144,12 +144,6 @@ impl BundleTypePropertiesBuilder {
     }
 }
 
-impl Default for BundleTypePropertiesBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Bundle {
     #[track_caller]
     pub fn new(fields: Interned<[BundleField]>) -> Self {
@@ -348,7 +342,6 @@ macro_rules! impl_tuples {
                 std::iter::once(MatchVariantWithoutScope(($(Expr::field(this, stringify!($num)),)*)))
             }
             fn mask_type(&self) -> Self::MaskType {
-                #![allow(clippy::unused_unit)]
                 let ($($var,)*) = self;
                 ($($var.mask_type(),)*)
             }
@@ -357,7 +350,6 @@ macro_rules! impl_tuples {
             }
             #[track_caller]
             fn from_canonical(canonical_type: CanonicalType) -> Self {
-                #![allow(clippy::unused_unit)]
                 let CanonicalType::Bundle(bundle) = canonical_type else {
                     panic!("expected bundle");
                 };
@@ -366,7 +358,7 @@ macro_rules! impl_tuples {
                 };
                 $(let BundleField { name, flipped, ty } = $var;
                 assert_eq!(&*name, stringify!($num));
-                assert!(!flipped);
+                assert_eq!(flipped, false);
                 let $var = $T::from_canonical(ty);)*
                 ($($var,)*)
             }
@@ -385,7 +377,7 @@ macro_rules! impl_tuples {
         impl<$($T: Type,)*> TypeWithDeref for ($($T,)*) {
             fn expr_deref(this: &Expr<Self>) -> &Self::MatchVariant {
                 let _ = this;
-                Interned::into_inner(($(Expr::field(*this, stringify!($num)),)*).intern_sized())
+                Interned::<_>::into_inner(($(Expr::field(*this, stringify!($num)),)*).intern_sized())
             }
         }
         impl<$($T: StaticType,)*> StaticType for ($($T,)*) {
diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs
index 2ed0b8e..13724ef 100644
--- a/crates/fayalite/src/enum_.rs
+++ b/crates/fayalite/src/enum_.rs
@@ -169,12 +169,6 @@ impl EnumTypePropertiesBuilder {
     }
 }
 
-impl Default for EnumTypePropertiesBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
 impl Enum {
     #[track_caller]
     pub fn new(variants: Interned<[EnumVariant]>) -> Self {
@@ -405,8 +399,9 @@ impl<T: Type> HdlOption<T> {
         else {
             unreachable!();
         };
-        let value = f(value).inspect_err(|_| {
+        let value = f(value).map_err(|e| {
             and_then_out.complete(()); // avoid error
+            e
         })?;
         let and_then_out = and_then_out.complete(Expr::ty(value));
         connect(and_then_out, value);
diff --git a/crates/fayalite/src/expr/ops.rs b/crates/fayalite/src/expr/ops.rs
index 3579641..6069f20 100644
--- a/crates/fayalite/src/expr/ops.rs
+++ b/crates/fayalite/src/expr/ops.rs
@@ -2057,7 +2057,7 @@ impl<ElementType: Type, Len: Size> ExprIndex<usize> for ArrayType<ElementType, L
 
     #[track_caller]
     fn expr_index(this: &Expr<Self>, index: usize) -> &Expr<Self::Output> {
-        Interned::into_inner(
+        Interned::<_>::into_inner(
             ArrayIndex::<ElementType>::new(Expr::as_dyn_array(*this), index)
                 .to_expr()
                 .intern_sized(),
@@ -2154,7 +2154,7 @@ impl<ElementType: Type, Len: Size, Width: Size> ExprIndex<Expr<UIntType<Width>>>
     type Output = ElementType;
 
     fn expr_index(this: &Expr<Self>, index: Expr<UIntType<Width>>) -> &Expr<Self::Output> {
-        Interned::into_inner(
+        Interned::<_>::into_inner(
             DynArrayIndex::<ElementType>::new(Expr::as_dyn_array(*this), Expr::as_dyn_int(index))
                 .to_expr()
                 .intern_sized(),
@@ -2279,7 +2279,7 @@ macro_rules! impl_int_slice {
                 let base = Expr::as_dyn_int(*this);
                 let base_ty = Expr::ty(base);
                 let range = base_ty.slice_index_to_range(index);
-                Interned::into_inner($name::new(base, range).to_expr().intern_sized())
+                Interned::<_>::into_inner($name::new(base, range).to_expr().intern_sized())
             }
         }
 
@@ -2291,7 +2291,7 @@ macro_rules! impl_int_slice {
                 let base = Expr::as_dyn_int(*this);
                 let base_ty = Expr::ty(base);
                 assert!(index < base_ty.width());
-                Interned::into_inner(
+                Interned::<_>::into_inner(
                     $name::new(base, index..(index + 1))
                         .to_expr()
                         .cast_to_static::<Bool>()
diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs
index dd631d0..e0d258a 100644
--- a/crates/fayalite/src/int.rs
+++ b/crates/fayalite/src/int.rs
@@ -147,7 +147,7 @@ where
 
     fn try_from_usize(v: usize) -> Option<Self::SizeType> {
         if v == VALUE {
-            Some(ConstUsize)
+            Some(Self::SizeType::default())
         } else {
             None
         }
@@ -301,7 +301,7 @@ macro_rules! impl_int {
             type Output = $name<Width::Size>;
 
             fn index(&self, width: Width) -> &Self::Output {
-                Interned::into_inner(Intern::intern_sized($name::new(width)))
+                Interned::<_>::into_inner(Intern::intern_sized($name::new(width)))
             }
         }
 
@@ -560,7 +560,7 @@ pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed {
     }
     fn bits_to_expr(bits: Cow<'_, BitSlice>) -> Expr<Self>;
     fn le_bytes_to_expr_wrapping(bytes: &[u8], bit_width: usize) -> Expr<Self> {
-        let bitslice = BitSlice::<u8, Lsb0>::from_slice(bytes);
+        let bitslice = BitSlice::<u8, Lsb0>::from_slice(&bytes);
         let bitslice = &bitslice[..bit_width.min(bitslice.len())];
         let mut bits = BitVec::new();
         bits.extend_from_bitslice(bitslice);
diff --git a/crates/fayalite/src/intern.rs b/crates/fayalite/src/intern.rs
index 3780ad3..9bd4d56 100644
--- a/crates/fayalite/src/intern.rs
+++ b/crates/fayalite/src/intern.rs
@@ -1,7 +1,10 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 #![allow(clippy::type_complexity)]
-use crate::intern::type_map::TypeIdMap;
+use crate::{
+    intern::type_map::TypeIdMap,
+    util::{ConstBool, GenericConstBool},
+};
 use bitvec::{ptr::BitPtr, slice::BitSlice, vec::BitVec};
 use hashbrown::{hash_map::RawEntryMut, HashMap, HashTable};
 use serde::{Deserialize, Serialize};
@@ -195,6 +198,7 @@ impl<T: ?Sized + Sync + Send + 'static> LazyInterned<T> {
 pub trait InternedCompare {
     type InternedCompareKey: Ord + Hash;
     fn interned_compare_key_ref(this: &Self) -> Self::InternedCompareKey;
+    fn interned_compare_key_weak(this: &std::sync::Weak<Self>) -> Self::InternedCompareKey;
 }
 
 /// Warning: doesn't do what you want with `T = dyn Trait`,
@@ -268,6 +272,9 @@ impl<T> InternedCompare for T {
     fn interned_compare_key_ref(this: &Self) -> Self::InternedCompareKey {
         PtrEqWithMetadata(this)
     }
+    fn interned_compare_key_weak(this: &std::sync::Weak<Self>) -> Self::InternedCompareKey {
+        PtrEqWithMetadata(this.as_ptr())
+    }
 }
 
 impl<T> InternedCompare for [T] {
@@ -275,6 +282,9 @@ impl<T> InternedCompare for [T] {
     fn interned_compare_key_ref(this: &Self) -> Self::InternedCompareKey {
         PtrEqWithMetadata(this)
     }
+    fn interned_compare_key_weak(this: &std::sync::Weak<Self>) -> Self::InternedCompareKey {
+        PtrEqWithMetadata(this.as_ptr())
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -285,6 +295,9 @@ impl InternedCompare for BitSlice {
     fn interned_compare_key_ref(this: &Self) -> Self::InternedCompareKey {
         BitSlicePtrEq(this.as_bitptr(), this.len())
     }
+    fn interned_compare_key_weak(_this: &std::sync::Weak<Self>) -> Self::InternedCompareKey {
+        unreachable!("not currently implementable since Weak<BitSlice> can't be constructed")
+    }
 }
 
 impl InternedCompare for str {
@@ -292,96 +305,341 @@ impl InternedCompare for str {
     fn interned_compare_key_ref(this: &Self) -> Self::InternedCompareKey {
         PtrEqWithMetadata(this)
     }
-}
-
-pub trait Intern: Any + Send + Sync {
-    fn intern(&self) -> Interned<Self>;
-    fn intern_sized(self) -> Interned<Self>
-    where
-        Self: Clone,
-    {
-        Self::intern_owned(self)
-    }
-    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Self::intern_cow(Cow::Owned(this))
-    }
-    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        this.intern()
+    fn interned_compare_key_weak(this: &std::sync::Weak<Self>) -> Self::InternedCompareKey {
+        PtrEqWithMetadata(this.as_ptr())
     }
 }
 
-pub struct Interner<T: ?Sized + 'static + Send + Sync> {
-    map: Mutex<HashMap<&'static T, ()>>,
+pub trait InternContext: 'static + Send + Sync + Hash + Ord + fmt::Debug + Clone {
+    type InternedImpl<T: ?Sized + 'static + Send + Sync>: 'static + Send + Sync + Clone;
+    type InternedGuardImpl<T: ?Sized + 'static + Send + Sync>: 'static
+        + Send
+        + Sync
+        + Clone
+        + Borrow<T>;
+    type AllContextsAreIdentical: GenericConstBool;
+    fn interned_compare_key<T: InternedCompare + ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> T::InternedCompareKey {
+        T::interned_compare_key_ref(Self::guard(v).borrow())
+    }
+    fn guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Self::InternedGuardImpl<T>;
+    fn try_guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Option<Self::InternedGuardImpl<T>>;
+    fn into_guard<T: ?Sized + 'static + Send + Sync>(
+        v: Self::InternedImpl<T>,
+    ) -> Self::InternedGuardImpl<T> {
+        Self::guard(&v)
+    }
+    fn unguard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedGuardImpl<T>,
+    ) -> Self::InternedImpl<T>;
+    fn unguard_move<T: ?Sized + 'static + Send + Sync>(
+        v: Self::InternedGuardImpl<T>,
+    ) -> Self::InternedImpl<T> {
+        Self::unguard(&v)
+    }
+    fn alloc_str(&self, value: Cow<'_, str>) -> Self::InternedGuardImpl<str>;
+    fn alloc_slice<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, [T]>,
+    ) -> Self::InternedGuardImpl<[T]>;
+    fn alloc_sized<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, T>,
+    ) -> Self::InternedGuardImpl<T>;
+    fn interner<T: ?Sized + Send + Sync + 'static>(&self) -> &Interner<T, Self>;
 }
 
-impl<T: ?Sized + 'static + Send + Sync> Interner<T> {
-    fn get() -> &'static Interner<T> {
+pub trait BitSliceInternContext: InternContext {
+    fn alloc_bit_slice(&self, value: Cow<'_, BitSlice>) -> Self::InternedGuardImpl<BitSlice>;
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
+pub struct GlobalContext;
+
+impl InternContext for GlobalContext {
+    type InternedImpl<T: ?Sized + 'static + Send + Sync> = &'static T;
+    type InternedGuardImpl<T: ?Sized + 'static + Send + Sync> = &'static T;
+    type AllContextsAreIdentical = ConstBool<true>;
+
+    fn guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Self::InternedGuardImpl<T> {
+        *v
+    }
+    fn try_guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Option<Self::InternedGuardImpl<T>> {
+        Some(*v)
+    }
+    fn unguard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedGuardImpl<T>,
+    ) -> Self::InternedImpl<T> {
+        *v
+    }
+    fn alloc_str(&self, value: Cow<'_, str>) -> Self::InternedGuardImpl<str> {
+        value.into_owned().leak()
+    }
+    fn alloc_slice<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, [T]>,
+    ) -> Self::InternedGuardImpl<[T]> {
+        value.into_owned().leak()
+    }
+    fn alloc_sized<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, T>,
+    ) -> Self::InternedGuardImpl<T> {
+        Box::leak(Box::new(value.into_owned()))
+    }
+    fn interner<T: ?Sized + 'static + Send + Sync>(&self) -> &Interner<T, Self> {
         static TYPE_ID_MAP: TypeIdMap = TypeIdMap::new();
         TYPE_ID_MAP.get_or_insert_default()
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync> Default for Interner<T> {
+impl BitSliceInternContext for GlobalContext {
+    fn alloc_bit_slice(&self, value: Cow<'_, BitSlice>) -> Self::InternedGuardImpl<BitSlice> {
+        value.into_owned().leak()
+    }
+}
+
+#[derive(Clone)]
+pub struct AGCContext(std::sync::Arc<TypeIdMap>);
+
+impl AGCContext {
+    pub fn new() -> Self {
+        Self(std::sync::Arc::new(TypeIdMap::new()))
+    }
+}
+
+impl Default for AGCContext {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct AGCContextId(*const ());
+
+impl fmt::Debug for AGCContextId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.0.fmt(f)
+    }
+}
+
+impl AGCContext {
+    pub fn id(&self) -> AGCContextId {
+        AGCContextId(std::sync::Arc::as_ptr(&self.0).cast())
+    }
+}
+
+impl Hash for AGCContext {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.id().hash(state);
+    }
+}
+
+impl Ord for AGCContext {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.id().cmp(&other.id())
+    }
+}
+
+impl PartialOrd for AGCContext {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Eq for AGCContext {}
+
+impl PartialEq for AGCContext {
+    fn eq(&self, other: &Self) -> bool {
+        self.id().eq(&other.id())
+    }
+}
+
+impl fmt::Debug for AGCContext {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("AGCContext")
+            .field("id", &self.id())
+            .finish_non_exhaustive()
+    }
+}
+
+impl InternContext for AGCContext {
+    type InternedImpl<T: ?Sized + 'static + Send + Sync> = std::sync::Weak<T>;
+    type InternedGuardImpl<T: ?Sized + 'static + Send + Sync> = std::sync::Arc<T>;
+    type AllContextsAreIdentical = ConstBool<false>;
+
+    fn interned_compare_key<T: InternedCompare + ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> T::InternedCompareKey {
+        T::interned_compare_key_weak(v)
+    }
+    fn guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Self::InternedGuardImpl<T> {
+        v.upgrade().expect("expired")
+    }
+    fn try_guard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedImpl<T>,
+    ) -> Option<Self::InternedGuardImpl<T>> {
+        v.upgrade()
+    }
+    fn unguard<T: ?Sized + 'static + Send + Sync>(
+        v: &Self::InternedGuardImpl<T>,
+    ) -> Self::InternedImpl<T> {
+        std::sync::Arc::downgrade(v)
+    }
+    fn alloc_str(&self, value: Cow<'_, str>) -> Self::InternedGuardImpl<str> {
+        match value {
+            Cow::Borrowed(value) => value.into(),
+            Cow::Owned(value) => value.into(),
+        }
+    }
+    fn alloc_slice<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, [T]>,
+    ) -> Self::InternedGuardImpl<[T]> {
+        match value {
+            Cow::Borrowed(value) => value.into(),
+            Cow::Owned(value) => value.into(),
+        }
+    }
+    fn alloc_sized<T: Clone + Send + Sync + 'static>(
+        &self,
+        value: Cow<'_, T>,
+    ) -> Self::InternedGuardImpl<T> {
+        std::sync::Arc::new(value.into_owned())
+    }
+    fn interner<T: ?Sized + Send + Sync + 'static>(&self) -> &Interner<T, Self> {
+        self.0.get_or_insert_default()
+    }
+}
+
+pub trait Intern<C: InternContext = GlobalContext>: Any + Send + Sync {
+    fn intern_with_ctx(&self, context: &C) -> Interned<Self, C>;
+    fn intern_sized_with_ctx(self, context: &C) -> Interned<Self, C>
+    where
+        Self: Clone,
+    {
+        Self::intern_owned_with_ctx(self, context)
+    }
+    fn intern_owned_with_ctx(this: <Self as ToOwned>::Owned, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        Self::intern_cow_with_ctx(Cow::Owned(this), context)
+    }
+    fn intern_cow_with_ctx(this: Cow<'_, Self>, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        this.intern_with_ctx(context)
+    }
+    fn intern(&self) -> Interned<Self, C>
+    where
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    {
+        self.intern_with_ctx(&C::default())
+    }
+    fn intern_sized(self) -> Interned<Self, C>
+    where
+        Self: Clone,
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    {
+        self.intern_sized_with_ctx(&C::default())
+    }
+    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    {
+        Self::intern_owned_with_ctx(this, &C::default())
+    }
+    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    {
+        Self::intern_cow_with_ctx(this, &C::default())
+    }
+}
+
+pub struct Interner<T: ?Sized + 'static + Send + Sync, C: InternContext> {
+    map: Mutex<HashMap<C::InternedGuardImpl<T>, ()>>,
+    _phantom: PhantomData<fn(&C)>,
+}
+
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Default for Interner<T, C> {
     fn default() -> Self {
         Self {
             map: Default::default(),
+            _phantom: Default::default(),
         }
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + Hash + Eq + ToOwned> Interner<T> {
-    fn intern<F: FnOnce(Cow<'_, T>) -> &'static T>(
+impl<T: ?Sized + 'static + Send + Sync + Hash + Eq + ToOwned, C: InternContext> Interner<T, C> {
+    fn intern<F: FnOnce(Cow<'_, T>) -> C::InternedGuardImpl<T>>(
         &self,
         alloc: F,
         value: Cow<'_, T>,
-    ) -> Interned<T> {
+    ) -> Interned<T, C> {
         let mut map = self.map.lock().unwrap();
         let hasher = map.hasher().clone();
         let hash = hasher.hash_one(&*value);
-        let inner = match map.raw_entry_mut().from_hash(hash, |k| **k == *value) {
-            RawEntryMut::Occupied(entry) => *entry.key(),
-            RawEntryMut::Vacant(entry) => {
-                *entry
-                    .insert_with_hasher(hash, alloc(value), (), |k| hasher.hash_one(&**k))
-                    .0
-            }
+        let inner = match map
+            .raw_entry_mut()
+            .from_hash(hash, |k| k.borrow() == &*value)
+        {
+            RawEntryMut::Occupied(entry) => C::unguard(entry.key()),
+            RawEntryMut::Vacant(entry) => C::unguard(
+                entry
+                    .insert_with_hasher(hash, alloc(value), (), |k| hasher.hash_one(k.borrow()))
+                    .0,
+            ),
         };
-        Interned { inner }
+        Interned {
+            inner,
+            _phantom: PhantomData,
+        }
     }
 }
 
-impl<T: Clone + 'static + Send + Sync + Hash + Eq> Interner<T> {
-    fn intern_sized(&self, value: Cow<'_, T>) -> Interned<T> {
-        self.intern(|value| Box::leak(Box::new(value.into_owned())), value)
+impl<T: Clone + 'static + Send + Sync + Hash + Eq, C: InternContext> Interner<T, C> {
+    fn intern_sized(&self, context: &C, value: Cow<'_, T>) -> Interned<T, C> {
+        self.intern(|value| context.alloc_sized(value), value)
     }
 }
 
-impl<T: Clone + 'static + Send + Sync + Hash + Eq> Interner<[T]> {
-    fn intern_slice(&self, value: Cow<'_, [T]>) -> Interned<[T]> {
-        self.intern(|value| value.into_owned().leak(), value)
+impl<T: Clone + 'static + Send + Sync + Hash + Eq, C: InternContext> Interner<[T], C> {
+    fn intern_slice(&self, context: &C, value: Cow<'_, [T]>) -> Interned<[T], C> {
+        self.intern(|value| context.alloc_slice(value), value)
     }
 }
 
-impl Interner<BitSlice> {
-    fn intern_bit_slice(&self, value: Cow<'_, BitSlice>) -> Interned<BitSlice> {
-        self.intern(|value| value.into_owned().leak(), value)
+impl<C: BitSliceInternContext> Interner<BitSlice, C> {
+    fn intern_bit_slice(&self, context: &C, value: Cow<'_, BitSlice>) -> Interned<BitSlice, C> {
+        self.intern(|value| context.alloc_bit_slice(value), value)
     }
 }
 
-impl Interner<str> {
-    fn intern_str(&self, value: Cow<'_, str>) -> Interned<str> {
-        self.intern(|value| value.into_owned().leak(), value)
+impl<C: InternContext> Interner<str, C> {
+    fn intern_str(&self, context: &C, value: Cow<'_, str>) -> Interned<str, C> {
+        self.intern(|value| context.alloc_str(value), value)
     }
 }
 
-pub struct Interned<T: ?Sized + 'static + Send + Sync> {
-    inner: &'static T,
+pub struct Interned<T: ?Sized + 'static + Send + Sync, C: InternContext = GlobalContext> {
+    inner: C::InternedImpl<T>,
+    _phantom: PhantomData<&'static C>,
 }
 
 macro_rules! forward_fmt_trait {
@@ -392,9 +650,23 @@ macro_rules! forward_fmt_trait {
             }
         }
 
-        impl<T: ?Sized + 'static + Send + Sync + fmt::$Tr> fmt::$Tr for Interned<T> {
+        impl<T: ?Sized + 'static + Send + Sync + fmt::$Tr, C: InternContext> fmt::$Tr
+            for Interned<T, C>
+        {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-                self.inner.fmt(f)
+                if let Some(guard) = C::try_guard(&self.inner) {
+                    guard.borrow().fmt(f)
+                } else {
+                    write!(f, "<Expired>")
+                }
+            }
+        }
+
+        impl<T: ?Sized + 'static + Send + Sync + fmt::$Tr, C: InternContext> fmt::$Tr
+            for Guard<T, C>
+        {
+            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+                self.inner.borrow().fmt(f)
             }
         }
     };
@@ -410,16 +682,18 @@ forward_fmt_trait!(UpperExp);
 forward_fmt_trait!(UpperHex);
 
 #[derive(Clone, Debug)]
-pub struct InternedSliceIter<T: Clone + 'static + Send + Sync> {
-    slice: Interned<[T]>,
+pub struct InternedSliceIter<T: Clone + 'static + Send + Sync, C: InternContext> {
+    slice: Interned<[T], C>,
     index: std::ops::Range<usize>,
 }
 
-impl<T: Clone + 'static + Send + Sync> Iterator for InternedSliceIter<T> {
+impl<T: Clone + 'static + Send + Sync, C: InternContext> Iterator for InternedSliceIter<T, C> {
     type Item = T;
 
     fn next(&mut self) -> Option<Self::Item> {
-        self.index.next().map(|index| self.slice[index].clone())
+        self.index
+            .next()
+            .map(|index| self.slice.guard()[index].clone())
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -427,186 +701,233 @@ impl<T: Clone + 'static + Send + Sync> Iterator for InternedSliceIter<T> {
     }
 }
 
-impl<T: Clone + 'static + Send + Sync> DoubleEndedIterator for InternedSliceIter<T> {
+impl<T: Clone + 'static + Send + Sync, C: InternContext> DoubleEndedIterator
+    for InternedSliceIter<T, C>
+{
     fn next_back(&mut self) -> Option<Self::Item> {
         self.index
             .next_back()
-            .map(|index| self.slice[index].clone())
+            .map(|index| self.slice.guard()[index].clone())
     }
 }
 
-impl<T: Clone + 'static + Send + Sync> FusedIterator for InternedSliceIter<T> {}
+impl<T: Clone + 'static + Send + Sync, C: InternContext> FusedIterator for InternedSliceIter<T, C> {}
 
-impl<T: Clone + 'static + Send + Sync> ExactSizeIterator for InternedSliceIter<T> {}
+impl<T: Clone + 'static + Send + Sync, C: InternContext> ExactSizeIterator
+    for InternedSliceIter<T, C>
+{
+}
 
-impl<T: Clone + 'static + Send + Sync> IntoIterator for Interned<[T]> {
+impl<T: Clone + 'static + Send + Sync, C: InternContext> IntoIterator for Interned<[T], C> {
     type Item = T;
-    type IntoIter = InternedSliceIter<T>;
+    type IntoIter = InternedSliceIter<T, C>;
 
     fn into_iter(self) -> Self::IntoIter {
         InternedSliceIter {
-            index: 0..self.len(),
+            index: 0..self.guard().len(),
             slice: self,
         }
     }
 }
 
-impl<'a, T: 'static + Send + Sync> IntoIterator for &'a Interned<[T]> {
-    type Item = &'a T;
-    type IntoIter = std::slice::Iter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.inner.iter()
-    }
-}
-
-impl<'a, T: 'static + Send + Sync> IntoIterator for &'a mut Interned<[T]> {
-    type Item = &'a T;
-    type IntoIter = std::slice::Iter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        self.inner.iter()
-    }
-}
-
-impl<I: Clone> FromIterator<I> for Interned<[I]>
+impl<'a, T: 'static + Send + Sync, C: InternContext> IntoIterator for &'a Interned<[T], C>
 where
-    [I]: Intern,
+    C::InternedImpl<[T]>: Borrow<[T]>,
+{
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.borrow().iter()
+    }
+}
+
+impl<'a, T: 'static + Send + Sync, C: InternContext> IntoIterator for &'a mut Interned<[T], C>
+where
+    C::InternedImpl<[T]>: Borrow<[T]>,
+{
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.inner.borrow().iter()
+    }
+}
+
+impl<I: Clone, C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default>
+    FromIterator<I> for Interned<[I], C>
+where
+    [I]: Intern<C>,
 {
     fn from_iter<T: IntoIterator<Item = I>>(iter: T) -> Self {
         Intern::intern_owned(Vec::from_iter(iter))
     }
 }
 
-impl<T: 'static + Clone + Send + Sync> From<Interned<[T]>> for Vec<T> {
-    fn from(value: Interned<[T]>) -> Self {
-        Vec::from(&*value)
+impl<T: 'static + Clone + Send + Sync, C: InternContext> From<Interned<[T], C>> for Vec<T> {
+    fn from(value: Interned<[T], C>) -> Self {
+        Vec::from(&*value.guard())
     }
 }
 
-impl<T: 'static + Clone + Send + Sync> From<Interned<[T]>> for Box<[T]> {
-    fn from(value: Interned<[T]>) -> Self {
-        Box::from(&*value)
+impl<T: 'static + Clone + Send + Sync, C: InternContext> From<Interned<[T], C>> for Box<[T]> {
+    fn from(value: Interned<[T], C>) -> Self {
+        Box::from(&*value.guard())
     }
 }
 
-impl From<Interned<str>> for String {
-    fn from(value: Interned<str>) -> Self {
-        String::from(&*value)
+impl<C: InternContext> From<Interned<str, C>> for String {
+    fn from(value: Interned<str, C>) -> Self {
+        String::from(&*value.guard())
     }
 }
 
-impl<I> Default for Interned<[I]>
+impl<I, C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default> Default
+    for Interned<[I], C>
 where
-    [I]: Intern,
+    [I]: Intern<C>,
 {
     fn default() -> Self {
         [][..].intern()
     }
 }
 
-impl Default for Interned<str> {
+impl<C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default> Default
+    for Interned<str, C>
+where
+    str: Intern<C>,
+{
     fn default() -> Self {
         "".intern()
     }
 }
 
-impl Default for Interned<BitSlice> {
+impl<C: BitSliceInternContext<AllContextsAreIdentical = ConstBool<true>> + Default> Default
+    for Interned<BitSlice, C>
+where
+    BitSlice: Intern<C>,
+{
     fn default() -> Self {
         <&BitSlice>::default().intern()
     }
 }
 
-impl<I: Clone + Default> Default for Interned<I>
+impl<I: Clone + Default, C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default>
+    Default for Interned<I, C>
 where
-    I: Intern,
+    I: Intern<C>,
 {
     fn default() -> Self {
         I::default().intern()
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync> Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Interned<T, C> {
     pub fn cast_unchecked<U: ?Sized + 'static + Send + Sync>(
         this: Self,
-        f: impl FnOnce(&'static T) -> &'static U,
-    ) -> Interned<U> {
+        f: impl FnOnce(C::InternedImpl<T>) -> C::InternedImpl<U>,
+    ) -> Interned<U, C> {
         Interned {
             inner: f(this.inner),
+            _phantom: PhantomData,
         }
     }
     pub fn try_cast_unchecked<U: ?Sized + 'static + Send + Sync, E>(
         this: Self,
-        f: impl FnOnce(&'static T) -> Result<&'static U, E>,
-    ) -> Result<Interned<U>, E> {
+        f: impl FnOnce(C::InternedImpl<T>) -> Result<C::InternedImpl<U>, E>,
+    ) -> Result<Interned<U, C>, E> {
         Ok(Interned {
             inner: f(this.inner)?,
+            _phantom: PhantomData,
         })
     }
-    pub fn into_inner(this: Self) -> &'static T {
+    pub fn into_inner(this: Self) -> C::InternedImpl<T> {
         this.inner
     }
-    pub fn get_ref(this: &Self) -> &&'static T {
+    pub fn get_ref(this: &Self) -> &C::InternedImpl<T> {
         &this.inner
     }
-}
-
-impl<T: ?Sized + 'static + Send + Sync> Clone for Interned<T> {
-    fn clone(&self) -> Self {
-        *self
+    pub fn guard(&self) -> Guard<T, C> {
+        Guard {
+            inner: C::guard(&self.inner),
+            _phantom: PhantomData,
+        }
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync> Copy for Interned<T> where &'static T: Copy {}
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Clone for Interned<T, C> {
+    fn clone(&self) -> Self {
+        Interned {
+            inner: self.inner.clone(),
+            _phantom: PhantomData,
+        }
+    }
+}
 
-impl<T: ?Sized + 'static + Send + Sync> Deref for Interned<T>
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Copy for Interned<T, C> where
+    C::InternedImpl<T>: Copy
+{
+}
+
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Deref for Interned<T, C>
 where
-    &'static T: Borrow<T>,
+    C::InternedImpl<T>: Borrow<T>,
 {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
-        self.inner
+        self.inner.borrow()
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + InternedCompare> PartialEq for Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> PartialEq
+    for Interned<T, C>
+{
     fn eq(&self, other: &Self) -> bool {
-        T::interned_compare_key_ref(self.inner) == T::interned_compare_key_ref(other.inner)
+        <C as InternContext>::interned_compare_key(&self.inner)
+            == <C as InternContext>::interned_compare_key(&other.inner)
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + InternedCompare> Eq for Interned<T> {}
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Eq for Interned<T, C> {}
 
-impl<T: ?Sized + 'static + Send + Sync + InternedCompare> PartialOrd for Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> PartialOrd
+    for Interned<T, C>
+{
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         Some(self.cmp(other))
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + InternedCompare> Ord for Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Ord for Interned<T, C> {
     fn cmp(&self, other: &Self) -> Ordering {
-        T::interned_compare_key_ref(self.inner).cmp(&T::interned_compare_key_ref(other.inner))
+        <C as InternContext>::interned_compare_key(&self.inner)
+            .cmp(&<C as InternContext>::interned_compare_key(&other.inner))
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + InternedCompare> Hash for Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Hash
+    for Interned<T, C>
+{
     fn hash<H: Hasher>(&self, state: &mut H) {
-        T::interned_compare_key_ref(self.inner).hash(state);
+        <C as InternContext>::interned_compare_key(&self.inner).hash(state);
     }
 }
 
-impl<T: ?Sized + 'static + Send + Sync + Serialize> Serialize for Interned<T> {
+impl<T: ?Sized + 'static + Send + Sync + Serialize, C: InternContext> Serialize for Interned<T, C> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: serde::Serializer,
     {
-        T::serialize(self, serializer)
+        self.guard().serialize(serializer)
     }
 }
 
-impl<'de, T: 'static + Send + Sync + Deserialize<'de> + Clone + Intern> Deserialize<'de>
-    for Interned<T>
+impl<
+        'de,
+        T: 'static + Send + Sync + Deserialize<'de> + Clone + Intern<C>,
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    > Deserialize<'de> for Interned<T, C>
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -616,9 +937,13 @@ impl<'de, T: 'static + Send + Sync + Deserialize<'de> + Clone + Intern> Deserial
     }
 }
 
-impl<'de, T: 'static + Send + Sync + Clone> Deserialize<'de> for Interned<[T]>
+impl<
+        'de,
+        T: 'static + Send + Sync + Clone,
+        C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default,
+    > Deserialize<'de> for Interned<[T], C>
 where
-    [T]: Intern,
+    [T]: Intern<C>,
     Vec<T>: Deserialize<'de>,
 {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -629,7 +954,11 @@ where
     }
 }
 
-impl<'de> Deserialize<'de> for Interned<BitSlice> {
+impl<'de, C: BitSliceInternContext<AllContextsAreIdentical = ConstBool<true>> + Default>
+    Deserialize<'de> for Interned<BitSlice, C>
+where
+    BitSlice: Intern<C>,
+{
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -638,7 +967,11 @@ impl<'de> Deserialize<'de> for Interned<BitSlice> {
     }
 }
 
-impl<'de> Deserialize<'de> for Interned<str> {
+impl<'de, C: InternContext<AllContextsAreIdentical = ConstBool<true>> + Default> Deserialize<'de>
+    for Interned<str, C>
+where
+    str: Intern<C>,
+{
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
@@ -647,83 +980,175 @@ impl<'de> Deserialize<'de> for Interned<str> {
     }
 }
 
-impl<T: Clone + Send + Sync + 'static + Hash + Eq> Intern for T {
-    fn intern(&self) -> Interned<Self> {
-        Self::intern_cow(Cow::Borrowed(self))
-    }
+pub struct Guard<T: ?Sized + 'static + Send + Sync, C: InternContext = GlobalContext> {
+    inner: C::InternedGuardImpl<T>,
+    _phantom: PhantomData<&'static C>,
+}
 
-    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Self::intern_cow(Cow::Owned(this))
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Guard<T, C> {
+    pub fn cast_unchecked<U: ?Sized + 'static + Send + Sync>(
+        this: Self,
+        f: impl FnOnce(C::InternedGuardImpl<T>) -> C::InternedGuardImpl<U>,
+    ) -> Guard<U, C> {
+        Guard {
+            inner: f(this.inner),
+            _phantom: PhantomData,
+        }
     }
-
-    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Interner::get().intern_sized(this)
+    pub fn try_cast_unchecked<U: ?Sized + 'static + Send + Sync, E>(
+        this: Self,
+        f: impl FnOnce(C::InternedGuardImpl<T>) -> Result<C::InternedGuardImpl<U>, E>,
+    ) -> Result<Guard<U, C>, E> {
+        Ok(Guard {
+            inner: f(this.inner)?,
+            _phantom: PhantomData,
+        })
+    }
+    pub fn into_inner(this: Self) -> C::InternedGuardImpl<T> {
+        this.inner
+    }
+    pub fn get_ref(this: &Self) -> &C::InternedGuardImpl<T> {
+        &this.inner
+    }
+    pub fn unguard(&self) -> Interned<T, C> {
+        Interned {
+            inner: C::unguard(&self.inner),
+            _phantom: PhantomData,
+        }
     }
 }
 
-impl<T: Clone + Send + Sync + 'static + Hash + Eq> Intern for [T] {
-    fn intern(&self) -> Interned<Self> {
-        Self::intern_cow(Cow::Borrowed(self))
-    }
-
-    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Self::intern_cow(Cow::Owned(this))
-    }
-
-    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Interner::get().intern_slice(this)
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Clone for Guard<T, C> {
+    fn clone(&self) -> Self {
+        Guard {
+            inner: self.inner.clone(),
+            _phantom: PhantomData,
+        }
     }
 }
 
-impl Intern for BitSlice {
-    fn intern(&self) -> Interned<Self> {
-        Self::intern_cow(Cow::Borrowed(self))
-    }
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Copy for Guard<T, C> where
+    C::InternedGuardImpl<T>: Copy
+{
+}
 
-    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Self::intern_cow(Cow::Owned(this))
-    }
+impl<T: ?Sized + 'static + Send + Sync, C: InternContext> Deref for Guard<T, C> {
+    type Target = T;
 
-    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self>
-    where
-        Self: ToOwned,
-    {
-        Interner::get().intern_bit_slice(this)
+    fn deref(&self) -> &Self::Target {
+        self.inner.borrow()
     }
 }
 
-impl Intern for str {
-    fn intern(&self) -> Interned<Self> {
-        Self::intern_cow(Cow::Borrowed(self))
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> PartialEq
+    for Guard<T, C>
+{
+    fn eq(&self, other: &Self) -> bool {
+        T::interned_compare_key_ref(self.inner.borrow())
+            == T::interned_compare_key_ref(other.inner.borrow())
+    }
+}
+
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Eq for Guard<T, C> {}
+
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> PartialOrd
+    for Guard<T, C>
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Ord for Guard<T, C> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        T::interned_compare_key_ref(self.inner.borrow())
+            .cmp(&T::interned_compare_key_ref(other.inner.borrow()))
+    }
+}
+
+impl<T: ?Sized + 'static + Send + Sync + InternedCompare, C: InternContext> Hash for Guard<T, C> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        T::interned_compare_key_ref(self.inner.borrow()).hash(state);
+    }
+}
+
+impl<T: Clone + Send + Sync + 'static + Hash + Eq, C: InternContext> Intern<C> for T {
+    fn intern_with_ctx(&self, context: &C) -> Interned<Self, C> {
+        Self::intern_cow_with_ctx(Cow::Borrowed(self), context)
     }
 
-    fn intern_owned(this: <Self as ToOwned>::Owned) -> Interned<Self>
+    fn intern_owned_with_ctx(this: <Self as ToOwned>::Owned, context: &C) -> Interned<Self, C>
     where
         Self: ToOwned,
     {
-        Self::intern_cow(Cow::Owned(this))
+        Self::intern_cow_with_ctx(Cow::Owned(this), context)
     }
 
-    fn intern_cow(this: Cow<'_, Self>) -> Interned<Self>
+    fn intern_cow_with_ctx(this: Cow<'_, Self>, context: &C) -> Interned<Self, C>
     where
         Self: ToOwned,
     {
-        Interner::get().intern_str(this)
+        context.interner().intern_sized(context, this)
+    }
+}
+
+impl<T: Clone + Send + Sync + 'static + Hash + Eq, C: InternContext> Intern<C> for [T] {
+    fn intern_with_ctx(&self, context: &C) -> Interned<Self, C> {
+        Self::intern_cow_with_ctx(Cow::Borrowed(self), context)
+    }
+
+    fn intern_owned_with_ctx(this: <Self as ToOwned>::Owned, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        Self::intern_cow_with_ctx(Cow::Owned(this), context)
+    }
+
+    fn intern_cow_with_ctx(this: Cow<'_, Self>, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        context.interner().intern_slice(context, this)
+    }
+}
+
+impl<C: BitSliceInternContext> Intern<C> for BitSlice {
+    fn intern_with_ctx(&self, context: &C) -> Interned<Self, C> {
+        Self::intern_cow_with_ctx(Cow::Borrowed(self), context)
+    }
+
+    fn intern_owned_with_ctx(this: <Self as ToOwned>::Owned, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        Self::intern_cow_with_ctx(Cow::Owned(this), context)
+    }
+
+    fn intern_cow_with_ctx(this: Cow<'_, Self>, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        context.interner().intern_bit_slice(context, this)
+    }
+}
+
+impl<C: InternContext> Intern<C> for str {
+    fn intern_with_ctx(&self, context: &C) -> Interned<Self, C> {
+        Self::intern_cow_with_ctx(Cow::Borrowed(self), context)
+    }
+
+    fn intern_owned_with_ctx(this: <Self as ToOwned>::Owned, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        Self::intern_cow_with_ctx(Cow::Owned(this), context)
+    }
+
+    fn intern_cow_with_ctx(this: Cow<'_, Self>, context: &C) -> Interned<Self, C>
+    where
+        Self: ToOwned,
+    {
+        context.interner().intern_str(context, this)
     }
 }
 
diff --git a/crates/fayalite/src/memory.rs b/crates/fayalite/src/memory.rs
index f583a8c..1762f57 100644
--- a/crates/fayalite/src/memory.rs
+++ b/crates/fayalite/src/memory.rs
@@ -634,7 +634,7 @@ impl<Element: Type, Len: Size> Mem<Element, Len> {
         self.0.source_location
     }
     pub fn array_type(self) -> ArrayType<Element, Len> {
-        self.0.array_type
+        self.0.array_type.clone()
     }
     pub fn initial_value(self) -> Option<Interned<BitSlice>> {
         self.0.initial_value
@@ -987,7 +987,7 @@ impl<Element: Type, Len: Size> MemBuilder<Element, Len> {
     #[allow(clippy::result_unit_err)]
     pub fn get_array_type(&self) -> Result<ArrayType<Element, Len>, ()> {
         Ok(ArrayType::new(
-            self.mem_element_type,
+            self.mem_element_type.clone(),
             Len::from_usize(self.get_depth()?),
         ))
     }
diff --git a/crates/fayalite/src/module.rs b/crates/fayalite/src/module.rs
index 7d6949c..2ba3800 100644
--- a/crates/fayalite/src/module.rs
+++ b/crates/fayalite/src/module.rs
@@ -607,10 +607,6 @@ impl BlockStack {
 pub struct Id(NonZeroU64);
 
 impl Id {
-    #[allow(
-        clippy::new_without_default,
-        reason = "returns a different value each time, so there isn't really a default value"
-    )]
     pub fn new() -> Self {
         static NEXT_ID: AtomicU64 = AtomicU64::new(1);
         Self(
@@ -949,7 +945,7 @@ impl From<NormalModuleBody<ModuleBuilding>> for NormalModuleBody {
                     Stmt::Declaration(decl) => {
                         let annotations = annotations_map
                             .remove(&decl)
-                            .map(Intern::intern_owned)
+                            .map(|v| Intern::intern_owned(v))
                             .unwrap_or_default();
                         match decl {
                             StmtDeclaration::Wire(StmtWire {
@@ -1619,7 +1615,10 @@ impl AssertValidityState {
         let module = self.module;
         if block == 0 {
             for module_io in &*module.module_io {
-                self.insert_new_base(TargetBase::intern_sized(module_io.module_io.into()), block);
+                self.insert_new_base(
+                    TargetBase::intern_sized(module_io.module_io.clone().into()),
+                    block,
+                );
             }
         }
         let Block { memories, stmts } = self.blocks[block];
@@ -1935,7 +1934,7 @@ impl ModuleBuilder {
         let module_io = module_io.canonical();
         let mut impl_ = self.impl_.borrow_mut();
         let impl_ = &mut *impl_;
-        impl_.io_indexes.insert(module_io, impl_.io.len());
+        impl_.io_indexes.insert(module_io.clone(), impl_.io.len());
         impl_.io.push(AnnotatedModuleIO {
             annotations: vec![],
             module_io,
@@ -2479,7 +2478,7 @@ pub fn memory_array_with_loc<Element: Type, Len: Size>(
     mem_array_type: ArrayType<Element, Len>,
     source_location: SourceLocation,
 ) -> MemBuilder<Element, Len> {
-    let mut retval = memory_impl(name, mem_array_type.element(), source_location);
+    let mut retval = memory_impl(name, mem_array_type.element().clone(), source_location);
     retval.depth(mem_array_type.len());
     retval
 }
diff --git a/crates/fayalite/src/module/transform/simplify_enums.rs b/crates/fayalite/src/module/transform/simplify_enums.rs
index bb57cf0..f398006 100644
--- a/crates/fayalite/src/module/transform/simplify_enums.rs
+++ b/crates/fayalite/src/module/transform/simplify_enums.rs
@@ -271,12 +271,12 @@ impl State {
             .into()),
             EnumTypeState::TagUIntAndBody(_) => {
                 let int_tag_expr = Expr::<TagAndBody<UInt, UInt>>::from_canonical(folded_expr).tag;
-                Ok(match_int_tag(int_tag_expr, source_location, folded_blocks).into())
+                Ok(match_int_tag(int_tag_expr, source_location, &folded_blocks).into())
             }
             EnumTypeState::UInt(_) => {
                 let int_tag_expr = Expr::<UInt>::from_canonical(folded_expr)
                     [..unfolded_enum_type.discriminant_bit_width()];
-                Ok(match_int_tag(int_tag_expr, source_location, folded_blocks).into())
+                Ok(match_int_tag(int_tag_expr, source_location, &folded_blocks).into())
             }
             EnumTypeState::Unchanged => Ok(StmtMatch {
                 expr: Expr::from_canonical(folded_expr),
@@ -929,10 +929,13 @@ impl Folder for State {
         unreachable!()
     }
 
-    fn fold_enum_literal<T: EnumType + Fold<Self>>(
+    fn fold_enum_literal<T: EnumType>(
         &mut self,
         _v: ops::EnumLiteral<T>,
-    ) -> Result<ops::EnumLiteral<T>, Self::Error> {
+    ) -> Result<ops::EnumLiteral<T>, Self::Error>
+    where
+        T: Fold<Self>,
+    {
         unreachable!()
     }
 
diff --git a/crates/fayalite/src/module/transform/simplify_memories.rs b/crates/fayalite/src/module/transform/simplify_memories.rs
index e8f9cbf..71e459c 100644
--- a/crates/fayalite/src/module/transform/simplify_memories.rs
+++ b/crates/fayalite/src/module/transform/simplify_memories.rs
@@ -766,7 +766,7 @@ impl ModuleState {
                     output_stmts.push(
                         StmtWire {
                             annotations: Default::default(),
-                            wire: canonical_wire,
+                            wire: canonical_wire.clone(),
                         }
                         .into(),
                     );
diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs
index 69080c9..380d2e6 100644
--- a/crates/fayalite/src/ty.rs
+++ b/crates/fayalite/src/ty.rs
@@ -330,6 +330,6 @@ impl<T: Type> Index<T> for AsMaskWithoutGenerics {
     type Output = T::MaskType;
 
     fn index(&self, ty: T) -> &Self::Output {
-        Interned::into_inner(Intern::intern_sized(ty.mask_type()))
+        Interned::<_>::into_inner(Intern::intern_sized(ty.mask_type()))
     }
 }
diff --git a/crates/fayalite/src/util/scoped_ref.rs b/crates/fayalite/src/util/scoped_ref.rs
index 27f2f89..7705377 100644
--- a/crates/fayalite/src/util/scoped_ref.rs
+++ b/crates/fayalite/src/util/scoped_ref.rs
@@ -106,9 +106,3 @@ impl<T: ?Sized> ScopedRef<T> {
         self.0.with_opt(f)
     }
 }
-
-impl<T: ?Sized> Default for ScopedRef<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
diff --git a/crates/fayalite/tests/module.rs b/crates/fayalite/tests/module.rs
index 222f7ba..b0b1fb6 100644
--- a/crates/fayalite/tests/module.rs
+++ b/crates/fayalite/tests/module.rs
@@ -2258,7 +2258,7 @@ pub fn check_memory_of_bundle() {
     let wmask: (Bool, Bool) = m.input();
     #[hdl]
     let clk: Clock = m.input();
-    let mem_init = Vec::from_iter((0..0x10u8).map(|i| (i ^ 3, (i ^ (i / 2)).cast_to_static())));
+    let mem_init = Vec::from_iter((0..0x10u8).map(|i| (i ^ 3, (i ^ i / 2).cast_to_static())));
     #[hdl]
     let mut mem = memory_with_init(mem_init);
     let read_port = mem.new_read_port();