diff --git a/const-type-layout-derive/src/lib.rs b/const-type-layout-derive/src/lib.rs
index 53858bf..cf2fe9d 100644
--- a/const-type-layout-derive/src/lib.rs
+++ b/const-type-layout-derive/src/lib.rs
@@ -78,22 +78,18 @@ pub fn derive_type_layout(input: TokenStream) -> TokenStream {
     let inhabited = inhabited_for_type(&crate_path, &input.data);
     let layout = layout_of_type(&crate_path, &ty_name, &ty_generics, &input.data, &reprs);
 
-    let inner_types = extract_inner_types(&input.data);
-
-    let discriminant_ty = if let syn::Data::Enum(_) = input.data {
-        Some(quote! { ::core::mem::Discriminant<Self>, })
-    } else {
-        None
-    };
-
-    let Generics {
-        type_layout_input_generics,
-        type_set_input_generics,
-    } = generate_generics(&crate_path, &input.generics, &extra_bounds, &type_params);
+    let mut inner_types = extract_inner_types(&input.data);
+
+    let discriminant_ty: syn::Type;
+    if let syn::Data::Enum(_) = input.data {
+        discriminant_ty = syn::parse_quote! { ::core::mem::Discriminant<Self> };
+        inner_types.push(&discriminant_ty);
+    }
+
+    let type_layout_input_generics =
+        generate_generics(&crate_path, &input.generics, &extra_bounds, &type_params);
     let (type_layout_impl_generics, type_layout_ty_generics, type_layout_where_clause) =
         type_layout_input_generics.split_for_impl();
-    let (type_set_impl_generics, type_set_ty_generics, type_set_where_clause) =
-        type_set_input_generics.split_for_impl();
 
     quote! {
         unsafe impl #type_layout_impl_generics #crate_path::TypeLayout for
@@ -109,15 +105,8 @@ pub fn derive_type_layout(input: TokenStream) -> TokenStream {
                     structure: #layout,
                 }
             };
-        }
 
-        unsafe impl #type_set_impl_generics #crate_path::typeset::ComputeTypeSet for
-            #ty_name #type_set_ty_generics #type_set_where_clause
-        {
-            type Output<__TypeSetRest: #crate_path::typeset::ExpandTypeSet> =
-                #crate_path::typeset::tset![
-                    #(#inner_types,)* #discriminant_ty .. @ __TypeSetRest
-                ];
+            type TypeGraphEdges = #crate_path::graph::hlist![#(#inner_types),*];
         }
     }
     .into()
@@ -308,19 +297,13 @@ fn extract_inner_types(data: &syn::Data) -> Vec<&syn::Type> {
     inner_types
 }
 
