diff --git a/src/lib.rs b/src/lib.rs
index 917d612..db7fc13 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -10,29 +10,25 @@ pub enum FluxValue {
     Map(BTreeMap<FluxValue, FluxValue>),
 }
 
-pub trait Serialize {
-    fn serialize(&self) -> FluxValue;
-}
-
-pub trait Deserialize {
-    fn deserialize(v: FluxValue) -> Self;
+pub trait ToFlux {
+    fn to_flux(&self) -> FluxValue;
 }
 
 pub trait FluxModule {
     fn init(&self);
     fn end(&self);
-    fn call(&self, func: &str, args: Vec<&dyn Serialize>) -> FluxValue;
+    fn call(&self, func: &str, args: Vec<&dyn ToFlux>) -> FluxValue;
 }
 
 pub mod runtime;
 pub mod values;
 
 pub mod prelude {
-    pub use crate::{Deserialize, FluxModule, Serialize};
+    pub use crate::{FluxModule, ToFlux};
 }
 
 impl FluxValue {
-    pub fn extract<T: Deserialize>(self) -> T {
-        T::deserialize(self)
+    pub fn extract<T: From<FluxValue>>(self) -> T {
+        T::from(self)
     }
 }
diff --git a/src/runtime/python.rs b/src/runtime/python.rs
index 1d39619..3266724 100644
--- a/src/runtime/python.rs
+++ b/src/runtime/python.rs
@@ -53,13 +53,13 @@ impl FluxModule for PythonModule<'_> {
         self.python.run(&code, None, None).unwrap();
     }
 
-    fn call(&self, func: &str, args: Vec<&dyn crate::Serialize>) -> crate::FluxValue {
+    fn call(&self, func: &str, args: Vec<&dyn crate::ToFlux>) -> crate::FluxValue {
         let module = self.python.import("__main__").unwrap();
         let func = module.get(self.python, func).unwrap();
 
         let py_args: Vec<PyObject> = args
             .iter()
-            .map(|a| flux_to_object(self.python, &a.serialize()))
+            .map(|a| flux_to_object(self.python, &a.to_flux()))
             .collect();
 
         let args_tuple = PyTuple::new(self.python, &py_args);
diff --git a/src/values.rs b/src/values.rs
index 00b306e..9f1301a 100644
--- a/src/values.rs
+++ b/src/values.rs
@@ -1,65 +1,65 @@
 use std::collections::{BTreeMap, HashMap};
 
-use crate::{Deserialize, FluxValue, Serialize};
+use crate::{FluxValue, ToFlux};
 
-impl Serialize for i64 {
-    fn serialize(&self) -> FluxValue {
+impl ToFlux for i64 {
+    fn to_flux(&self) -> FluxValue {
         FluxValue::Int(*self)
     }
 }
 
-impl Serialize for f64 {
-    fn serialize(&self) -> FluxValue {
+impl ToFlux for f64 {
+    fn to_flux(&self) -> FluxValue {
         FluxValue::Float(self.to_bits())
     }
 }
 
-impl Deserialize for f64 {
-    fn deserialize(v: FluxValue) -> Self {
-        match v {
+impl From<FluxValue> for f64 {
+    fn from(value: FluxValue) -> Self {
+        match value {
             FluxValue::Float(bits) => f64::from_bits(bits),
             v => panic!("Expected Int, instead got {v:?}"),
         }
     }
 }
 
-impl Serialize for &str {
-    fn serialize(&self) -> FluxValue {
+impl ToFlux for &str {
+    fn to_flux(&self) -> FluxValue {
         FluxValue::Str(self.to_string())
     }
 }
 
-impl Serialize for String {
-    fn serialize(&self) -> FluxValue {
+impl ToFlux for String {
+    fn to_flux(&self) -> FluxValue {
         FluxValue::Str(self.clone())
     }
 }
 
-impl Deserialize for i64 {
-    fn deserialize(v: FluxValue) -> Self {
-        match v {
+impl From<FluxValue> for i64 {
+    fn from(value: FluxValue) -> Self {
+        match value {
             FluxValue::Int(i) => i,
             v => panic!("Expected Int, instead got {v:?}"),
         }
     }
 }
 
-impl<K: Serialize, V: Serialize> Serialize for HashMap<K, V> {
-    fn serialize(&self) -> FluxValue {
+impl<K: ToFlux, V: ToFlux> ToFlux for HashMap<K, V> {
+    fn to_flux(&self) -> FluxValue {
         FluxValue::Map(
             self.iter()
-                .map(|(k, v)| (k.serialize(), v.serialize()))
+                .map(|(k, v)| (k.to_flux(), v.to_flux()))
                 .collect::<BTreeMap<FluxValue, FluxValue>>(),
         )
     }
 }
 
-impl<K: Deserialize + Ord, V: Deserialize> Deserialize for BTreeMap<K, V> {
-    fn deserialize(v: FluxValue) -> Self {
-        match v {
+impl<K: From<FluxValue> + Ord, V: From<FluxValue>> From<FluxValue> for BTreeMap<K, V> {
+    fn from(value: FluxValue) -> Self {
+        match value {
             FluxValue::Map(m) => m
                 .iter()
-                .map(|(k, v)| (K::deserialize(k.clone()), V::deserialize(v.clone())))
+                .map(|(k, v)| (K::from(k.clone()), V::from(v.clone())))
                 .collect::<BTreeMap<K, V>>(),
             v => panic!("Expected Int, instead got {v:?}"),
         }