diff --git a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
index f952f426..3a3d3cee 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_bundle.rs
@@ -396,15 +396,29 @@ impl ToTokens for Builder {
         quote_spanned! {self.ident.span()=>
             #[automatically_derived]
             #[allow(non_camel_case_types, dead_code, private_interfaces)]
-            impl #filled_impl_generics ::fayalite::expr::ToExpr for #filled_ty
+            impl #filled_impl_generics ::fayalite::expr::ValueType for #filled_ty
             #filled_where_clause
             {
                 type Type = #target #type_generics;
+                type ValueCategory = ::fayalite::expr::value_category::ValueCategoryExpr;
+
+                fn ty(&self) -> <Self as ::fayalite::expr::ValueType>::Type {
+                    #target {
+                        #(#field_idents: ::fayalite::expr::ValueType::ty(&self.#field_idents),)*
+                    }
+                }
+            }
+
+            #[automatically_derived]
+            #[allow(non_camel_case_types, dead_code, private_interfaces)]
+            impl #filled_impl_generics ::fayalite::expr::ToExpr for #filled_ty
+            #filled_where_clause
+            {
                 fn to_expr(
                     &self,
-                ) -> ::fayalite::expr::Expr<<Self as ::fayalite::expr::ToExpr>::Type> {
+                ) -> ::fayalite::expr::Expr<<Self as ::fayalite::expr::ValueType>::Type> {
                     let __ty = #target {
-                        #(#field_idents: ::fayalite::expr::Expr::ty(self.#field_idents),)*
+                        #(#field_idents: ::fayalite::expr::ValueType::ty(&self.#field_idents),)*
                     };
                     let __field_values = [
                         #(::fayalite::expr::Expr::canonical(self.#field_idents),)*
@@ -695,10 +709,10 @@ impl ToTokens for ParsedBundle {
                 v.field(&value.#ident);
             }
         }));
-        let to_sim_value_fields = Vec::from_iter(fields.named().into_iter().map(|field| {
+        let value_type_fields = Vec::from_iter(fields.named().into_iter().map(|field| {
             let ident: &Ident = field.ident().as_ref().unwrap();
             quote_spanned! {span=>
-                #ident: ::fayalite::sim::value::SimValue::ty(&self.#ident),
+                #ident: ::fayalite::expr::ValueType::ty(&self.#ident),
             }
         }));
         let fields_len = fields.named().into_iter().len();
@@ -806,28 +820,39 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
-            impl #impl_generics ::fayalite::sim::value::ToSimValue for #mask_type_sim_value_ident #type_generics
+            impl #impl_generics ::fayalite::expr::ValueType for #mask_type_sim_value_ident #type_generics
             #where_clause
             {
                 type Type = #mask_type_ident #type_generics;
+                type ValueCategory = ::fayalite::expr::value_category::ValueCategorySimValue;
 
+                fn ty(&self) -> <Self as ::fayalite::expr::ValueType>::Type {
+                    #mask_type_ident {
+                        #(#value_type_fields)*
+                    }
+                }
+            }
+            #[automatically_derived]
+            impl #impl_generics ::fayalite::sim::value::ToSimValue for #mask_type_sim_value_ident #type_generics
+            #where_clause
+            {
                 fn to_sim_value(
                     &self,
                 ) -> ::fayalite::sim::value::SimValue<
-                    <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                    <Self as ::fayalite::expr::ValueType>::Type,
                 > {
                     let ty = #mask_type_ident {
-                        #(#to_sim_value_fields)*
+                        #(#value_type_fields)*
                     };
                     ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self))
                 }
                 fn into_sim_value(
                     self,
                 ) -> ::fayalite::sim::value::SimValue<
-                    <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                    <Self as ::fayalite::expr::ValueType>::Type,
                 > {
                     let ty = #mask_type_ident {
-                        #(#to_sim_value_fields)*
+                        #(#value_type_fields)*
                     };
                     ::fayalite::sim::value::SimValue::from_value(ty, self)
                 }
@@ -955,28 +980,39 @@ impl ToTokens for ParsedBundle {
                 }
             }
             #[automatically_derived]
-            impl #impl_generics ::fayalite::sim::value::ToSimValue for #sim_value_ident #type_generics
+            impl #impl_generics ::fayalite::expr::ValueType for #sim_value_ident #type_generics
             #where_clause
             {
                 type Type = #target #type_generics;
+                type ValueCategory = ::fayalite::expr::value_category::ValueCategorySimValue;
 
+                fn ty(&self) -> <Self as ::fayalite::expr::ValueType>::Type {
+                    #target {
+                        #(#value_type_fields)*
+                    }
+                }
+            }
+            #[automatically_derived]
+            impl #impl_generics ::fayalite::sim::value::ToSimValue for #sim_value_ident #type_generics
+            #where_clause
+            {
                 fn to_sim_value(
                     &self,
                 ) -> ::fayalite::sim::value::SimValue<
-                    <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                    <Self as ::fayalite::expr::ValueType>::Type,
                 > {
                     let ty = #target {
-                        #(#to_sim_value_fields)*
+                        #(#value_type_fields)*
                     };
                     ::fayalite::sim::value::SimValue::from_value(ty, ::fayalite::__std::clone::Clone::clone(self))
                 }
                 fn into_sim_value(
                     self,
                 ) -> ::fayalite::sim::value::SimValue<
-                    <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                    <Self as ::fayalite::expr::ValueType>::Type,
                 > {
                     let ty = #target {
-                        #(#to_sim_value_fields)*
+                        #(#value_type_fields)*
                     };
                     ::fayalite::sim::value::SimValue::from_value(ty, self)
                 }
diff --git a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
index 885cf871..90838f0b 100644
--- a/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
+++ b/crates/fayalite-proc-macros-impl/src/hdl_enum.rs
@@ -1024,16 +1024,26 @@ impl ToTokens for ParsedEnum {
                         <::fayalite::int::Bool as ::fayalite::ty::StaticType>::TYPE_PROPERTIES;
                 }
                 #[automatically_derived]