-struct Generics {
-    type_layout_input_generics: syn::Generics,
-    type_set_input_generics: syn::Generics,
-}
-
 fn generate_generics(
     crate_path: &syn::Path,
     generics: &syn::Generics,
     extra_bounds: &[syn::WherePredicate],
     type_params: &[&syn::Ident],
-) -> Generics {
+) -> syn::Generics {
     let mut type_layout_input_generics = generics.clone();
-    let mut type_set_input_generics = generics.clone();
 
     for ty in type_params {
         type_layout_input_generics
@@ -329,13 +312,6 @@ fn generate_generics(
             .push(syn::parse_quote! {
                 #ty: #crate_path::TypeLayout
             });
-
-        type_set_input_generics
-            .make_where_clause()
-            .predicates
-            .push(syn::parse_quote! {
-                #ty: #crate_path::typeset::ComputeTypeSet
-            });
     }
 
     for bound in extra_bounds {
@@ -343,17 +319,9 @@ fn generate_generics(
             .make_where_clause()
             .predicates
             .push(bound.clone());
-
-        type_set_input_generics
-            .make_where_clause()
-            .predicates
-            .push(bound.clone());
     }
 
-    Generics {
-        type_layout_input_generics,
-        type_set_input_generics,
-    }
+    type_layout_input_generics
 }
 
 fn layout_of_type(
diff --git a/src/graph.rs b/src/graph.rs
new file mode 100644
index 0000000..56f6f26
--- /dev/null
+++ b/src/graph.rs
@@ -0,0 +1,276 @@
+#![allow(missing_docs)] // FIXME
+
+use core::{marker::Freeze, mem::MaybeUninit};
+
+use crate::{TypeLayout, TypeLayoutInfo};
+
+pub(crate) use private::TypeHList;
+
+pub macro hlist {
+    () => { private::Empty },
+    ($H:ty $(, $R:ty)*) => {
+        private::Cons<$H, hlist![$($R),*]>
+    },
+}
+
+#[allow(clippy::module_name_repetitions)]
+#[must_use]
+pub const fn type_layout_graph<T: TypeLayout>() -> &'static [&'static TypeLayoutInfo<'static>] {
+    expand_type_layout_stack_graph_into_static_slice::<T, private::Empty, T, private::Empty>(None)
+}
+
+// compute the type graph by keeping an on-stack linked list of already-seen
+//  types
+// as the stack graph is computed, accumulate the hlist type that is layout-
+//  equivalent to an array storing all of the type layouts
+// once the graph is computed on the stack, recompute it inside a const using
+//  the now-known type of the hlist
+// a static slice to the array of type layouts is returned
+const fn expand_type_layout_stack_graph_into_static_slice<
+    GraphRoot: TypeLayout,
+    GraphNodesArray: 'static + Copy + Freeze + private::HList,
+    T: TypeLayout,
+    RemainingTypes: private::TypeHList,
+>(
+    tys: Option<&GraphStackNode>,
+) -> &'static [&'static TypeLayoutInfo<'static>] {
+    let layout = &T::TYPE_LAYOUT;
+
+    // check if this type has already been inserted into the graph
+    let mut it = &tys;
+    while let Some(i) = it {
+        if type_layout_info_eq(i.ty, layout) {
+            // if no types remain, continue by computing the graph again, this
+            //  time in a const with the now-known array hlist type
+            if RemainingTypes::LEN == 0 {
+                return compute_type_layout_graph_static_slice::<GraphRoot, GraphNodesArray>();
+            }
+
+            // if more types remain, continue with recursion
+            return expand_type_layout_stack_graph_into_static_slice::<
+                GraphRoot,
+                GraphNodesArray,
+                RemainingTypes::Head,
+                RemainingTypes::Tail,
+            >(tys);
+        }
+
+        it = &i.next;
+    }
+
+    if <<T::TypeGraphEdges as private::TypeHList>::Concat<RemainingTypes> as private::HList>::LEN
+        == 0
+    {
+        // if no types remain, also considering the links from T, continue by
+        //  computing the graph again, this time in a const with the now-known
+        //  array hlist type
+        // the GraphNodesArray HList is extended by one element for T
+        return compute_type_layout_graph_static_slice::<
+            GraphRoot,
+            private::Cons<&'static TypeLayoutInfo<'static>, GraphNodesArray>,
+        >();
+    }
+
+    // if more types remain, continue with recursion, adding the links from T
+    //  to the stack of remaining types
+    // the GraphNodesArray HList is extended by one element for T
+    expand_type_layout_stack_graph_into_static_slice::<
+        GraphRoot,
+        private::Cons<&'static TypeLayoutInfo<'static>, GraphNodesArray>,
+        <<T::TypeGraphEdges as private::TypeHList>::Concat<RemainingTypes> as private::TypeHList>::Head,
+        <<T::TypeGraphEdges as private::TypeHList>::Concat<RemainingTypes> as private::TypeHList>::Tail,
+    >(Some(&GraphStackNode {
+        ty: layout,
+        next: tys,
+    }))
+}
+
+// on-stack linked list node that stores one type layout
+struct GraphStackNode<'a> {
+    ty: &'static TypeLayoutInfo<'static>,
+    next: Option<&'a Self>,
+}
+
+// transform the static reference to the hlist that's layout-equivalent to the
+//  array storing all type layouts into a static slice to the same array
+const fn compute_type_layout_graph_static_slice<
+    GraphRoot: TypeLayout,
+    GraphNodesArray: 'static + Copy + Freeze + private::HList,
+>() -> &'static [&'static TypeLayoutInfo<'static>] {
+    // SAFETY:
+    // - HList is a sealed trait and is constructed here to be made of only Cons of
+    //   TypeLayoutInfo and Empty
+    // - Cons is a repr(C) struct with a head followed by a tail, Empty is a
+    //   zero-sized repr(C) struct
+    // - the HList is layout-equivalent to an array of the same length as HList::LEN
+    // - fill_type_layout_graph_erased_reference provides a static non-dangling
+    //   reference that we can use to produce the data pointer for a slice
+    unsafe {
+        core::slice::from_raw_parts(
+            core::ptr::from_ref(compute_type_layout_graph_static_array_ref::<
+                GraphRoot,
+                GraphNodesArray,
+            >())
+            .cast(),
+            GraphNodesArray::LEN,
+        )
+    }
+}
+
+// create a static reference to the type layout hlist using an inline const
+const fn compute_type_layout_graph_static_array_ref<
+    GraphRoot: TypeLayout,
+    GraphNodesArray: 'static + Copy + Freeze + private::HList,
+>() -> &'static GraphNodesArray {
+    &const { compute_type_layout_graph_array::<GraphRoot, GraphNodesArray>() }
+}
+
+// create the hlist that's layout-equivalent to the array storing all type
+//  layouts and fill it with these type layouts
+const fn compute_type_layout_graph_array<GraphRoot: TypeLayout, GraphNodesArray: private::HList>(
+) -> GraphNodesArray {
+    // layout-compatible with MaybeUninit::<[_; LEN]>::uninit()
+    let mut graph = MaybeUninit::<GraphNodesArray>::uninit();
+
+    // SAFETY:
+    // - HList is a sealed trait and is constructed here to be made of only Cons of
+    //   TypeLayoutInfo and Empty
+    // - Cons is a repr(C) struct with a head followed by a tail, Empty is a
+    //   zero-sized repr(C) struct
+    // - the HList is layout-equivalent to an array of the same length as HList::LEN
+    // - the mutable slice is to a slice of uninit elements, and an uninit array can
+    //   always be accessed as an array of uninit elements
+    let graph_slice = unsafe {
+        core::slice::from_raw_parts_mut(
+            core::ptr::from_mut(&mut graph).cast(),
+            GraphNodesArray::LEN,
+        )
+    };
+    let graph_len = fill_type_layout_graph_slice::<GraphRoot, private::Empty>(graph_slice, 0);
+
+    assert!(
+        graph_len == GraphNodesArray::LEN,
+        "bug: initialized graph has the wrong size"
+    );
+
+    // Safety: we have just checked that all array elements have been initialized
+    unsafe { graph.assume_init() }
+}
+
+// compute the type graph by filling a slice of uninitialized type layouts and
+//  using it to check which types have already been seen
+// once the graph is computed, return the number of elements initialized
+const fn fill_type_layout_graph_slice<T: TypeLayout, Remaining: private::TypeHList>(
+    tys: &mut [MaybeUninit<&'static TypeLayoutInfo<'static>>],
+    init_tys_len: usize,
+) -> usize {
+    let layout = &T::TYPE_LAYOUT;
+
+    // check if this type has already been inserted into the graph
+    let mut i = 0;
+    while i < init_tys_len {
+        // Safety: tys has been initialized for 0..tys_len
+        if type_layout_info_eq(unsafe { tys[i].assume_init_ref() }, layout) {
+            // if no types remain, return the initialized length of the array
+            if Remaining::LEN == 0 {
+                return init_tys_len;
+            }
+
+            // if more types remain, continue with recursion
+            return fill_type_layout_graph_slice::<Remaining::Head, Remaining::Tail>(
+                tys,
+                init_tys_len,
+            );
+        }
+        i += 1;
+    }
+
+    // push the type layout into the slice to initialize the next element
+    assert!(init_tys_len < tys.len(), "bug: type layout graph too small");
+    tys[init_tys_len] = MaybeUninit::new(layout);
+
+    if <<T::TypeGraphEdges as private::TypeHList>::Concat<Remaining> as private::HList>::LEN == 0 {
+        // if no types remain, also considering the links from T, return the
+        //  initialized length of the array
+        return init_tys_len + 1;
+    }
+
+    // if more types remain, continue with recursion, adding the links from T
+    //  to the stack of remaining types
+    fill_type_layout_graph_slice::<
+        <<T::TypeGraphEdges as private::TypeHList>::Concat<Remaining> as private::TypeHList>::Head,
+        <<T::TypeGraphEdges as private::TypeHList>::Concat<Remaining> as private::TypeHList>::Tail,
+    >(tys, init_tys_len + 1)
+}
+
+// simple type layout info equality by checking the equality of their type names
+const fn type_layout_info_eq(a: &TypeLayoutInfo, b: &TypeLayoutInfo) -> bool {
+    str_eq(a.name, b.name)
+}
+
+const fn str_eq(a: &str, b: &str) -> bool {
+    if a.len() != b.len() {
+        return false;
+    }
+
+    let (a, b) = (a.as_bytes(), b.as_bytes());
+
+    let mut i = 0;
+
+    while i < a.len() {
+        if a[i] != b[i] {
+            return false;
+        }
+
+        i += 1;
+    }
+
+    true
+}
+
+mod private {
+    use crate::TypeLayout;
+
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub struct Empty;
+
+    #[repr(C)]
+    #[derive(Copy, Clone)]
+    pub struct Cons<H, T> {
+        head: H,
+        tail: T,
+    }
+
+    pub trait HList {
+        const LEN: usize;
+    }
+
+    impl HList for Empty {
+        const LEN: usize = 0;
+    }
+
+    impl<H, T: HList> HList for Cons<H, T> {
+        const LEN: usize = 1 + T::LEN;
+    }
+
+    pub trait TypeHList: HList {
+        type Head: TypeLayout;
+        type Tail: TypeHList;
+
+        type Concat<L: TypeHList>: TypeHList;
+    }
+
+    impl TypeHList for Empty {
+        type Concat<L: TypeHList> = L;
+        // Empty's head can be anything since we never use it
+        type Head = ();
+        type Tail = Self;
+    }
+
+    impl<H: TypeLayout, T: TypeHList> TypeHList for Cons<H, T> {
+        type Concat<L: TypeHList> = Cons<H, T::Concat<L>>;
+        type Head = H;
+        type Tail = T;
+    }
+}
diff --git a/src/impls/core/array.rs b/src/impls/core/array.rs
index f29092d..b2200b1 100644
--- a/src/impls/core/array.rs
+++ b/src/impls/core/array.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T: TypeLayout, const N: usize> TypeLayout for [T; N] {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -12,7 +11,3 @@ unsafe impl<T: TypeLayout, const N: usize> TypeLayout for [T; N] {
         structure: TypeStructure::Primitive,
     };
 }
