From 7e9d7739fba743927392ac9f5466af25ee09515f Mon Sep 17 00:00:00 2001
From: Jacob Lifshay <programmerjake@gmail.com>
Date: Fri, 1 May 2026 18:35:21 -0700
Subject: [PATCH] use #[hdl(cmp_eq)] for HdlOption and implement conversion <->
 Option

---
 crates/fayalite/src/enum_.rs | 208 ++++++++++++++++++++---------------
 1 file changed, 121 insertions(+), 87 deletions(-)

diff --git a/crates/fayalite/src/enum_.rs b/crates/fayalite/src/enum_.rs
index d545f93..f6af578 100644
--- a/crates/fayalite/src/enum_.rs
+++ b/crates/fayalite/src/enum_.rs
@@ -2,7 +2,7 @@
 // See Notices.txt for copyright information
 
 use crate::{
-    expr::{Expr, HdlPartialEq, HdlPartialEqImpl, ToExpr, ValueType, ops::VariantAccess},
+    expr::{Expr, ToExpr, ValueType, ops::VariantAccess},
     hdl,
     int::{Bool, UIntValue},
     intern::{Intern, Interned},
@@ -10,7 +10,7 @@ use crate::{
         EnumMatchVariantAndInactiveScopeImpl, EnumMatchVariantsIterImpl, Scope, connect,
         enum_match_variants_helper, incomplete_wire, wire,
     },
-    sim::value::SimValue,
+    sim::value::{SimValue, ToSimValue, ToSimValueWithType},
     source_location::SourceLocation,
     ty::{
         CanonicalType, MatchVariantAndInactiveScope, OpaqueSimValue, OpaqueSimValueSize,
@@ -21,7 +21,7 @@ use crate::{
 };
 use bitvec::{order::Lsb0, slice::BitSlice, view::BitView};
 use serde::{Deserialize, Serialize};
-use std::{borrow::Cow, convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
+use std::{convert::Infallible, fmt, iter::FusedIterator, sync::Arc};
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Serialize, Deserialize)]
 pub struct EnumVariant {
@@ -732,95 +732,12 @@ pub fn enum_type_to_sim_builder<T: EnumType>(v: T) -> T::SimBuilder {
     v.into()
 }
 
-#[hdl]
+#[hdl(cmp_eq)]
 pub enum HdlOption<T: Type> {
     HdlNone,
     HdlSome(T),
 }
 
-impl<Lhs: Type + HdlPartialEqImpl<Rhs>, Rhs: Type> HdlPartialEqImpl<HdlOption<Rhs>>
-    for HdlOption<Lhs>
-{
-    fn cmp_value_eq(
-        lhs: Self,
-        lhs_value: Cow<'_, Self::SimValue>,
-        rhs: HdlOption<Rhs>,
-        rhs_value: Cow<'_, <HdlOption<Rhs> as Type>::SimValue>,
-    ) -> bool {
-        type SimValueMatch<T> = <T as Type>::SimValue;
-        match (&*lhs_value, &*rhs_value) {
-            (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_)) => {
-                true
-            }
-            (SimValueMatch::<Self>::HdlSome(..), SimValueMatch::<HdlOption<Rhs>>::HdlNone(_))
-            | (SimValueMatch::<Self>::HdlNone(_), SimValueMatch::<HdlOption<Rhs>>::HdlSome(..)) => {
-                false
-            }
-            (
-                SimValueMatch::<Self>::HdlSome(l, _),
-                SimValueMatch::<HdlOption<Rhs>>::HdlSome(r, _),
-            ) => HdlPartialEqImpl::cmp_value_eq(
-                lhs.HdlSome,
-                Cow::Borrowed(&**l),
-                rhs.HdlSome,
-                Cow::Borrowed(&**r),
-            ),
-        }
-    }
-
-    #[hdl]
-    fn cmp_expr_eq(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
-        #[hdl]
-        let cmp_eq = wire();
-        #[hdl]
-        match lhs {
-            HdlSome(lhs) =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(rhs) => connect(cmp_eq, lhs.cmp_eq(rhs)),
-                    HdlNone => connect(cmp_eq, false),
-                }
-            }
-            HdlNone =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(_) => connect(cmp_eq, false),
-                    HdlNone => connect(cmp_eq, true),
-                }
-            }
-        }
-        cmp_eq
-    }
-
-    #[hdl]
-    fn cmp_expr_ne(lhs: Expr<Self>, rhs: Expr<HdlOption<Rhs>>) -> Expr<Bool> {
-        #[hdl]
-        let cmp_ne = wire();
-        #[hdl]
-        match lhs {
-            HdlSome(lhs) =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(rhs) => connect(cmp_ne, lhs.cmp_ne(rhs)),
-                    HdlNone => connect(cmp_ne, true),
-                }
-            }
-            HdlNone =>
-            {
-                #[hdl]
-                match rhs {
-                    HdlSome(_) => connect(cmp_ne, true),
-                    HdlNone => connect(cmp_ne, false),
-                }
-            }
-        }
-        cmp_ne
-    }
-}
-
 #[allow(non_snake_case)]
 pub fn HdlNone<T: StaticType>() -> Expr<HdlOption<T>> {
     HdlOption[T::TYPE].HdlNone()
@@ -832,6 +749,123 @@ pub fn HdlSome<T: Type>(value: impl ToExpr<Type = T>) -> Expr<HdlOption<T>> {
     HdlOption[value.ty()].HdlSome(value)
 }
 
+impl<T: Type> From<SimValue<HdlOption<T>>> for Option<SimValue<T>> {
+    #[hdl]
+    fn from(value: SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<'a, T: Type> From<&'a SimValue<HdlOption<T>>> for Option<&'a SimValue<T>> {
+    #[hdl]
+    fn from(value: &'a SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<'a, T: Type> From<&'a mut SimValue<HdlOption<T>>> for Option<&'a mut SimValue<T>> {
+    #[hdl]
+    fn from(value: &'a mut SimValue<HdlOption<T>>) -> Self {
+        #[hdl(sim)]
+        match value {
+            HdlSome(v) => Some(v),
+            HdlNone => None,
+        }
+    }
+}
+
+impl<T: ValueType<Type: StaticType<MaskType: StaticType>>> ValueType for Option<T> {
+    type Type = HdlOption<T::Type>;
+    type ValueCategory = T::ValueCategory;
+
+    fn ty(&self) -> Self::Type {
+        StaticType::TYPE
+    }
+}
+
+impl<T: Type, V: ToSimValueWithType<T>> ToSimValueWithType<HdlOption<T>> for Option<V> {
+    #[hdl]
+    fn to_sim_value_with_type(&self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                ty.HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                ty.HdlNone()
+            }
+        }
+    }
+    #[hdl]
+    fn into_sim_value_with_type(self, ty: HdlOption<T>) -> SimValue<HdlOption<T>> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                ty.HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                ty.HdlNone()
+            }
+        }
+    }
+}
+
+impl<T: ToSimValue<Type: StaticType<MaskType: StaticType>>> ToSimValue for Option<T> {
+    #[hdl]
+    fn to_sim_value(&self) -> SimValue<Self::Type> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                HdlNone()
+            }
+        }
+    }
+    #[hdl]
+    fn into_sim_value(self) -> SimValue<Self::Type> {
+        match self {
+            Some(v) =>
+            {
+                #[hdl(sim)]
+                HdlSome(v)
+            }
+            None =>
+            {
+                #[hdl(sim)]
+                HdlNone()
+            }
+        }
+    }
+}
+
+impl<T: ToExpr<Type: StaticType<MaskType: StaticType>>> ToExpr for Option<T> {
+    fn to_expr(&self) -> Expr<Self::Type> {
+        match self {
+            Some(v) => HdlSome(v),
+            None => HdlNone(),
+        }
+    }
+}
+
 impl<T: Type> HdlOption<T> {
     #[track_caller]
     pub fn try_map<R: Type, E>(