-                impl #static_impl_generics ::fayalite::sim::value::ToSimValue
+                impl #static_impl_generics ::fayalite::expr::ValueType
                 for #sim_value_ident #static_type_generics
                 #static_where_clause
                 {
                     type Type = #target #static_type_generics;
+                    type ValueCategory = ::fayalite::expr::value_category::ValueCategorySimValue;
 
+                    fn ty(&self) -> <Self as ::fayalite::expr::ValueType>::Type {
+                        ::fayalite::ty::StaticType::TYPE
+                    }
+                }
+                #[automatically_derived]
+                impl #static_impl_generics ::fayalite::sim::value::ToSimValue
+                for #sim_value_ident #static_type_generics
+                #static_where_clause
+                {
                     fn to_sim_value(
                         &self,
                     ) -> ::fayalite::sim::value::SimValue<
-                        <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                        <Self as ::fayalite::expr::ValueType>::Type,
                     > {
                         ::fayalite::sim::value::SimValue::from_value(
                             ::fayalite::ty::StaticType::TYPE,
@@ -1043,7 +1053,7 @@ impl ToTokens for ParsedEnum {
                     fn into_sim_value(
                         self,
                     ) -> ::fayalite::sim::value::SimValue<
-                        <Self as ::fayalite::sim::value::ToSimValue>::Type,
+                        <Self as ::fayalite::expr::ValueType>::Type,
                     > {
                         ::fayalite::sim::value::SimValue::from_value(
                             ::fayalite::ty::StaticType::TYPE,
diff --git a/crates/fayalite-proc-macros-impl/src/lib.rs b/crates/fayalite-proc-macros-impl/src/lib.rs
index 13ec7a2e..152053cb 100644
--- a/crates/fayalite-proc-macros-impl/src/lib.rs
+++ b/crates/fayalite-proc-macros-impl/src/lib.rs
@@ -887,7 +887,13 @@ pub(crate) fn outline_generated(contents: TokenStream, prefix: &str) -> TokenStr
         }
     }
     let _print_on_panic = PrintOnPanic(&contents);
-    let contents = prettyplease::unparse(&parse_quote! { #contents });
+    let mut parse_err = None;
+    let (Ok(contents) | Err(contents)) = syn::parse2(contents.clone())
+        .map(|file| prettyplease::unparse(&file))
+        .map_err(|e| {
+            parse_err = Some(e);
+            contents.to_string()
+        });
     let hash = <sha2::Sha256 as sha2::Digest>::digest(&contents);
     let hash = base16ct::HexDisplay(&hash[..5]);
     file.write_all(contents.as_bytes()).unwrap();
@@ -899,9 +905,26 @@ pub(crate) fn outline_generated(contents: TokenStream, prefix: &str) -> TokenStr
             e.unwrap();
         }
     }
-    eprintln!("generated {}", dest_file.display());
+    let log_msg = if let Some(parse_err) = parse_err {
+        format!(
+            "fayalite-proc-macros-impl internal error:\nfailed to parse generated output: {parse_err}\nunformatted output is in: {}\n",
+            dest_file.display()
+        )
+    } else {
+        format!("generated {}\n", dest_file.display())
+    };
+    // write message atomically if possible
+    let mut stderr = std::io::stderr().lock();
+    let write_result = stderr.write_all(log_msg.as_bytes());
+    let flush_result = stderr.flush();
+    drop(stderr); // unlock before we try to panic
+    write_result.unwrap();
+    flush_result.unwrap();
+    std::io::stderr()
+        .lock()
+        .write_all(log_msg.as_bytes())
+        .unwrap();
     let dest_file = dest_file.to_str().unwrap();
-
     quote! {
         include!(#dest_file);
     }
diff --git a/crates/fayalite/examples/blinky.rs b/crates/fayalite/examples/blinky.rs
index 75799fdc..d2cdb336 100644
--- a/crates/fayalite/examples/blinky.rs
+++ b/crates/fayalite/examples/blinky.rs
@@ -12,7 +12,7 @@ fn blinky(platform_io_builder: PlatformIOBuilder<'_>) {
         clk: clk_input.clk,
         rst,
     };
-    let max_value = (Expr::ty(clk_input).frequency() / 2.0).round_ties_even() as u64 - 1;
+    let max_value = (clk_input.ty().frequency() / 2.0).round_ties_even() as u64 - 1;
     let int_ty = UInt::range_inclusive(0..=max_value);
     #[hdl]
     let counter_reg: UInt = reg_builder().clock_domain(cd).reset(0u8.cast_to(int_ty));
diff --git a/crates/fayalite/examples/tx_only_uart.rs b/crates/fayalite/examples/tx_only_uart.rs
index 5c20b395..59e29682 100644
--- a/crates/fayalite/examples/tx_only_uart.rs
+++ b/crates/fayalite/examples/tx_only_uart.rs
@@ -105,7 +105,7 @@ fn tx_only_uart(
     connect(tx, tx_bits[uart_state_reg]);
 
     #[hdl]
-    if uart_state_reg.cmp_eq(Expr::ty(tx_bits).len() - 1) {
+    if uart_state_reg.cmp_eq(tx_bits.ty().len() - 1) {
         connect(next_uart_state, 0_hdl_u4);
         let next_addr_val = addr_reg + 1u8;
         #[hdl]
diff --git a/crates/fayalite/src/array.rs b/crates/fayalite/src/array.rs
index 569f2e28..a07ebb4c 100644
--- a/crates/fayalite/src/array.rs
+++ b/crates/fayalite/src/array.rs
@@ -221,7 +221,7 @@ impl<T: Type, Len: Size> Type for ArrayType<T, Len> {
         let value = AsMut::<[SimValue<T>]>::as_mut(value);
         assert_eq!(self.len(), value.len());
         for element_value in value {
-            assert_eq!(SimValue::ty(element_value), element_ty);
+            assert_eq!(element_value.ty(), element_ty);
             let (element_opaque, rest) = opaque.split_at(element_size);
             SimValue::opaque_mut(element_value).clone_from_slice(element_opaque);
             opaque = rest;
@@ -238,7 +238,7 @@ impl<T: Type, Len: Size> Type for ArrayType<T, Len> {
         let value = AsRef::<[SimValue<T>]>::as_ref(value);
         assert_eq!(self.len(), value.len());
         for element_value in value {
-            assert_eq!(SimValue::ty(element_value), element_ty);
+            assert_eq!(element_value.ty(), element_ty);
             writer.fill_prefix_with(element_size, |writer| {
                 writer.fill_cloned_from_slice(SimValue::opaque(element_value).as_slice())
             });
@@ -331,9 +331,7 @@ where
     Lhs: ExprPartialEq<Rhs>,
 {
     fn cmp_eq(lhs: Expr<Self>, rhs: Expr<ArrayType<Rhs, Len>>) -> Expr<Bool> {
-        let lhs_ty = Expr::ty(lhs);
-        let rhs_ty = Expr::ty(rhs);
-        assert_eq!(lhs_ty.len(), rhs_ty.len());
+        assert_eq!(lhs.ty().len(), rhs.ty().len());
         lhs.into_iter()
             .zip(rhs)
             .map(|(l, r)| l.cmp_eq(r))
@@ -343,9 +341,7 @@ where
     }
 
     fn cmp_ne(lhs: Expr<Self>, rhs: Expr<ArrayType<Rhs, Len>>) -> Expr<Bool> {
-        let lhs_ty = Expr::ty(lhs);
-        let rhs_ty = Expr::ty(rhs);
-        assert_eq!(lhs_ty.len(), rhs_ty.len());
+        assert_eq!(lhs.ty().len(), rhs.ty().len());
         lhs.into_iter()
             .zip(rhs)
             .map(|(l, r)| l.cmp_ne(r))
@@ -374,7 +370,7 @@ impl<T: Type, Len: Size> ExprIntoIterator for ArrayType<T, Len> {
     fn expr_into_iter(e: Expr<Self>) -> Self::ExprIntoIter {
         ExprArrayIter {
             base: e,
-            indexes: 0..Expr::ty(e).len(),
+            indexes: 0..e.ty().len(),
         }
     }
 }
diff --git a/crates/fayalite/src/bundle.rs b/crates/fayalite/src/bundle.rs
index 0edf1928..04689c84 100644
--- a/crates/fayalite/src/bundle.rs
+++ b/crates/fayalite/src/bundle.rs
@@ -3,8 +3,9 @@
 
 use crate::{
     expr::{
-        CastToBits, Expr, ReduceBits, ToExpr,
+        CastToBits, Expr, ReduceBits, ToExpr, ToSimValueInner, ValueType,
         ops::{ArrayLiteral, BundleLiteral, ExprPartialEq},
+        value_category::{ValueCategoryCommon, ValueCategoryExpr, ValueCategoryValue},
     },
     int::{Bool, DynSize},
     intern::{Intern, InternSlice, Interned},
@@ -317,7 +318,7 @@ impl<'a> BundleSimValueFromOpaque<'a> {
     #[track_caller]
     pub fn field_clone_from_opaque<T: Type>(&mut self, field_value: &mut SimValue<T>) {
         let (field_ty, field_opaque) = self.field_ty_and_opaque::<T>();
-        assert_eq!(field_ty, SimValue::ty(field_value));
+        assert_eq!(field_ty, field_value.ty());
         SimValue::opaque_mut(field_value).clone_from_slice(field_opaque);
     }
 }
@@ -353,7 +354,7 @@ impl<'a> BundleSimValueToOpaque<'a> {
         else {
             panic!("tried to write too many fields with BundleSimValueToOpaque");
         };
-        assert_eq!(T::from_canonical(ty), SimValue::ty(field_value));
+        assert_eq!(T::from_canonical(ty), field_value.ty());
         self.writer.fill_prefix_with(ty.size(), |writer| {
             writer.fill_cloned_from_slice(SimValue::opaque(field_value).as_slice())
         });
@@ -566,23 +567,54 @@ macro_rules! impl_tuples {
                 builder.finish()
             };
         }
-        impl<$($T: ToExpr,)*> ToExpr for ($($T,)*) {
+        impl<$($T: ToSimValue,)*> ToSimValueInner for ($($T,)*)
+        where
+            Self: ValueType,
+        {
+            fn to_sim_value_inner(this: &Self) -> <Self::Type as Type>::SimValue {
+                let ($($var,)*) = this;
+                ($($var.to_sim_value(),)*)
+            }
+            fn into_sim_value_inner(this: Self) -> <Self::Type as Type>::SimValue {
+                let ($($var,)*) = this;
+                ($($var.into_sim_value(),)*)
+            }
+        }
+        impl<$($T: ValueType,)*> ValueType for ($($T,)*)
+        where
+            ValueCategoryValue: ValueCategoryCommon<($($T::ValueCategory,)*)>,
+        {
             type Type = ($($T::Type,)*);
-
+            type ValueCategory = <ValueCategoryValue as ValueCategoryCommon<($($T::ValueCategory,)*)>>::Common;
+            fn ty(&self) -> Self::Type {
+                let ($($var,)*) = self;
+                ($($var.ty(),)*)
+            }
+        }
+        impl<$($T: ToExpr,)*> ToExpr for ($($T,)*)
+        where
+            Self: ValueType<Type = ($($T::Type,)*)>,
+        {
             fn to_expr(&self) -> Expr<Self::Type> {
                 let ($($var,)*) = self;
                 $(let $var = $var.to_expr();)*
-                let ty = ($(Expr::ty($var),)*);
+                let ty = ($($var.ty(),)*);
                 let field_values = [$(Expr::canonical($var)),*];
                 BundleLiteral::new(ty, field_values.intern_slice()).to_expr()
             }
         }
-        impl<$($T: Type,)*> ToExpr for TupleBuilder<($(Expr<$T>,)*)> {
+        impl<$($T: Type,)*> ValueType for TupleBuilder<($(Expr<$T>,)*)> {
             type Type = ($($T,)*);
-
+            type ValueCategory = ValueCategoryExpr;
+            fn ty(&self) -> Self::Type {
+                let ($($var,)*) = self.0;
+                ($($var.ty(),)*)
+            }
+        }
+        impl<$($T: Type,)*> ToExpr for TupleBuilder<($(Expr<$T>,)*)> {
             fn to_expr(&self) -> Expr<Self::Type> {
                 let ($($var,)*) = self.0;
-                let ty = ($(Expr::ty($var),)*);
+                let ty = ($($var.ty(),)*);
                 let field_values = [$(Expr::canonical($var)),*];
                 BundleLiteral::new(ty, field_values.intern_slice()).to_expr()
             }
@@ -618,7 +650,7 @@ macro_rules! impl_tuples {
                 };
                 let mut opaque = OpaqueSimValue::empty();
                 $(let $var = $var.into_sim_value_with_type($ty_var.ty);
-                assert_eq!(SimValue::ty(&$var), $ty_var.ty);
+                assert_eq!($var.ty(), $ty_var.ty);
                 opaque.extend_from_slice(SimValue::opaque(&$var).as_slice());
                 )*
                 SimValue::from_opaque(ty, opaque)
@@ -640,19 +672,21 @@ macro_rules! impl_tuples {
                 SimValue::from_value(ty, ($($var,)*))
             }
         }
-        impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*) {
-            type Type = ($($T::Type,)*);
+        impl<$($T: ToSimValue,)*> ToSimValue for ($($T,)*)
+        where
+            Self: ValueType<Type = ($($T::Type,)*)>,
+        {
             #[track_caller]
             fn to_sim_value(&self) -> SimValue<Self::Type> {
                 let ($($var,)*) = self;
                 $(let $var = $var.to_sim_value();)*
-                SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*))
+                SimValue::from_value(($($var.ty(),)*), ($($var,)*))
             }
             #[track_caller]
             fn into_sim_value(self) -> SimValue<Self::Type> {
                 let ($($var,)*) = self;
                 $(let $var = $var.to_sim_value();)*
-                SimValue::from_value(($(SimValue::ty(&$var),)*), ($($var,)*))
+                SimValue::from_value(($($var.ty(),)*), ($($var,)*))
             }
         }
         impl<$($Lhs: Type + ExprPartialEq<$Rhs>, $Rhs: Type,)*> ExprPartialEq<($($Rhs,)*)> for ($($Lhs,)*) {
@@ -775,9 +809,16 @@ impl<T: ?Sized + Send + Sync + 'static> Default for PhantomDataBuilder<T> {
     }
 }
 
-impl<T: ?Sized + Send + Sync + 'static> ToExpr for PhantomDataBuilder<T> {
+impl<T: ?Sized + Send + Sync + 'static> ValueType for PhantomDataBuilder<T> {
     type Type = PhantomData<T>;
+    type ValueCategory = ValueCategoryValue;
 
+    fn ty(&self) -> Self::Type {
+        PhantomData
+    }
+}
+
+impl<T: ?Sized + Send + Sync + 'static> ToExpr for PhantomDataBuilder<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         PhantomData.to_expr()
     }
@@ -803,17 +844,22 @@ impl<T: ?Sized + Send + Sync + 'static> StaticType for PhantomData<T> {
     const MASK_TYPE_PROPERTIES: TypeProperties = <()>::TYPE_PROPERTIES;
 }
 
-impl<T: ?Sized + Send + Sync + 'static> ToExpr for PhantomData<T> {
+impl<T: ?Sized + Send + Sync + 'static> ValueType for PhantomData<T> {
     type Type = PhantomData<T>;
+    type ValueCategory = ValueCategoryValue;
 
+    fn ty(&self) -> Self::Type {
+        PhantomData
+    }
+}
+
+impl<T: ?Sized + Send + Sync + 'static> ToExpr for PhantomData<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         BundleLiteral::new(PhantomData, Interned::default()).to_expr()
     }
 }
 
 impl<T: ?Sized + Send + Sync + 'static> ToSimValue for PhantomData<T> {
-    type Type = PhantomData<T>;
-
     #[track_caller]
     fn to_sim_value(&self) -> SimValue<Self> {
         SimValue::from_value(*self, *self)
diff --git a/crates/fayalite/src/clock.rs b/crates/fayalite/src/clock.rs
index 909edbdf..168142b7 100644
--- a/crates/fayalite/src/clock.rs
+++ b/crates/fayalite/src/clock.rs
@@ -1,10 +1,11 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
-    expr::{Expr, ToExpr},
+    expr::{Expr, ValueType},
     hdl,
     int::Bool,
     reset::{Reset, ResetType},
+    sim::value::SimValue,
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
@@ -91,29 +92,34 @@ impl StaticType for Clock {
 }
 
 pub trait ToClock {
-    fn to_clock(&self) -> Expr<Clock>;
+    type Output: ValueType<Type = Clock>;
+    fn to_clock(&self) -> Self::Output;
 }
 
 impl<T: ?Sized + ToClock> ToClock for &'_ T {
-    fn to_clock(&self) -> Expr<Clock> {
+    type Output = T::Output;
+    fn to_clock(&self) -> Self::Output {
         (**self).to_clock()
     }
 }
 
 impl<T: ?Sized + ToClock> ToClock for &'_ mut T {
-    fn to_clock(&self) -> Expr<Clock> {
+    type Output = T::Output;
+    fn to_clock(&self) -> Self::Output {
         (**self).to_clock()
     }
 }
 
 impl<T: ?Sized + ToClock> ToClock for Box<T> {
-    fn to_clock(&self) -> Expr<Clock> {
+    type Output = T::Output;
+    fn to_clock(&self) -> Self::Output {
         (**self).to_clock()
     }
 }
 
 impl ToClock for Expr<Clock> {
-    fn to_clock(&self) -> Expr<Clock> {
+    type Output = Expr<Clock>;
+    fn to_clock(&self) -> Self::Output {
         *self
     }
 }
@@ -125,7 +131,25 @@ pub struct ClockDomain<R: ResetType = Reset> {
 }
 
 impl ToClock for bool {
-    fn to_clock(&self) -> Expr<Clock> {
-        self.to_expr().to_clock()
+    type Output = SimValue<Clock>;
+
+    fn to_clock(&self) -> Self::Output {
+        SimValue::from_value(Clock, *self)
+    }
+}
+
+impl ToClock for SimValue<Bool> {
+    type Output = SimValue<Clock>;
+
+    fn to_clock(&self) -> Self::Output {
+        SimValue::from_value(Clock, **self)
+    }
+}
+
+impl ToClock for SimValue<Clock> {
+    type Output = SimValue<Clock>;
+
+    fn to_clock(&self) -> Self::Output {
+        self.clone()
     }
 }
diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs
index 083072b5..e1a6dfa3 100644
--- a/crates/fayalite/src/enum_.rs
+++ b/crates/fayalite/src/enum_.rs
@@ -3,7 +3,7 @@
 
 use crate::{
     expr::{
-        Expr, ToExpr,
+        Expr, ToExpr, ValueType,
         ops::{ExprPartialEq, VariantAccess},
     },
     hdl,
@@ -599,7 +599,7 @@ impl<'a> EnumSimValueFromOpaque<'a> {
         let (Some(variant_ty), variant_bits, padding_bits) = self.known_variant(true) else {
             self.usage_error(true);
         };
-        assert_eq!(SimValue::ty(value), T::from_canonical(variant_ty));
+        assert_eq!(value.ty(), T::from_canonical(variant_ty));
         SimValue::bits_mut(value)
             .bits_mut()
             .copy_from_bitslice(variant_bits);
@@ -711,7 +711,7 @@ impl<'a> EnumSimValueToOpaque<'a> {
         let Some(variant_ty) = self.variants[discriminant].ty else {
             panic!("expected variant to have no field");
         };
-        assert_eq!(SimValue::ty(value), T::from_canonical(variant_ty));
+        assert_eq!(value.ty(), T::from_canonical(variant_ty));
         self.known_variant(discriminant, Some(SimValue::opaque(value)), padding)
     }
 }
@@ -813,7 +813,7 @@ pub fn HdlNone<T: StaticType>() -> Expr<HdlOption<T>> {
 #[allow(non_snake_case)]
 pub fn HdlSome<T: Type>(value: impl ToExpr<Type = T>) -> Expr<HdlOption<T>> {
     let value = value.to_expr();
-    HdlOption[Expr::ty(value)].HdlSome(value)
+    HdlOption[value.ty()].HdlSome(value)
 }
 
 impl<T: Type> HdlOption<T> {
@@ -853,7 +853,7 @@ impl<T: Type> HdlOption<T> {
         let value = f(value).inspect_err(|_| {
             and_then_out.complete(()); // avoid error
         })?;
-        let and_then_out = and_then_out.complete(Expr::ty(value));
+        let and_then_out = and_then_out.complete(value.ty());
         connect(and_then_out, value);
         drop(some_scope);
         let (Wrap::<<Self as Type>::MatchVariant>::HdlNone, none_scope) =
@@ -861,7 +861,7 @@ impl<T: Type> HdlOption<T> {
         else {
             unreachable!();
         };
-        connect(and_then_out, Expr::ty(and_then_out).HdlNone());
+        connect(and_then_out, and_then_out.ty().HdlNone());
         drop(none_scope);
         Ok(and_then_out)
     }
@@ -879,8 +879,8 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn and<U: Type>(expr: Expr<Self>, opt_b: Expr<HdlOption<U>>) -> Expr<HdlOption<U>> {
         #[hdl]
-        let and_out = wire(Expr::ty(opt_b));
-        connect(and_out, Expr::ty(opt_b).HdlNone());
+        let and_out = wire(opt_b.ty());
+        connect(and_out, opt_b.ty().HdlNone());
         #[hdl]
         if let HdlSome(_) = expr {
             connect(and_out, opt_b);
@@ -894,8 +894,8 @@ impl<T: Type> HdlOption<T> {
         f: impl FnOnce(Expr<T>) -> Result<Expr<Bool>, E>,
     ) -> Result<Expr<Self>, E> {
         #[hdl]
-        let filtered = wire(Expr::ty(expr));
-        connect(filtered, Expr::ty(expr).HdlNone());
+        let filtered = wire(expr.ty());
+        connect(filtered, expr.ty().HdlNone());
         let mut f = Some(f);
         #[hdl]
         if let HdlSome(v) = expr {
@@ -969,7 +969,7 @@ impl<T: Type> HdlOption<T> {
         f: impl FnOnce(Expr<T>) -> Expr<R>,
     ) -> Expr<R> {
         #[hdl]
-        let mapped = wire(Expr::ty(default));
+        let mapped = wire(default.ty());
         let mut f = Some(f);
         #[hdl]
         match expr {
@@ -994,12 +994,12 @@ impl<T: Type> HdlOption<T> {
         match expr {
             HdlSome(v) => {
                 let v = f.take().unwrap()(v);
-                let mapped = *retval.get_or_insert_with(|| mapped.complete(Expr::ty(v)));
+                let mapped = *retval.get_or_insert_with(|| mapped.complete(v.ty()));
                 connect(mapped, v);
             }
             HdlNone => {
                 let v = default.take().unwrap()();
-                let mapped = *retval.get_or_insert_with(|| mapped.complete(Expr::ty(v)));
+                let mapped = *retval.get_or_insert_with(|| mapped.complete(v.ty()));
                 connect(mapped, v);
             }
         }
@@ -1009,7 +1009,7 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn or(expr: Expr<Self>, opt_b: Expr<Self>) -> Expr<Self> {
         #[hdl]
-        let or_out = wire(Expr::ty(expr));
+        let or_out = wire(expr.ty());
         connect(or_out, opt_b);
         #[hdl]
         if let HdlSome(_) = expr {
@@ -1021,7 +1021,7 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn or_else(expr: Expr<Self>, f: impl FnOnce() -> Expr<Self>) -> Expr<Self> {
         #[hdl]
-        let or_else_out = wire(Expr::ty(expr));
+        let or_else_out = wire(expr.ty());
         connect(or_else_out, f());
         #[hdl]
         if let HdlSome(_) = expr {
@@ -1033,7 +1033,7 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn unwrap_or(expr: Expr<Self>, default: Expr<T>) -> Expr<T> {
         #[hdl]
-        let unwrap_or_else_out = wire(Expr::ty(default));
+        let unwrap_or_else_out = wire(default.ty());
         connect(unwrap_or_else_out, default);
         #[hdl]
         if let HdlSome(v) = expr {
@@ -1045,7 +1045,7 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn unwrap_or_else(expr: Expr<Self>, f: impl FnOnce() -> Expr<T>) -> Expr<T> {
         #[hdl]
-        let unwrap_or_else_out = wire(Expr::ty(expr).HdlSome);
+        let unwrap_or_else_out = wire(expr.ty().HdlSome);
         connect(unwrap_or_else_out, f());
         #[hdl]
         if let HdlSome(v) = expr {
@@ -1057,14 +1057,14 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn xor(expr: Expr<Self>, opt_b: Expr<Self>) -> Expr<Self> {
         #[hdl]
-        let xor_out = wire(Expr::ty(expr));
+        let xor_out = wire(expr.ty());
         #[hdl]
         if let HdlSome(_) = expr {
             #[hdl]
             if let HdlNone = opt_b {
                 connect(xor_out, expr);
             } else {
-                connect(xor_out, Expr::ty(expr).HdlNone());
+                connect(xor_out, expr.ty().HdlNone());
             }
         } else {
             connect(xor_out, opt_b);
@@ -1075,8 +1075,8 @@ impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn zip<U: Type>(expr: Expr<Self>, other: Expr<HdlOption<U>>) -> Expr<HdlOption<(T, U)>> {
         #[hdl]
-        let zip_out = wire(HdlOption[(Expr::ty(expr).HdlSome, Expr::ty(other).HdlSome)]);
-        connect(zip_out, Expr::ty(zip_out).HdlNone());
+        let zip_out = wire(HdlOption[(expr.ty().HdlSome, other.ty().HdlSome)]);
+        connect(zip_out, zip_out.ty().HdlNone());
         #[hdl]
         if let HdlSome(l) = expr {
             #[hdl]
@@ -1093,11 +1093,11 @@ impl<T: Type> HdlOption<HdlOption<T>> {
     #[track_caller]
     pub fn flatten(expr: Expr<Self>) -> Expr<HdlOption<T>> {
         #[hdl]
-        let flattened = wire(Expr::ty(expr).HdlSome);
+        let flattened = wire(expr.ty().HdlSome);
         #[hdl]
         match expr {
             HdlSome(v) => connect(flattened, v),
-            HdlNone => connect(flattened, Expr::ty(expr).HdlSome.HdlNone()),
+            HdlNone => connect(flattened, expr.ty().HdlSome.HdlNone()),
         }
         flattened
     }
@@ -1107,7 +1107,7 @@ impl<T: Type, U: Type> HdlOption<(T, U)> {
     #[hdl]
     #[track_caller]
     pub fn unzip(expr: Expr<Self>) -> Expr<(HdlOption<T>, HdlOption<U>)> {
-        let (t, u) = Expr::ty(expr).HdlSome;
+        let (t, u) = expr.ty().HdlSome;
         #[hdl]
         let unzipped = wire((HdlOption[t], HdlOption[u]));
         connect(unzipped, (HdlOption[t].HdlNone(), HdlOption[u].HdlNone()));
diff --git a/crates/fayalite/src/expr.rs b/crates/fayalite/src/expr.rs
index 89e60cda..45e02234 100644
--- a/crates/fayalite/src/expr.rs
+++ b/crates/fayalite/src/expr.rs
@@ -9,7 +9,7 @@ use crate::{
         ops::ExprCastTo,
         target::{GetTarget, Target},
     },
-    int::{Bool, DynSize, IntType, SIntType, SIntValue, Size, SizeType, UInt, UIntType, UIntValue},
+    int::{Bool, DynSize, IntType, SIntValue, Size, SizeType, UInt, UIntType, UIntValue},
     intern::{Intern, Interned},
     memory::{DynPortType, MemPort, PortType},
     module::{
@@ -20,6 +20,7 @@ use crate::{
     reg::Reg,
     reset::{AsyncReset, Reset, ResetType, ResetTypeDispatch, SyncReset},
     ty::{CanonicalType, StaticType, Type, TypeWithDeref},
+    util::ConstBool,
     wire::Wire,
 };
 use bitvec::slice::BitSlice;
@@ -27,6 +28,7 @@ use std::{convert::Infallible, fmt, ops::Deref};
 
 pub mod ops;
 pub mod target;
+pub mod value_category;
 
 macro_rules! expr_enum {
     (
@@ -77,9 +79,18 @@ macro_rules! expr_enum {
             }
         }
 
-        impl ToExpr for $ExprEnum {
+        impl ValueType for $ExprEnum {
             type Type = CanonicalType;
+            type ValueCategory = value_category::ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                match self {
+                    $(Self::$Variant(v) => v.ty().canonical(),)*
+                }
+            }
+        }
+
+        impl ToExpr for $ExprEnum {
             fn to_expr(&self) -> Expr<Self::Type> {
                 match self {
                     $(Self::$Variant(v) => Expr::canonical(v.to_expr()),)*
@@ -282,7 +293,7 @@ impl<T: Type + fmt::Debug> fmt::Debug for Expr<T> {
                 __flow,
             } = self;
             let expr_ty = __ty.canonical();
-            let enum_ty = __enum.to_expr().__ty;
+            let enum_ty = __enum.to_expr().ty();
             assert_eq!(
                 expr_ty, enum_ty,
                 "expr ty mismatch:\nExpr {{\n__enum: {__enum:?},\n__ty: {__ty:?},\n__flow: {__flow:?}\n}}"
@@ -296,23 +307,20 @@ impl<T: Type> Expr<T> {
     pub fn expr_enum(this: Self) -> Interned<ExprEnum> {
         this.__enum
     }
-    pub fn ty(this: Self) -> T {
-        this.__ty
-    }
     pub fn flow(this: Self) -> Flow {
         this.__flow
     }
     pub fn canonical(this: Self) -> Expr<CanonicalType> {
         Expr {
             __enum: this.__enum,
-            __ty: this.__ty.canonical(),
+            __ty: this.ty().canonical(),
             __flow: this.__flow,
         }
     }
     pub fn from_canonical(this: Expr<CanonicalType>) -> Self {
         Expr {
             __enum: this.__enum,
-            __ty: T::from_canonical(this.__ty),
+            __ty: T::from_canonical(this.ty()),
             __flow: this.__flow,
         }
     }
@@ -322,7 +330,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: T::from_dyn_int(this.__ty),
+            __ty: T::from_dyn_int(this.ty()),
             __flow: this.__flow,
         }
     }
@@ -332,7 +340,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: this.__ty.as_dyn_int(),
+            __ty: this.ty().as_dyn_int(),
             __flow: this.__flow,
         }
     }
@@ -342,7 +350,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: Bundle::new(this.__ty.fields()),
+            __ty: Bundle::new(this.ty().fields()),
             __flow: this.__flow,
         }
     }
@@ -352,7 +360,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: T::from_canonical(CanonicalType::Bundle(this.__ty)),
+            __ty: T::from_canonical(CanonicalType::Bundle(this.ty())),
             __flow: this.__flow,
         }
     }
@@ -369,7 +377,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: Enum::new(this.__ty.variants()),
+            __ty: Enum::new(this.ty().variants()),
             __flow: this.__flow,
         }
     }
@@ -379,7 +387,7 @@ impl<T: Type> Expr<T> {
     {
         Expr {
             __enum: this.__enum,
-            __ty: T::from_canonical(CanonicalType::Enum(this.__ty)),
+            __ty: T::from_canonical(CanonicalType::Enum(this.ty())),
             __flow: this.__flow,
         }
     }
@@ -409,7 +417,7 @@ impl<T: Type, Len: Size> Expr<ArrayType<T, Len>> {
     pub fn as_dyn_array(this: Self) -> Expr<Array> {
         Expr {
             __enum: this.__enum,
-            __ty: this.__ty.as_dyn_array(),
+            __ty: this.ty().as_dyn_array(),
             __flow: this.__flow,
         }
     }
@@ -435,54 +443,41 @@ impl<T: Type, State: Visitor + ?Sized> Visit<State> for Expr<T> {
     }
 }
 
-pub trait ToExpr {
-    type Type: Type;
+pub trait ToExpr: ValueType + ToValueless {
     fn to_expr(&self) -> Expr<Self::Type>;
 }
 
 impl<T: Type> ToExpr for Expr<T> {
-    type Type = T;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         *self
     }
 }
 
 impl<T: ?Sized + ToExpr> ToExpr for &'_ T {
-    type Type = T::Type;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         T::to_expr(self)
     }
 }
 
 impl<T: ?Sized + ToExpr> ToExpr for &'_ mut T {
-    type Type = T::Type;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         T::to_expr(self)
     }
 }
 
 impl<T: ?Sized + ToExpr> ToExpr for Box<T> {
-    type Type = T::Type;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         T::to_expr(self)
     }
 }
 
 impl<T: ?Sized + ToExpr + Send + Sync + 'static> ToExpr for Interned<T> {
-    type Type = T::Type;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         T::to_expr(self)
     }
 }
 
 impl<Width: Size> ToExpr for UIntValue<Width> {
-    type Type = UIntType<Width>;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::UIntLiteral(self.clone().as_dyn_int().intern()).intern(),
@@ -493,8 +488,6 @@ impl<Width: Size> ToExpr for UIntValue<Width> {
 }
 
 impl<Width: Size> ToExpr for SIntValue<Width> {
-    type Type = SIntType<Width>;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::SIntLiteral(self.clone().as_dyn_int().intern()).intern(),
@@ -504,9 +497,16 @@ impl<Width: Size> ToExpr for SIntValue<Width> {
     }
 }
 
-impl ToExpr for bool {
+impl ValueType for bool {
     type Type = Bool;
+    type ValueCategory = value_category::ValueCategoryValue;
 
+    fn ty(&self) -> Self::Type {
+        Bool
+    }
+}
+
+impl ToExpr for bool {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::BoolLiteral(*self).intern(),
@@ -537,8 +537,6 @@ impl Flow {
 }
 
 impl<T: Type> ToExpr for ModuleIO<T> {
-    type Type = T;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::ModuleIO(self.canonical()).intern_sized(),
@@ -561,8 +559,6 @@ impl<T: Type> GetTarget for ModuleIO<T> {
 }
 
 impl<T: BundleType> ToExpr for Instance<T> {
-    type Type = T;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::Instance(self.canonical()).intern_sized(),
@@ -585,8 +581,6 @@ impl<T: BundleType> GetTarget for Instance<T> {
 }
 
 impl<T: Type> ToExpr for Wire<T> {
-    type Type = T;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::Wire(self.canonical()).intern_sized(),
@@ -609,8 +603,6 @@ impl<T: Type> GetTarget for Wire<T> {
 }
 
 impl<T: Type, R: ResetType> ToExpr for Reg<T, R> {
-    type Type = T;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         struct Dispatch;
         impl ResetTypeDispatch for Dispatch {
@@ -650,8 +642,6 @@ impl<T: Type, R: ResetType> GetTarget for Reg<T, R> {
 }
 
 impl<T: PortType> ToExpr for MemPort<T> {
-    type Type = T::Port;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::MemPort(self.canonical()).intern_sized(),
@@ -674,20 +664,21 @@ impl<T: PortType> GetTarget for MemPort<T> {
 }
 
 pub trait HdlPartialEq<Rhs> {
-    fn cmp_eq(self, rhs: Rhs) -> Expr<Bool>;
-    fn cmp_ne(self, rhs: Rhs) -> Expr<Bool>;
+    type Output: ValueType<Type = Bool>;
+    fn cmp_eq(&self, rhs: Rhs) -> Self::Output;
+    fn cmp_ne(&self, rhs: Rhs) -> Self::Output;
 }
 
 pub trait HdlPartialOrd<Rhs>: HdlPartialEq<Rhs> {
-    fn cmp_lt(self, rhs: Rhs) -> Expr<Bool>;
-    fn cmp_le(self, rhs: Rhs) -> Expr<Bool>;
-    fn cmp_gt(self, rhs: Rhs) -> Expr<Bool>;
-    fn cmp_ge(self, rhs: Rhs) -> Expr<Bool>;
+    fn cmp_lt(&self, rhs: Rhs) -> Self::Output;
+    fn cmp_le(&self, rhs: Rhs) -> Self::Output;
+    fn cmp_gt(&self, rhs: Rhs) -> Self::Output;
+    fn cmp_ge(&self, rhs: Rhs) -> Self::Output;
 }
 
 pub trait ReduceBits {
-    type UIntOutput;
-    type BoolOutput;
+    type UIntOutput: ValueType<Type = UInt<1>>;
+    type BoolOutput: ValueType<Type = Bool>;
     fn reduce_bitand(self) -> Self::UIntOutput;
     fn reduce_bitor(self) -> Self::UIntOutput;
     fn reduce_bitxor(self) -> Self::UIntOutput;
@@ -699,43 +690,59 @@ pub trait ReduceBits {
     fn parity_even(self) -> Self::BoolOutput;
 }
 
-pub trait CastToBits {
-    fn cast_to_bits(&self) -> Expr<UInt>;
+pub trait CastToBits: ValueType {
+    type Output: ValueType<Type = UInt>;
+    fn cast_to_bits(&self) -> Self::Output;
 }
 
-impl<T: ToExpr + ?Sized> CastToBits for T {
-    fn cast_to_bits(&self) -> Expr<UInt> {
+impl<T: Type> CastToBits for Expr<T> {
+    type Output = Expr<UInt>;
+    fn cast_to_bits(&self) -> Self::Output {
         ops::CastToBits::new(Expr::canonical(self.to_expr())).to_expr()
     }
 }
 
-pub trait CastBitsTo {
+pub trait CastBitsTo: ValueType<Type: IntType<Signed = ConstBool<false>>> {
+    type Output<T: Type>: ValueType<Type = T>;
     #[track_caller]
-    fn cast_bits_to<T: Type>(&self, ty: T) -> Expr<T>;
+    fn cast_bits_to<T: Type>(&self, ty: T) -> Self::Output<T>;
 }
 
-impl<T: ToExpr<Type = UIntType<Width>> + ?Sized, Width: Size> CastBitsTo for T {
+impl<Width: Size> CastBitsTo for Expr<UIntType<Width>> {
+    type Output<T: Type> = Expr<T>;
     fn cast_bits_to<ToType: Type>(&self, ty: ToType) -> Expr<ToType> {
-        ops::CastBitsTo::new(Expr::as_dyn_int(self.to_expr()), ty).to_expr()
+        ops::CastBitsTo::new(Expr::as_dyn_int(*self), ty).to_expr()
     }
 }
 
-pub trait CastTo: ToExpr {
-    fn cast_to<ToType: Type>(&self, to_type: ToType) -> Expr<ToType>
-    where
-        Self::Type: ExprCastTo<ToType>,
-    {
-        ExprCastTo::cast_to(self.to_expr(), to_type)
-    }
-    fn cast_to_static<ToType: StaticType>(&self) -> Expr<ToType>
-    where
-        Self::Type: ExprCastTo<ToType>,
-    {
-        ExprCastTo::cast_to(self.to_expr(), ToType::TYPE)
+pub trait CastToImpl<ToType: Type> {
+    type Output: ValueType<Type = ToType>;
+    fn cast_to(this: &Self, to_type: ToType) -> Self::Output;
+}
+
+impl<T: Type + ExprCastTo<ToType>, ToType: Type> CastToImpl<ToType> for Expr<T> {
+    type Output = Expr<ToType>;
+    fn cast_to(this: &Self, to_type: ToType) -> Self::Output {
+        ExprCastTo::cast_to(*this, to_type)
     }
 }
 
-impl<T: ToExpr + ?Sized> CastTo for T {}
+pub trait CastTo: ValueType {
+    fn cast_to<ToType: Type>(&self, to_type: ToType) -> <Self as CastToImpl<ToType>>::Output
+    where
+        Self: CastToImpl<ToType>,
+    {
+        CastToImpl::cast_to(self, to_type)
+    }
+    fn cast_to_static<ToType: StaticType>(&self) -> <Self as CastToImpl<ToType>>::Output
+    where
+        Self: CastToImpl<ToType>,
+    {
+        CastToImpl::cast_to(self, ToType::TYPE)
+    }
+}
+
+impl<T: ValueType + ?Sized> CastTo for T {}
 
 #[doc(hidden)]
 pub fn check_match_expr<T: Type>(
@@ -761,7 +768,7 @@ pub fn repeat<T: Type, L: SizeType>(
     let element = element.to_expr();
     let canonical_element = Expr::canonical(element);
     ops::ArrayLiteral::new(
-        Expr::ty(element),
+        element.ty(),
         std::iter::repeat(canonical_element)
             .take(L::Size::as_usize(len))
             .collect(),
@@ -769,9 +776,16 @@ pub fn repeat<T: Type, L: SizeType>(
     .to_expr()
 }
 
-impl<T: ?Sized + crate::phantom_const::PhantomConstValue> ToExpr for PhantomConst<T> {
+impl<T: ?Sized + crate::phantom_const::PhantomConstValue> ValueType for PhantomConst<T> {
     type Type = Self;
+    type ValueCategory = value_category::ValueCategoryValue;
 
+    fn ty(&self) -> Self::Type {
+        *self
+    }
+}
+
+impl<T: ?Sized + crate::phantom_const::PhantomConstValue> ToExpr for PhantomConst<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::PhantomConst(self.canonical_phantom_const()).intern_sized(),
@@ -792,3 +806,231 @@ impl<T: ?Sized + crate::phantom_const::PhantomConstValue> ToLiteralBits for Phan
         Ok(Interned::default())
     }
 }
+
+#[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
+pub struct Valueless<T: Type>(T);
+
+impl<T: Type> Valueless<T> {
+    pub const fn new(ty: T) -> Self {
+        Self(ty)
+    }
+    pub const fn ty(self) -> T {
+        self.0
+    }
+}
+
+impl<T: StaticType> Default for Valueless<T> {
+    fn default() -> Self {
+        Self(T::TYPE)
+    }
+}
+
+pub trait ValueType {
+    type Type: Type;
+    type ValueCategory: value_category::ValueCategory;
+    fn ty(&self) -> Self::Type;
+}
+
+trait ToValuelessSealed {}
+
+#[expect(private_bounds)]
+pub trait ToValueless: ValueType + ToValuelessSealed {
+    fn to_valueless(&self) -> Valueless<Self::Type> {
+        Valueless::new(self.ty())
+    }
+}
+
+impl<T: ?Sized + ValueType> ToValuelessSealed for T {}
+
+impl<T: ?Sized + ValueType> ToValueless for T {}
+
+impl<T: Type> ValueType for Valueless<T> {
+    type Type = T;
+    type ValueCategory = value_category::ValueCategoryValueless;
+
+    fn ty(&self) -> Self::Type {
+        self.0
+    }
+}
+
+impl<'a, T: ?Sized + ValueType> ValueType for &'a T {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<'a, T: ?Sized + ValueType> ValueType for &'a mut T {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<T: ?Sized + ValueType> ValueType for Box<T> {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<T: ?Sized + ValueType> ValueType for std::sync::Arc<T> {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<T: ?Sized + ValueType> ValueType for std::rc::Rc<T> {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<T: ?Sized + ValueType + 'static + Send + Sync> ValueType for Interned<T> {
+    type Type = T::Type;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        T::ty(self)
+    }
+}
+
+impl<T: Type> ValueType for Expr<T> {
+    type Type = T;
+    type ValueCategory = value_category::ValueCategoryExpr;
+
+    fn ty(&self) -> Self::Type {
+        self.__ty
+    }
+}
+
+trait ToValueWithCategorySealed {}
+
+#[expect(private_bounds)]
+pub trait ToValueWithCategory: ValueType + ToValueWithCategorySealed {
+    type ToValueWithCategoryOutput: ValueType<Type = Self::Type, ValueCategory = Self::ValueCategory>;
+    fn to_value_with_category(this: &Self) -> Self::ToValueWithCategoryOutput;
+    fn into_value_with_category(this: Self) -> Self::ToValueWithCategoryOutput
+    where
+        Self: Sized;
+}
+
+pub trait ToValueWithCategoryHelper<C: value_category::ValueCategory>:
+    ValueType<ValueCategory = C>
+{
+    type HelperOutput: ValueType<Type = Self::Type, ValueCategory = C>;
+    fn to_value_with_category_helper(this: &Self) -> Self::HelperOutput;
+    fn into_value_with_category_helper(this: Self) -> Self::HelperOutput
+    where
+        Self: Sized;
+}
+
+impl<
+    T: ?Sized + ToValueWithCategoryHelper<C> + ValueType<ValueCategory = C>,
+    C: value_category::ValueCategory,
+> ToValueWithCategorySealed for T
+{
+}
+
+impl<
+    T: ?Sized + ToValueWithCategoryHelper<C> + ValueType<ValueCategory = C>,
+    C: value_category::ValueCategory,
+> ToValueWithCategory for T
+{
+    type ToValueWithCategoryOutput = T::HelperOutput;
+    fn to_value_with_category(this: &Self) -> Self::ToValueWithCategoryOutput {
+        Self::to_value_with_category_helper(this)
+    }
+    fn into_value_with_category(this: Self) -> Self::ToValueWithCategoryOutput
+    where
+        Self: Sized,
+    {
+        Self::into_value_with_category_helper(this)
+    }
+}
+
+impl<T: ?Sized + ToExpr<ValueCategory = value_category::ValueCategoryExpr>>
+    ToValueWithCategoryHelper<value_category::ValueCategoryExpr> for T
+{
+    type HelperOutput = Expr<T::Type>;
+    fn to_value_with_category_helper(this: &Self) -> Self::HelperOutput {
+        this.to_expr()
+    }
+    fn into_value_with_category_helper(this: Self) -> Self::HelperOutput
+    where
+        Self: Sized,
+    {
+        this.to_expr()
+    }
+}
+
+impl<
+    T: ?Sized + crate::sim::value::ToSimValue<ValueCategory = value_category::ValueCategorySimValue>,
+> ToValueWithCategoryHelper<value_category::ValueCategorySimValue> for T
+{
+    type HelperOutput = crate::sim::value::SimValue<T::Type>;
+    fn to_value_with_category_helper(this: &Self) -> Self::HelperOutput {
+        this.to_sim_value()
+    }
+    fn into_value_with_category_helper(this: Self) -> Self::HelperOutput
+    where
+        Self: Sized,
+    {
+        this.into_sim_value()
+    }
+}
+
+impl<T: ?Sized + ValueType<ValueCategory = value_category::ValueCategoryValueless>>
+    ToValueWithCategoryHelper<value_category::ValueCategoryValueless> for T
+{
+    type HelperOutput = Valueless<T::Type>;
+    fn to_value_with_category_helper(this: &Self) -> Self::HelperOutput {
+        this.to_valueless()
+    }
+    fn into_value_with_category_helper(this: Self) -> Self::HelperOutput
+    where
+        Self: Sized,
+    {
+        this.to_valueless()
+    }
+}
+
+impl<
+    T: ?Sized
+        + ToSimValueInner<
+            ValueCategory = value_category::ValueCategoryValue,
+            Type: Type<SimValue = O>,
+        >,
+    O: ValueType<ValueCategory = value_category::ValueCategoryValue, Type = T::Type>,
+> ToValueWithCategoryHelper<value_category::ValueCategoryValue> for T
+{
+    type HelperOutput = O;
+    fn to_value_with_category_helper(this: &Self) -> Self::HelperOutput {
+        T::to_sim_value_inner(this)
+    }
+    fn into_value_with_category_helper(this: Self) -> Self::HelperOutput
+    where
+        Self: Sized,
+    {
+        T::into_sim_value_inner(this)
+    }
+}
+
+pub trait ToSimValueInner: ValueType {
+    fn to_sim_value_inner(this: &Self) -> <Self::Type as Type>::SimValue;
+    fn into_sim_value_inner(this: Self) -> <Self::Type as Type>::SimValue
+    where
+        Self: Sized;
+}
diff --git a/crates/fayalite/src/expr/ops.rs b/crates/fayalite/src/expr/ops.rs
index b10e3ae8..96482c4c 100644
--- a/crates/fayalite/src/expr/ops.rs
+++ b/crates/fayalite/src/expr/ops.rs
@@ -8,16 +8,15 @@ use crate::{
     enum_::{Enum, EnumType, EnumVariant},
     expr::{
         CastBitsTo as _, CastTo, CastToBits as _, Expr, ExprEnum, Flow, HdlPartialEq,
-        HdlPartialOrd, NotALiteralExpr, ReduceBits, ToExpr, ToLiteralBits,
+        HdlPartialOrd, NotALiteralExpr, ReduceBits, ToExpr, ToLiteralBits, ToValueless, ValueType,
+        Valueless,
         target::{
             GetTarget, Target, TargetPathArrayElement, TargetPathBundleField,
             TargetPathDynArrayElement, TargetPathElement,
         },
+        value_category::ValueCategoryExpr,
     },
-    int::{
-        Bool, BoolOrIntType, DynSize, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt,
-        UIntType, UIntValue,
-    },
+    int::{Bool, BoolOrIntType, DynSize, IntType, KnownSize, SInt, SIntType, Size, UInt, UIntType},
     intern::{Intern, Interned},
     phantom_const::{PhantomConst, PhantomConstValue},
     reset::{
@@ -39,24 +38,8 @@ use std::{
     },
 };
 
-macro_rules! forward_value_to_expr_unary_op_trait {
-    (
-        #[generics($($generics:tt)*)]
-        #[value($Value:ty)]
-        $Trait:ident::$method:ident
-    ) => {
-        impl<$($generics)*> $Trait for $Value
-        where
-            Expr<<$Value as ToExpr>::Type>: $Trait,
-        {
-            type Output = <Expr<<$Value as ToExpr>::Type> as $Trait>::Output;
-
-            fn $method(self) -> Self::Output {
-                $Trait::$method(self.to_expr())
-            }
-        }
-    };
-}
+#[cfg(test)]
+mod test_ops_impls;
 
 macro_rules! impl_unary_op_trait {
     (
@@ -107,9 +90,16 @@ impl<Width: Size> NotU<Width> {
     }
 }
 
-impl<Width: Size> ToExpr for NotU<Width> {
+impl<Width: Size> ValueType for NotU<Width> {
     type Type = UIntType<Width>;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.arg.to_valueless().not().ty()
+    }
+}
+
+impl<Width: Size> ToExpr for NotU<Width> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::NotU(NotU {
@@ -117,7 +107,7 @@ impl<Width: Size> ToExpr for NotU<Width> {
                 literal_bits: self.literal_bits,
             })
             .intern(),
-            __ty: self.arg.__ty,
+            __ty: self.ty(),
             __flow: Flow::Source,
         }
     }
@@ -138,12 +128,6 @@ impl_unary_op_trait! {
     }
 }
 
-forward_value_to_expr_unary_op_trait! {
-    #[generics(Width: Size)]
-    #[value(UIntValue<Width>)]
-    Not::not
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct NotS<Width: Size = DynSize> {
     arg: Expr<SIntType<Width>>,
@@ -164,9 +148,16 @@ impl<Width: Size> NotS<Width> {
     }
 }
 
-impl<Width: Size> ToExpr for NotS<Width> {
+impl<Width: Size> ValueType for NotS<Width> {
     type Type = UIntType<Width>;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.arg.to_valueless().not().ty()
+    }
+}
+
+impl<Width: Size> ToExpr for NotS<Width> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::NotS(NotS {
@@ -174,7 +165,7 @@ impl<Width: Size> ToExpr for NotS<Width> {
                 literal_bits: self.literal_bits,
             })
             .intern(),
-            __ty: self.arg.__ty.as_same_width_uint(),
+            __ty: self.ty(),
             __flow: Flow::Source,
         }
     }
@@ -195,12 +186,6 @@ impl_unary_op_trait! {
     }
 }
 
-forward_value_to_expr_unary_op_trait! {
-    #[generics(Width: Size)]
-    #[value(SIntValue<Width>)]
-    Not::not
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct NotB {
     arg: Expr<Bool>,
@@ -221,9 +206,16 @@ impl NotB {
     }
 }
 
-impl ToExpr for NotB {
+impl ValueType for NotB {
     type Type = Bool;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        Bool
+    }
+}
+
+impl ToExpr for NotB {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::NotB(NotB {
@@ -231,7 +223,7 @@ impl ToExpr for NotB {
                 literal_bits: self.literal_bits,
             })
             .intern(),
-            __ty: self.arg.__ty,
+            __ty: self.arg.ty(),
             __flow: Flow::Source,
         }
     }
@@ -270,22 +262,21 @@ impl Neg {
         });
         retval
     }
-    pub fn ty(self) -> SInt {
-        SInt::new_dyn(
-            Expr::ty(self.arg)
-                .width()
-                .checked_add(1)
-                .expect("width too big"),
-        )
-    }
     pub fn arg(self) -> Expr<SInt> {
         self.arg
     }
 }
 
-impl ToExpr for Neg {
+impl ValueType for Neg {
     type Type = SInt;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.arg.to_valueless().neg().ty()
+    }
+}
+
+impl ToExpr for Neg {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::Neg(*self).intern(),
@@ -310,12 +301,6 @@ impl_unary_op_trait! {
     }
 }
 
-forward_value_to_expr_unary_op_trait! {
-    #[generics(Width: Size)]
-    #[value(SIntValue<Width>)]
-    StdNeg::neg
-}
-
 macro_rules! impl_binary_op_trait {
     (
         #[generics($($generics:tt)*)]
@@ -323,44 +308,17 @@ macro_rules! impl_binary_op_trait {
             $($body:tt)*
         }
     ) => {
-        impl<
-                Rhs: ToExpr<Type = $Rhs>,
-                $($generics)*
-            > $Trait<Rhs> for Expr<$Lhs>
-        {
+        impl<$($generics)*> $Trait<Expr<$Rhs>> for Expr<$Lhs> {
             type Output = Expr<$Output>;
 
-            fn $method(self, rhs: Rhs) -> Self::Output {
+            fn $method(self, $rhs: Expr<$Rhs>) -> Self::Output {
                 let $lhs = self;
-                let $rhs = rhs.to_expr();
                 $($body)*
             }
         }
     };
 }
 
-macro_rules! forward_value_to_expr_binary_op_trait {
-    (
-        #[generics($($generics:tt)*)]
-        #[lhs_value($LhsValue:ty)]
-        $Trait:ident::$method:ident
-    ) => {
-        impl<
-                Rhs,
-                $($generics)*
-            > $Trait<Rhs> for $LhsValue
-        where
-            Expr<<$LhsValue as ToExpr>::Type>: $Trait<Rhs>,
-        {
-            type Output = <Expr<<$LhsValue as ToExpr>::Type> as $Trait<Rhs>>::Output;
-
-            fn $method(self, rhs: Rhs) -> Self::Output {
-                $Trait::$method(self.to_expr(), rhs)
-            }
-        }
-    };
-}
-
 fn binary_op_literal_bits<ResultTy: BoolOrIntType, Lhs: BoolOrIntType, Rhs: BoolOrIntType>(
     result_ty: ResultTy,
     lhs: Expr<Lhs>,
@@ -412,9 +370,16 @@ macro_rules! binary_op_bitwise {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                $ty
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -461,9 +426,6 @@ macro_rules! binary_op_bitwise {
             pub fn rhs(self) -> Expr<$ty> {
                 self.rhs
             }
-            pub fn ty(self) -> UInt {
-                UInt::new_dyn(Expr::ty(self.lhs).width().max(Expr::ty(self.rhs).width()))
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -474,9 +436,16 @@ macro_rules! binary_op_bitwise {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = UInt;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().$method(self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -492,12 +461,6 @@ macro_rules! binary_op_bitwise {
                 $name::new(Expr::as_dyn_int(lhs), Expr::as_dyn_int(rhs)).to_expr()
             }
         }
-
-        forward_value_to_expr_binary_op_trait! {
-            #[generics(LhsWidth: Size)]
-            #[lhs_value($value<LhsWidth>)]
-            $Trait::$method
-        }
     };
 }
 
@@ -538,15 +501,6 @@ macro_rules! binary_op_add_sub {
             pub fn rhs(self) -> Expr<$ty> {
                 self.rhs
             }
-            pub fn ty(self) -> $ty {
-                $ty::new_dyn(
-                    Expr::ty(self.lhs)
-                        .width()
-                        .max(Expr::ty(self.rhs).width())
-                        .checked_add(1)
-                        .expect("width too big"),
-                )
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -557,9 +511,16 @@ macro_rules! binary_op_add_sub {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                $Trait::$method(self.lhs.to_valueless(), self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -575,12 +536,6 @@ macro_rules! binary_op_add_sub {
                 $name::new(Expr::as_dyn_int(lhs), Expr::as_dyn_int(rhs)).to_expr()
             }
         }
-
-        forward_value_to_expr_binary_op_trait! {
-            #[generics(LhsWidth: Size)]
-            #[lhs_value($value<LhsWidth>)]
-            $Trait::$method
-        }
     };
 }
 
@@ -616,14 +571,6 @@ macro_rules! binary_op_mul {
             pub fn rhs(self) -> Expr<$ty> {
                 self.rhs
             }
-            pub fn ty(self) -> $ty {
-                $ty::new_dyn(
-                    Expr::ty(self.lhs)
-                        .width()
-                        .checked_add(Expr::ty(self.rhs).width())
-                        .expect("width too big"),
-                )
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -634,9 +581,16 @@ macro_rules! binary_op_mul {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().mul(self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -652,12 +606,6 @@ macro_rules! binary_op_mul {
                 $name::new(Expr::as_dyn_int(lhs), Expr::as_dyn_int(rhs)).to_expr()
             }
         }
-
-        forward_value_to_expr_binary_op_trait! {
-            #[generics(LhsWidth: Size)]
-            #[lhs_value($value<LhsWidth>)]
-            Mul::mul
-        }
     };
 }
 
@@ -689,9 +637,6 @@ impl<LhsWidth: Size> DivU<LhsWidth> {
     pub fn rhs(self) -> Expr<UInt> {
         self.rhs
     }
-    pub fn ty(self) -> UIntType<LhsWidth> {
-        Expr::ty(self.lhs)
-    }
 }
 
 impl<LhsWidth: Size> ToLiteralBits for DivU<LhsWidth> {
@@ -702,9 +647,16 @@ impl<LhsWidth: Size> ToLiteralBits for DivU<LhsWidth> {
 
 impl_get_target_none!([LhsWidth: Size] DivU<LhsWidth>);
 
-impl<LhsWidth: Size> ToExpr for DivU<LhsWidth> {
+impl<LhsWidth: Size> ValueType for DivU<LhsWidth> {
     type Type = UIntType<LhsWidth>;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.lhs.to_valueless().div(self.rhs.to_valueless()).ty()
+    }
+}
+
+impl<LhsWidth: Size> ToExpr for DivU<LhsWidth> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::DivU(DivU {
@@ -726,12 +678,6 @@ impl_binary_op_trait! {
     }
 }
 
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(UIntValue<LhsWidth>)]
-    Div::div
-}
-
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
 pub struct DivS {
     lhs: Expr<SInt>,
@@ -757,14 +703,6 @@ impl DivS {
     pub fn rhs(self) -> Expr<SInt> {
         self.rhs
     }
-    pub fn ty(self) -> SInt {
-        SInt::new_dyn(
-            Expr::ty(self.lhs)
-                .width()
-                .checked_add(1)
-                .expect("width too big"),
-        )
-    }
 }
 
 impl ToLiteralBits for DivS {
@@ -775,9 +713,16 @@ impl ToLiteralBits for DivS {
 
 impl_get_target_none!([] DivS);
 
-impl ToExpr for DivS {
+impl ValueType for DivS {
     type Type = SInt;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.lhs.to_valueless().div(self.rhs.to_valueless()).ty()
+    }
+}
+
+impl ToExpr for DivS {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::DivS(*self).intern(),
@@ -794,12 +739,6 @@ impl_binary_op_trait! {
     }
 }
 
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(SIntValue<LhsWidth>)]
-    Div::div
-}
-
 macro_rules! binary_op_rem {
     ($name:ident, $ty:ident, $value:ident) => {
         #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
@@ -831,9 +770,6 @@ macro_rules! binary_op_rem {
             pub fn rhs(self) -> Expr<$ty> {
                 self.rhs
             }
-            pub fn ty(self) -> $ty {
-                $ty::new_dyn(Expr::ty(self.lhs).width().min(Expr::ty(self.rhs).width()))
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -844,9 +780,16 @@ macro_rules! binary_op_rem {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().rem(self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -862,12 +805,6 @@ macro_rules! binary_op_rem {
                 $name::new(Expr::as_dyn_int(lhs), Expr::as_dyn_int(rhs)).to_expr()
             }
         }
-
-        forward_value_to_expr_binary_op_trait! {
-            #[generics(LhsWidth: Size)]
-            #[lhs_value($value<LhsWidth>)]
-            Rem::rem
-        }
     };
 }
 
@@ -894,7 +831,7 @@ impl<T: BundleType> BundleLiteral<T> {
         for (&field, &field_value) in fields.iter().zip(field_values.iter()) {
             assert_eq!(
                 field.ty,
-                Expr::ty(field_value),
+                field_value.ty(),
                 "field's type doesn't match value's type: field name {:?}",
                 field.name
             );
@@ -914,9 +851,6 @@ impl<T: BundleType> BundleLiteral<T> {
                 .ok_or(NotALiteralExpr),
         }
     }
-    pub fn ty(self) -> T {
-        self.ty
-    }
     pub fn field_values(self) -> Interned<[Expr<CanonicalType>]> {
         self.field_values
     }
@@ -930,9 +864,16 @@ impl<T: BundleType> ToLiteralBits for BundleLiteral<T> {
 
 impl_get_target_none!([T: BundleType] BundleLiteral<T>);
 
-impl<T: BundleType> ToExpr for BundleLiteral<T> {
+impl<T: BundleType> ValueType for BundleLiteral<T> {
     type Type = T;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: BundleType> ToExpr for BundleLiteral<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::BundleLiteral(BundleLiteral {
@@ -968,7 +909,7 @@ impl<Element: Type, Len: Size> ArrayLiteral<Element, Len> {
         for &element_value in element_values.iter() {
             assert_eq!(
                 canonical_element_type,
-                Expr::ty(element_value),
+                element_value.ty(),
                 "array's element type doesn't match element value's type",
             );
             if let (Some(literal_bits), Ok(element_bits)) =
@@ -997,12 +938,6 @@ impl<Element: Type, Len: Size> ArrayLiteral<Element, Len> {
     pub fn is_empty(self) -> bool {
         self.element_values.is_empty()
     }
-    pub fn ty(self) -> ArrayType<Element, Len> {
-        ArrayType::new(
-            self.element_type,
-            Len::from_usize(self.element_values.len()),
-        )
-    }
     pub fn element_values(self) -> Interned<[Expr<CanonicalType>]> {
         self.element_values
     }
@@ -1016,9 +951,19 @@ impl<Element: Type, Len: Size> ToLiteralBits for ArrayLiteral<Element, Len> {
 
 impl_get_target_none!([Element: Type, Len: Size] ArrayLiteral<Element, Len>);
 
-impl<Element: Type, Len: Size> ToExpr for ArrayLiteral<Element, Len> {
+impl<Element: Type, Len: Size> ValueType for ArrayLiteral<Element, Len> {
     type Type = ArrayType<Element, Len>;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        ArrayType::new(
+            self.element_type,
+            Len::from_usize(self.element_values.len()),
+        )
+    }
+}
+
+impl<Element: Type, Len: Size> ToExpr for ArrayLiteral<Element, Len> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::ArrayLiteral(ArrayLiteral {
@@ -1034,12 +979,22 @@ impl<Element: Type, Len: Size> ToExpr for ArrayLiteral<Element, Len> {
     }
 }
 
-impl<T: ToExpr<Type: StaticType>, const N: usize> ToExpr for [T; N]
+impl<T: ValueType<Type: StaticType>, const N: usize> ValueType for [T; N]
 where
     ConstUsize<N>: KnownSize,
 {
     type Type = Array<T::Type, N>;
+    type ValueCategory = T::ValueCategory;
 
+    fn ty(&self) -> Self::Type {
+        StaticType::TYPE
+    }
+}
+
+impl<T: ToExpr<Type: StaticType>, const N: usize> ToExpr for [T; N]
+where
+    ConstUsize<N>: KnownSize,
+{
     fn to_expr(&self) -> Expr<Self::Type> {
         ArrayLiteral::new(
             T::Type::TYPE,
@@ -1049,9 +1004,16 @@ where
     }
 }
 
+impl<T: ValueType<Type: StaticType>> ValueType for [T] {
+    type Type = Array<T::Type>;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        ArrayType::new_dyn(StaticType::TYPE, self.len())
+    }
+}
+
 impl<T: ToExpr<Type: StaticType>> ToExpr for [T] {
-    type Type = Array<T::Type>;
-
     fn to_expr(&self) -> Expr<Self::Type> {
         ArrayLiteral::new(
             T::Type::TYPE,
@@ -1061,9 +1023,16 @@ impl<T: ToExpr<Type: StaticType>> ToExpr for [T] {
     }
 }
 
-impl<T: ToExpr<Type: StaticType>> ToExpr for Vec<T> {
+impl<T: ValueType<Type: StaticType>> ValueType for Vec<T> {
     type Type = Array<T::Type>;
+    type ValueCategory = T::ValueCategory;
 
+    fn ty(&self) -> Self::Type {
+        <[T]>::ty(self)
+    }
+}
+
+impl<T: ToExpr<Type: StaticType>> ToExpr for Vec<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         <[T]>::to_expr(self)
     }
@@ -1090,7 +1059,7 @@ impl<T: EnumType> EnumLiteral<T> {
         assert!(variant_index < variants.len());
         assert_eq!(
             variants[variant_index].ty,
-            variant_value.map(Expr::ty),
+            variant_value.map(|v| v.ty()),
             "variant's type doesn't match value's type: variant name {:?}",
             variants[variant_index].name
         );
@@ -1130,9 +1099,6 @@ impl<T: EnumType> EnumLiteral<T> {
         };
         Self::new_by_index(ty, *variant_index, variant_value)
     }
-    pub fn ty(self) -> T {
-        self.ty
-    }
     pub fn variant_index(self) -> usize {
         self.variant_index
     }
@@ -1152,9 +1118,16 @@ impl<T: EnumType> ToLiteralBits for EnumLiteral<T> {
 
 impl_get_target_none!([T: EnumType] EnumLiteral<T>);
 
-impl<T: EnumType> ToExpr for EnumLiteral<T> {
+impl<T: EnumType> ValueType for EnumLiteral<T> {
     type Type = T;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: EnumType> ToExpr for EnumLiteral<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::EnumLiteral(EnumLiteral {
@@ -1199,25 +1172,6 @@ macro_rules! impl_dyn_shl {
             pub fn rhs(self) -> Expr<UInt> {
                 self.rhs
             }
-            #[track_caller]
-            pub fn ty(self) -> $ty {
-                let Some(pow2_rhs_width) = Expr::ty(self.rhs)
-                    .width()
-                    .try_into()
-                    .ok()
-                    .and_then(|v| 2usize.checked_pow(v))
-                else {
-                    panic!(
-                        "dynamic left-shift amount's bit-width is too big, try casting the shift \
-                        amount to a smaller bit-width before shifting"
-                    );
-                };
-                $ty::new_dyn(
-                    (pow2_rhs_width - 1)
-                        .checked_add(Expr::ty(self.lhs).width())
-                        .expect("width too big"),
-                )
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -1228,9 +1182,17 @@ macro_rules! impl_dyn_shl {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            #[track_caller]
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().shl(self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             #[track_caller]
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
@@ -1282,10 +1244,6 @@ macro_rules! impl_dyn_shr {
             pub fn rhs(self) -> Expr<UInt> {
                 self.rhs
             }
-            #[track_caller]
-            pub fn ty(self) -> $ty<LhsWidth> {
-                Expr::ty(self.lhs)
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -1296,9 +1254,17 @@ macro_rules! impl_dyn_shr {
 
         impl_get_target_none!([] $name);
 
-        impl<LhsWidth: Size> ToExpr for $name<LhsWidth> {
+        impl<LhsWidth: Size> ValueType for $name<LhsWidth> {
             type Type = $ty<LhsWidth>;
+            type ValueCategory = ValueCategoryExpr;
 
+            #[track_caller]
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().shr(self.rhs.to_valueless()).ty()
+            }
+        }
+
+        impl<LhsWidth: Size> ToExpr for $name<LhsWidth> {
             #[track_caller]
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
@@ -1308,7 +1274,7 @@ macro_rules! impl_dyn_shr {
                         literal_bits: self.literal_bits,
                     })
                     .intern(),
-                    __ty: Expr::ty(self.lhs),
+                    __ty: self.ty(),
                     __flow: Flow::Source,
                 }
             }
@@ -1327,12 +1293,8 @@ macro_rules! impl_dyn_shr {
 impl_dyn_shr!(DynShrU, UIntType, UIntValue);
 impl_dyn_shr!(DynShrS, SIntType, SIntValue);
 
-fn fixed_shr_width(lhs_width: usize, rhs: usize) -> Option<usize> {
-    Some(lhs_width.saturating_sub(rhs).max(1))
-}
-
 macro_rules! binary_op_fixed_shift {
-    ($name:ident, $ty:ident, $value:ident, $width_fn:path, $Trait:ident::$method:ident) => {
+    ($name:ident, $ty:ident, $value:ident, $Trait:ident::$method:ident) => {
         #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug)]
         pub struct $name {
             lhs: Expr<$ty>,
@@ -1361,11 +1323,6 @@ macro_rules! binary_op_fixed_shift {
             pub fn rhs(self) -> usize {
                 self.rhs
             }
-            pub fn ty(self) -> $ty {
-                $ty::new_dyn(
-                    $width_fn(Expr::ty(self.lhs).width(), self.rhs).expect("width too big"),
-                )
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -1376,9 +1333,16 @@ macro_rules! binary_op_fixed_shift {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $ty;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                self.lhs.to_valueless().$method(self.rhs).ty()
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -1398,34 +1362,10 @@ macro_rules! binary_op_fixed_shift {
     };
 }
 
-binary_op_fixed_shift!(FixedShlU, UIntType, UIntValue, usize::checked_add, Shl::shl);
-binary_op_fixed_shift!(FixedShlS, SIntType, SIntValue, usize::checked_add, Shl::shl);
-binary_op_fixed_shift!(FixedShrU, UIntType, UIntValue, fixed_shr_width, Shr::shr);
-binary_op_fixed_shift!(FixedShrS, SIntType, SIntValue, fixed_shr_width, Shr::shr);
-
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(UIntValue<LhsWidth>)]
-    Shl::shl
-}
-
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(SIntValue<LhsWidth>)]
-    Shl::shl
-}
-
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(UIntValue<LhsWidth>)]
-    Shr::shr
-}
-
-forward_value_to_expr_binary_op_trait! {
-    #[generics(LhsWidth: Size)]
-    #[lhs_value(SIntValue<LhsWidth>)]
-    Shr::shr
-}
+binary_op_fixed_shift!(FixedShlU, UIntType, UIntValue, Shl::shl);
+binary_op_fixed_shift!(FixedShlS, SIntType, SIntValue, Shl::shl);
+binary_op_fixed_shift!(FixedShrU, UIntType, UIntValue, Shr::shr);
+binary_op_fixed_shift!(FixedShrS, SIntType, SIntValue, Shr::shr);
 
 pub trait ExprPartialEq<Rhs: Type>: Type {
     fn cmp_eq(lhs: Expr<Self>, rhs: Expr<Rhs>) -> Expr<Bool>;
@@ -1439,33 +1379,34 @@ pub trait ExprPartialOrd<Rhs: Type>: ExprPartialEq<Rhs> {
     fn cmp_ge(lhs: Expr<Self>, rhs: Expr<Rhs>) -> Expr<Bool>;
 }
 
-impl<Lhs: ToExpr, Rhs: ToExpr> HdlPartialEq<Rhs> for Lhs
+impl<Lhs: Type, Rhs: Type, R: ToExpr<Type = Rhs>> HdlPartialEq<R> for Expr<Lhs>
 where
-    Lhs::Type: ExprPartialEq<Rhs::Type>,
+    Lhs: ExprPartialEq<Rhs>,
 {
-    fn cmp_eq(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialEq::cmp_eq(self.to_expr(), rhs.to_expr())
+    type Output = Expr<Bool>;
+    fn cmp_eq(&self, rhs: R) -> Self::Output {
+        ExprPartialEq::cmp_eq(*self, rhs.to_expr())
     }
-    fn cmp_ne(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialEq::cmp_ne(self.to_expr(), rhs.to_expr())
+    fn cmp_ne(&self, rhs: R) -> Self::Output {
+        ExprPartialEq::cmp_ne(*self, rhs.to_expr())
     }
 }
 
-impl<Lhs: ToExpr, Rhs: ToExpr> HdlPartialOrd<Rhs> for Lhs
+impl<Lhs: Type, Rhs: Type, R: ToExpr<Type = Rhs>> HdlPartialOrd<R> for Expr<Lhs>
 where
-    Lhs::Type: ExprPartialOrd<Rhs::Type>,
+    Lhs: ExprPartialOrd<Rhs>,
 {
-    fn cmp_lt(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialOrd::cmp_lt(self.to_expr(), rhs.to_expr())
+    fn cmp_lt(&self, rhs: R) -> Self::Output {
+        ExprPartialOrd::cmp_lt(*self, rhs.to_expr())
     }
-    fn cmp_le(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialOrd::cmp_le(self.to_expr(), rhs.to_expr())
+    fn cmp_le(&self, rhs: R) -> Self::Output {
+        ExprPartialOrd::cmp_le(*self, rhs.to_expr())
     }
-    fn cmp_gt(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialOrd::cmp_gt(self.to_expr(), rhs.to_expr())
+    fn cmp_gt(&self, rhs: R) -> Self::Output {
+        ExprPartialOrd::cmp_gt(*self, rhs.to_expr())
     }
-    fn cmp_ge(self, rhs: Rhs) -> Expr<Bool> {
-        ExprPartialOrd::cmp_ge(self.to_expr(), rhs.to_expr())
+    fn cmp_ge(&self, rhs: R) -> Self::Output {
+        ExprPartialOrd::cmp_ge(*self, rhs.to_expr())
     }
 }
 
@@ -1515,9 +1456,16 @@ macro_rules! impl_compare_op {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = Bool;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                Bool
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -1633,9 +1581,6 @@ macro_rules! impl_cast_int_op {
             pub fn arg(self) -> Expr<$from> {
                 self.arg
             }
-            pub fn ty(self) -> $to<ToWidth> {
-                self.ty
-            }
         }
 
         impl ToLiteralBits for $name {
@@ -1646,9 +1591,16 @@ macro_rules! impl_cast_int_op {
 
         impl_get_target_none!([ToWidth: Size] $name<ToWidth>);
 
-        impl<ToWidth: Size> ToExpr for $name<ToWidth> {
+        impl<ToWidth: Size> ValueType for $name<ToWidth> {
             type Type = $to<ToWidth>;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                self.ty
+            }
+        }
+
+        impl<ToWidth: Size> ToExpr for $name<ToWidth> {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name($name {
@@ -1681,13 +1633,17 @@ macro_rules! impl_cast_bit_op {
         impl_cast_bit_op!($name, $from, $(#[dyn] $from_dyn,)? $to);
 
         impl $Trait for Expr<$from> {
-            fn $trait_fn(&self) -> Expr<$to> {
+            type Output = Expr<$to>;
+
+            fn $trait_fn(&self) -> Self::Output {
                 self.cast_to_static()
             }
         }
 
         $(impl $Trait for Expr<$from_dyn> {
-            fn $trait_fn(&self) -> Expr<$to> {
+            type Output = Expr<$to>;
+
+            fn $trait_fn(&self) -> Self::Output {
                 self.cast_to_static()
             }
         })?
@@ -1738,9 +1694,16 @@ macro_rules! impl_cast_bit_op {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = $to;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                Self::Type::TYPE
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -1793,7 +1756,9 @@ impl_cast_bit_op!(CastClockToUInt, Clock, UInt<1>, #[dyn] UInt);
 impl_cast_bit_op!(CastClockToSInt, Clock, SInt<1>, #[dyn] SInt);
 
 impl<T: ResetType> ToReset for Expr<T> {
-    fn to_reset(&self) -> Expr<Reset> {
+    type Output = Expr<Reset>;
+
+    fn to_reset(&self) -> Self::Output {
         struct Dispatch;
         impl ResetTypeDispatch for Dispatch {
             type Input<T: ResetType> = Expr<T>;
@@ -1934,10 +1899,10 @@ impl<FieldType: Type + fmt::Debug> fmt::Debug for FieldAccess<FieldType> {
 impl<FieldType: Type> FieldAccess<FieldType> {
     #[track_caller]
     pub fn new_by_index(base: Expr<Bundle>, field_index: usize) -> Self {
-        let field = Expr::ty(base).fields()[field_index];
+        let field = base.ty().fields()[field_index];
         let field_type = FieldType::from_canonical(field.ty);
         let literal_bits = base.to_literal_bits().map(|bits| {
-            bits[Expr::ty(base).field_offsets()[field_index].bit_width..][..field.ty.bit_width()]
+            bits[base.ty().field_offsets()[field_index].bit_width..][..field.ty.bit_width()]
                 .intern()
         });
         let target = base.target().map(|base| {
@@ -1956,7 +1921,7 @@ impl<FieldType: Type> FieldAccess<FieldType> {
     }
     #[track_caller]
     pub fn new_by_name(base: Expr<Bundle>, name: Interned<str>) -> Self {
-        let base_ty = Expr::ty(base);
+        let base_ty = base.ty();
         let Some(field_index) = base_ty.name_indexes().get(&name) else {
             panic!("unknown field {name:?}: in {base_ty:?}");
         };
@@ -1991,9 +1956,16 @@ impl<FieldType: Type> ToLiteralBits for FieldAccess<FieldType> {
     }
 }
 
-impl<FieldType: Type> ToExpr for FieldAccess<FieldType> {
+impl<FieldType: Type> ValueType for FieldAccess<FieldType> {
     type Type = FieldType;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.field_type
+    }
+}
+
+impl<FieldType: Type> ToExpr for FieldAccess<FieldType> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::FieldAccess(FieldAccess {
@@ -2023,10 +1995,10 @@ pub struct VariantAccess<VariantType: Type = CanonicalType> {
 impl<VariantType: Type> VariantAccess<VariantType> {
     #[track_caller]
     pub fn new_by_index(base: Expr<Enum>, variant_index: usize) -> Self {
-        let variant = Expr::ty(base).variants()[variant_index];
+        let variant = base.ty().variants()[variant_index];
         let variant_type = variant.ty.map(VariantType::from_canonical);
         let literal_bits = base.to_literal_bits().and_then(|bits| {
-            let discriminant_bit_width = Expr::ty(base).discriminant_bit_width();
+            let discriminant_bit_width = base.ty().discriminant_bit_width();
             if bits[..discriminant_bit_width]
                 != [variant_index].view_bits::<Lsb0>()[..discriminant_bit_width]
             {
@@ -2047,7 +2019,7 @@ impl<VariantType: Type> VariantAccess<VariantType> {
     }
     #[track_caller]
     pub fn new_by_name(base: Expr<Enum>, name: Interned<str>) -> Self {
-        let base_ty = Expr::ty(base);
+        let base_ty = base.ty();
         let Some(variant_index) = base_ty.name_indexes().get(&name) else {
             panic!("unknown variant {name:?}: in {base_ty:?}");
         };
@@ -2078,9 +2050,17 @@ impl<VariantType: Type> ToLiteralBits for VariantAccess<VariantType> {
 
 impl_get_target_none!([VariantType: Type] VariantAccess<VariantType>);
 
-impl<VariantType: Type> ToExpr for VariantAccess<VariantType> {
+impl<VariantType: Type> ValueType for VariantAccess<VariantType> {
     type Type = VariantType;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.variant_type
+            .unwrap_or_else(|| VariantType::from_canonical(().canonical()))
+    }
+}
+
+impl<VariantType: Type> ToExpr for VariantAccess<VariantType> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::VariantAccess(VariantAccess {
@@ -2091,9 +2071,7 @@ impl<VariantType: Type> ToExpr for VariantAccess<VariantType> {
                 literal_bits: self.literal_bits,
             })
             .intern(),
-            __ty: self
-                .variant_type
-                .unwrap_or_else(|| VariantType::from_canonical(().canonical())),
+            __ty: self.ty(),
             __flow: Flow::Source,
         }
     }
@@ -2111,7 +2089,7 @@ pub struct ArrayIndex<ElementType: Type = CanonicalType> {
 impl<ElementType: Type> ArrayIndex<ElementType> {
     #[track_caller]
     pub fn new(base: Expr<Array>, element_index: usize) -> Self {
-        let base_ty = Expr::ty(base);
+        let base_ty = base.ty();
         assert!(element_index < base_ty.len());
         let element_type = ElementType::from_canonical(base_ty.element());
         let literal_bits = base.to_literal_bits().map(|bits| {
@@ -2159,15 +2137,22 @@ impl<ElementType: Type> GetTarget for ArrayIndex<ElementType> {
     }
 }
 
-impl<ElementType: Type> ToExpr for ArrayIndex<ElementType> {
+impl<ElementType: Type> ValueType for ArrayIndex<ElementType> {
     type Type = ElementType;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.element_type
+    }
+}
+
+impl<ElementType: Type> ToExpr for ArrayIndex<ElementType> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::ArrayIndex(ArrayIndex {
                 base: self.base,
                 element_index: self.element_index,
-                element_type: Expr::ty(self.base).element(),
+                element_type: self.base.ty().element(),
                 literal_bits: self.literal_bits,
                 target: self.target,
             })
@@ -2203,7 +2188,7 @@ pub struct DynArrayIndex<ElementType: Type = CanonicalType> {
 impl<ElementType: Type> DynArrayIndex<ElementType> {
     #[track_caller]
     pub fn new(base: Expr<Array>, element_index: Expr<UInt>) -> Self {
-        let base_ty = Expr::ty(base);
+        let base_ty = base.ty();
         let element_type = ElementType::from_canonical(base_ty.element());
         let literal_bits = base
             .to_literal_bits()
@@ -2255,15 +2240,22 @@ impl<ElementType: Type> GetTarget for DynArrayIndex<ElementType> {
     }
 }
 
-impl<ElementType: Type> ToExpr for DynArrayIndex<ElementType> {
+impl<ElementType: Type> ValueType for DynArrayIndex<ElementType> {
     type Type = ElementType;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.element_type
+    }
+}
+
+impl<ElementType: Type> ToExpr for DynArrayIndex<ElementType> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::DynArrayIndex(DynArrayIndex {
                 base: self.base,
                 element_index: self.element_index,
-                element_type: Expr::ty(self.base).element(),
+                element_type: self.base.ty().element(),
                 literal_bits: self.literal_bits,
                 target: self.target,
             })
@@ -2356,7 +2348,7 @@ macro_rules! impl_int_slice {
         impl $name {
             pub fn new(base: Expr<$ty>, range: Range<usize>) -> Self {
                 assert!(
-                    range.start <= range.end && range.end <= Expr::ty(base).width(),
+                    range.start <= range.end && range.end <= base.ty().width(),
                     "invalid range"
                 );
                 let literal_bits = base
@@ -2385,37 +2377,63 @@ macro_rules! impl_int_slice {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = UInt;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                UInt::new_dyn(self.range().len())
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
-                    __ty: UInt::new_dyn(self.range().len()),
+                    __ty: self.ty(),
                     __flow: Flow::Source,
                 }
             }
         }
 
+        impl<Width: Size, I: BuiltInRange<usize>> std::ops::Index<I> for Valueless<$ty<Width>> {
+            type Output = Valueless<UInt>;
+
+            #[track_caller]
+            fn index(&self, index: I) -> &Self::Output {
+                let range = self.ty().slice_index_to_range(index);
+                Interned::into_inner(Valueless::new(UInt::new_dyn(range.len())).intern_sized())
+            }
+        }
+
         impl<Width: Size, I: BuiltInRange<usize>> ExprIndex<I> for $ty<Width> {
             type Output = UInt;
 
             #[track_caller]
             fn expr_index(this: &Expr<Self>, index: I) -> &Expr<Self::Output> {
                 let base = Expr::as_dyn_int(*this);
-                let base_ty = Expr::ty(base);
-                let range = base_ty.slice_index_to_range(index);
+                let range = base.ty().slice_index_to_range(index);
                 Interned::into_inner($name::new(base, range).to_expr().intern_sized())
             }
         }
 
+        impl<Width: Size> std::ops::Index<usize> for Valueless<$ty<Width>> {
+            type Output = Valueless<Bool>;
+
+            #[track_caller]
+            fn index(&self, index: usize) -> &Self::Output {
+                assert!(index < self.ty().width());
+                &const { Valueless::new(Bool) }
+            }
+        }
+
         impl<Width: Size> ExprIndex<usize> for $ty<Width> {
             type Output = Bool;
 
             #[track_caller]
             fn expr_index(this: &Expr<Self>, index: usize) -> &Expr<Self::Output> {
                 let base = Expr::as_dyn_int(*this);
-                let base_ty = Expr::ty(base);
+                let base_ty = base.ty();
                 assert!(index < base_ty.width());
                 Interned::into_inner(
                     $name::new(base, index..(index + 1))
@@ -2457,9 +2475,16 @@ macro_rules! impl_reduce_bits {
 
         impl_get_target_none!([] $name);
 
-        impl ToExpr for $name {
+        impl ValueType for $name {
             type Type = UInt<1>;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                StaticType::TYPE
+            }
+        }
+
+        impl ToExpr for $name {
             fn to_expr(&self) -> Expr<Self::Type> {
                 Expr {
                     __enum: ExprEnum::$name(*self).intern(),
@@ -2629,13 +2654,20 @@ impl ToLiteralBits for CastToBits {
 
 impl_get_target_none!([] CastToBits);
 
-impl ToExpr for CastToBits {
+impl ValueType for CastToBits {
     type Type = UInt;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        UInt::new_dyn(self.arg.ty().bit_width())
+    }
+}
+
+impl ToExpr for CastToBits {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::CastToBits(*self).intern(),
-            __ty: UInt::new_dyn(Expr::ty(self.arg).bit_width()),
+            __ty: self.ty(),
             __flow: Flow::Source,
         }
     }
@@ -2653,7 +2685,7 @@ impl<T: Type> CastBitsTo<T> {
     pub fn new(arg: Expr<UInt>, ty: T) -> Self {
         let ty_props = ty.canonical().type_properties();
         assert!(ty_props.is_castable_from_bits);
-        assert_eq!(Expr::ty(arg).width(), ty_props.bit_width);
+        assert_eq!(arg.ty().width(), ty_props.bit_width);
         Self {
             arg,
             ty,
@@ -2663,9 +2695,6 @@ impl<T: Type> CastBitsTo<T> {
     pub fn arg(self) -> Expr<UInt> {
         self.arg
     }
-    pub fn ty(self) -> T {
-        self.ty
-    }
 }
 
 impl<T: Type> ToLiteralBits for CastBitsTo<T> {
@@ -2676,9 +2705,16 @@ impl<T: Type> ToLiteralBits for CastBitsTo<T> {
 
 impl_get_target_none!([T: Type] CastBitsTo<T>);
 
-impl<T: Type> ToExpr for CastBitsTo<T> {
+impl<T: Type> ValueType for CastBitsTo<T> {
     type Type = T;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: Type> ToExpr for CastBitsTo<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::CastBitsTo(CastBitsTo {
@@ -2703,9 +2739,6 @@ impl<T: Type> Uninit<T> {
     pub fn new(ty: T) -> Self {
         Self { ty }
     }
-    pub fn ty(self) -> T {
-        self.ty
-    }
 }
 
 impl<T: Type> ToLiteralBits for Uninit<T> {
@@ -2716,9 +2749,16 @@ impl<T: Type> ToLiteralBits for Uninit<T> {
 
 impl_get_target_none!([T: Type] Uninit<T>);
 
-impl<T: Type> ToExpr for Uninit<T> {
+impl<T: Type> ValueType for Uninit<T> {
     type Type = T;
+    type ValueCategory = ValueCategoryExpr;
 
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: Type> ToExpr for Uninit<T> {
     fn to_expr(&self) -> Expr<Self::Type> {
         Expr {
             __enum: ExprEnum::Uninit(Uninit {
diff --git a/crates/fayalite/src/expr/ops/test_ops_impls.rs b/crates/fayalite/src/expr/ops/test_ops_impls.rs
new file mode 100644
index 00000000..863da419
--- /dev/null
+++ b/crates/fayalite/src/expr/ops/test_ops_impls.rs
@@ -0,0 +1,355 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use crate::{expr::Valueless, prelude::*};
+use std::num::NonZero;
+
+macro_rules! assert_impls_for {
+    (
+        $([$($args:tt)*])?
+        $m:ident! {$($rest:tt)*}
+    ) => {
+        $m! {$($($args)*)? $($rest)*}
+    };
+    (
+        #[kinds()]
+        $($rest:tt)*
+    ) => {};
+    (
+        #[kinds($first_kind:tt $(, $kinds:tt)* $(,)?)]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kind($first_kind)]
+            $($rest)*
+        }
+        assert_impls_for! {
+            #[kinds($($kinds),*)]
+            $($rest)*
+        }
+    };
+    (
+        #[type($($ty:tt)*)]
+        $(#[$($meta:tt)*])*
+        $([$($args:tt)*])?
+        $m:ident $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            $(#[$($meta)*])*
+            [$($($args)*)? $($ty)*,]
+            $m $($rest)*
+        }
+    };
+    (
+        #[kind((int<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds((uint<$lt, $Width>), (sint<$lt, $Width>))]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((int_value<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds((uint_value<$lt, $Width>), (sint_value<$lt, $Width>))]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((uint_nz<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                (NonZero<usize>),
+                NonZeroU_N,
+                (uint<$lt, $Width>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((sint_nz<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                (NonZero<isize>),
+                NonZeroI_N,
+                (sint<$lt, $Width>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((uint<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                usize,
+                u_N,
+                (UIntValue<$Width: Size>),
+                (&$lt UIntValue<$Width: Size>),
+                (SimValue<UIntType<$Width: Size>>),
+                (&$lt SimValue<UIntType<$Width: Size>>),
+                (Expr<UIntType<$Width: Size>>),
+                (Valueless<UIntType<$Width: Size>>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((sint<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                isize,
+                i_N,
+                (SIntValue<$Width: Size>),
+                (&$lt SIntValue<$Width: Size>),
+                (SimValue<SIntType<$Width: Size>>),
+                (&$lt SimValue<SIntType<$Width: Size>>),
+                (Expr<SIntType<$Width: Size>>),
+                (Valueless<SIntType<$Width: Size>>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((uint_value<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                (UIntValue<$Width: Size>),
+                (&$lt UIntValue<$Width: Size>),
+                (SimValue<UIntType<$Width: Size>>),
+                (&$lt SimValue<UIntType<$Width: Size>>),
+                (Expr<UIntType<$Width: Size>>),
+                (Valueless<UIntType<$Width: Size>>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((sint_value<$lt:lifetime, $Width:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                (SIntValue<$Width: Size>),
+                (&$lt SIntValue<$Width: Size>),
+                (SimValue<SIntType<$Width: Size>>),
+                (&$lt SimValue<SIntType<$Width: Size>>),
+                (Expr<SIntType<$Width: Size>>),
+                (Valueless<SIntType<$Width: Size>>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((Bool<$lt:lifetime>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(
+                bool,
+                (SimValue<Bool>),
+                (&$lt SimValue<Bool>),
+                (Expr<Bool>),
+                (Valueless<Bool>),
+            )]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(u_N)]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(u8, u16, u32, u64, u128)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(i_N)]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds(i8, i16, i32, i64, i128)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(NonZeroU_N)]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds((NonZero<u8>), (NonZero<u16>), (NonZero<u32>), (NonZero<u64>), (NonZero<u128>))]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(NonZeroI_N)]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[kinds((NonZero<i8>), (NonZero<i16>), (NonZero<i32>), (NonZero<i64>), (NonZero<i128>))]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(($wrapper:ident<$Ty:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([][] $wrapper<$Ty>)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((&$lt:lifetime $wrapper:ident<$Ty:ident>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([$lt,][] &$lt $wrapper<$Ty>)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(($wrapper:ident<$Width:ident: Size>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([][$Width: Size,] $wrapper<$Width>)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind(($wrapper:ident<$ty:ident<$Width:ident: Size>>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([][$Width: Size,] $wrapper<$ty<$Width>>)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((&$lt:lifetime $wrapper:ident<$Width:ident: Size>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([$lt,][$Width: Size,] &$lt $wrapper<$Width>)]
+            $($rest)*
+        }
+    };
+    (
+        #[kind((&$lt:lifetime $wrapper:ident<$ty:ident<$Width:ident: Size>>))]
+        $($rest:tt)*
+    ) => {
+        assert_impls_for! {
+            #[type([$lt,][$Width: Size,] &$lt $wrapper<$ty<$Width>>)]
+            $($rest)*
+        }
+    };
+    (#[kind(usize)] $($rest:tt)*) => {assert_impls_for! { #[type([][] usize)] $($rest)* }};
+    (#[kind(isize)] $($rest:tt)*) => {assert_impls_for! { #[type([][] isize)] $($rest)* }};
+    (#[kind(bool)] $($rest:tt)*) => {assert_impls_for! { #[type([][] bool)] $($rest)* }};
+    (#[kind(u8)] $($rest:tt)*) => {assert_impls_for! { #[type([][] u8)] $($rest)* }};
+    (#[kind(u16)] $($rest:tt)*) => {assert_impls_for! { #[type([][] u16)] $($rest)* }};
+    (#[kind(u32)] $($rest:tt)*) => {assert_impls_for! { #[type([][] u32)] $($rest)* }};
+    (#[kind(u64)] $($rest:tt)*) => {assert_impls_for! { #[type([][] u64)] $($rest)* }};
+    (#[kind(u128)] $($rest:tt)*) => {assert_impls_for! { #[type([][] u128)] $($rest)* }};
+    (#[kind(i8)] $($rest:tt)*) => {assert_impls_for! { #[type([][] i8)] $($rest)* }};
+    (#[kind(i16)] $($rest:tt)*) => {assert_impls_for! { #[type([][] i16)] $($rest)* }};
+    (#[kind(i32)] $($rest:tt)*) => {assert_impls_for! { #[type([][] i32)] $($rest)* }};
+    (#[kind(i64)] $($rest:tt)*) => {assert_impls_for! { #[type([][] i64)] $($rest)* }};
+    (#[kind(i128)] $($rest:tt)*) => {assert_impls_for! { #[type([][] i128)] $($rest)* }};
+}
+
+macro_rules! assert_neg_impls {
+    ([$($Lifetimes:tt)*][$($Bounds:tt)*] $ty:ty,) => {
+        const _: () = {
+            fn _check_neg_impl<$($Lifetimes)*$($Bounds)*>(v: $ty) -> impl ValueType {
+                std::ops::Neg::neg(v)
+            }
+        };
+    };
+}
+
+assert_impls_for! {
+    #[kinds((sint<'a, Width>))]
+    assert_neg_impls! {}
+}
+
+macro_rules! assert_not_impls {
+    ([$($Lifetimes:tt)*][$($Bounds:tt)*] $ty:ty,) => {
+        const _: () = {
+            fn _check_not_impl<$($Lifetimes)*$($Bounds)*>(v: $ty) -> impl ValueType {
+                std::ops::Not::not(v)
+            }
+        };
+    };
+}
+
+assert_impls_for! {
+    #[kinds((int<'a, Width>), (Bool<'a>))]
+    assert_not_impls! {}
+}
+
+macro_rules! assert_simple_bin_op_impls {
+    ([$($LLifetimes:tt)*][$($LBounds:tt)*] $L:ty, [$($RLifetimes:tt)*][$($RBounds:tt)*] $R:ty, $Trait:ident::$f:ident) => {
+        const _: () = {
+            fn _check_simple_bin_op_impl<$($LLifetimes)* $($RLifetimes)* $($LBounds)* $($RBounds)*>(l: $L, r: $R) -> impl ValueType {
+                std::ops::$Trait::$f(l, r)
+            }
+        };
+    };
+    ($LLifetimes:tt $LBounds:tt $L:ty, $RLifetimes:tt $RBounds:tt $R:ty, $FirstTrait:ident::$first_f:ident, $($rest:tt)*) => {
+        assert_simple_bin_op_impls! {
+            $LLifetimes $LBounds $L, $RLifetimes $RBounds $R, $FirstTrait::$first_f
+        }
+        assert_simple_bin_op_impls! {
+            $LLifetimes $LBounds $L, $RLifetimes $RBounds $R, $($rest)*
+        }
+    };
+}
+
+assert_impls_for! {
+    #[kinds((uint_value<'l, L>))]
+    #[kinds((uint_nz<'r, R>))]
+    assert_simple_bin_op_impls! {Add::add, Sub::sub, Mul::mul, Div::div, Rem::rem, BitAnd::bitand, BitOr::bitor, BitXor::bitxor}
+}
+
+assert_impls_for! {
+    #[kinds((uint_nz<'l, L>))]
+    #[kinds((uint_value<'r, R>))]
+    assert_simple_bin_op_impls! {Add::add, Sub::sub, Mul::mul, Div::div, Rem::rem, BitAnd::bitand, BitOr::bitor, BitXor::bitxor, Shl::shl, Shr::shr}
+}
+
+assert_impls_for! {
+    #[kinds((sint_value<'l, L>))]
+    #[kinds((sint_nz<'r, R>))]
+    assert_simple_bin_op_impls! {Add::add, Sub::sub, Mul::mul, Div::div, Rem::rem, BitAnd::bitand, BitOr::bitor, BitXor::bitxor}
+}
+
+assert_impls_for! {
+    #[kinds((sint_nz<'l, L>))]
+    #[kinds((sint_value<'r, R>))]
+    assert_simple_bin_op_impls! {Add::add, Sub::sub, Mul::mul, Div::div, Rem::rem, BitAnd::bitand, BitOr::bitor, BitXor::bitxor, Shl::shl, Shr::shr}
+}
+
+assert_impls_for! {
+    #[kinds((uint_value<'l, L>))]
+    assert_simple_bin_op_impls! {[][] usize, Shl::shl, Shr::shr}
+}
+
+assert_impls_for! {
+    #[kinds((sint_value<'l, L>))]
+    assert_simple_bin_op_impls! {[][] usize, Shl::shl, Shr::shr}
+}
diff --git a/crates/fayalite/src/expr/target.rs b/crates/fayalite/src/expr/target.rs
index c8c55e93..95d8e0f5 100644
--- a/crates/fayalite/src/expr/target.rs
+++ b/crates/fayalite/src/expr/target.rs
@@ -3,7 +3,7 @@
 use crate::{
     array::Array,
     bundle::{Bundle, BundleField},
-    expr::{Expr, Flow, ToExpr},
+    expr::{Expr, Flow, ToExpr, ValueType, value_category::ValueCategoryExpr},
     intern::{Intern, Interned},
     memory::{DynPortType, MemPort},
     module::{Instance, ModuleIO, TargetName},
@@ -196,9 +196,18 @@ macro_rules! impl_target_base {
             }
         }
 
-        impl ToExpr for $TargetBase {
+        impl ValueType for $TargetBase {
             type Type = CanonicalType;
+            type ValueCategory = ValueCategoryExpr;
 
+            fn ty(&self) -> Self::Type {
+                match self {
+                    $(Self::$Variant(v) => v.ty().canonical(),)*
+                }
+            }
+        }
+
+        impl ToExpr for $TargetBase {
             fn to_expr(&self) -> Expr<Self::Type> {
                 match self {
                     $(Self::$Variant(v) => Expr::canonical(v.to_expr()),)*
diff --git a/crates/fayalite/src/expr/value_category.rs b/crates/fayalite/src/expr/value_category.rs
new file mode 100644
index 00000000..9909f68d
--- /dev/null
+++ b/crates/fayalite/src/expr/value_category.rs
@@ -0,0 +1,338 @@
+// SPDX-License-Identifier: LGPL-3.0-or-later
+// See Notices.txt for copyright information
+
+use crate::{expr::ValueType, ty::Type};
+
+trait ValueCategorySealed {}
+
+#[expect(private_bounds)]
+pub trait ValueCategory:
+    ValueCategorySealed
+    + Copy
+    + Ord
+    + Default
+    + std::fmt::Debug
+    + std::hash::Hash
+    + 'static
+    + Send
+    + Sync
+{
+    type DispatchOutput<D: ValueCategoryDispatch<InputValueCategory = Self>>: ValueType<Type = D::Type, ValueCategory: ValueCategoryIsValueSimValueExprOrValueless>;
+    #[track_caller]
+    fn dispatch<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> Self::DispatchOutput<D>;
+    #[track_caller]
+    fn dispatch_enum<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> ValueCategoryDispatchOutputEnum<D>;
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Debug, Hash)]
+pub struct ValueCategoryValue;
+
+impl ValueCategorySealed for ValueCategoryValue {}
+
+impl ValueCategory for ValueCategoryValue {
+    type DispatchOutput<D: ValueCategoryDispatch<InputValueCategory = Self>> = D::Value;
+
+    #[track_caller]
+    fn dispatch<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> Self::DispatchOutput<D> {
+        dispatch.dispatch_value()
+    }
+
+    #[track_caller]
+    fn dispatch_enum<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> ValueCategoryDispatchOutputEnum<D> {
+        ValueCategoryDispatchOutputEnum::Value(dispatch.dispatch_value())
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Debug, Hash)]
+pub struct ValueCategorySimValue;
+
+impl ValueCategorySealed for ValueCategorySimValue {}
+
+impl ValueCategory for ValueCategorySimValue {
+    type DispatchOutput<D: ValueCategoryDispatch<InputValueCategory = Self>> = D::SimValue;
+
+    #[track_caller]
+    fn dispatch<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> Self::DispatchOutput<D> {
+        dispatch.dispatch_sim_value()
+    }
+
+    #[track_caller]
+    fn dispatch_enum<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> ValueCategoryDispatchOutputEnum<D> {
+        ValueCategoryDispatchOutputEnum::SimValue(dispatch.dispatch_sim_value())
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Debug, Hash)]
+pub struct ValueCategoryExpr;
+
+impl ValueCategorySealed for ValueCategoryExpr {}
+
+impl ValueCategory for ValueCategoryExpr {
+    type DispatchOutput<D: ValueCategoryDispatch<InputValueCategory = Self>> = D::Expr;
+
+    #[track_caller]
+    fn dispatch<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> Self::DispatchOutput<D> {
+        dispatch.dispatch_expr()
+    }
+
+    #[track_caller]
+    fn dispatch_enum<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> ValueCategoryDispatchOutputEnum<D> {
+        ValueCategoryDispatchOutputEnum::Expr(dispatch.dispatch_expr())
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Default, Debug, Hash)]
+pub struct ValueCategoryValueless;
+
+impl ValueCategorySealed for ValueCategoryValueless {}
+
+impl ValueCategory for ValueCategoryValueless {
+    type DispatchOutput<D: ValueCategoryDispatch<InputValueCategory = Self>> = D::Valueless;
+
+    #[track_caller]
+    fn dispatch<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> Self::DispatchOutput<D> {
+        dispatch.dispatch_valueless()
+    }
+
+    #[track_caller]
+    fn dispatch_enum<D: ValueCategoryDispatch<InputValueCategory = Self>>(
+        dispatch: D,
+    ) -> ValueCategoryDispatchOutputEnum<D> {
+        ValueCategoryDispatchOutputEnum::Valueless(dispatch.dispatch_valueless())
+    }
+}
+
+pub trait ValueCategoryIsValue: ValueCategoryIsValueOrSimValue {}
+
+impl ValueCategoryIsValue for ValueCategoryValue {}
+
+pub trait ValueCategoryIsValueOrSimValue: ValueCategoryIsValueSimValueOrExpr {}
+
+impl ValueCategoryIsValueOrSimValue for ValueCategoryValue {}
+impl ValueCategoryIsValueOrSimValue for ValueCategorySimValue {}
+
+pub trait ValueCategoryIsValueSimValueOrExpr: ValueCategoryIsValueSimValueExprOrValueless {}
+
+impl ValueCategoryIsValueSimValueOrExpr for ValueCategoryValue {}
+impl ValueCategoryIsValueSimValueOrExpr for ValueCategorySimValue {}
+impl ValueCategoryIsValueSimValueOrExpr for ValueCategoryExpr {}
+
+pub trait ValueCategoryIsValueSimValueExprOrValueless: ValueCategory {}
+
+impl ValueCategoryIsValueSimValueExprOrValueless for ValueCategoryValue {}
+impl ValueCategoryIsValueSimValueExprOrValueless for ValueCategorySimValue {}
+impl ValueCategoryIsValueSimValueExprOrValueless for ValueCategoryExpr {}
+impl ValueCategoryIsValueSimValueExprOrValueless for ValueCategoryValueless {}
+
+pub trait ValueCategoryIsValueless: ValueCategoryIsExprOrValueless {}
+
+impl ValueCategoryIsValueless for ValueCategoryValueless {}
+
+pub trait ValueCategoryIsExprOrValueless: ValueCategoryIsValueSimValueExprOrValueless {}
+
+impl ValueCategoryIsExprOrValueless for ValueCategoryExpr {}
+impl ValueCategoryIsExprOrValueless for ValueCategoryValueless {}
+
+pub trait ValueCategoryIsSimValueExprOrValueless:
+    ValueCategoryIsValueSimValueExprOrValueless
+{
+}
+
+impl ValueCategoryIsSimValueExprOrValueless for ValueCategorySimValue {}
+impl ValueCategoryIsSimValueExprOrValueless for ValueCategoryExpr {}
+impl ValueCategoryIsSimValueExprOrValueless for ValueCategoryValueless {}
+
+trait ValueCategoryCommonSealed {}
+
+pub trait ValueCategoryCommon<
+    T: ValueCategoryCommonSealed
+        + Copy
+        + Ord
+        + Default
+        + std::fmt::Debug
+        + std::hash::Hash
+        + 'static
+        + Send
+        + Sync,
+>: ValueCategory
+{
+    type Common: ValueCategory;
+}
+
+macro_rules! impl_value_category_common {
+    ($($T:ident),* $(,)?) => {
+        impl_value_category_common!([$($T,)*]);
+    };
+    ([$($A:ident,)?]) => {};
+    ([$FirstT:ident, $($T:ident,)+]) => {
+        impl_value_category_common!([$($T,)*]);
+
+        impl<$FirstT: ValueCategory, $($T: ValueCategory),*> ValueCategoryCommonSealed for ($FirstT, $($T),*) {}
+
+        impl<This, $FirstT, $($T),*> ValueCategoryCommon<($FirstT, $($T),*)> for This
+        where
+            $FirstT: ValueCategory,
+            $($T: ValueCategory,)*
+            This: ValueCategoryCommon<($FirstT,), Common: ValueCategoryCommon<($($T,)*)>>,
+        {
+            type Common = <<This as ValueCategoryCommon<($FirstT,)>>::Common as ValueCategoryCommon<($($T,)*)>>::Common;
+        }
+    };
+}
+
+impl_value_category_common!(T11, T10, T9, T8, T7, T6, T5, T4, T3, T2, T1, T0);
+
+impl<T: ValueCategory> ValueCategoryCommonSealed for (T,) {}
+
+impl ValueCategoryCommonSealed for () {}
+
+impl<T: ValueCategory> ValueCategoryCommon<()> for T {
+    type Common = T;
+}
+
+impl<T: ValueCategoryIsValue> ValueCategoryCommon<(ValueCategoryValue,)> for T {
+    type Common = ValueCategoryValue;
+}
+
+impl<T: ValueCategoryIsValueOrSimValue> ValueCategoryCommon<(ValueCategorySimValue,)> for T {
+    type Common = ValueCategorySimValue;
+}
+
+impl<T: ValueCategoryIsValueSimValueOrExpr> ValueCategoryCommon<(ValueCategoryExpr,)> for T {
+    type Common = ValueCategoryExpr;
+}
+
+impl<T: ValueCategoryIsValueSimValueExprOrValueless> ValueCategoryCommon<(ValueCategoryValueless,)>
+    for T
+{
+    type Common = ValueCategoryValueless;
+}
+
+pub trait ValueCategoryDispatch: Sized {
+    type Type: Type;
+    type InputValueCategory: ValueCategory;
+    type Value: ValueType<ValueCategory: ValueCategoryIsValueSimValueExprOrValueless, Type = Self::Type>;
+    type SimValue: ValueType<ValueCategory: ValueCategoryIsSimValueExprOrValueless, Type = Self::Type>;
+    type Expr: ValueType<ValueCategory: ValueCategoryIsExprOrValueless, Type = Self::Type>;
+    type Valueless: ValueType<ValueCategory: ValueCategoryIsValueless, Type = Self::Type>;
+    fn dispatch_value(self) -> Self::Value
+    where
+        Self: ValueCategoryDispatch<InputValueCategory = ValueCategoryValue>;
+    fn dispatch_sim_value(self) -> Self::SimValue
+    where
+        Self: ValueCategoryDispatch<InputValueCategory = ValueCategorySimValue>;
+    fn dispatch_expr(self) -> Self::Expr
+    where
+        Self: ValueCategoryDispatch<InputValueCategory = ValueCategoryExpr>;
+    fn dispatch_valueless(self) -> Self::Valueless
+    where
+        Self: ValueCategoryDispatch<InputValueCategory = ValueCategoryValueless>;
+    fn dispatch(self) -> <Self::InputValueCategory as ValueCategory>::DispatchOutput<Self> {
+        Self::InputValueCategory::dispatch(self)
+    }
+    fn dispatch_enum(self) -> ValueCategoryDispatchOutputEnum<Self> {
+        Self::InputValueCategory::dispatch_enum(self)
+    }
+}
+
+pub enum ValueCategoryDispatchOutputEnum<T: ValueCategoryDispatch> {
+    Value(T::Value),
+    SimValue(T::SimValue),
+    Expr(T::Expr),
+    Valueless(T::Valueless),
+}
+
+impl<T: ValueCategoryDispatch> ValueCategoryDispatchOutputEnum<T> {
+    pub fn try_into_value(self) -> Result<T::Value, Self> {
+        if let Self::Value(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+    pub fn try_into_sim_value(self) -> Result<T::SimValue, Self> {
+        if let Self::SimValue(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+    pub fn try_into_expr(self) -> Result<T::Expr, Self> {
+        if let Self::Expr(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+    pub fn try_into_valueless(self) -> Result<T::Valueless, Self> {
+        if let Self::Valueless(v) = self {
+            Ok(v)
+        } else {
+            Err(self)
+        }
+    }
+    #[track_caller]
+    #[cold]
+    fn unwrap_invalid(self, expected_kind: &'static str) -> ! {
+        match self {
+            Self::Value(_) => panic!("expected {expected_kind}, got Value"),
+            Self::SimValue(_) => panic!("expected {expected_kind}, got SimValue"),
+            Self::Expr(_) => panic!("expected {expected_kind}, got Expr"),
+            Self::Valueless(_) => panic!("expected {expected_kind}, got Valueless"),
+        }
+    }
+    #[track_caller]
+    pub fn into_value_unwrap(self) -> T::Value {
+        let Self::Value(v) = self else {
+            self.unwrap_invalid("Value");
+        };
+        v
+    }
+    #[track_caller]
+    pub fn into_sim_value_unwrap(self) -> T::SimValue {
+        let Self::SimValue(v) = self else {
+            self.unwrap_invalid("SimValue");
+        };
+        v
+    }
+    #[track_caller]
+    pub fn into_expr_unwrap(self) -> T::Expr {
+        let Self::Expr(v) = self else {
+            self.unwrap_invalid("Expr");
+        };
+        v
+    }
+    #[track_caller]
+    pub fn into_valueless_unwrap(self) -> T::Valueless {
+        let Self::Valueless(v) = self else {
+            self.unwrap_invalid("Valueless");
+        };
+        v
+    }
+    pub fn ty(&self) -> T::Type {
+        match self {
+            Self::Value(v) => v.ty(),
+            Self::SimValue(v) => v.ty(),
+            Self::Expr(v) => v.ty(),
+            Self::Valueless(v) => v.ty(),
+        }
+    }
+}
diff --git a/crates/fayalite/src/firrtl.rs b/crates/fayalite/src/firrtl.rs
index 59fbec7f..88b97ac5 100644
--- a/crates/fayalite/src/firrtl.rs
+++ b/crates/fayalite/src/firrtl.rs
@@ -877,7 +877,7 @@ impl<'a> Exporter<'a> {
         definitions: &RcDefinitions,
         const_ty: bool,
     ) -> Result<String> {
-        let from_ty = Expr::ty(value);
+        let from_ty = value.ty();
         let mut value = self.expr(Expr::canonical(value), definitions, const_ty)?;
         if from_ty.width().checked_add(1) == Some(to_ty.width())
             && !FromTy::Signed::VALUE
@@ -926,7 +926,7 @@ impl<'a> Exporter<'a> {
         definitions: &RcDefinitions,
         const_ty: bool,
     ) -> Result<String> {
-        let base_width = Expr::ty(base).width();
+        let base_width = base.ty().width();
         let base = self.expr(Expr::canonical(base), definitions, const_ty)?;
         if range.is_empty() {
             Ok(format!("tail({base}, {base_width})"))
@@ -1653,7 +1653,7 @@ impl<'a> Exporter<'a> {
                 let value_str = self.expr(expr.arg(), definitions, const_ty)?;
                 self.expr_cast_to_bits(
                     value_str,
-                    Expr::ty(expr.arg()),
+                    expr.arg().ty(),
                     definitions,
                     Indent {
                         indent_depth: &Cell::new(0),
@@ -1776,7 +1776,7 @@ impl<'a> Exporter<'a> {
                 let mut out = self.expr(Expr::canonical(expr.base()), definitions, const_ty)?;
                 let name = self
                     .type_state
-                    .get_bundle_field(Expr::ty(expr.base()), expr.field_name())?;
+                    .get_bundle_field(expr.base().ty(), expr.field_name())?;
                 write!(out, ".{name}").unwrap();
                 Ok(out)
             }
@@ -2101,12 +2101,12 @@ impl<'a> Exporter<'a> {
                     rhs,
                     source_location,
                 }) => {
-                    if Expr::ty(lhs) != Expr::ty(rhs) {
+                    if lhs.ty() != rhs.ty() {
                         writeln!(
                             body,
                             "{indent}; connect different types:\n{indent}; lhs: {:?}\n{indent}; rhs: {:?}",
-                            Expr::ty(lhs),
-                            Expr::ty(rhs),
+                            lhs.ty(),
+                            rhs.ty(),
                         )
                         .unwrap();
                     }
@@ -2200,7 +2200,7 @@ impl<'a> Exporter<'a> {
                         FileInfo::new(source_location),
                     )
                     .unwrap();
-                    let enum_ty = Expr::ty(expr);
+                    let enum_ty = expr.ty();
                     let match_arms_indent = indent.push();
                     for ((variant_index, variant), match_arm_block) in
                         enum_ty.variants().iter().enumerate().zip(blocks)
diff --git a/crates/fayalite/src/int.rs b/crates/fayalite/src/int.rs
index 7fa77ce4..d897d5ba 100644
--- a/crates/fayalite/src/int.rs
+++ b/crates/fayalite/src/int.rs
@@ -4,8 +4,10 @@
 use crate::{
     array::ArrayType,
     expr::{
-        Expr, NotALiteralExpr, ToExpr, ToLiteralBits,
+        Expr, HdlPartialEq, HdlPartialOrd, NotALiteralExpr, ToExpr, ToLiteralBits, ToSimValueInner,
+        ToValueless, ValueType, Valueless,
         target::{GetTarget, Target},
+        value_category::ValueCategoryValue,
     },
     hdl,
     intern::{Intern, Interned, Memoize},
@@ -530,6 +532,23 @@ fn deserialize_int_value<'de, D: Deserializer<'de>>(
     })
 }
 
+macro_rules! impl_valueless_op_forward {
+    (
+        #[forward_to = $ForwardTrait:path]
+        impl<$($G:ident: $Bound:path),*> $TraitPath:ident$(::$TraitPathRest:ident)+<$($Rhs:ty)?> for $SelfTy:ty {
+            $($(type $Output:ident;)?
+            use $forward_fn:path as $fn:ident($self:ident $(, $rhs:ident)?);)?
+        }
+    ) => {
+        impl<$($G: $Bound),*> $TraitPath$(::$TraitPathRest)+<$($Rhs)?> for $SelfTy {
+            $($(type $Output = <$SelfTy as $ForwardTrait>::$Output;)?
+            fn $fn($self $(, $rhs: $Rhs)?) $(-> Self::$Output)? {
+                $forward_fn($self $(, $rhs)?)
+            })?
+        }
+    };
+}
+
 macro_rules! impl_int {
     ($pretty_name:ident, $name:ident, $generic_name:ident, $value:ident, $SIGNED:literal) => {
         #[derive(Copy, Clone, PartialEq, Eq, Hash)]
@@ -582,6 +601,176 @@ macro_rules! impl_int {
             }
         }
 
+        impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+            std::ops::Add<Rhs> for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<$name>;
+
+            fn add(self, rhs: Rhs) -> Self::Output {
+                Valueless::new($name::new_dyn(
+                    self.ty()
+                        .width()
+                        .max(rhs.ty().width())
+                        .checked_add(1)
+                        .expect("width too big"),
+                ))
+            }
+        }
+
+        impl_valueless_op_forward! {
+            #[forward_to = std::ops::Add<Rhs>]
+            impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+                std::ops::Sub<Rhs> for Valueless<$name<LhsWidth>>
+            {
+                type Output;
+
+                use std::ops::Add::<Rhs>::add as sub(self, rhs);
+            }
+        }
+
+        impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+            std::ops::BitOr<Rhs> for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<UInt>;
+
+            fn bitor(self, rhs: Rhs) -> Self::Output {
+                Valueless::new(UInt::new_dyn(self.ty().width().max(rhs.ty().width())))
+            }
+        }
+
+        impl_valueless_op_forward! {
+            #[forward_to = std::ops::BitOr<Rhs>]
+            impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+                std::ops::BitAnd<Rhs> for Valueless<$name<LhsWidth>>
+            {
+                type Output;
+
+                use std::ops::BitOr::<Rhs>::bitor as bitand(self, rhs);
+            }
+        }
+
+        impl_valueless_op_forward! {
+            #[forward_to = std::ops::BitOr<Rhs>]
+            impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+                std::ops::BitXor<Rhs> for Valueless<$name<LhsWidth>>
+            {
+                type Output;
+
+                use std::ops::BitOr::<Rhs>::bitor as bitxor(self, rhs);
+            }
+        }
+
+        impl<Width: Size> std::ops::Not for Valueless<$name<Width>> {
+            type Output = Valueless<UIntType<Width>>;
+
+            fn not(self) -> Self::Output {
+                Valueless::new(self.ty().as_same_width_uint())
+            }
+        }
+
+        impl<Width: Size> std::ops::Not for $value<Width> {
+            type Output = UIntValue<Width>;
+
+            fn not(mut self) -> Self::Output {
+                // modifies in-place despite using `Not::not`
+                let _ = Not::not(self.bits_mut());
+                UIntValue::new(self.into_bits())
+            }
+        }
+
+        impl<Width: Size> std::ops::Not for &'_ $value<Width> {
+            type Output = UIntValue<Width>;
+
+            fn not(self) -> Self::Output {
+                $value::not(self.clone())
+            }
+        }
+
+        impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+            std::ops::Mul<Rhs> for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<$name>;
+
+            fn mul(self, rhs: Rhs) -> Self::Output {
+                Valueless::new($name::new_dyn(
+                    self.ty()
+                        .width()
+                        .checked_add(rhs.ty().width())
+                        .expect("width too big"),
+                ))
+            }
+        }
+
+        impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = $name<RhsWidth>>>
+            std::ops::Rem<Rhs> for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<$name>;
+
+            fn rem(self, rhs: Rhs) -> Self::Output {
+                Valueless::new($name::new_dyn(self.ty().width().min(rhs.ty().width())))
+            }
+        }
+
+        impl<LhsWidth: Size, RhsWidth: Size> std::ops::Shl<Valueless<UIntType<RhsWidth>>>
+            for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<$name>;
+
+            #[track_caller]
+            fn shl(self, rhs: Valueless<UIntType<RhsWidth>>) -> Self::Output {
+                let Some(pow2_rhs_width) = rhs
+                    .ty()
+                    .width()
+                    .try_into()
+                    .ok()
+                    .and_then(|v| 2usize.checked_pow(v))
+                else {
+                    panic!(
+                        "dynamic left-shift amount's bit-width is too big, try casting the shift \
+                        amount to a smaller bit-width before shifting"
+                    );
+                };
+                Valueless::new($name::new_dyn(
+                    (pow2_rhs_width - 1)
+                        .checked_add(self.ty().width())
+                        .expect("width too big"),
+                ))
+            }
+        }
+
+        impl<LhsWidth: Size, RhsWidth: Size> std::ops::Shr<Valueless<UIntType<RhsWidth>>>
+            for Valueless<$name<LhsWidth>>
+        {
+            type Output = Valueless<$name<LhsWidth>>;
+
+            fn shr(self, _rhs: Valueless<UIntType<RhsWidth>>) -> Self::Output {
+                self
+            }
+        }
+
+        impl<LhsWidth: Size> std::ops::Shl<usize> for Valueless<$name<LhsWidth>> {
+            type Output = Valueless<$name>;
+
+            fn shl(self, rhs: usize) -> Self::Output {
+                Valueless::new($name::new_dyn(
+                    self.ty().width().checked_add(rhs).expect("width too big"),
+                ))
+            }
+        }
+
+        impl<LhsWidth: Size> std::ops::Shr<usize> for Valueless<$name<LhsWidth>> {
+            type Output = Valueless<$name>;
+
+            fn shr(self, rhs: usize) -> Self::Output {
+                let width = self.ty().width().saturating_sub(rhs);
+                Valueless::new($name::new_dyn(if $SIGNED && width == 0 {
+                    1
+                } else {
+                    width
+                }))
+            }
+        }
+
         impl<Width: Size> sealed::BoolOrIntTypeSealed for $name<Width> {}
 
         impl<Width: Size> BoolOrIntType for $name<Width> {
@@ -861,11 +1050,6 @@ macro_rules! impl_int {
             pub fn into_bits(self) -> Arc<BitVec> {
                 self.bits
             }
-            pub fn ty(&self) -> $name<Width> {
-                $name {
-                    width: Width::from_usize(self.width()),
-                }
-            }
             pub fn as_dyn_int(self) -> $value {
                 $value {
                     bits: self.bits,
@@ -878,6 +1062,74 @@ macro_rules! impl_int {
             pub fn bits_mut(&mut self) -> &mut BitSlice {
                 Arc::<BitVec>::make_mut(&mut self.bits)
             }
+            pub fn hdl_cmp<R: Size>(&self, other: &$value<R>) -> std::cmp::Ordering {
+                self.to_bigint().cmp(&other.to_bigint())
+            }
+        }
+
+        impl<Width: Size> ValueType for $value<Width> {
+            type Type = $name<Width>;
+            type ValueCategory = ValueCategoryValue;
+
+            fn ty(&self) -> Self::Type {
+                $name {
+                    width: Width::from_usize(self.width()),
+                }
+            }
+        }
+
+        impl<'r, L: Size, R: Size> HdlPartialEq<&'r $value<R>> for $value<L> {
+            type Output = bool;
+            fn cmp_eq(&self, rhs: &'r $value<R>) -> Self::Output {
+                if self.width() == rhs.width() {
+                    self.bits() == rhs.bits()
+                } else {
+                    self.to_bigint() == rhs.to_bigint()
+                }
+            }
+            fn cmp_ne(&self, rhs: &'r $value<R>) -> Self::Output {
+                !self.cmp_eq(rhs)
+            }
+        }
+
+        impl<'r, L: Size, R: Size> HdlPartialOrd<&'r $value<R>> for $value<L> {
+            fn cmp_lt(&self, rhs: &'r $value<R>) -> Self::Output {
+                self.hdl_cmp(rhs).is_lt()
+            }
+            fn cmp_le(&self, rhs: &'r $value<R>) -> Self::Output {
+                self.hdl_cmp(rhs).is_le()
+            }
+            fn cmp_gt(&self, rhs: &'r $value<R>) -> Self::Output {
+                self.hdl_cmp(rhs).is_gt()
+            }
+            fn cmp_ge(&self, rhs: &'r $value<R>) -> Self::Output {
+                self.hdl_cmp(rhs).is_ge()
+            }
+        }
+
+        impl<L: Size, R: Size> HdlPartialEq<$value<R>> for $value<L> {
+            type Output = bool;
+            fn cmp_eq(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_eq(&rhs)
+            }
+            fn cmp_ne(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_ne(&rhs)
+            }
+        }
+
+        impl<L: Size, R: Size> HdlPartialOrd<$value<R>> for $value<L> {
+            fn cmp_lt(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_lt(&rhs)
+            }
+            fn cmp_le(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_le(&rhs)
+            }
+            fn cmp_gt(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_gt(&rhs)
+            }
+            fn cmp_ge(&self, rhs: $value<R>) -> Self::Output {
+                self.cmp_ge(&rhs)
+            }
         }
 
         impl<Width: Size> ToLiteralBits for $value<Width> {
@@ -923,6 +1175,17 @@ macro_rules! impl_int {
                 Arc::make_mut(&mut self.bits)
             }
         }
+
+        impl<'l, 'r, L: Size, R: Size> std::ops::Add<&'r $value<R>> for &'l $value<L> {
+            type Output = $value;
+
+            fn add(self, rhs: &'r $value<R>) -> Self::Output {
+                self.to_valueless()
+                    .add(rhs.to_valueless())
+                    .ty()
+                    .value_from_bigint_wrapping(&(self.to_bigint() + rhs.to_bigint()))
+            }
+        }
     };
 }
 
@@ -1015,11 +1278,58 @@ impl SInt {
     }
 }
 
-macro_rules! impl_prim_int {
+impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = UIntType<RhsWidth>>> std::ops::Div<Rhs>
+    for Valueless<UIntType<LhsWidth>>
+{
+    type Output = Self;
+
+    fn div(self, _rhs: Rhs) -> Self::Output {
+        self
+    }
+}
+
+impl<LhsWidth: Size, RhsWidth: Size, Rhs: ToValueless<Type = SIntType<RhsWidth>>> std::ops::Div<Rhs>
+    for Valueless<SIntType<LhsWidth>>
+{
+    type Output = Valueless<SInt>;
+
+    fn div(self, _rhs: Rhs) -> Self::Output {
+        Valueless::new(SInt::new_dyn(
+            self.ty().width().checked_add(1).expect("width too big"),
+        ))
+    }
+}
+
+impl<Width: Size> std::ops::Neg for Valueless<SIntType<Width>> {
+    type Output = Valueless<SInt>;
+    fn neg(self) -> Self::Output {
+        Valueless::new(SInt::new_dyn(
+            self.ty().width().checked_add(1).expect("width too big"),
+        ))
+    }
+}
+
+impl<Width: Size> std::ops::Neg for SIntValue<Width> {
+    type Output = SIntValue;
+    fn neg(self) -> Self::Output {
+        -&self
+    }
+}
+
+impl<Width: Size> std::ops::Neg for &'_ SIntValue<Width> {
+    type Output = SIntValue;
+    fn neg(self) -> Self::Output {
+        let ty = self.to_valueless().neg().ty();
+        ty.from_bigint_wrapping(&-self.to_bigint())
+    }
+}
+
+macro_rules! impl_prim_int_to_expr {
     (
         $(#[$meta:meta])*
         $prim_int:ident, $ty:ty
     ) => {
+        $(#[$meta])*
         impl From<$prim_int> for <$ty as BoolOrIntType>::Value {
             fn from(v: $prim_int) -> Self {
                 <$ty>::le_bytes_to_value_wrapping(
@@ -1028,15 +1338,32 @@ macro_rules! impl_prim_int {
                 )
             }
         }
+        $(#[$meta])*
         impl From<NonZero<$prim_int>> for <$ty as BoolOrIntType>::Value {
             fn from(v: NonZero<$prim_int>) -> Self {
                 v.get().into()
             }
         }
         $(#[$meta])*
-        impl ToExpr for $prim_int {
+        impl ToSimValueInner for $prim_int {
+            fn to_sim_value_inner(this: &Self) -> <Self::Type as Type>::SimValue {
+                Self::into_sim_value_inner(*this)
+            }
+            fn into_sim_value_inner(this: Self) -> <Self::Type as Type>::SimValue {
+                this.into()
+            }
+        }
+        $(#[$meta])*
+        impl ValueType for $prim_int {
             type Type = $ty;
+            type ValueCategory = ValueCategoryValue;
 
+            fn ty(&self) -> Self::Type {
+                StaticType::TYPE
+            }
+        }
+        $(#[$meta])*
+        impl ToExpr for $prim_int {
             fn to_expr(&self) -> Expr<Self::Type> {
                 <$ty>::le_bytes_to_expr_wrapping(
                     &self.to_le_bytes(),
@@ -1045,9 +1372,25 @@ macro_rules! impl_prim_int {
             }
         }
         $(#[$meta])*
-        impl ToExpr for NonZero<$prim_int> {
+        impl ToSimValueInner for NonZero<$prim_int> {
+            fn to_sim_value_inner(this: &Self) -> <Self::Type as Type>::SimValue {
+                Self::into_sim_value_inner(*this)
+            }
+            fn into_sim_value_inner(this: Self) -> <Self::Type as Type>::SimValue {
+                this.into()
+            }
+        }
+        $(#[$meta])*
+        impl ValueType for NonZero<$prim_int> {
             type Type = $ty;
+            type ValueCategory = ValueCategoryValue;
 
+            fn ty(&self) -> Self::Type {
+                StaticType::TYPE
+            }
+        }
+        $(#[$meta])*
+        impl ToExpr for NonZero<$prim_int> {
             fn to_expr(&self) -> Expr<Self::Type> {
                 self.get().to_expr()
             }
@@ -1055,25 +1398,203 @@ macro_rules! impl_prim_int {
     };
 }
 
-impl_prim_int!(u8, UInt<8>);
-impl_prim_int!(u16, UInt<16>);
-impl_prim_int!(u32, UInt<32>);
-impl_prim_int!(u64, UInt<64>);
-impl_prim_int!(u128, UInt<128>);
-impl_prim_int!(i8, SInt<8>);
-impl_prim_int!(i16, SInt<16>);
-impl_prim_int!(i32, SInt<32>);
-impl_prim_int!(i64, SInt<64>);
-impl_prim_int!(i128, SInt<128>);
+macro_rules! impl_for_all_prim_uints {
+    (
+        #[size =, $(rest:tt)*]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_uints!(
+            #[usize =, $($rest)*]
+            $m!()
+        );
+    };
+    (
+        #[size = size, $(rest:tt)*]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_uints!(
+            #[usize = usize, $($rest)*]
+            $m!()
+        );
+    };
+    (
+        #[usize = $($usize:ident)?, NonZero = $NonZero:ident]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_uints!(
+            #[usize = $($usize)?, NonZero = $NonZero, NonZero<usize> = $((NonZero<$usize>))?]
+            $m!()
+        );
+    };
+    (
+        #[usize = $($usize:ident)?, NonZero =]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_uints!(
+            #[usize = $($usize)?, NonZero =, NonZero<usize> =]
+            $m!()
+        );
+    };
+    (
+        #[usize = $($usize:ident)?, NonZero = $($NonZero:ident)?, NonZero<usize> = $(($($NonZeroUsize:tt)*))?]
+        $m:ident!()
+    ) => {
+        $m!(u8, UInt<8>);
+        $m!(u16, UInt<16>);
+        $m!(u32, UInt<32>);
+        $m!(u64, UInt<64>);
+        $m!(u128, UInt<128>);
+        $($m!($NonZero<u8>, UInt<8>);)?
+        $($m!($NonZero<u16>, UInt<16>);)?
+        $($m!($NonZero<u32>, UInt<32>);)?
+        $($m!($NonZero<u64>, UInt<64>);)?
+        $($m!($NonZero<u128>, UInt<128>);)?
+        $($m!(
+            /// for portability reasons, [`usize`] always translates to [`UInt<64>`][type@UInt]
+            $usize, UInt<64>
+        );)?
+        $($m!(
+            /// for portability reasons, [`usize`] always translates to [`UInt<64>`][type@UInt]
+            $($NonZeroUsize)*, UInt<64>
+        );)?
+    };
+}
 
-impl_prim_int!(
-    /// for portability reasons, [`usize`] always translates to [`UInt<64>`][type@UInt]
-    usize, UInt<64>
+macro_rules! impl_for_all_prim_sints {
+    (
+        #[size =, $(rest:tt)*]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_sints!(
+            #[isize =, $($rest)*]
+            $m!()
+        );
+    };
+    (
+        #[size = size, $(rest:tt)*]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_sints!(
+            #[isize = isize, $($rest)*]
+            $m!()
+        );
+    };
+    (
+        #[isize = $($isize:ident)?, NonZero = $NonZero:ident]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_sints!(
+            #[isize = $($isize)?, NonZero = $NonZero, NonZero<isize> = $((NonZero<$isize>))?]
+            $m!()
+        );
+    };
+    (
+        #[isize = $($isize:ident)?, NonZero =]
+        $m:ident!()
+    ) => {
+        impl_for_all_prim_sints!(
+            #[isize = $($isize)?, NonZero =, NonZero<isize> =]
+            $m!()
+        );
+    };
+    (
+        #[isize = $($isize:ident)?, NonZero = $($NonZero:ident)?, NonZero<isize> = $(($($NonZeroIsize:tt)*))?]
+        $m:ident!()
+    ) => {
+        $m!(i8, SInt<8>);
+        $m!(i16, SInt<16>);
+        $m!(i32, SInt<32>);
+        $m!(i64, SInt<64>);
+        $m!(i128, SInt<128>);
+        $($m!($NonZero<i8>, SInt<8>);)?
+        $($m!($NonZero<i16>, SInt<16>);)?
+        $($m!($NonZero<i32>, SInt<32>);)?
+        $($m!($NonZero<i64>, SInt<64>);)?
+        $($m!($NonZero<i128>, SInt<128>);)?
+        $($m!(
+            /// for portability reasons, [`isize`] always translates to [`SInt<64>`][type@SInt]
+            $isize, SInt<64>
+        );)?
+        $($m!(
+            /// for portability reasons, [`isize`] always translates to [`SInt<64>`][type@SInt]
+            $($NonZeroIsize)*, SInt<64>
+        );)?
+    };
+}
+
+impl_for_all_prim_uints!(
+    #[usize = usize, NonZero =]
+    impl_prim_int_to_expr!()
 );
 
-impl_prim_int!(
-    /// for portability reasons, [`isize`] always translates to [`SInt<64>`][type@SInt]
-    isize, SInt<64>
+impl_for_all_prim_sints!(
+    #[isize = isize, NonZero =]
+    impl_prim_int_to_expr!()
+);
+
+macro_rules! impl_prim_int_from_value {
+    ($prim_int:ident, UInt<$width:literal>) => {
+        impl_prim_int_from_value!($prim_int, UInt<$width>, UIntValue<ConstUsize<$width>>);
+    };
+    ($prim_int:ident, SInt<$width:literal>) => {
+        impl_prim_int_from_value!($prim_int, SInt<$width>, SIntValue<ConstUsize<$width>>);
+    };
+    ($prim_int:ident, $ty:ty, $value:ty) => {
+        impl From<$value> for $prim_int {
+            fn from(value: $value) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl<'a> From<&'a mut $value> for $prim_int {
+            fn from(value: &'a mut $value) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl From<SimValue<$ty>> for $prim_int {
+            fn from(value: SimValue<$ty>) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl<'a> From<&'a mut SimValue<$ty>> for $prim_int {
+            fn from(value: &'a mut SimValue<$ty>) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl<'a> From<&'a SimValue<$ty>> for $prim_int {
+            fn from(value: &'a SimValue<$ty>) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl<'a> From<&'a $value> for $prim_int {
+            fn from(value: &'a $value) -> Self {
+                value.as_int()
+            }
+        }
+
+        impl $value {
+            pub fn as_int(&self) -> $prim_int {
+                let mut le_bytes = (0 as $prim_int).to_le_bytes();
+                let bitslice = BitSlice::<u8, Lsb0>::from_slice_mut(&mut le_bytes);
+                bitslice.clone_from_bitslice(self.bits());
+                $prim_int::from_le_bytes(le_bytes)
+            }
+        }
+    };
+}
+
+impl_for_all_prim_uints!(
+    #[usize =, NonZero =]
+    impl_prim_int_from_value!()
+);
+
+impl_for_all_prim_sints!(
+    #[isize =, NonZero =]
+    impl_prim_int_from_value!()
 );
 
 pub trait BoolOrIntType: Type + sealed::BoolOrIntTypeSealed {
@@ -1307,6 +1828,23 @@ impl ToLiteralBits for bool {
     }
 }
 
+impl ToSimValueInner for bool {
+    fn to_sim_value_inner(this: &Self) -> <Self::Type as Type>::SimValue {
+        *this
+    }
+    fn into_sim_value_inner(this: Self) -> <Self::Type as Type>::SimValue {
+        this
+    }
+}
+
+impl std::ops::Not for Valueless<Bool> {
+    type Output = Valueless<Bool>;
+
+    fn not(self) -> Self::Output {
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/fayalite/src/memory.rs b/crates/fayalite/src/memory.rs
index 46eb59bd..83e74376 100644
--- a/crates/fayalite/src/memory.rs
+++ b/crates/fayalite/src/memory.rs
@@ -7,7 +7,10 @@ use crate::{
     array::{Array, ArrayType},
     bundle::{Bundle, BundleType},
     clock::Clock,
-    expr::{Expr, Flow, ToExpr, ToLiteralBits, ops::BundleLiteral, repeat},
+    expr::{
+        Expr, Flow, ToExpr, ToLiteralBits, ValueType, ops::BundleLiteral, repeat,
+        value_category::ValueCategoryExpr,
+    },
     hdl,
     int::{Bool, DynSize, Size, UInt, UIntType},
     intern::{Intern, Interned},
@@ -366,10 +369,16 @@ impl<T: PortType> fmt::Debug for MemPort<T> {
     }
 }
 
-impl<T: PortType> MemPort<T> {
-    pub fn ty(&self) -> T::Port {
+impl<T: PortType> ValueType for MemPort<T> {
+    type Type = T::Port;
+    type ValueCategory = ValueCategoryExpr;
+
+    fn ty(&self) -> T::Port {
         T::port_ty(self)
     }
+}
+
+impl<T: PortType> MemPort<T> {
     pub fn source_location(&self) -> SourceLocation {
         self.source_location
     }
@@ -830,7 +839,7 @@ impl<Element: Type, Len: Size> MemBuilder<Element, Len> {
         depth: Option<usize>,
         initial_value: Expr<Array>,
     ) -> Interned<BitSlice> {
-        let initial_value_ty = Expr::ty(initial_value);
+        let initial_value_ty = initial_value.ty();
         assert_eq!(
             *mem_element_type,
             Element::from_canonical(initial_value_ty.element()),
@@ -1011,7 +1020,7 @@ impl<Element: Type, Len: Size> MemBuilder<Element, Len> {
             target.depth,
             initial_value,
         ));
-        target.depth = Some(Expr::ty(initial_value).len());
+        target.depth = Some(initial_value.ty().len());
     }
     #[track_caller]
     pub fn initial_value_bit_slice(&mut self, initial_value: Interned<BitSlice>) {
diff --git a/crates/fayalite/src/module.rs b/crates/fayalite/src/module.rs
index 5ffeaae2..9d1a0e76 100644
--- a/crates/fayalite/src/module.rs
+++ b/crates/fayalite/src/module.rs
@@ -8,12 +8,13 @@ use crate::{
     clock::{Clock, ClockDomain},
     enum_::{Enum, EnumMatchVariantsIter, EnumType},
     expr::{
-        Expr, Flow, ToExpr,
+        Expr, Flow, ToExpr, ValueType,
         ops::VariantAccess,
         target::{
             GetTarget, Target, TargetBase, TargetPathArrayElement, TargetPathBundleField,
             TargetPathElement,
         },
+        value_category::ValueCategoryExpr,
     },
     formal::FormalKind,
     int::{Bool, DynSize, Size},
@@ -205,7 +206,7 @@ impl StmtConnect {
             source_location,
         } = *self;
         assert!(
-            Expr::ty(lhs).can_connect(Expr::ty(rhs)),
+            lhs.ty().can_connect(rhs.ty()),
             "can't connect types that are not equivalent:\nlhs type:\n{lhs_orig_ty:?}\nrhs type:\n{rhs_orig_ty:?}\nat: {source_location}",
         );
         assert!(
@@ -219,14 +220,14 @@ impl StmtConnect {
         match Expr::flow(rhs) {
             Flow::Source | Flow::Duplex => {}
             Flow::Sink => assert!(
-                Expr::ty(rhs).is_passive(),
+                rhs.ty().is_passive(),
                 "can't connect from sink with non-passive type\nat: {source_location}"
             ),
         }
     }
     #[track_caller]
     fn assert_validity(&self) {
-        self.assert_validity_with_original_types(Expr::ty(self.lhs), Expr::ty(self.rhs));
+        self.assert_validity_with_original_types(self.lhs.ty(), self.rhs.ty());
     }
 }
 
@@ -331,7 +332,7 @@ impl Copy for StmtMatch {}
 impl StmtMatch {
     #[track_caller]
     fn assert_validity(&self) {
-        assert_eq!(Expr::ty(self.expr).variants().len(), self.blocks.len());
+        assert_eq!(self.expr.ty().variants().len(), self.blocks.len());
     }
 }
 
@@ -765,6 +766,15 @@ impl<T: BundleType> fmt::Debug for Instance<T> {
     }
 }
 
+impl<T: BundleType> ValueType for Instance<T> {
+    type Type = T;
+    type ValueCategory = ValueCategoryExpr;
+
+    fn ty(&self) -> T {
+        self.instantiated.io_ty()
+    }
+}
+
 impl<T: BundleType> Instance<T> {
     pub fn canonical(self) -> Instance<Bundle> {
         let Self {
@@ -828,9 +838,6 @@ impl<T: BundleType> Instance<T> {
     pub fn must_connect_to(&self) -> bool {
         true
     }
-    pub fn ty(&self) -> T {
-        self.instantiated.io_ty()
-    }
 }
 
 #[derive(Clone, PartialEq, Eq, Hash, Debug)]
@@ -2028,7 +2035,7 @@ impl<CD> RegBuilder<CD, (), ()> {
             init: _,
             ty: _,
         } = self;
-        let ty = Expr::ty(init);
+        let ty = init.ty();
         RegBuilder {
             name,
             source_location,
@@ -2597,7 +2604,7 @@ pub fn enum_match_variants_helper<T: EnumType>(
     ModuleBuilder::with(|m| {
         let mut impl_ = m.impl_.borrow_mut();
         let body = impl_.body.builder_normal_body();
-        let enum_ty = Expr::ty(base);
+        let enum_ty = base.ty();
         let outer_block: BlockId = m.block_stack.top();
         let blocks = Interned::from_iter(enum_ty.variants().iter().map(|_| body.new_block()));
         body.block(outer_block).stmts.push(
@@ -2649,7 +2656,7 @@ pub fn connect_any_with_loc<Lhs: ToExpr, Rhs: ToExpr>(
         rhs,
         source_location,
     };
-    connect.assert_validity_with_original_types(Expr::ty(lhs_orig), Expr::ty(rhs_orig));
+    connect.assert_validity_with_original_types(lhs_orig.ty(), rhs_orig.ty());
     ModuleBuilder::with(|m| {
         m.impl_
             .borrow_mut()
@@ -2764,7 +2771,7 @@ pub fn memory_with_init_and_loc<Element: Type, Len: Size>(
     source_location: SourceLocation,
 ) -> MemBuilder<Element, Len> {
     let initial_value = initial_value.to_expr();
-    let mut retval = memory_array_with_loc(name, Expr::ty(initial_value), source_location);
+    let mut retval = memory_array_with_loc(name, initial_value.ty(), source_location);
     retval.initial_value(initial_value);
     retval
 }
@@ -2807,6 +2814,15 @@ pub struct ModuleIO<T: Type> {
     source_location: SourceLocation,
 }
 
+impl<T: Type> ValueType for ModuleIO<T> {
+    type Type = T;
+    type ValueCategory = ValueCategoryExpr;
+
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
 impl<T: Type> fmt::Debug for ModuleIO<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("ModuleIO")
@@ -2908,9 +2924,6 @@ impl<T: Type> ModuleIO<T> {
             unreachable!()
         }
     }
-    pub fn ty(&self) -> T {
-        self.ty
-    }
 }
 
 #[derive(PartialEq, Eq, Hash, Clone, Copy)]
diff --git a/crates/fayalite/src/module/transform/deduce_resets.rs b/crates/fayalite/src/module/transform/deduce_resets.rs
index bd4e939c..73f92dd2 100644
--- a/crates/fayalite/src/module/transform/deduce_resets.rs
+++ b/crates/fayalite/src/module/transform/deduce_resets.rs
@@ -521,7 +521,7 @@ impl State {
             Entry::Vacant(entry) => (
                 *entry.insert(Resets::with_new_nodes(
                     &mut self.reset_graph,
-                    Expr::ty(expr),
+                    expr.ty(),
                     source_location,
                 )),
                 true,
@@ -1020,7 +1020,7 @@ fn cast_bit_op<P: Pass, T: Type, A: Type>(
                 }
                 macro_rules! match_arg_ty {
                     ($($Variant:ident),*) => {
-                        *match Expr::ty(arg) {
+                        *match arg.ty() {
                             CanonicalType::Array(_)
                             | CanonicalType::Enum(_)
                             | CanonicalType::Bundle(_)
@@ -1660,7 +1660,8 @@ impl RunPassDispatch for AnyReg {
             let clock_domain = Expr::<Bundle>::from_canonical(
                 Expr::canonical(reg.clock_domain()).run_pass(pass_args)?.0,
             );
-            match Expr::ty(clock_domain)
+            match clock_domain
+                .ty()
                 .field_by_name("rst".intern())
                 .expect("ClockDomain has rst field")
                 .ty
diff --git a/crates/fayalite/src/module/transform/simplify_enums.rs b/crates/fayalite/src/module/transform/simplify_enums.rs
index bd5f7d52..3e013e70 100644
--- a/crates/fayalite/src/module/transform/simplify_enums.rs
+++ b/crates/fayalite/src/module/transform/simplify_enums.rs
@@ -528,7 +528,7 @@ fn connect_port(
     rhs: Expr<CanonicalType>,
     source_location: SourceLocation,
 ) {
-    if Expr::ty(lhs) == Expr::ty(rhs) {
+    if lhs.ty() == rhs.ty() {
         stmts.push(
             StmtConnect {
                 lhs,
@@ -539,7 +539,7 @@ fn connect_port(
         );
         return;
     }
-    match (Expr::ty(lhs), Expr::ty(rhs)) {
+    match (lhs.ty(), rhs.ty()) {
         (CanonicalType::Bundle(lhs_type), CanonicalType::UInt(_) | CanonicalType::Bool(_)) => {
             let lhs = Expr::<Bundle>::from_canonical(lhs);
             for field in lhs_type.fields() {
@@ -586,8 +586,8 @@ fn connect_port(
         | (CanonicalType::PhantomConst(_), _)
         | (CanonicalType::DynSimOnly(_), _) => unreachable!(
             "trying to connect memory ports:\n{:?}\n{:?}",
-            Expr::ty(lhs),
-            Expr::ty(rhs),
+            lhs.ty(),
+            rhs.ty(),
         ),
     }
 }
@@ -607,14 +607,17 @@ fn match_int_tag(
         };
     };
     let mut retval = StmtIf {
-        cond: int_tag_expr
-            .cmp_eq(Expr::ty(int_tag_expr).from_int_wrapping(next_to_last_variant_index)),
+        cond: int_tag_expr.cmp_eq(
+            int_tag_expr
+                .ty()
+                .from_int_wrapping(next_to_last_variant_index),
+        ),
         source_location,
         blocks: [next_to_last_block, last_block],
     };
     for (variant_index, block) in blocks_iter.rev() {
         retval = StmtIf {
-            cond: int_tag_expr.cmp_eq(Expr::ty(int_tag_expr).from_int_wrapping(variant_index)),
+            cond: int_tag_expr.cmp_eq(int_tag_expr.ty().from_int_wrapping(variant_index)),
             source_location,
             blocks: [
                 block,
@@ -657,7 +660,7 @@ impl Folder for State {
             ExprEnum::VariantAccess(op) => {
                 let folded_base_expr = Expr::canonical(op.base()).fold(self)?;
                 Ok(*Expr::expr_enum(self.handle_variant_access(
-                    Expr::ty(op.base()),
+                    op.base().ty(),
                     folded_base_expr,
                     op.variant_index(),
                 )?))
@@ -867,7 +870,7 @@ impl Folder for State {
             }) => {
                 let folded_expr = Expr::canonical(expr).fold(self)?;
                 let folded_blocks = blocks.fold(self)?;
-                self.handle_match(Expr::ty(expr), folded_expr, source_location, &folded_blocks)
+                self.handle_match(expr.ty(), folded_expr, source_location, &folded_blocks)
             }
             Stmt::Connect(StmtConnect {
                 lhs,
@@ -878,8 +881,8 @@ impl Folder for State {
                 let folded_rhs = rhs.fold(self)?;
                 let mut output_stmts = vec![];
                 self.handle_stmt_connect(
-                    Expr::ty(lhs),
-                    Expr::ty(rhs),
+                    lhs.ty(),
+                    rhs.ty(),
                     folded_lhs,
                     folded_rhs,
                     source_location,
diff --git a/crates/fayalite/src/module/transform/simplify_memories.rs b/crates/fayalite/src/module/transform/simplify_memories.rs
index 35f186d3..662921b0 100644
--- a/crates/fayalite/src/module/transform/simplify_memories.rs
+++ b/crates/fayalite/src/module/transform/simplify_memories.rs
@@ -530,7 +530,7 @@ impl ModuleState {
             connect_read(
                 output_stmts,
                 wire_read,
-                Expr::<UInt>::from_canonical(port_read).cast_bits_to(Expr::ty(wire_read)),
+                Expr::<UInt>::from_canonical(port_read).cast_bits_to(wire_read.ty()),
             );
         };
         let connect_write_enum =
diff --git a/crates/fayalite/src/phantom_const.rs b/crates/fayalite/src/phantom_const.rs
index eb6a7584..70920f74 100644
--- a/crates/fayalite/src/phantom_const.rs
+++ b/crates/fayalite/src/phantom_const.rs
@@ -3,7 +3,7 @@
 
 use crate::{
     expr::{
-        Expr, ToExpr,
+        Expr, ToExpr, ValueType,
         ops::{ExprPartialEq, ExprPartialOrd},
     },
     int::Bool,
@@ -374,48 +374,46 @@ impl<'de, T: ?Sized + PhantomConstValue> Deserialize<'de> for PhantomConst<T> {
 
 impl<T: ?Sized + PhantomConstValue> ExprPartialEq<Self> for PhantomConst<T> {
     fn cmp_eq(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         true.to_expr()
     }
 
     fn cmp_ne(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         false.to_expr()
     }
 }
 
 impl<T: ?Sized + PhantomConstValue> ExprPartialOrd<Self> for PhantomConst<T> {
     fn cmp_lt(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         false.to_expr()
     }
 
     fn cmp_le(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         true.to_expr()
     }
 
     fn cmp_gt(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         false.to_expr()
     }
 
     fn cmp_ge(lhs: Expr<Self>, rhs: Expr<Self>) -> Expr<Bool> {
-        assert_eq!(Expr::ty(lhs), Expr::ty(rhs));
+        assert_eq!(lhs.ty(), rhs.ty());
         true.to_expr()
     }
 }
 
 impl<T: ?Sized + PhantomConstValue> SimValuePartialEq<Self> for PhantomConst<T> {
     fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        assert_eq!(SimValue::ty(this), SimValue::ty(other));
+        assert_eq!(this.ty(), other.ty());
         true
     }
 }
 
 impl<T: ?Sized + PhantomConstValue> ToSimValue for PhantomConst<T> {
-    type Type = PhantomConst<T>;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_value(*self, *self)
     }
@@ -479,7 +477,7 @@ impl_phantom_const_get! {
 impl_phantom_const_get! {
     impl PhantomConstGet<T> for Expr<PhantomConst<T>> {
         fn get(&self) -> _ {
-            PhantomConst::get(Expr::ty(*self))
+            PhantomConst::get(self.ty())
         }
     }
 }
diff --git a/crates/fayalite/src/platform.rs b/crates/fayalite/src/platform.rs
index 194aa6e3..bf074345 100644
--- a/crates/fayalite/src/platform.rs
+++ b/crates/fayalite/src/platform.rs
@@ -3,7 +3,7 @@
 
 use crate::{
     bundle::{Bundle, BundleField, BundleType},
-    expr::{Expr, ExprEnum},
+    expr::{Expr, ExprEnum, ValueType},
     intern::{Intern, Interned},
     module::{Module, ModuleBuilder, ModuleIO, connect_with_loc, instance_with_loc, wire_with_loc},
     source_location::SourceLocation,
@@ -616,7 +616,7 @@ impl<T: Type> Peripheral<T> {
         drop(state);
         let Self { ty, common } = self;
         let instance_io_field = Expr::field(output, &common.id.name);
-        assert_eq!(ty, Expr::ty(instance_io_field));
+        assert_eq!(ty, instance_io_field.ty());
         Ok(UsedPeripheral {
             instance_io_field,
             common,
@@ -654,7 +654,7 @@ impl<T: Type> UsedPeripheral<T> {
             ref common,
         } = *self;
         PeripheralRef {
-            ty: Expr::ty(instance_io_field),
+            ty: instance_io_field.ty(),
             common,
         }
     }
@@ -915,7 +915,7 @@ impl<'a, T: Type> PeripheralRef<'a, T> {
         main_module_io_fields.push(BundleField {
             name: self.name(),
             flipped: self.is_input(),
-            ty: Expr::ty(canonical_wire),
+            ty: canonical_wire.ty(),
         });
         on_use_function(&mut **shared_state, self.canonical(), canonical_wire);
         drop(on_use_state);
diff --git a/crates/fayalite/src/prelude.rs b/crates/fayalite/src/prelude.rs
index 4cc173e8..4c5bfdf4 100644
--- a/crates/fayalite/src/prelude.rs
+++ b/crates/fayalite/src/prelude.rs
@@ -13,7 +13,7 @@ pub use crate::{
     enum_::{Enum, HdlNone, HdlOption, HdlSome},
     expr::{
         CastBitsTo, CastTo, CastToBits, Expr, HdlPartialEq, HdlPartialOrd, MakeUninitExpr,
-        ReduceBits, ToExpr, repeat,
+        ReduceBits, ToExpr, ValueType, repeat,
     },
     formal::{
         MakeFormalExpr, all_const, all_seq, any_const, any_seq, formal_global_clock, formal_reset,
diff --git a/crates/fayalite/src/reg.rs b/crates/fayalite/src/reg.rs
index 20e0b944..7f506552 100644
--- a/crates/fayalite/src/reg.rs
+++ b/crates/fayalite/src/reg.rs
@@ -2,7 +2,7 @@
 // See Notices.txt for copyright information
 use crate::{
     clock::ClockDomain,
-    expr::{Expr, Flow},
+    expr::{Expr, Flow, ValueType, value_category::ValueCategoryExpr},
     intern::Interned,
     module::{NameId, ScopedNameId},
     reset::{Reset, ResetType},
@@ -20,7 +20,16 @@ pub struct Reg<T: Type, R: ResetType = Reset> {
     init: Option<Expr<T>>,
 }
 
-impl<T: Type + fmt::Debug, R: ResetType> fmt::Debug for Reg<T, R> {
+impl<T: Type, R: ResetType> ValueType for Reg<T, R> {
+    type Type = T;
+    type ValueCategory = ValueCategoryExpr;
+
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: Type, R: ResetType> fmt::Debug for Reg<T, R> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let Self {
             name,
@@ -68,7 +77,7 @@ impl<T: Type, R: ResetType> Reg<T, R> {
             "register type must be a storable type"
         );
         if let Some(init) = init {
-            assert_eq!(ty, Expr::ty(init), "register's type must match init type");
+            assert_eq!(ty, init.ty(), "register's type must match init type");
         }
         Self {
             name: scoped_name,
@@ -78,9 +87,6 @@ impl<T: Type, R: ResetType> Reg<T, R> {
             init,
         }
     }
-    pub fn ty(&self) -> T {
-        self.ty
-    }
     pub fn source_location(&self) -> SourceLocation {
         self.source_location
     }
diff --git a/crates/fayalite/src/reset.rs b/crates/fayalite/src/reset.rs
index 5dff2784..d9b7e8ac 100644
--- a/crates/fayalite/src/reset.rs
+++ b/crates/fayalite/src/reset.rs
@@ -2,8 +2,9 @@
 // See Notices.txt for copyright information
 use crate::{
     clock::Clock,
-    expr::{Expr, ToExpr, ops},
+    expr::{Expr, ValueType, ops},
     int::{Bool, SInt, UInt},
+    prelude::SimValue,
     source_location::SourceLocation,
     ty::{
         CanonicalType, OpaqueSimValueSize, OpaqueSimValueSlice, OpaqueSimValueWriter,
@@ -132,29 +133,34 @@ macro_rules! reset_type {
         }
 
         pub trait $Trait {
-            fn $trait_fn(&self) -> Expr<$name>;
+            type Output: ValueType<Type = $name>;
+            fn $trait_fn(&self) -> Self::Output;
         }
 
         impl<T: ?Sized + $Trait> $Trait for &'_ T {
-            fn $trait_fn(&self) -> Expr<$name> {
+            type Output = T::Output;
+            fn $trait_fn(&self) -> Self::Output {
                 (**self).$trait_fn()
             }
         }
 
         impl<T: ?Sized + $Trait> $Trait for &'_ mut T {
-            fn $trait_fn(&self) -> Expr<$name> {
+            type Output = T::Output;
+            fn $trait_fn(&self) -> Self::Output {
                 (**self).$trait_fn()
             }
         }
 
         impl<T: ?Sized + $Trait> $Trait for Box<T> {
-            fn $trait_fn(&self) -> Expr<$name> {
+            type Output = T::Output;
+            fn $trait_fn(&self) -> Self::Output {
                 (**self).$trait_fn()
             }
         }
 
         $($impl_trait $Trait for Expr<$name> {
-            fn $trait_fn(&self) -> Expr<$name> {
+            type Output = Expr<$name>;
+            fn $trait_fn(&self) -> Self::Output {
                 *self
             }
         })?
@@ -171,13 +177,15 @@ reset_type!(
 );
 
 impl ToSyncReset for bool {
-    fn to_sync_reset(&self) -> Expr<SyncReset> {
-        self.to_expr().to_sync_reset()
+    type Output = SimValue<SyncReset>;
+    fn to_sync_reset(&self) -> Self::Output {
+        SimValue::from_value(SyncReset, *self)
     }
 }
 
 impl ToAsyncReset for bool {
-    fn to_async_reset(&self) -> Expr<AsyncReset> {
-        self.to_expr().to_async_reset()
+    type Output = SimValue<AsyncReset>;
+    fn to_async_reset(&self) -> Self::Output {
+        SimValue::from_value(SyncReset, *self)
     }
 }
diff --git a/crates/fayalite/src/sim.rs b/crates/fayalite/src/sim.rs
index 808ead40..bf24befb 100644
--- a/crates/fayalite/src/sim.rs
+++ b/crates/fayalite/src/sim.rs
@@ -1504,9 +1504,10 @@ impl<I: BoolOrIntType> MaybeNeedsSettleFn<&'_ mut interpreter::State> for ReadBo
     fn call(self, state: &mut interpreter::State) -> Self::Output {
         let Self { compiled_value, io } = self;
         match compiled_value.range.len().as_single() {
-            Some(TypeLenSingle::SmallSlot) => Expr::ty(io)
+            Some(TypeLenSingle::SmallSlot) => io
+                .ty()
                 .value_from_int_wrapping(state.small_slots[compiled_value.range.small_slots.start]),
-            Some(TypeLenSingle::BigSlot) => Expr::ty(io).value_from_int_wrapping(
+            Some(TypeLenSingle::BigSlot) => io.ty().value_from_int_wrapping(
                 state.big_slots[compiled_value.range.big_slots.start].clone(),
             ),
             Some(TypeLenSingle::SimOnlySlot) | None => unreachable!(),
@@ -2889,7 +2890,7 @@ impl SimulationImpl {
                 },
             );
         }
-        let size = Expr::ty(io).size();
+        let size = io.ty().size();
         let mut opaque = OpaqueSimValue::with_capacity(size);
         opaque.rewrite_with(size, |mut writer| {
             SimulationImpl::read_write_sim_value_helper(
@@ -2922,7 +2923,7 @@ impl SimulationImpl {
             );
             writer.fill_cloned_from_slice(OpaqueSimValueSlice::empty())
         });
-        SimValue::from_opaque(Expr::ty(io), opaque)
+        SimValue::from_opaque(io.ty(), opaque)
     }
     /// doesn't modify `opaque`
     fn value_changed(
@@ -3006,7 +3007,7 @@ impl SimulationImpl {
             .get_module_mut(which_module)
             .write_helper(io, which_module);
         self.event_queue.add_event_for_now(EventKind::State);
-        assert_eq!(Expr::ty(io), SimValue::ty(value));
+        assert_eq!(io.ty(), value.ty());
         Self::read_write_sim_value_helper(
             &mut self.state,
             compiled_value,
@@ -3272,7 +3273,7 @@ macro_rules! impl_simulation_methods {
             value: impl ToExpr<Type = I>,
         ) {
             let value = value.to_expr();
-            assert_eq!(Expr::ty(io), Expr::ty(value), "type mismatch");
+            assert_eq!(io.ty(), value.ty(), "type mismatch");
             let value = value
                 .to_literal_bits()
                 .expect("the value that is being written to an input must be a literal");
@@ -3343,7 +3344,7 @@ macro_rules! impl_simulation_methods {
         pub $($async)? fn write<IO: Type, V: value::ToSimValueWithType<IO>>(&mut $self, io: Expr<IO>, value: V) {
             $self.sim_impl.borrow_mut().write(
                 Expr::canonical(io),
-                &SimValue::into_canonical(value.into_sim_value_with_type(Expr::ty(io))),
+                &SimValue::into_canonical(value.into_sim_value_with_type(io.ty())),
                 $which_module,
             );
         }
diff --git a/crates/fayalite/src/sim/compiler.rs b/crates/fayalite/src/sim/compiler.rs
index 7a0ac0a2..40108904 100644
--- a/crates/fayalite/src/sim/compiler.rs
+++ b/crates/fayalite/src/sim/compiler.rs
@@ -1714,7 +1714,7 @@ impl MakeTraceDeclTarget {
     }
     fn ty(self) -> CanonicalType {
         match self {
-            MakeTraceDeclTarget::Expr(expr) => Expr::ty(expr),
+            MakeTraceDeclTarget::Expr(expr) => expr.ty(),
             MakeTraceDeclTarget::Memory { ty, .. } => ty,
         }
     }
@@ -2771,7 +2771,7 @@ impl Compiler {
         let retval = parts
             .into_iter()
             .map(|part| part.cast_to_bits())
-            .reduce(|accumulator, part| accumulator | (part << Expr::ty(accumulator).width))
+            .reduce(|accumulator, part| accumulator | (part << accumulator.ty().width))
             .unwrap_or_else(|| UInt[0].zero().to_expr());
         let retval = self.compile_expr(instantiated_module, Expr::canonical(retval));
         let retval = self
@@ -2783,7 +2783,7 @@ impl Compiler {
         instantiated_module: InstantiatedModule,
         expr: ops::CastToBits,
     ) -> CompiledValue<UInt> {
-        match Expr::ty(expr.arg()) {
+        match expr.arg().ty() {
             CanonicalType::UInt(_) => {
                 self.compile_cast_scalar_to_bits(instantiated_module, expr.arg(), |arg| arg)
             }
@@ -2949,7 +2949,7 @@ impl Compiler {
             return retval;
         }
         let mut cast_bit = |arg: Expr<CanonicalType>| {
-            let src_signed = match Expr::ty(arg) {
+            let src_signed = match arg.ty() {
                 CanonicalType::UInt(_) => false,
                 CanonicalType::SInt(_) => true,
                 CanonicalType::Bool(_) => false,
@@ -2963,7 +2963,7 @@ impl Compiler {
                 CanonicalType::PhantomConst(_) => unreachable!(),
                 CanonicalType::DynSimOnly(_) => unreachable!(),
             };
-            let dest_signed = match Expr::ty(expr) {
+            let dest_signed = match expr.ty() {
                 CanonicalType::UInt(_) => false,
                 CanonicalType::SInt(_) => true,
                 CanonicalType::Bool(_) => false,
@@ -2977,22 +2977,23 @@ impl Compiler {
                 CanonicalType::PhantomConst(_) => unreachable!(),
                 CanonicalType::DynSimOnly(_) => unreachable!(),
             };
-            self.simple_nary_big_expr(instantiated_module, Expr::ty(expr), [arg], |dest, [src]| {
-                match (src_signed, dest_signed) {
-                    (false, false) | (true, true) => {
-                        vec![Insn::Copy { dest, src }]
-                    }
-                    (false, true) => vec![Insn::CastToSInt {
-                        dest,
-                        src,
-                        dest_width: 1,
-                    }],
-                    (true, false) => vec![Insn::CastToUInt {
-                        dest,
-                        src,
-                        dest_width: 1,
-                    }],
+            self.simple_nary_big_expr(instantiated_module, expr.ty(), [arg], |dest, [src]| match (
+                src_signed,
+                dest_signed,
+            ) {
+                (false, false) | (true, true) => {
+                    vec![Insn::Copy { dest, src }]
                 }
+                (false, true) => vec![Insn::CastToSInt {
+                    dest,
+                    src,
+                    dest_width: 1,
+                }],
+                (true, false) => vec![Insn::CastToUInt {
+                    dest,
+                    src,
+                    dest_width: 1,
+                }],
             })
             .into()
         };
@@ -3032,21 +3033,13 @@ impl Compiler {
                 })
                 .into(),
             ExprEnum::PhantomConst(_) => self
-                .compile_aggregate_literal(instantiated_module, Expr::ty(expr), Interned::default())
+                .compile_aggregate_literal(instantiated_module, expr.ty(), Interned::default())
                 .into(),
             ExprEnum::BundleLiteral(literal) => self
-                .compile_aggregate_literal(
-                    instantiated_module,
-                    Expr::ty(expr),
-                    literal.field_values(),
-                )
+                .compile_aggregate_literal(instantiated_module, expr.ty(), literal.field_values())
                 .into(),
             ExprEnum::ArrayLiteral(literal) => self
-                .compile_aggregate_literal(
-                    instantiated_module,
-                    Expr::ty(expr),
-                    literal.element_values(),
-                )
+                .compile_aggregate_literal(instantiated_module, expr.ty(), literal.element_values())
                 .into(),
             ExprEnum::EnumLiteral(expr) => {
                 let enum_bits_ty = UInt[expr.ty().type_properties().bit_width];
@@ -3074,13 +3067,13 @@ impl Compiler {
             ExprEnum::NotU(expr) => self
                 .simple_nary_big_expr(
                     instantiated_module,
-                    Expr::ty(expr.arg()).canonical(),
+                    expr.arg().ty().canonical(),
                     [Expr::canonical(expr.arg())],
                     |dest, [src]| {
                         vec![Insn::NotU {
                             dest,
                             src,
-                            width: Expr::ty(expr.arg()).width(),
+                            width: expr.arg().ty().width(),
                         }]
                     },
                 )
@@ -3088,7 +3081,7 @@ impl Compiler {
             ExprEnum::NotS(expr) => self
                 .simple_nary_big_expr(
                     instantiated_module,
-                    Expr::ty(expr.arg()).canonical(),
+                    expr.arg().ty().canonical(),
                     [Expr::canonical(expr.arg())],
                     |dest, [src]| vec![Insn::NotS { dest, src }],
                 )
@@ -3096,7 +3089,7 @@ impl Compiler {
             ExprEnum::NotB(expr) => self
                 .simple_nary_big_expr(
                     instantiated_module,
-                    Expr::ty(expr.arg()).canonical(),
+                    expr.arg().ty().canonical(),
                     [Expr::canonical(expr.arg())],
                     |dest, [src]| {
                         vec![Insn::NotU {
@@ -3600,12 +3593,12 @@ impl Compiler {
                 .map_ty(Bundle::from_canonical)
                 .field_by_index(expr.field_index()),
             ExprEnum::VariantAccess(variant_access) => {
-                let start = Expr::ty(variant_access.base()).discriminant_bit_width();
-                let len = Expr::ty(expr).bit_width();
+                let start = variant_access.base().ty().discriminant_bit_width();
+                let len = expr.ty().bit_width();
                 self.compile_expr(
                     instantiated_module,
                     variant_access.base().cast_to_bits()[start..start + len]
-                        .cast_bits_to(Expr::ty(expr)),
+                        .cast_bits_to(expr.ty()),
                 )
             }
             ExprEnum::ArrayIndex(expr) => self
@@ -3627,45 +3620,39 @@ impl Compiler {
                     .map_ty(Array::from_canonical)
                     .element_dyn(index_slot)
             }
-            ExprEnum::ReduceBitAndU(expr) => if Expr::ty(expr.arg()).width() == 0 {
+            ExprEnum::ReduceBitAndU(expr) => if expr.arg().ty().width() == 0 {
                 self.compile_expr(instantiated_module, Expr::canonical(true.to_expr()))
             } else {
                 self.compile_expr(
                     instantiated_module,
-                    Expr::canonical(
-                        expr.arg()
-                            .cmp_eq(Expr::ty(expr.arg()).from_int_wrapping(-1)),
-                    ),
+                    Expr::canonical(expr.arg().cmp_eq(expr.arg().ty().from_int_wrapping(-1))),
                 )
             }
             .into(),
-            ExprEnum::ReduceBitAndS(expr) => if Expr::ty(expr.arg()).width() == 0 {
+            ExprEnum::ReduceBitAndS(expr) => if expr.arg().ty().width() == 0 {
                 self.compile_expr(instantiated_module, Expr::canonical(true.to_expr()))
             } else {
                 self.compile_expr(
                     instantiated_module,
-                    Expr::canonical(
-                        expr.arg()
-                            .cmp_eq(Expr::ty(expr.arg()).from_int_wrapping(-1)),
-                    ),
+                    Expr::canonical(expr.arg().cmp_eq(expr.arg().ty().from_int_wrapping(-1))),
                 )
             }
             .into(),
-            ExprEnum::ReduceBitOrU(expr) => if Expr::ty(expr.arg()).width() == 0 {
+            ExprEnum::ReduceBitOrU(expr) => if expr.arg().ty().width() == 0 {
                 self.compile_expr(instantiated_module, Expr::canonical(false.to_expr()))
             } else {
                 self.compile_expr(
                     instantiated_module,
-                    Expr::canonical(expr.arg().cmp_ne(Expr::ty(expr.arg()).from_int_wrapping(0))),
+                    Expr::canonical(expr.arg().cmp_ne(expr.arg().ty().from_int_wrapping(0))),
                 )
             }
             .into(),
-            ExprEnum::ReduceBitOrS(expr) => if Expr::ty(expr.arg()).width() == 0 {
+            ExprEnum::ReduceBitOrS(expr) => if expr.arg().ty().width() == 0 {
                 self.compile_expr(instantiated_module, Expr::canonical(false.to_expr()))
             } else {
                 self.compile_expr(
                     instantiated_module,
-                    Expr::canonical(expr.arg().cmp_ne(Expr::ty(expr.arg()).from_int_wrapping(0))),
+                    Expr::canonical(expr.arg().cmp_ne(expr.arg().ty().from_int_wrapping(0))),
                 )
             }
             .into(),
@@ -3678,7 +3665,7 @@ impl Compiler {
                         vec![Insn::ReduceBitXor {
                             dest,
                             src,
-                            input_width: Expr::ty(expr.arg()).width(),
+                            input_width: expr.arg().ty().width(),
                         }]
                     },
                 )
@@ -3692,7 +3679,7 @@ impl Compiler {
                         vec![Insn::ReduceBitXor {
                             dest,
                             src,
-                            input_width: Expr::ty(expr.arg()).width(),
+                            input_width: expr.arg().ty().width(),
                         }]
                     },
                 )
@@ -3790,8 +3777,8 @@ impl Compiler {
         mut rhs: Expr<CanonicalType>,
         source_location: SourceLocation,
     ) {
-        if Expr::ty(lhs) != Expr::ty(rhs) || !Expr::ty(lhs).is_passive() {
-            match Expr::ty(lhs) {
+        if lhs.ty() != rhs.ty() || !lhs.ty().is_passive() {
+            match lhs.ty() {
                 CanonicalType::UInt(lhs_ty) => {
                     rhs = Expr::canonical(Expr::<UInt>::from_canonical(rhs).cast_to(lhs_ty));
                 }
@@ -3800,7 +3787,7 @@ impl Compiler {
                 }
                 CanonicalType::Bool(_) => unreachable!(),
                 CanonicalType::Array(lhs_ty) => {
-                    let CanonicalType::Array(rhs_ty) = Expr::ty(rhs) else {
+                    let CanonicalType::Array(rhs_ty) = rhs.ty() else {
                         unreachable!();
                     };
                     assert_eq!(lhs_ty.len(), rhs_ty.len());
@@ -3820,13 +3807,13 @@ impl Compiler {
                     return;
                 }
                 CanonicalType::Enum(lhs_ty) => {
-                    let CanonicalType::Enum(rhs_ty) = Expr::ty(rhs) else {
+                    let CanonicalType::Enum(rhs_ty) = rhs.ty() else {
                         unreachable!();
                     };
                     todo!("handle connect with different enum types");
                 }
                 CanonicalType::Bundle(lhs_ty) => {
-                    let CanonicalType::Bundle(rhs_ty) = Expr::ty(rhs) else {
+                    let CanonicalType::Bundle(rhs_ty) = rhs.ty() else {
                         unreachable!();
                     };
                     assert_eq!(lhs_ty.fields().len(), rhs_ty.fields().len());
diff --git a/crates/fayalite/src/sim/value.rs b/crates/fayalite/src/sim/value.rs
index ff836d52..112ef1ca 100644
--- a/crates/fayalite/src/sim/value.rs
+++ b/crates/fayalite/src/sim/value.rs
@@ -6,7 +6,10 @@ use crate::{
     bundle::{Bundle, BundleType},
     clock::Clock,
     enum_::{Enum, EnumType},
-    expr::{CastBitsTo, Expr, ToExpr},
+    expr::{
+        CastBitsTo, Expr, ToExpr, ToValueless, ValueType, Valueless,
+        value_category::{ValueCategorySimValue, ValueCategoryValue},
+    },
     int::{Bool, IntType, KnownSize, SInt, SIntType, SIntValue, Size, UInt, UIntType, UIntValue},
     reset::{AsyncReset, Reset, SyncReset},
     source_location::SourceLocation,
@@ -26,6 +29,7 @@ use std::{
     borrow::{Borrow, BorrowMut, Cow},
     fmt::{self, Write},
     hash::{BuildHasher, Hash, Hasher, RandomState},
+    num::NonZero,
     ops::{Deref, DerefMut, Index, IndexMut},
     sync::{Arc, Mutex},
 };
@@ -136,7 +140,7 @@ impl<T: Type<SimValue: Serialize> + Serialize> Serialize for SimValue<T> {
         S: Serializer,
     {
         SerdeSimValue {
-            ty: SimValue::ty(self),
+            ty: self.ty(),
             value: std::borrow::Cow::Borrowed(&*self),
         }
         .serialize(serializer)
@@ -157,6 +161,15 @@ pub struct SimValue<T: Type> {
     inner: AlternatingCell<SimValueInner<T>>,
 }
 
+impl<T: Type> ValueType for SimValue<T> {
+    type Type = T;
+    type ValueCategory = ValueCategorySimValue;
+
+    fn ty(&self) -> Self::Type {
+        self.inner.share().ty
+    }
+}
+
 impl<T: Type<SimValue: fmt::Display>> fmt::Display for SimValue<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         T::SimValue::fmt(self, f)
@@ -218,9 +231,6 @@ impl<T: Type> SimValue<T> {
             inner: AlternatingCell::new_unique(inner),
         }
     }
-    pub fn ty(this: &Self) -> T {
-        this.inner.share().ty
-    }
     pub fn into_opaque(this: Self) -> OpaqueSimValue {
         this.inner.into_inner().into_opaque()
     }
@@ -259,7 +269,7 @@ impl<T: Type> SimValue<T> {
         SimValue::from_opaque(ty.canonical(), opaque)
     }
     pub fn canonical(this: &Self) -> SimValue<CanonicalType> {
-        SimValue::from_opaque(Self::ty(this).canonical(), Self::opaque(this).clone())
+        SimValue::from_opaque(this.ty().canonical(), Self::opaque(this).clone())
     }
     #[track_caller]
     pub fn from_dyn_int(v: SimValue<T::Dyn>) -> Self
@@ -280,7 +290,7 @@ impl<T: Type> SimValue<T> {
     where
         T: IntType,
     {
-        SimValue::from_opaque(Self::ty(this).as_dyn_int(), Self::opaque(&this).clone())
+        SimValue::from_opaque(this.ty().as_dyn_int(), Self::opaque(&this).clone())
     }
     #[track_caller]
     pub fn from_bundle(v: SimValue<Bundle>) -> Self
@@ -302,7 +312,7 @@ impl<T: Type> SimValue<T> {
         T: BundleType,
     {
         SimValue::from_opaque(
-            Bundle::from_canonical(Self::ty(this).canonical()),
+            Bundle::from_canonical(this.ty().canonical()),
             Self::opaque(&this).clone(),
         )
     }
@@ -326,7 +336,7 @@ impl<T: Type> SimValue<T> {
         T: EnumType,
     {
         SimValue::from_opaque(
-            Enum::from_canonical(Self::ty(this).canonical()),
+            Enum::from_canonical(this.ty().canonical()),
             Self::opaque(&this).clone(),
         )
     }
@@ -357,8 +367,6 @@ impl<T: Type> fmt::Debug for SimValue<T> {
 }
 
 impl<T: Type> ToExpr for SimValue<T> {
-    type Type = T;
-
     #[track_caller]
     fn to_expr(&self) -> Expr<Self::Type> {
         let inner = self.inner.share();
@@ -450,48 +458,160 @@ impl<T: SimValuePartialEq<U>, U: Type> PartialEq<SimValue<U>> for SimValue<T> {
     }
 }
 
-impl<Width: Size> SimValuePartialEq<Self> for UIntType<Width> {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+pub trait SimValueEq: SimValuePartialEq {}
+
+impl<T: SimValueEq> Eq for SimValue<T> {}
+
+pub trait SimValuePartialOrd<T: Type = Self>: SimValuePartialEq<T> {
+    #[track_caller]
+    fn sim_value_partial_cmp(
+        this: &SimValue<Self>,
+        other: &SimValue<T>,
+    ) -> Option<std::cmp::Ordering>;
+}
+
+impl<T: SimValuePartialOrd<U>, U: Type> PartialOrd<SimValue<U>> for SimValue<T> {
+    #[track_caller]
+    fn partial_cmp(&self, other: &SimValue<U>) -> Option<std::cmp::Ordering> {
+        T::sim_value_partial_cmp(self, other)
     }
 }
 
-impl<Width: Size> SimValuePartialEq<Self> for SIntType<Width> {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+pub trait SimValueOrd: SimValuePartialOrd + SimValueEq {
+    #[track_caller]
+    fn sim_value_cmp(this: &SimValue<Self>, other: &SimValue<Self>) -> std::cmp::Ordering;
+}
+
+impl<T: SimValueOrd> Ord for SimValue<T> {
+    #[track_caller]
+    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
+        T::sim_value_cmp(self, other)
     }
 }
 
-impl SimValuePartialEq<Bool> for Bool {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Bool>) -> bool {
-        **this == **other
+impl<L: Size, R: Size> SimValuePartialEq<UIntType<R>> for UIntType<L> {
+    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<UIntType<R>>) -> bool {
+        this.hdl_eq(&other)
     }
 }
 
-impl SimValuePartialEq for Clock {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+impl<Width: Size> SimValueEq for UIntType<Width> {}
+
+impl<L: Size, R: Size> SimValuePartialOrd<UIntType<R>> for UIntType<L> {
+    fn sim_value_partial_cmp(
+        this: &SimValue<Self>,
+        other: &SimValue<UIntType<R>>,
+    ) -> Option<std::cmp::Ordering> {
+        Some(this.hdl_cmp(other))
     }
 }
 
-impl SimValuePartialEq for Reset {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+impl<Width: Size> SimValueOrd for UIntType<Width> {
+    fn sim_value_cmp(this: &SimValue<Self>, other: &SimValue<Self>) -> std::cmp::Ordering {
+        this.hdl_cmp(other)
     }
 }
 
-impl SimValuePartialEq for SyncReset {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+impl<L: Size, R: Size> SimValuePartialEq<SIntType<R>> for SIntType<L> {
+    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<SIntType<R>>) -> bool {
+        this.hdl_eq(other)
     }
 }
 
-impl SimValuePartialEq for AsyncReset {
-    fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
-        **this == **other
+impl<Width: Size> SimValueEq for SIntType<Width> {}
+
+impl<L: Size, R: Size> SimValuePartialOrd<SIntType<R>> for SIntType<L> {
+    fn sim_value_partial_cmp(
+        this: &SimValue<Self>,
+        other: &SimValue<SIntType<R>>,
+    ) -> Option<std::cmp::Ordering> {
+        Some(this.hdl_cmp(other))
     }
 }
 
+impl<Width: Size> SimValueOrd for SIntType<Width> {
+    fn sim_value_cmp(this: &SimValue<Self>, other: &SimValue<Self>) -> std::cmp::Ordering {
+        this.hdl_cmp(other)
+    }
+}
+
+macro_rules! impl_sim_value_cmp_as_bool {
+    ($ty:ident) => {
+        impl SimValuePartialEq for $ty {
+            fn sim_value_eq(this: &SimValue<Self>, other: &SimValue<Self>) -> bool {
+                **this == **other
+            }
+        }
+
+        impl SimValueEq for $ty {}
+
+        impl SimValuePartialOrd for $ty {
+            fn sim_value_partial_cmp(
+                this: &SimValue<Self>,
+                other: &SimValue<Self>,
+            ) -> Option<std::cmp::Ordering> {
+                bool::partial_cmp(this, other)
+            }
+        }
+
+        impl SimValueOrd for $ty {
+            fn sim_value_cmp(this: &SimValue<Self>, other: &SimValue<Self>) -> std::cmp::Ordering {
+                bool::cmp(this, other)
+            }
+        }
+    };
+}
+
+impl_sim_value_cmp_as_bool!(Bool);
+impl_sim_value_cmp_as_bool!(Clock);
+impl_sim_value_cmp_as_bool!(Reset);
+impl_sim_value_cmp_as_bool!(SyncReset);
+impl_sim_value_cmp_as_bool!(AsyncReset);
+
+macro_rules! forward_unary_op_to_value {
+    (#[trait = $($Trait:tt)+] fn $f:ident();) => {
+        impl<'a, T: Type, O: Type> $($Trait)+ for &'a SimValue<T>
+        where
+            &'a T::SimValue: $($Trait)+<Output: ToSimValueWithType<O>>,
+            Valueless<T>: $($Trait)+<Output = Valueless<O>>,
+        {
+            type Output = SimValue<O>;
+
+            fn $f(self) -> Self::Output {
+                let ty = self.to_valueless().$f().ty();
+                (&**self)
+                    .$f()
+                    .into_sim_value_with_type(self.to_valueless().$f().ty())
+            }
+        }
+
+        impl<T: Type, O: Type> $($Trait)+ for SimValue<T>
+        where
+            T::SimValue: $($Trait)+<Output: ToSimValueWithType<O>>,
+            Valueless<T>: $($Trait)+<Output = Valueless<O>>,
+        {
+            type Output = SimValue<O>;
+
+            fn $f(self) -> Self::Output {
+                let ty = self.to_valueless().$f().ty();
+                SimValue::into_value(self)
+                    .$f()
+                    .into_sim_value_with_type(ty)
+            }
+        }
+    };
+}
+
+forward_unary_op_to_value! {
+    #[trait = std::ops::Neg]
+    fn neg();
+}
+
+forward_unary_op_to_value! {
+    #[trait = std::ops::Not]
+    fn not();
+}
+
 #[doc(hidden)]
 pub mod match_sim_value {
     use crate::{
@@ -603,9 +723,7 @@ pub mod match_sim_value {
     }
 }
 
-pub trait ToSimValue: ToSimValueWithType<<Self as ToSimValue>::Type> {
-    type Type: Type;
-
+pub trait ToSimValue: ToSimValueWithType<<Self as ValueType>::Type> + ValueType {
     #[track_caller]
     fn to_sim_value(&self) -> SimValue<Self::Type>;
     #[track_caller]
@@ -647,31 +765,31 @@ pub trait ToSimValueWithType<T: Type> {
 
 macro_rules! forward_to_sim_value_with_type {
     ([$($generics:tt)*] $ty:ty) => {
-        impl<$($generics)*> ToSimValueWithType<<Self as ToSimValue>::Type> for $ty {
-            fn to_sim_value_with_type(&self, ty: <Self as ToSimValue>::Type) -> SimValue<<Self as ToSimValue>::Type> {
+        impl<$($generics)*> ToSimValueWithType<<Self as ValueType>::Type> for $ty {
+            fn to_sim_value_with_type(&self, ty: <Self as ValueType>::Type) -> SimValue<<Self as ValueType>::Type> {
                 let retval = Self::to_sim_value(self);
-                assert_eq!(SimValue::ty(&retval), ty);
+                assert_eq!(retval.ty(), ty);
                 retval
             }
             #[track_caller]
-            fn into_sim_value_with_type(self, ty: <Self as ToSimValue>::Type) -> SimValue<<Self as ToSimValue>::Type>
+            fn into_sim_value_with_type(self, ty: <Self as ValueType>::Type) -> SimValue<<Self as ValueType>::Type>
             where
                 Self: Sized,
             {
                 let retval = Self::into_sim_value(self);
-                assert_eq!(SimValue::ty(&retval), ty);
+                assert_eq!(retval.ty(), ty);
                 retval
             }
             #[track_caller]
-            fn arc_into_sim_value_with_type(self: Arc<Self>, ty: <Self as ToSimValue>::Type) -> SimValue<<Self as ToSimValue>::Type> {
+            fn arc_into_sim_value_with_type(self: Arc<Self>, ty: <Self as ValueType>::Type) -> SimValue<<Self as ValueType>::Type> {
                 let retval = Self::arc_into_sim_value(self);
-                assert_eq!(SimValue::ty(&retval), ty);
+                assert_eq!(retval.ty(), ty);
                 retval
             }
             #[track_caller]
-            fn arc_to_sim_value_with_type(self: &Arc<Self>, ty: <Self as ToSimValue>::Type) -> SimValue<<Self as ToSimValue>::Type> {
+            fn arc_to_sim_value_with_type(self: &Arc<Self>, ty: <Self as ValueType>::Type) -> SimValue<<Self as ValueType>::Type> {
                 let retval = Self::arc_to_sim_value(self);
-                assert_eq!(SimValue::ty(&retval), ty);
+                assert_eq!(retval.ty(), ty);
                 retval
             }
         }
@@ -679,7 +797,6 @@ macro_rules! forward_to_sim_value_with_type {
 }
 
 impl<T: Type> ToSimValue for SimValue<T> {
-    type Type = T;
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         self.clone()
     }
@@ -736,8 +853,6 @@ impl<T: Type> ToSimValueWithType<T> for BitSlice {
 }
 
 impl<'a, This: ?Sized + ToSimValue> ToSimValue for &'a This {
-    type Type = This::Type;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         This::to_sim_value(self)
     }
@@ -750,8 +865,6 @@ impl<This: ?Sized + ToSimValueWithType<T>, T: Type> ToSimValueWithType<T> for &'
 }
 
 impl<This: ?Sized + ToSimValue> ToSimValue for &'_ mut This {
-    type Type = This::Type;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         This::to_sim_value(self)
     }
@@ -764,8 +877,6 @@ impl<This: ?Sized + ToSimValueWithType<T>, T: Type> ToSimValueWithType<T> for &'
 }
 
 impl<This: ?Sized + ToSimValue> ToSimValue for Arc<This> {
-    type Type = This::Type;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         This::arc_to_sim_value(self)
     }
@@ -786,7 +897,6 @@ impl<This: ?Sized + ToSimValueWithType<T>, T: Type> ToSimValueWithType<T> for Ar
 impl<This: ?Sized + ToSimValue + Send + Sync + 'static> ToSimValue
     for crate::intern::Interned<This>
 {
-    type Type = This::Type;
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         This::to_sim_value(self)
     }
@@ -801,8 +911,6 @@ impl<This: ?Sized + ToSimValueWithType<T> + Send + Sync + 'static, T: Type> ToSi
 }
 
 impl<This: ToSimValue> ToSimValue for Box<This> {
-    type Type = This::Type;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         This::to_sim_value(self)
     }
@@ -845,8 +953,6 @@ impl<Element: ToSimValueWithType<T>, T: Type> ToSimValueWithType<Array<T>> for [
 }
 
 impl<Element: ToSimValue<Type: StaticType>> ToSimValue for [Element] {
-    type Type = Array<Element::Type>;
-
     #[track_caller]
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self)
@@ -882,8 +988,6 @@ impl<Element: ToSimValue<Type: StaticType>, const N: usize> ToSimValue for [Elem
 where
     ConstUsize<N>: KnownSize,
 {
-    type Type = Array<Element::Type, N>;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_array_elements(StaticType::TYPE, self)
     }
@@ -937,8 +1041,6 @@ impl<Element: ToSimValueWithType<T>, T: Type> ToSimValueWithType<Array<T>> for V
 }
 
 impl<Element: ToSimValue<Type: StaticType>> ToSimValue for Vec<Element> {
-    type Type = Array<Element::Type>;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self)
     }
@@ -979,8 +1081,6 @@ impl<Element: ToSimValueWithType<T>, T: Type> ToSimValueWithType<Array<T>> for B
 }
 
 impl<Element: ToSimValue<Type: StaticType>> ToSimValue for Box<[Element]> {
-    type Type = Array<Element::Type>;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_array_elements(ArrayType::new_dyn(StaticType::TYPE, self.len()), self)
     }
@@ -1010,11 +1110,10 @@ impl<Element: ToSimValueWithType<CanonicalType>> ToSimValueWithType<CanonicalTyp
 }
 
 impl<T: Type> ToSimValue for Expr<T> {
-    type Type = T;
     #[track_caller]
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_bitslice(
-            Expr::ty(*self),
+            self.ty(),
             &crate::expr::ToLiteralBits::to_literal_bits(self)
                 .expect("must be a literal expression"),
         )
@@ -1034,8 +1133,6 @@ macro_rules! impl_to_sim_value_for_bool_like {
 }
 
 impl ToSimValue for bool {
-    type Type = Bool;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_value(Bool, *self)
     }
@@ -1073,10 +1170,8 @@ impl ToSimValueWithType<CanonicalType> for bool {
 }
 
 macro_rules! impl_to_sim_value_for_primitive_int {
-    ($prim:ident) => {
+    ($prim:ty) => {
         impl ToSimValue for $prim {
-            type Type = <$prim as ToExpr>::Type;
-
             #[track_caller]
             fn to_sim_value(
                 &self,
@@ -1087,15 +1182,15 @@ macro_rules! impl_to_sim_value_for_primitive_int {
 
         forward_to_sim_value_with_type!([] $prim);
 
-        impl ToSimValueWithType<<<$prim as ToExpr>::Type as IntType>::Dyn> for $prim {
+        impl ToSimValueWithType<<<$prim as ValueType>::Type as IntType>::Dyn> for $prim {
             #[track_caller]
             fn to_sim_value_with_type(
                 &self,
-                ty: <<$prim as ToExpr>::Type as IntType>::Dyn,
-            ) -> SimValue<<<$prim as ToExpr>::Type as IntType>::Dyn> {
+                ty: <<$prim as ValueType>::Type as IntType>::Dyn,
+            ) -> SimValue<<<$prim as ValueType>::Type as IntType>::Dyn> {
                 SimValue::from_value(
                     ty,
-                    <<$prim as ToExpr>::Type as Type>::SimValue::from(*self).as_dyn_int(),
+                    <<$prim as ValueType>::Type as Type>::SimValue::from(*self).as_dyn_int(),
                 )
             }
         }
@@ -1103,7 +1198,7 @@ macro_rules! impl_to_sim_value_for_primitive_int {
         impl ToSimValueWithType<CanonicalType> for $prim {
             #[track_caller]
             fn to_sim_value_with_type(&self, ty: CanonicalType) -> SimValue<CanonicalType> {
-                let ty: <<$prim as ToExpr>::Type as IntType>::Dyn = Type::from_canonical(ty);
+                let ty: <<$prim as ValueType>::Type as IntType>::Dyn = Type::from_canonical(ty);
                 SimValue::into_canonical(self.to_sim_value_with_type(ty))
             }
         }
@@ -1122,12 +1217,22 @@ impl_to_sim_value_for_primitive_int!(i32);
 impl_to_sim_value_for_primitive_int!(i64);
 impl_to_sim_value_for_primitive_int!(i128);
 impl_to_sim_value_for_primitive_int!(isize);
+impl_to_sim_value_for_primitive_int!(NonZero<u8>);
+impl_to_sim_value_for_primitive_int!(NonZero<u16>);
+impl_to_sim_value_for_primitive_int!(NonZero<u32>);
+impl_to_sim_value_for_primitive_int!(NonZero<u64>);
+impl_to_sim_value_for_primitive_int!(NonZero<u128>);
+impl_to_sim_value_for_primitive_int!(NonZero<usize>);
+impl_to_sim_value_for_primitive_int!(NonZero<i8>);
+impl_to_sim_value_for_primitive_int!(NonZero<i16>);
+impl_to_sim_value_for_primitive_int!(NonZero<i32>);
+impl_to_sim_value_for_primitive_int!(NonZero<i64>);
+impl_to_sim_value_for_primitive_int!(NonZero<i128>);
+impl_to_sim_value_for_primitive_int!(NonZero<isize>);
 
 macro_rules! impl_to_sim_value_for_int_value {
     ($IntValue:ident, $Int:ident, $IntType:ident) => {
         impl<Width: Size> ToSimValue for $IntValue<Width> {
-            type Type = $IntType<Width>;
-
             fn to_sim_value(&self) -> SimValue<Self::Type> {
                 SimValue::from_value(self.ty(), self.clone())
             }
@@ -1488,8 +1593,6 @@ impl<T: SimOnlyValueTrait> ToSimValueWithType<SimOnly<T>> for SimOnlyValue<T> {
 }
 
 impl ToSimValue for DynSimOnlyValue {
-    type Type = DynSimOnly;
-
     fn to_sim_value(&self) -> SimValue<Self::Type> {
         SimValue::from_value(self.ty(), self.clone())
     }
@@ -1499,15 +1602,22 @@ impl ToSimValue for DynSimOnlyValue {
     }
 }
 
-impl<T: SimOnlyValueTrait> ToSimValue for SimOnlyValue<T> {
+impl<T: SimOnlyValueTrait> ValueType for SimOnlyValue<T> {
     type Type = SimOnly<T>;
+    type ValueCategory = ValueCategoryValue;
 
+    fn ty(&self) -> Self::Type {
+        SimOnly::new()
+    }
+}
+
+impl<T: SimOnlyValueTrait> ToSimValue for SimOnlyValue<T> {
     fn to_sim_value(&self) -> SimValue<Self::Type> {
-        SimValue::from_value(Default::default(), self.clone())
+        SimValue::from_value(self.ty(), self.clone())
     }
 
     fn into_sim_value(self) -> SimValue<Self::Type> {
-        SimValue::from_value(Default::default(), self)
+        SimValue::from_value(self.ty(), self)
     }
 }
 
diff --git a/crates/fayalite/src/sim/value/sim_only_value_unsafe.rs b/crates/fayalite/src/sim/value/sim_only_value_unsafe.rs
index 3df80a8e..2424c03f 100644
--- a/crates/fayalite/src/sim/value/sim_only_value_unsafe.rs
+++ b/crates/fayalite/src/sim/value/sim_only_value_unsafe.rs
@@ -3,6 +3,7 @@
 
 //! `unsafe` parts of [`DynSimOnlyValue`]
 
+use crate::expr::{ValueType, value_category::ValueCategoryValue};
 use serde::{Serialize, de::DeserializeOwned};
 use std::{
     any::{self, TypeId},
@@ -295,10 +296,16 @@ impl<T: SimOnlyValueTrait> From<SimOnlyValue<T>> for DynSimOnlyValue {
     }
 }
 
-impl DynSimOnlyValue {
-    pub fn ty(&self) -> DynSimOnly {
+impl ValueType for DynSimOnlyValue {
+    type Type = DynSimOnly;
+    type ValueCategory = ValueCategoryValue;
+
+    fn ty(&self) -> Self::Type {
         self.0.ty()
     }
+}
+
+impl DynSimOnlyValue {
     pub fn type_id(&self) -> TypeId {
         self.0.type_id_dyn()
     }
diff --git a/crates/fayalite/src/ty.rs b/crates/fayalite/src/ty.rs
index d9ea6b27..76c09555 100644
--- a/crates/fayalite/src/ty.rs
+++ b/crates/fayalite/src/ty.rs
@@ -11,7 +11,7 @@ use crate::{
     intern::{Intern, Interned},
     phantom_const::PhantomConst,
     reset::{AsyncReset, Reset, SyncReset},
-    sim::value::{DynSimOnlyValue, DynSimOnly, SimValue, ToSimValueWithType},
+    sim::value::{DynSimOnly, DynSimOnlyValue, SimValue, ToSimValueWithType},
     source_location::SourceLocation,
     util::{ConstUsize, slice_range, try_slice_range},
 };
diff --git a/crates/fayalite/src/util/ready_valid.rs b/crates/fayalite/src/util/ready_valid.rs
index 057af466..f0956799 100644
--- a/crates/fayalite/src/util/ready_valid.rs
+++ b/crates/fayalite/src/util/ready_valid.rs
@@ -25,7 +25,7 @@ impl<T: Type> ReadyValid<T> {
     #[hdl]
     pub fn firing_data(expr: impl ToExpr<Type = Self>) -> Expr<HdlOption<T>> {
         let expr = expr.to_expr();
-        let option_ty = Expr::ty(expr).data;
+        let option_ty = expr.ty().data;
         #[hdl]
         let firing_data = wire(option_ty);
         connect(firing_data, option_ty.HdlNone());
@@ -42,7 +42,7 @@ impl<T: Type> ReadyValid<T> {
     ) -> Expr<ReadyValid<R>> {
         let data = HdlOption::map(expr.data, f);
         #[hdl]
-        let mapped = wire(ReadyValid[Expr::ty(data).HdlSome]);
+        let mapped = wire(ReadyValid[data.ty().HdlSome]);
         connect(mapped.data, data);
         connect(expr.ready, mapped.ready);
         mapped
diff --git a/crates/fayalite/src/wire.rs b/crates/fayalite/src/wire.rs
index 51f8cf7d..a350d9a4 100644
--- a/crates/fayalite/src/wire.rs
+++ b/crates/fayalite/src/wire.rs
@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
 // See Notices.txt for copyright information
 use crate::{
-    expr::{Expr, Flow, ToExpr},
+    expr::{Expr, Flow, ToExpr, ValueType, value_category::ValueCategoryExpr},
     intern::Interned,
     module::{IncompleteDeclaration, NameId, ScopedNameId, StmtDeclaration, StmtWire},
     source_location::SourceLocation,
@@ -16,7 +16,16 @@ pub struct Wire<T: Type> {
     ty: T,
 }
 
-impl<T: Type + fmt::Debug> fmt::Debug for Wire<T> {
+impl<T: Type> ValueType for Wire<T> {
+    type Type = T;
+    type ValueCategory = ValueCategoryExpr;
+
+    fn ty(&self) -> Self::Type {
+        self.ty
+    }
+}
+
+impl<T: Type> fmt::Debug for Wire<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Wire({:?}: ", self.name)?;
         self.ty.fmt(f)?;
@@ -49,9 +58,6 @@ impl<T: Type> Wire<T> {
             ty: T::from_canonical(ty),
         }
     }
-    pub fn ty(&self) -> T {
-        self.ty
-    }
     pub fn new_unchecked(
         scoped_name: ScopedNameId,
         source_location: SourceLocation,
diff --git a/crates/fayalite/tests/module.rs b/crates/fayalite/tests/module.rs
index a0392503..8765a4dd 100644
--- a/crates/fayalite/tests/module.rs
+++ b/crates/fayalite/tests/module.rs
@@ -215,7 +215,7 @@ where
     let o: Array<T, N> = m.output();
     let bytes = v.to_string().as_bytes().to_expr();
     #[hdl]
-    let o2: Array<UInt<8>> = m.output(Expr::ty(bytes));
+    let o2: Array<UInt<8>> = m.output(bytes.ty());
     connect(
         o,
         #[hdl]
diff --git a/crates/fayalite/tests/sim.rs b/crates/fayalite/tests/sim.rs
index be4e2071..e55a5178 100644
--- a/crates/fayalite/tests/sim.rs
+++ b/crates/fayalite/tests/sim.rs
@@ -86,7 +86,7 @@ pub fn mod1() {
     #[hdl]
     let child = instance(mod1_child());
     #[hdl]
-    let o: mod1_child = m.output(Expr::ty(child));
+    let o: mod1_child = m.output(child.ty());
     connect(o, child);
 }