-
-unsafe impl<T: ComputeTypeSet, const N: usize> ComputeTypeSet for [T; N] {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
diff --git a/src/impls/core/cell.rs b/src/impls/core/cell.rs
index aed83df..0f2c3d7 100644
--- a/src/impls/core/cell.rs
+++ b/src/impls/core/cell.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T: TypeLayout> TypeLayout for core::cell::UnsafeCell<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -20,11 +19,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::cell::UnsafeCell<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::cell::UnsafeCell<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::cell::Cell<T> {
+    type TypeGraphEdges = hlist![core::cell::UnsafeCell<T>];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -41,12 +38,10 @@ unsafe impl<T: TypeLayout> TypeLayout for core::cell::Cell<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::cell::Cell<T> {
-    type Output<R: ExpandTypeSet> = tset![core::cell::UnsafeCell<T>, .. @ R];
-}
-
 #[cfg(feature = "impl-sync-unsafe-cell")]
 unsafe impl<T: TypeLayout> TypeLayout for core::cell::SyncUnsafeCell<T> {
+    type TypeGraphEdges = hlist![core::cell::UnsafeCell<T>];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -63,12 +58,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::cell::SyncUnsafeCell<T> {
     };
 }
 
-#[cfg(feature = "impl-sync-unsafe-cell")]
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::cell::SyncUnsafeCell<T> {
-    type Output<R: ExpandTypeSet> = tset![core::cell::UnsafeCell<T>, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::cell::OnceCell<T> {
+    type TypeGraphEdges = hlist![core::cell::UnsafeCell<core::option::Option<T>>];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -84,7 +76,3 @@ unsafe impl<T: TypeLayout> TypeLayout for core::cell::OnceCell<T> {
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::cell::OnceCell<T> {
-    type Output<R: ExpandTypeSet> = tset![core::cell::UnsafeCell<core::option::Option<T>>, .. @ R];
-}
diff --git a/src/impls/core/cmp.rs b/src/impls/core/cmp.rs
index dd35acf..1f1477c 100644
--- a/src/impls/core/cmp.rs
+++ b/src/impls/core/cmp.rs
@@ -1,9 +1,10 @@
 use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
+    graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
 };
 
 unsafe impl<T: TypeLayout> TypeLayout for core::cmp::Reverse<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -20,11 +21,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::cmp::Reverse<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::cmp::Reverse<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl TypeLayout for core::cmp::Ordering {
+    type TypeGraphEdges = hlist![::core::mem::Discriminant<Self>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -52,9 +51,3 @@ unsafe impl TypeLayout for core::cmp::Ordering {
         },
     };
 }
-
-unsafe impl ComputeTypeSet for core::cmp::Ordering {
-    type Output<R: ExpandTypeSet> = tset![
-        ::core::mem::Discriminant<Self>, .. @ R
-    ];
-}
diff --git a/src/impls/core/convert.rs b/src/impls/core/convert.rs
index 1897d92..86f3ec5 100644
--- a/src/impls/core/convert.rs
+++ b/src/impls/core/convert.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl TypeLayout for core::convert::Infallible {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::any![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -15,7 +14,3 @@ unsafe impl TypeLayout for core::convert::Infallible {
         },
     };
 }
-
-unsafe impl ComputeTypeSet for core::convert::Infallible {
-    type Output<T: ExpandTypeSet> = tset![.. @ T];
-}
diff --git a/src/impls/core/ffi.rs b/src/impls/core/ffi.rs
index 1c09ddf..d4b26aa 100644
--- a/src/impls/core/ffi.rs
+++ b/src/impls/core/ffi.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl TypeLayout for core::ffi::c_void {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -15,7 +14,3 @@ unsafe impl TypeLayout for core::ffi::c_void {
         },
     };
 }
-
-unsafe impl ComputeTypeSet for core::ffi::c_void {
-    type Output<T: ExpandTypeSet> = tset![.. @ T];
-}
diff --git a/src/impls/core/fn.rs b/src/impls/core/fn.rs
index cf5890a..6d13822 100644
--- a/src/impls/core/fn.rs
+++ b/src/impls/core/fn.rs
@@ -1,7 +1,4 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 macro_rules! impl_fn_pointer_type_layout {
     (impl extern $abi:literal fn($($T:ident),*) -> $R:ident) => {
@@ -28,10 +25,8 @@ macro_rules! impl_fn_pointer_type_layout {
                 alignment: ::core::mem::align_of::<Self>(),
                 structure: TypeStructure::Primitive,
             };
-        }
 
-        unsafe impl<$R: ComputeTypeSet, $($T: ComputeTypeSet),*> ComputeTypeSet for $ty {
-            type Output<Z: ExpandTypeSet> = tset![$R $(, $T)*, .. @ Z];
+            type TypeGraphEdges = hlist![$R $(, $T)*];
         }
     };
     ($(fn($($T:ident),*) -> $R:ident),*) => {
@@ -71,12 +66,8 @@ macro_rules! impl_variadic_extern_fn_pointer_type_layout {
                 alignment: ::core::mem::align_of::<Self>(),
                 structure: TypeStructure::Primitive,
             };
-        }
 
-        unsafe impl<$R: ComputeTypeSet, $($T: ComputeTypeSet),*> ComputeTypeSet
-            for unsafe extern $abi fn($($T),*, ...) -> $R
-        {
-            type Output<Z: ExpandTypeSet> = tset![$R $(, $T)*, .. @ Z];
+            type TypeGraphEdges = hlist![$R $(, $T)*];
         }
     };
     ($(unsafe extern "C" fn($($T:ident),+, ...) -> $R:ident),*) => {
diff --git a/src/impls/core/marker.rs b/src/impls/core/marker.rs
index 05b1bd9..fcc8d3b 100644
--- a/src/impls/core/marker.rs
+++ b/src/impls/core/marker.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T> TypeLayout for core::marker::PhantomData<T> {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -16,11 +15,9 @@ unsafe impl<T> TypeLayout for core::marker::PhantomData<T> {
     };
 }
 
-unsafe impl<T> ComputeTypeSet for core::marker::PhantomData<T> {
-    type Output<R: ExpandTypeSet> = tset![.. @ R];
-}
-
 unsafe impl TypeLayout for core::marker::PhantomPinned {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -32,7 +29,3 @@ unsafe impl TypeLayout for core::marker::PhantomPinned {
         },
     };
 }
-
-unsafe impl ComputeTypeSet for core::marker::PhantomPinned {
-    type Output<T: ExpandTypeSet> = tset![.. @ T];
-}
diff --git a/src/impls/core/mem.rs b/src/impls/core/mem.rs
index d57104a..c528730 100644
--- a/src/impls/core/mem.rs
+++ b/src/impls/core/mem.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T: TypeLayout> TypeLayout for core::mem::ManuallyDrop<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -20,11 +19,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::mem::ManuallyDrop<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::mem::ManuallyDrop<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::mem::MaybeUninit<T> {
+    type TypeGraphEdges = hlist![(), core::mem::ManuallyDrop<T>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -48,11 +45,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::mem::MaybeUninit<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::mem::MaybeUninit<T> {
-    type Output<R: ExpandTypeSet> = tset![(), core::mem::ManuallyDrop<T>, .. @ R];
-}
-
 unsafe impl<T> TypeLayout for core::mem::Discriminant<T> {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -61,7 +56,3 @@ unsafe impl<T> TypeLayout for core::mem::Discriminant<T> {
         structure: TypeStructure::Primitive,
     };
 }
-
-unsafe impl<T> ComputeTypeSet for core::mem::Discriminant<T> {
-    type Output<R: ExpandTypeSet> = tset![.. @ R];
-}
diff --git a/src/impls/core/num.rs b/src/impls/core/num.rs
index b6ca5d1..257073b 100644
--- a/src/impls/core/num.rs
+++ b/src/impls/core/num.rs
@@ -1,7 +1,4 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 macro_rules! impl_nonzero_type_layout {
     (impl $nz:ident => $ty:ty) => {
@@ -23,10 +20,8 @@ macro_rules! impl_nonzero_type_layout {
                     ],
                 },
             };
-        }
 
-        unsafe impl ComputeTypeSet for core::num::$nz {
-            type Output<T: ExpandTypeSet> = tset![$ty, .. @ T];
+            type TypeGraphEdges = hlist![$ty];
         }
     };
     ($($nz:ident => $ty:ty),*) => {
@@ -42,6 +37,8 @@ impl_nonzero_type_layout! {
 }
 
 unsafe impl<T: TypeLayout> TypeLayout for core::num::Wrapping<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -58,11 +55,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::num::Wrapping<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::num::Wrapping<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::num::Saturating<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -78,7 +73,3 @@ unsafe impl<T: TypeLayout> TypeLayout for core::num::Saturating<T> {
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::num::Saturating<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
diff --git a/src/impls/core/ops.rs b/src/impls/core/ops.rs
index 5038ec8..184712d 100644
--- a/src/impls/core/ops.rs
+++ b/src/impls/core/ops.rs
@@ -1,9 +1,10 @@
 use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
+    graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
 };
 
 unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::Range<Idx> {
+    type TypeGraphEdges = hlist![Idx];
+
     const INHABITED: crate::MaybeUninhabited = Idx::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -27,11 +28,9 @@ unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::Range<Idx> {
     };
 }
 
-unsafe impl<Idx: ComputeTypeSet> ComputeTypeSet for core::ops::Range<Idx> {
-    type Output<R: ExpandTypeSet> = tset![Idx, .. @ R];
-}
-
 unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeFrom<Idx> {
+    type TypeGraphEdges = hlist![Idx];
+
     const INHABITED: crate::MaybeUninhabited = Idx::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -48,11 +47,9 @@ unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeFrom<Idx> {
     };
 }
 
-unsafe impl<Idx: ComputeTypeSet> ComputeTypeSet for core::ops::RangeFrom<Idx> {
-    type Output<R: ExpandTypeSet> = tset![Idx, .. @ R];
-}
-
 unsafe impl TypeLayout for core::ops::RangeFull {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -65,11 +62,9 @@ unsafe impl TypeLayout for core::ops::RangeFull {
     };
 }
 
-unsafe impl ComputeTypeSet for core::ops::RangeFull {
-    type Output<R: ExpandTypeSet> = tset![.. @ R];
-}
-
 unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeTo<Idx> {
+    type TypeGraphEdges = hlist![Idx];
+
     const INHABITED: crate::MaybeUninhabited = Idx::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -86,11 +81,9 @@ unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeTo<Idx> {
     };
 }
 
-unsafe impl<Idx: ComputeTypeSet> ComputeTypeSet for core::ops::RangeTo<Idx> {
-    type Output<R: ExpandTypeSet> = tset![Idx, .. @ R];
-}
-
 unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeToInclusive<Idx> {
+    type TypeGraphEdges = hlist![Idx];
+
     const INHABITED: crate::MaybeUninhabited = Idx::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -107,11 +100,9 @@ unsafe impl<Idx: TypeLayout> TypeLayout for core::ops::RangeToInclusive<Idx> {
     };
 }
 
-unsafe impl<Idx: ComputeTypeSet> ComputeTypeSet for core::ops::RangeToInclusive<Idx> {
-    type Output<R: ExpandTypeSet> = tset![Idx, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::ops::Bound<T> {
+    type TypeGraphEdges = hlist![T, ::core::mem::Discriminant<Self>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -152,13 +143,9 @@ unsafe impl<T: TypeLayout> TypeLayout for core::ops::Bound<T> {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::ops::Bound<T> {
-    type Output<R: ExpandTypeSet> = tset![
-        T, ::core::mem::Discriminant<Self>, .. @ R
-    ];
-}
-
 unsafe impl<B: TypeLayout, C: TypeLayout> TypeLayout for core::ops::ControlFlow<B, C> {
+    type TypeGraphEdges = hlist![B, C, ::core::mem::Discriminant<Self>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::any![B, C];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -191,9 +178,3 @@ unsafe impl<B: TypeLayout, C: TypeLayout> TypeLayout for core::ops::ControlFlow<
         },
     };
 }
-
-unsafe impl<B: ComputeTypeSet, C: ComputeTypeSet> ComputeTypeSet for core::ops::ControlFlow<B, C> {
-    type Output<R: ExpandTypeSet> = tset![
-        B, C, ::core::mem::Discriminant<Self>, .. @ R
-    ];
-}
diff --git a/src/impls/core/option.rs b/src/impls/core/option.rs
index bb47a2e..6966dc6 100644
--- a/src/impls/core/option.rs
+++ b/src/impls/core/option.rs
@@ -1,9 +1,10 @@
 use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
+    graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
 };
 
 unsafe impl<T: TypeLayout> TypeLayout for core::option::Option<T> {
+    type TypeGraphEdges = hlist![T, ::core::mem::Discriminant<Self>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -30,9 +31,3 @@ unsafe impl<T: TypeLayout> TypeLayout for core::option::Option<T> {
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::option::Option<T> {
-    type Output<R: ExpandTypeSet> = tset![
-        T, ::core::mem::Discriminant<Self>, .. @ R
-    ];
-}
diff --git a/src/impls/core/pin.rs b/src/impls/core/pin.rs
index 6d9ea6c..48a5c0d 100644
--- a/src/impls/core/pin.rs
+++ b/src/impls/core/pin.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T: TypeLayout + core::ops::Deref> TypeLayout for core::pin::Pin<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -19,7 +18,3 @@ unsafe impl<T: TypeLayout + core::ops::Deref> TypeLayout for core::pin::Pin<T> {
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet + core::ops::Deref> ComputeTypeSet for core::pin::Pin<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
diff --git a/src/impls/core/primitive.rs b/src/impls/core/primitive.rs
index 528acd0..53b7241 100644
--- a/src/impls/core/primitive.rs
+++ b/src/impls/core/primitive.rs
@@ -1,7 +1,4 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 macro_rules! impl_primitive_type_layout {
     (impl $ty:ty => $val:expr) => {
@@ -14,10 +11,8 @@ macro_rules! impl_primitive_type_layout {
                 alignment: ::core::mem::align_of::<Self>(),
                 structure: TypeStructure::Primitive,
             };
-        }
 
-        unsafe impl ComputeTypeSet for $ty {
-            type Output<T: ExpandTypeSet> = tset![.. @ T];
+            type TypeGraphEdges = hlist![];
         }
     };
     ($($ty:ty => $val:expr),*) => {
@@ -34,6 +29,8 @@ impl_primitive_type_layout! {
 
 #[cfg(feature = "impl-never")]
 unsafe impl TypeLayout for ! {
+    type TypeGraphEdges = hlist![];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::any![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -42,8 +39,3 @@ unsafe impl TypeLayout for ! {
         structure: TypeStructure::Primitive,
     };
 }
-
-#[cfg(feature = "impl-never")]
-unsafe impl ComputeTypeSet for ! {
-    type Output<T: ExpandTypeSet> = tset![.. @ T];
-}
diff --git a/src/impls/core/ptr.rs b/src/impls/core/ptr.rs
index 1bf5a79..f111cf4 100644
--- a/src/impls/core/ptr.rs
+++ b/src/impls/core/ptr.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<T: TypeLayout> TypeLayout for *const T {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -13,11 +12,9 @@ unsafe impl<T: TypeLayout> TypeLayout for *const T {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for *const T {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for *mut T {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -27,11 +24,9 @@ unsafe impl<T: TypeLayout> TypeLayout for *mut T {
     };
 }
 
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for *mut T {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<T: TypeLayout> TypeLayout for core::ptr::NonNull<T> {
+    type TypeGraphEdges = hlist![*const T];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -47,7 +42,3 @@ unsafe impl<T: TypeLayout> TypeLayout for core::ptr::NonNull<T> {
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::ptr::NonNull<T> {
-    type Output<R: ExpandTypeSet> = tset![*const T, .. @ R];
-}
diff --git a/src/impls/core/ref.rs b/src/impls/core/ref.rs
index 8087752..497a29f 100644
--- a/src/impls/core/ref.rs
+++ b/src/impls/core/ref.rs
@@ -1,9 +1,8 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 unsafe impl<'a, T: TypeLayout + 'a> TypeLayout for &'a T {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -13,11 +12,9 @@ unsafe impl<'a, T: TypeLayout + 'a> TypeLayout for &'a T {
     };
 }
 
-unsafe impl<'a, T: ComputeTypeSet + 'a> ComputeTypeSet for &'a T {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
-
 unsafe impl<'a, T: TypeLayout + 'a> TypeLayout for &'a mut T {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::all![];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -26,7 +23,3 @@ unsafe impl<'a, T: TypeLayout + 'a> TypeLayout for &'a mut T {
         structure: TypeStructure::Primitive,
     };
 }
-
-unsafe impl<'a, T: ComputeTypeSet + 'a> ComputeTypeSet for &'a mut T {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
diff --git a/src/impls/core/result.rs b/src/impls/core/result.rs
index 3df460a..fb07d2e 100644
--- a/src/impls/core/result.rs
+++ b/src/impls/core/result.rs
@@ -1,9 +1,10 @@
 use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
+    graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure, Variant,
 };
 
 unsafe impl<T: TypeLayout, E: TypeLayout> TypeLayout for core::result::Result<T, E> {
+    type TypeGraphEdges = hlist![T, E, ::core::mem::Discriminant<Self>];
+
     const INHABITED: crate::MaybeUninhabited = crate::inhabited::any![T, E];
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -34,9 +35,3 @@ unsafe impl<T: TypeLayout, E: TypeLayout> TypeLayout for core::result::Result<T,
         },
     };
 }
-
-unsafe impl<T: ComputeTypeSet, E: ComputeTypeSet> ComputeTypeSet for core::result::Result<T, E> {
-    type Output<R: ExpandTypeSet> = tset![
-        T, E, ::core::mem::Discriminant<Self>, .. @ R
-    ];
-}
diff --git a/src/impls/core/sync/atomic.rs b/src/impls/core/sync/atomic.rs
index 037bd88..95cd46d 100644
--- a/src/impls/core/sync/atomic.rs
+++ b/src/impls/core/sync/atomic.rs
@@ -1,7 +1,4 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 macro_rules! impl_atomic_int_layout {
     (impl $at:ident ( $align:literal : $cfg:literal ) => $ty:ty => $val:literal) => {
@@ -24,11 +21,8 @@ macro_rules! impl_atomic_int_layout {
                     ],
                 },
             };
-        }
 
-        #[cfg(target_has_atomic_load_store = $cfg)]
-        unsafe impl ComputeTypeSet for core::sync::atomic::$at {
-            type Output<T: ExpandTypeSet> = tset![core::cell::UnsafeCell<$ty>, .. @ T];
+            type TypeGraphEdges = hlist![core::cell::UnsafeCell<$ty>];
         }
     };
     ($($at:ident ( $align:literal : $cfg:literal ) => $ty:ty => $val:literal),*) => {
@@ -71,12 +65,8 @@ macro_rules! impl_atomic_int_ptr_sized_layout {
                     ],
                 },
             };
-        }
 
-        #[cfg(target_has_atomic_load_store = "ptr")]
-        #[cfg(target_pointer_width = $cfg)]
-        unsafe impl ComputeTypeSet for core::sync::atomic::$at {
-            type Output<T: ExpandTypeSet> = tset![core::cell::UnsafeCell<$ty>, .. @ T];
+            type TypeGraphEdges = hlist![core::cell::UnsafeCell<$ty>];
         }
     };
     ($($at:ident ( $align:literal : $cfg:literal ) => $ty:ty => $val:literal),*) => {
@@ -113,12 +103,8 @@ macro_rules! impl_atomic_ptr_layout {
                     ],
                 },
             };
-        }
 
-        #[cfg(target_has_atomic_load_store = "ptr")]
-        #[cfg(target_pointer_width = $cfg)]
-        unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::sync::atomic::AtomicPtr<T> {
-            type Output<R: ExpandTypeSet> = tset![core::cell::UnsafeCell<T>, .. @ R];
+            type TypeGraphEdges = hlist![core::cell::UnsafeCell<T>];
         }
     };
     ($(( $align:literal : $cfg:literal )),*) => {
diff --git a/src/impls/core/sync/mod.rs b/src/impls/core/sync/mod.rs
index 1d1748f..b075d44 100644
--- a/src/impls/core/sync/mod.rs
+++ b/src/impls/core/sync/mod.rs
@@ -1,14 +1,13 @@
 #[cfg(feature = "impl-sync-exclusive")]
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 #[cfg(feature = "impl-atomics")]
 mod atomic;
 
 #[cfg(feature = "impl-sync-exclusive")]
 unsafe impl<T: TypeLayout> TypeLayout for core::sync::Exclusive<T> {
+    type TypeGraphEdges = hlist![T];
+
     const INHABITED: crate::MaybeUninhabited = T::INHABITED;
     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
         name: ::core::any::type_name::<Self>(),
@@ -24,8 +23,3 @@ unsafe impl<T: TypeLayout> TypeLayout for core::sync::Exclusive<T> {
         },
     };
 }
-
-#[cfg(feature = "impl-sync-exclusive")]
-unsafe impl<T: ComputeTypeSet> ComputeTypeSet for core::sync::Exclusive<T> {
-    type Output<R: ExpandTypeSet> = tset![T, .. @ R];
-}
diff --git a/src/impls/core/tuple.rs b/src/impls/core/tuple.rs
index 778280e..48e26df 100644
--- a/src/impls/core/tuple.rs
+++ b/src/impls/core/tuple.rs
@@ -1,7 +1,4 @@
-use crate::{
-    typeset::{tset, ComputeTypeSet, ExpandTypeSet},
-    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-};
+use crate::{graph::hlist, Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure};
 
 macro_rules! impl_tuple_type_layout {
     (impl ($($a:tt => $T:ident),+)) => {
@@ -22,10 +19,8 @@ macro_rules! impl_tuple_type_layout {
                     }),*],
                 },
             };
-        }
 
-        unsafe impl<$($T: ComputeTypeSet),*> ComputeTypeSet for ($($T,)*) {
-            type Output<T: ExpandTypeSet> = tset![$($T),*, .. @ T];
+            type TypeGraphEdges = hlist![$($T),*];
         }
     };
     ($(($($a:tt => $T:ident),+)),*) => {
diff --git a/src/lib.rs b/src/lib.rs
index 3cdd206..7ecf5e5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -130,6 +130,8 @@ r#"TypeLayoutInfo {
 #![feature(offset_of_enum)]
 // required, soon-stabilized features
 #![cfg_attr(not(version("1.83")), feature(const_mut_refs))]
+#![cfg_attr(not(version("1.83")), feature(const_slice_from_raw_parts_mut))]
+#![cfg_attr(not(version("1.79")), feature(inline_const))]
 #![cfg_attr(not(version("1.82")), feature(offset_of_nested))]
 // docs-specific features
 #![cfg_attr(doc, feature(doc_auto_cfg))]
@@ -143,12 +145,10 @@ r#"TypeLayoutInfo {
 #![cfg_attr(feature = "impl-never", feature(never_type))]
 #![cfg_attr(feature = "impl-sync-exclusive", feature(exclusive_wrapper))]
 #![cfg_attr(feature = "impl-sync-unsafe-cell", feature(sync_unsafe_cell))]
-// required INCOMPLETE features
-#![allow(incomplete_features)]
-#![feature(specialization)]
 // optional feature-gated INCOMPLETE features
 #![cfg_attr(
     feature = "serialize-to-generic-const-array",
+    allow(incomplete_features),
     feature(generic_const_exprs)
 )]
 // further crate attributes
@@ -167,10 +167,10 @@ use core::ops::Deref;
 pub use const_type_layout_derive::TypeLayout;
 
 mod discriminant;
+pub mod graph;
 mod impls;
 pub mod inhabited;
 mod ser;
-pub mod typeset;
 
 pub use discriminant::Discriminant;
 
@@ -262,8 +262,7 @@ impl<T: Default> Default for MaybeUninhabited<T> {
 /// # use const_type_layout::{
 /// #    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
 /// # };
-/// # use const_type_layout::inhabited;
-/// # use const_type_layout::typeset::{ComputeTypeSet, ExpandTypeSet, tset};
+/// # use const_type_layout::{graph, inhabited};
 /// struct Foo {
 ///     a: u8,
 ///     b: u16,
@@ -292,11 +291,10 @@ impl<T: Default> Default for MaybeUninhabited<T> {
 ///             ],
 ///         },
 ///     };
+///
+///     type TypeGraphEdges = graph::hlist![u8, u16];
 /// }
 /// ```
-///
-/// Note that if you implement [`TypeLayout`], you should also implement
-/// [`typeset::ComputeTypeSet`] for it.
 pub unsafe trait TypeLayout: Sized {
     /// Marker for whether the type is
     /// [inhabited](https://doc.rust-lang.org/reference/glossary.html#inhabited) or
@@ -305,15 +303,18 @@ pub unsafe trait TypeLayout: Sized {
 
     /// Shallow layout of the type.
     const TYPE_LAYOUT: TypeLayoutInfo<'static>;
+
+    #[allow(missing_docs)] // FIXME
+    type TypeGraphEdges: graph::TypeHList;
 }
 
 /// Utility trait that provides the deep layout of a type.
-pub trait TypeGraphLayout: TypeLayout + typeset::ComputeTypeSet {
+pub trait TypeGraphLayout: TypeLayout {
     /// Shallow layout of the type.
     const TYPE_GRAPH: TypeLayoutGraph<'static>;
 }
 
-impl<T: TypeLayout + typeset::ComputeTypeSet> TypeGraphLayout for T {
+impl<T: TypeLayout> TypeGraphLayout for T {
     const TYPE_GRAPH: TypeLayoutGraph<'static> = TypeLayoutGraph::new::<T>();
 }
 
@@ -464,23 +465,10 @@ pub struct Field<'a> {
 impl TypeLayoutGraph<'static> {
     #[must_use]
     /// Construct the deep type layout descriptor for a type `T`.
-    pub const fn new<T: TypeLayout + typeset::ComputeTypeSet>() -> Self {
+    pub const fn new<T: TypeLayout>() -> Self {
         Self {
             ty: <T as TypeLayout>::TYPE_LAYOUT.name,
-            // SAFETY:
-            // - ComputeSet is a sealed trait and its TYS const is always a HList made of only Cons
-            //   of &'static TypeLayoutInfo and Empty
-            // - Cons is a repr(C) struct with a head followed by a tail, Empty is a zero-sized
-            //   repr(C) struct
-            // - the HList is layout-equivalent to an array of the same length as ComputeSet::LEN
-            // - ComputeSet::TYS provides a static non-dangling reference that we can use to produce
-            //   the data pointer for a slice
-            tys: unsafe {
-                core::slice::from_raw_parts(
-                    core::ptr::from_ref(<typeset::TypeSet<T> as typeset::ComputeSet>::TYS).cast(),
-                    <typeset::TypeSet<T> as typeset::ComputeSet>::LEN,
-                )
-            },
+            tys: graph::type_layout_graph::<T>(),
         }
     }
 }
diff --git a/src/typeset.rs b/src/typeset.rs
deleted file mode 100644
index 9d8ac60..0000000
--- a/src/typeset.rs
+++ /dev/null
@@ -1,203 +0,0 @@
-//! Helper module to compute the set of types that a type links to and expand it
-//! into the complete type graph.
-
-#[doc(hidden)]
-pub trait ComputeSet: sealed::ComputeSet {
-    const LEN: usize;
-    type Len;
-
-    type Output<H: ComputeTypeSet>: ExpandTypeSet;
-
-    type TyHList: 'static + Copy + core::marker::Freeze;
-    const TYS: &'static Self::TyHList;
-}
-
-mod sealed {
-    pub trait ComputeSet {}
-
-    impl ComputeSet for super::private::Empty {}
-    impl<H2: super::ComputeTypeSet, T: ComputeSet> ComputeSet for super::private::Cons<H2, T> {}
-}
-
-type Set<H, T> = <T as ComputeSet>::Output<H>;
-
-/// Computes the set of types that a type links to.
-///
-/// # Safety
-///
-/// It is only safe to implement this trait if it accurately includes
-/// all inner component types that are referenced by this type's layout. Use
-/// [`#[derive(TypeLayout)]`](const_type_layout_derive::TypeLayout) instead.
-///
-/// # Example
-///
-/// The struct `Foo` with `u8` and `u16` fields links to `u8` and `u16`:
-///
-/// ```rust
-/// # #![feature(const_type_name)]
-/// # #![feature(offset_of)]
-/// # use const_type_layout::{
-/// #    Field, MaybeUninhabited, TypeLayout, TypeLayoutInfo, TypeStructure,
-/// # };
-/// # use const_type_layout::inhabited;
-/// # use const_type_layout::typeset::{ComputeTypeSet, ExpandTypeSet, tset};
-/// struct Foo {
-///     a: u8,
-///     b: u16,
-/// }
-///
-/// # unsafe impl TypeLayout for Foo {
-/// #     const INHABITED: MaybeUninhabited = inhabited::all![u8, u16];
-/// #
-/// #     const TYPE_LAYOUT: TypeLayoutInfo<'static> = TypeLayoutInfo {
-/// #         name: ::core::any::type_name::<Self>(),
-/// #         size: ::core::mem::size_of::<Self>(),
-/// #         alignment: ::core::mem::align_of::<Self>(),
-/// #         structure: TypeStructure::Struct {
-/// #             repr: "",
-/// #             fields: &[
-/// #                 Field {
-/// #                     name: "a",
-/// #                     offset: MaybeUninhabited::new::<u8>(::core::mem::offset_of!(Self, a)),
-/// #                     ty: ::core::any::type_name::<u8>(),
-/// #                 },
-/// #                 Field {
-/// #                     name: "b",
-/// #                     offset: MaybeUninhabited::new::<u16>(::core::mem::offset_of!(Self, b)),
-/// #                     ty: ::core::any::type_name::<u16>(),
-/// #                 },
-/// #             ],
-/// #         },
-/// #     };
-/// # }
-///
-/// unsafe impl ComputeTypeSet for Foo {
-///     type Output<T: ExpandTypeSet> = tset![u8, u16];
-/// }
-/// ```
-///
-/// Note that to you implement [`ComputeTypeSet`] you must also implement
-/// [`crate::TypeLayout`] for it.
-pub unsafe trait ComputeTypeSet: crate::TypeLayout {
-    /// Extend the set `T` into a (larger) set containing also the types this
-    /// type links to.
-    ///
-    /// Enums implementing [`crate::TypeLayout`] and [`ComputeTypeSet`]
-    /// manually should include [`core::mem::Discriminant<Self>`] in
-    /// their [`ComputeTypeSet::Output`] using the [`tset`] helper macro.
-    type Output<T: ExpandTypeSet>: ExpandTypeSet;
-}
-
-/// Helper macro to expand a list of types, e.g. `H, R1, R2`, and an optional
-/// tail, `.. @ T`, into a set of types.
-///
-/// This macro is used when implementing the [`ComputeTypeSet::Output`]
-/// associated type to specify the list of types a type links to.
-pub macro tset {
-    () => { private::Empty },
-    (.. @ $T:tt) => { $T },
-    ($H:ty $(, $R:ty)*) => {
-        Set<$H, tset![$($R),*]>
-    },
-    ($H:ty, $($R:ty,)* .. @ $T:ty ) => {
-        Set<$H, tset![$($R,)* .. @ $T]>
-    },
-}
-
-#[doc(hidden)]
-pub trait ExpandTypeSet: ComputeSet {
-    type Output<T: ExpandTypeSet>: ExpandTypeSet;
-}
-
-impl ExpandTypeSet for private::Empty {
-    type Output<T: ExpandTypeSet> = T;
-}
-
-impl<H: ComputeTypeSet, T: ExpandTypeSet> ExpandTypeSet for private::Cons<H, T> {
-    type Output<R: ExpandTypeSet> =
-        <T as ExpandTypeSet>::Output<Set<H, <H as ComputeTypeSet>::Output<R>>>;
-}
-
-#[doc(hidden)]
-pub trait TypeSetFixedPoint: ExpandTypeSet {
-    type Output: ExpandTypeSet;
-}
-
-impl<T: ExpandTypeSet> TypeSetFixedPoint for T {
-    type Output = <T as private::ComputeTypeSetFixedPoint<
-        <T as ExpandTypeSet>::Output<private::Empty>,
-    >>::Output;
-}
-
-mod private {
-    use super::{sealed, ComputeSet, ComputeTypeSet, ExpandTypeSet, Set};
-
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct Empty;
-
-    #[repr(C)]
-    #[derive(Copy, Clone)]
-    pub struct Cons<H, T> {
-        head: H,
-        tail: T,
-    }
-
-    impl ComputeSet for Empty {
-        type Len = Self;
-        type Output<H: ComputeTypeSet> = Cons<H, Self>;
-        type TyHList = Self;
-
-        const LEN: usize = 0;
-        const TYS: &'static Self::TyHList = &Self;
-    }
-
-    impl<H2: ComputeTypeSet, T: ExpandTypeSet> ComputeSet for Cons<H2, T> {
-        type Len = Cons<(), T::Len>;
-        type Output<H1: ComputeTypeSet> = <Self as ComputeCons<H1>>::Output;
-        type TyHList = Cons<&'static crate::TypeLayoutInfo<'static>, T::TyHList>;
-
-        const LEN: usize = T::LEN + 1;
-        const TYS: &'static Self::TyHList = &Cons {
-            head: &H2::TYPE_LAYOUT,
-            tail: *T::TYS,
-        };
-    }
-
-    pub trait ComputeCons<H: ComputeTypeSet>: sealed::ComputeSet {
-        type Output: ExpandTypeSet;
-    }
-
-    impl<H: ComputeTypeSet> ComputeCons<H> for Empty {
-        type Output = Cons<H, Self>;
-    }
-
-    impl<H: ComputeTypeSet, T: ExpandTypeSet> ComputeCons<H> for Cons<H, T> {
-        type Output = Self;
-    }
-
-    impl<H1: ComputeTypeSet, H2: ComputeTypeSet, T: ExpandTypeSet> ComputeCons<H1> for Cons<H2, T> {
-        default type Output = Cons<H2, Set<H1, T>>;
-    }
-
-    pub trait ComputeTypeSetFixedPoint<E: ExpandTypeSet>: ExpandTypeSet {
-        type Output: ExpandTypeSet;
-    }
-
-    trait Same<T> {}
-    impl<T> Same<T> for T {}
-
-    impl<T: ExpandTypeSet, E: ExpandTypeSet> ComputeTypeSetFixedPoint<E> for T
-    where
-        T::Len: Same<E::Len>,
-    {
-        type Output = Self;
-    }
-
-    impl<T: ExpandTypeSet, E: ExpandTypeSet> ComputeTypeSetFixedPoint<E> for T {
-        default type Output = <E as ComputeTypeSetFixedPoint<<E as ExpandTypeSet>::Output<Empty>>>::Output;
-    }
-}
-
-pub(super) type TypeSet<T> =
-    <Set<T, <T as ComputeTypeSet>::Output<private::Empty>> as TypeSetFixedPoint>::Output;