Repository: swimos/swim-rust (language: rust)

Issue:
Rename `ValidatedForm` to `ValueSchema`



Discussion / hints:

Fix patch:
diff --git a/swim_client/src/downlink/subscription/mod.rs b/swim_client/src/downlink/subscription/mod.rs
index d514c6e62..22fceea35 100644
--- a/swim_client/src/downlink/subscription/mod.rs
+++ b/swim_client/src/downlink/subscription/mod.rs
@@ -40,7 +40,7 @@ use pin_utils::pin_mut;
 use std::collections::HashMap;
 use std::pin::Pin;
 use std::sync::{Arc, Weak};
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::request::Request;
@@ -141,7 +141,7 @@ impl Downlinks {
     }
 
     /// Attempt to subscribe to a remote value lane where the type of the values is described by a
-    /// [`ValidatedForm`]. The downlink is returned with a single active
+    /// [`ValueSchema`]. The downlink is returned with a single active
     /// subscription to its events.
     #[instrument(skip(self, init), level = "info")]
     pub async fn subscribe_value<T>(
@@ -150,7 +150,7 @@ impl Downlinks {
         path: AbsolutePath,
     ) -> RequestResult<(TypedValueDownlink<T>, ValueDownlinkReceiver<T>)>
     where
-        T: Form + ValidatedForm + Send + 'static,
+        T: Form + ValueSchema + Send + 'static,
     {
         info!("Subscribing to typed value lane");
 
@@ -195,7 +195,7 @@ impl Downlinks {
     }
 
     /// Attempt to subscribe to a remote map lane where the types of the keys and values are
-    /// described by  [`ValidatedForm`]s. The downlink is returned with a single active
+    /// described by  [`ValueSchema`]s. The downlink is returned with a single active
     /// subscription to its events.
     #[instrument(skip(self), level = "info")]
     pub async fn subscribe_map<K, V>(
@@ -203,8 +203,8 @@ impl Downlinks {
         path: AbsolutePath,
     ) -> RequestResult<(TypedMapDownlink<K, V>, MapDownlinkReceiver<K, V>)>
     where
-        K: ValidatedForm + Send + 'static,
-        V: ValidatedForm + Send + 'static,
+        K: ValueSchema + Send + 'static,
+        V: ValueSchema + Send + 'static,
     {
         info!("Subscribing to typed map lane");
 
@@ -247,7 +247,7 @@ impl Downlinks {
         path: AbsolutePath,
     ) -> RequestResult<TypedCommandDownlink<T>>
     where
-        T: ValidatedForm + Send + 'static,
+        T: ValueSchema + Send + 'static,
     {
         Ok(TypedCommandDownlink::new(
             self.subscribe_command_inner(T::schema(), path).await?,
@@ -287,7 +287,7 @@ impl Downlinks {
         violations: SchemaViolations,
     ) -> RequestResult<TypedEventDownlink<T>>
     where
-        T: ValidatedForm + Send + 'static,
+        T: ValueSchema + Send + 'static,
     {
         Ok(TypedEventDownlink::new(
             self.subscribe_event_inner(T::schema(), path, violations)
diff --git a/swim_client/src/downlink/typed/command/mod.rs b/swim_client/src/downlink/typed/command/mod.rs
index d77c0ce77..a61b2ee5f 100644
--- a/swim_client/src/downlink/typed/command/mod.rs
+++ b/swim_client/src/downlink/typed/command/mod.rs
@@ -23,7 +23,7 @@ use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
 use std::marker::PhantomData;
 use std::sync::Arc;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use utilities::sync::promise;
 
@@ -99,11 +99,11 @@ impl Display for CommandViewError {
 
 impl Error for CommandViewError {}
 
-impl<T: ValidatedForm> TypedCommandDownlink<T> {
-    /// Create a sender for a more refined type (the [`ValidatedForm`] implementation for `U`
-    /// will always produce a [`swim_common::model::Value`] that is acceptable to the [`ValidatedForm`] implementation
+impl<T: ValueSchema> TypedCommandDownlink<T> {
+    /// Create a sender for a more refined type (the [`ValueSchema`] implementation for `U`
+    /// will always produce a [`swim_common::model::Value`] that is acceptable to the [`ValueSchema`] implementation
     /// for `T`) to the downlink.
-    pub fn contravariant_view<U: ValidatedForm>(
+    pub fn contravariant_view<U: ValueSchema>(
         &self,
     ) -> Result<TypedCommandDownlink<U>, CommandViewError> {
         let schema_cmp = U::schema().partial_cmp(&T::schema());
diff --git a/swim_client/src/downlink/typed/event/mod.rs b/swim_client/src/downlink/typed/event/mod.rs
index 3f707a7d9..b25c2cb05 100644
--- a/swim_client/src/downlink/typed/event/mod.rs
+++ b/swim_client/src/downlink/typed/event/mod.rs
@@ -22,7 +22,7 @@ use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
 use std::marker::PhantomData;
 use std::sync::Arc;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use utilities::sync::{promise, topic};
@@ -30,7 +30,7 @@ use utilities::sync::{promise, topic};
 #[cfg(test)]
 mod tests;
 
-/// A downlink to a remote lane producing events that are compatible with the [`ValidatedForm`]
+/// A downlink to a remote lane producing events that are compatible with the [`ValueSchema`]
 /// implementation for `T`.
 pub struct TypedEventDownlink<T> {
     inner: Arc<UntypedEventDownlink>,
@@ -171,10 +171,10 @@ impl Display for EventViewError {
 
 impl Error for EventViewError {}
 
-impl<T: ValidatedForm> EventDownlinkSubscriber<T> {
+impl<T: ValueSchema> EventDownlinkSubscriber<T> {
     /// Create a read-only view for a value downlink that converts all received values to a new type.
     /// The type of the view must have an equal or greater schema than the original downlink.
-    pub fn covariant_cast<U: ValidatedForm>(
+    pub fn covariant_cast<U: ValueSchema>(
         self,
     ) -> Result<EventDownlinkSubscriber<U>, EventViewError> {
         let schema_cmp = U::schema().partial_cmp(&T::schema());
diff --git a/swim_client/src/downlink/typed/map/mod.rs b/swim_client/src/downlink/typed/map/mod.rs
index 1ee3727a5..4735b8576 100644
--- a/swim_client/src/downlink/typed/map/mod.rs
+++ b/swim_client/src/downlink/typed/map/mod.rs
@@ -29,7 +29,7 @@ use std::fmt::{Debug, Display, Formatter};
 use std::marker::PhantomData;
 use std::sync::Arc;
 use swim_common::form::structural::read::ReadError;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::request::Request;
@@ -39,7 +39,7 @@ use utilities::sync::{promise, topic};
 type MapDlVariance<K, V> = fn(K, V) -> (K, V);
 
 /// A downlink to a remote map lane containing values that are compatible with the
-/// [`ValidatedForm`] implementations for `K` and `V`.
+/// [`ValueSchema`] implementations for `K` and `V`.
 pub struct TypedMapDownlink<K, V> {
     inner: Arc<UntypedMapDownlink>,
     _type: PhantomData<MapDlVariance<K, V>>,
@@ -105,7 +105,7 @@ impl<K: Form, V: Form> TypedMapDownlink<K, V> {
     }
 }
 
-impl<K: Form + ValidatedForm + 'static, V: Form + ValidatedForm + 'static> TypedMapDownlink<K, V> {
+impl<K: Form + ValueSchema + 'static, V: Form + ValueSchema + 'static> TypedMapDownlink<K, V> {
     /// Get the value associated with a specific key.
     pub async fn get(&self, key: K) -> Result<Option<V>, DownlinkError> {
         actions::<K, V>(self.inner.sender()).get(key).await
@@ -298,14 +298,14 @@ fn actions<K, V>(sender: &mpsc::Sender<MapAction>) -> MapActions<K, V> {
     MapActions::new(sender)
 }
 
-impl<K: Form + ValidatedForm, V: Form + ValidatedForm> MapDownlinkSender<K, V> {
-    /// Create a sender for more refined key and value types (the [`ValidatedForm`] implementations
+impl<K: Form + ValueSchema, V: Form + ValueSchema> MapDownlinkSender<K, V> {
+    /// Create a sender for more refined key and value types (the [`ValueSchema`] implementations
     /// for `K2` and `V2` will always produce [`Value`]s that are acceptable to the
-    /// [`ValidatedForm`] implementations for `K` and `V`) to the downlink.
+    /// [`ValueSchema`] implementations for `K` and `V`) to the downlink.
     pub fn contravariant_view<K2, V2>(&self) -> Result<MapDownlinkContraView<K2, V2>, MapViewError>
     where
-        K2: Form + ValidatedForm,
-        V2: Form + ValidatedForm,
+        K2: Form + ValueSchema,
+        V2: Form + ValueSchema,
     {
         let key_schema_good = K2::schema()
             .partial_cmp(&K::schema())
@@ -337,13 +337,13 @@ impl<K: Form + ValidatedForm, V: Form + ValidatedForm> MapDownlinkSender<K, V> {
         }
     }
 
-    /// Create a sender for more general key and value types (the [`ValidatedForm`] implementations
+    /// Create a sender for more general key and value types (the [`ValueSchema`] implementations
     /// for `K` and `V` will always produce [`Value`]s that are acceptable to the
-    /// [`ValidatedForm`] implementations for `K2` and `Vv`) to the downlink.
+    /// [`ValueSchema`] implementations for `K2` and `Vv`) to the downlink.
     pub fn covariant_view<K2, V2>(&self) -> Result<MapDownlinkView<K2, V2>, MapViewError>
     where
-        K2: Form + ValidatedForm,
-        V2: Form + ValidatedForm,
+        K2: Form + ValueSchema,
+        V2: Form + ValueSchema,
     {
         let key_schema_good = K2::schema()
             .partial_cmp(&K::schema())
@@ -378,8 +378,8 @@ impl<K: Form + ValidatedForm, V: Form + ValidatedForm> MapDownlinkSender<K, V> {
 
 impl<K, V> MapDownlinkSender<K, V>
 where
-    K: Form + ValidatedForm + 'static,
-    V: Form + ValidatedForm + 'static,
+    K: Form + ValueSchema + 'static,
+    V: Form + ValueSchema + 'static,
 {
     /// Get the value associated with a specific key.
     pub async fn get(&self, key: K) -> Result<Option<V>, DownlinkError> {
@@ -470,8 +470,8 @@ where
 
 impl<K, V> MapDownlinkView<K, V>
 where
-    K: Form + ValidatedForm + 'static,
-    V: Form + ValidatedForm + 'static,
+    K: Form + ValueSchema + 'static,
+    V: Form + ValueSchema + 'static,
 {
     /// Get the value associated with a specific key.
     pub async fn get(&self, key: K) -> Result<Option<V>, DownlinkError> {
@@ -526,8 +526,8 @@ where
 
 impl<K, V> MapDownlinkContraView<K, V>
 where
-    K: Form + ValidatedForm + 'static,
-    V: Form + ValidatedForm + 'static,
+    K: Form + ValueSchema + 'static,
+    V: Form + ValueSchema + 'static,
 {
     /// Update an entry into the map returning any existing value associated with the key.
     pub async fn update(&self, key: K, value: V) -> Result<(), DownlinkError> {
@@ -720,8 +720,8 @@ impl<'a, K, V> MapActions<'a, K, V> {
 
 impl<'a, K, V> MapActions<'a, K, V>
 where
-    K: Form + ValidatedForm + 'static,
-    V: Form + ValidatedForm + 'static,
+    K: Form + ValueSchema + 'static,
+    V: Form + ValueSchema + 'static,
 {
     /// Get the value associated with a specific key.
     pub async fn get(&self, key: K) -> Result<Option<V>, DownlinkError> {
@@ -938,13 +938,13 @@ impl Display for MapViewError {
 
 impl Error for MapViewError {}
 
-impl<K: Form + ValidatedForm, V: Form + ValidatedForm> MapDownlinkSubscriber<K, V> {
+impl<K: Form + ValueSchema, V: Form + ValueSchema> MapDownlinkSubscriber<K, V> {
     /// Create a read-only view for a value downlink that converts all received values to a new type.
     /// The type of the view must have an equal or greater schema than the original downlink.
     pub fn covariant_cast<K2, V2>(self) -> Result<MapDownlinkSubscriber<K2, V2>, MapViewError>
     where
-        K2: Form + ValidatedForm,
-        V2: Form + ValidatedForm,
+        K2: Form + ValueSchema,
+        V2: Form + ValueSchema,
     {
         let key_schema_good = K2::schema()
             .partial_cmp(&K::schema())
diff --git a/swim_client/src/downlink/typed/mod.rs b/swim_client/src/downlink/typed/mod.rs
index 08ef3a009..ad676d1d0 100644
--- a/swim_client/src/downlink/typed/mod.rs
+++ b/swim_client/src/downlink/typed/mod.rs
@@ -16,7 +16,7 @@ use crate::downlink::model::map::{MapAction, ViewWithEvent};
 use crate::downlink::model::value::{Action, SharedValue, UpdateResult};
 use crate::downlink::{error::DownlinkError, error::UpdateFailure, Event, RawDownlink};
 use std::fmt::{Display, Formatter};
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::Value;
 use tokio::sync::oneshot;
 use utilities::sync::topic;
@@ -60,7 +60,7 @@ where
     }
 }
 
-async fn await_fallible<T: Form + ValidatedForm>(
+async fn await_fallible<T: Form + ValueSchema>(
     rx: oneshot::Receiver<Result<UpdateResult<SharedValue>, DownlinkError>>,
 ) -> Result<T, DownlinkError> {
     let value = rx
@@ -73,7 +73,7 @@ async fn await_fallible<T: Form + ValidatedForm>(
     })
 }
 
-async fn await_value<T: Form + ValidatedForm>(
+async fn await_value<T: Form + ValueSchema>(
     rx: oneshot::Receiver<Result<SharedValue, DownlinkError>>,
 ) -> Result<T, DownlinkError> {
     let value = rx.await.map_err(|_| DownlinkError::DroppedChannel)??;
@@ -83,14 +83,14 @@ async fn await_value<T: Form + ValidatedForm>(
     })
 }
 
-async fn await_optional<T: Form + ValidatedForm>(
+async fn await_optional<T: Form + ValueSchema>(
     rx: oneshot::Receiver<Result<Option<SharedValue>, DownlinkError>>,
 ) -> Result<Option<T>, DownlinkError> {
     let maybe_value = rx.await.map_err(|_| DownlinkError::DroppedChannel)??;
     match maybe_value {
         Some(value) => Form::try_from_value(value.as_ref())
             .map_err(|_| {
-                let schema = <T as ValidatedForm>::schema();
+                let schema = <T as ValueSchema>::schema();
                 DownlinkError::SchemaViolation((*value).clone(), schema)
             })
             .map(Some),
diff --git a/swim_client/src/downlink/typed/value/mod.rs b/swim_client/src/downlink/typed/value/mod.rs
index 049d1a318..5875cd361 100644
--- a/swim_client/src/downlink/typed/value/mod.rs
+++ b/swim_client/src/downlink/typed/value/mod.rs
@@ -26,14 +26,14 @@ use std::error::Error;
 use std::fmt::{Debug, Display, Formatter};
 use std::marker::PhantomData;
 use std::sync::Arc;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use tokio::sync::{mpsc, oneshot};
 use utilities::sync::{promise, topic};
 
 /// A downlink to a remote value lane containing values that are compatible with the
-/// [`ValidatedForm`] implementation for `T`.
+/// [`ValueSchema`] implementation for `T`.
 pub struct TypedValueDownlink<T> {
     inner: Arc<UntypedValueDownlink>,
     _type: PhantomData<fn(T) -> T>,
@@ -206,13 +206,13 @@ impl<T> ValueDownlinkView<T> {
     }
 }
 
-impl<T: ValidatedForm> ValueDownlinkSender<T> {
-    /// Create a sender for a more refined type (the [`ValidatedForm`] implementation for `U`
-    /// will always produce a [`Value`] that is acceptable to the [`ValidatedForm`] implementation
+impl<T: ValueSchema> ValueDownlinkSender<T> {
+    /// Create a sender for a more refined type (the [`ValueSchema`] implementation for `U`
+    /// will always produce a [`Value`] that is acceptable to the [`ValueSchema`] implementation
     /// for `T`) to the downlink.
     pub fn contravariant_view<U>(&self) -> Result<ValueDownlinkContraView<U>, ValueViewError>
     where
-        U: ValidatedForm,
+        U: ValueSchema,
     {
         let schema_cmp = U::schema().partial_cmp(&T::schema());
 
@@ -231,7 +231,7 @@ impl<T: ValidatedForm> ValueDownlinkSender<T> {
     /// The type of the view must have an equal or greater schema than the original downlink.
     pub fn covariant_view<U>(&self) -> Result<ValueDownlinkView<U>, ValueViewError>
     where
-        U: ValidatedForm,
+        U: ValueSchema,
     {
         let schema_cmp = U::schema().partial_cmp(&T::schema());
 
@@ -247,7 +247,7 @@ impl<T: ValidatedForm> ValueDownlinkSender<T> {
     }
 }
 
-impl<T: Form + ValidatedForm + 'static> ValueDownlinkSender<T> {
+impl<T: Form + ValueSchema + 'static> ValueDownlinkSender<T> {
     /// Get the current value of the downlink.
     pub async fn get(&self) -> Result<T, DownlinkError> {
         ValueActions::new(&self.inner).get().await
@@ -282,7 +282,7 @@ impl<T: Form + ValidatedForm + 'static> ValueDownlinkSender<T> {
     }
 }
 
-impl<T: Form + ValidatedForm + 'static> ValueDownlinkContraView<T> {
+impl<T: Form + ValueSchema + 'static> ValueDownlinkContraView<T> {
     /// Set the value of the downlink, waiting until the set has completed.
     pub async fn set(&self, value: T) -> Result<(), DownlinkError> {
         ValueActions::new(&self.inner).set(value).await
@@ -294,14 +294,14 @@ impl<T: Form + ValidatedForm + 'static> ValueDownlinkContraView<T> {
     }
 }
 
-impl<T: Form + ValidatedForm + 'static> ValueDownlinkView<T> {
+impl<T: Form + ValueSchema + 'static> ValueDownlinkView<T> {
     /// Get the current value of the downlink.
     pub async fn get(&self) -> Result<T, DownlinkError> {
         ValueActions::new(&self.inner).get().await
     }
 }
 
-impl<T: Form + ValidatedForm + 'static> TypedValueDownlink<T> {
+impl<T: Form + ValueSchema + 'static> TypedValueDownlink<T> {
     /// Get the current value of the downlink.
     pub async fn get(&self) -> Result<T, DownlinkError> {
         ValueActions::new(self.inner.sender()).get().await
@@ -358,7 +358,7 @@ impl<'a, T> ValueActions<'a, T> {
 
 impl<'a, T> ValueActions<'a, T>
 where
-    T: Form + ValidatedForm + 'static,
+    T: Form + ValueSchema + 'static,
 {
     async fn get(&self) -> Result<T, DownlinkError> {
         let (tx, rx) = oneshot::channel();
@@ -470,13 +470,13 @@ impl<T> ValueDownlinkSubscriber<T> {
     }
 }
 
-impl<T: Form + ValidatedForm> ValueDownlinkSubscriber<T> {
+impl<T: Form + ValueSchema> ValueDownlinkSubscriber<T> {
     /// Create a read-only view for a value downlink subscriberthat converts all received values
     /// to a new type. The type of the view must have an equal or greater schema than the original
     /// downlink.
     pub fn covariant_cast<U>(self) -> Result<ValueDownlinkSubscriber<U>, ValueViewError>
     where
-        U: Form + ValidatedForm,
+        U: Form + ValueSchema,
     {
         let schema_cmp = U::schema().partial_cmp(&T::schema());
 
diff --git a/swim_client/src/interface/mod.rs b/swim_client/src/interface/mod.rs
index 38a9703bb..d23b73335 100644
--- a/swim_client/src/interface/mod.rs
+++ b/swim_client/src/interface/mod.rs
@@ -38,7 +38,7 @@ use std::fmt::{Display, Formatter};
 use std::fs::File;
 use std::io::Read;
 use std::sync::Arc;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::parser::parse_single;
 use swim_common::model::Value;
 use swim_common::routing::ws::WebsocketFactory;
@@ -182,7 +182,7 @@ impl SwimClient {
         initial: T,
     ) -> Result<(TypedValueDownlink<T>, ValueDownlinkReceiver<T>), ClientError>
     where
-        T: Form + ValidatedForm + Send + 'static,
+        T: Form + ValueSchema + Send + 'static,
     {
         self.downlinks
             .subscribe_value(initial, path)
@@ -196,8 +196,8 @@ impl SwimClient {
         path: AbsolutePath,
     ) -> Result<(TypedMapDownlink<K, V>, MapDownlinkReceiver<K, V>), ClientError>
     where
-        K: ValidatedForm + Send + 'static,
-        V: ValidatedForm + Send + 'static,
+        K: ValueSchema + Send + 'static,
+        V: ValueSchema + Send + 'static,
     {
         self.downlinks
             .subscribe_map(path)
@@ -211,7 +211,7 @@ impl SwimClient {
         path: AbsolutePath,
     ) -> Result<TypedCommandDownlink<T>, ClientError>
     where
-        T: ValidatedForm + Send + 'static,
+        T: ValueSchema + Send + 'static,
     {
         self.downlinks
             .subscribe_command(path)
@@ -226,7 +226,7 @@ impl SwimClient {
         violations: SchemaViolations,
     ) -> Result<TypedEventDownlink<T>, ClientError>
     where
-        T: ValidatedForm + Send + 'static,
+        T: ValueSchema + Send + 'static,
     {
         self.downlinks
             .subscribe_event(path, violations)
diff --git a/swim_common/form_derive/src/lib.rs b/swim_common/form_derive/src/lib.rs
index 63269026c..c2418d5cf 100644
--- a/swim_common/form_derive/src/lib.rs
+++ b/swim_common/form_derive/src/lib.rs
@@ -57,7 +57,7 @@ pub fn derive_tag(input: TokenStream) -> TokenStream {
         .into()
 }
 
-#[proc_macro_derive(ValidatedForm, attributes(form))]
+#[proc_macro_derive(ValueSchema, attributes(form))]
 pub fn derive_validated_form(input: TokenStream) -> TokenStream {
     let input = parse_macro_input!(input as DeriveInput);
     build_validated_form(input)
diff --git a/swim_common/form_derive/src/validated_form/mod.rs b/swim_common/form_derive/src/validated_form/mod.rs
index 0299fecc8..5d7d52b87 100644
--- a/swim_common/form_derive/src/validated_form/mod.rs
+++ b/swim_common/form_derive/src/validated_form/mod.rs
@@ -20,7 +20,7 @@ use crate::form::form_parser::build_type_contents;
 use crate::parser::FieldManifest;
 use crate::validated_form::attrs::{build_attrs, build_head_attribute};
 use crate::validated_form::vf_parser::{
-    type_contents_to_validated, StandardSchema, ValidatedField, ValidatedFormDescriptor,
+    type_contents_to_validated, StandardSchema, ValidatedField, ValueSchemaDescriptor,
 };
 use macro_utilities::add_bound;
 use macro_utilities::Label;
@@ -34,7 +34,7 @@ mod vf_parser;
 
 mod range;
 
-// Builds the ValidatedForm implementation from the DeriveInput.
+// Builds the ValueSchema implementation from the DeriveInput.
 pub fn build_validated_form(
     input: DeriveInput,
 ) -> Result<proc_macro2::TokenStream, Vec<syn::Error>> {
@@ -53,7 +53,7 @@ pub fn build_validated_form(
     let type_contents = type_contents_to_tokens(&type_contents);
 
     let ts = quote! {
-        impl #impl_generics swim_common::form::ValidatedForm for #structure_name #ty_generics #where_clause
+        impl #impl_generics swim_common::form::ValueSchema for #structure_name #ty_generics #where_clause
         {
             fn schema() -> swim_common::model::schema::StandardSchema {
                 #type_contents
@@ -65,7 +65,7 @@ pub fn build_validated_form(
 }
 
 fn type_contents_to_tokens(
-    type_contents: &TypeContents<'_, ValidatedFormDescriptor, ValidatedField>,
+    type_contents: &TypeContents<'_, ValueSchemaDescriptor, ValidatedField>,
 ) -> TokenStream {
     match type_contents {
         TypeContents::Struct(repr) => {
@@ -157,7 +157,7 @@ fn derive_items(fields: &[ValidatedField], descriptor: &FieldManifest) -> TokenS
         let field = fields.iter().find(|f| f.form_field.is_body()).unwrap();
         let ty = &field.form_field.original.ty;
 
-        return quote!(<#ty as swim_common::form::ValidatedForm>::schema());
+        return quote!(<#ty as swim_common::form::ValueSchema>::schema());
     }
 
     let mut schemas = fields.iter().fold(TokenStream2::new(), |ts, field| {
@@ -192,7 +192,7 @@ fn derive_items(fields: &[ValidatedField], descriptor: &FieldManifest) -> TokenS
 fn derive_compound_schema(
     fields: &[ValidatedField],
     compound_type: &CompoundTypeKind,
-    descriptor: &ValidatedFormDescriptor,
+    descriptor: &ValueSchemaDescriptor,
     ident: &Label,
 ) -> TokenStream2 {
     let manifest = &descriptor.form_descriptor.manifest;
@@ -230,14 +230,14 @@ fn derive_compound_schema(
 }
 
 fn build_generics(
-    type_contents: &TypeContents<ValidatedFormDescriptor, ValidatedField>,
+    type_contents: &TypeContents<ValueSchemaDescriptor, ValidatedField>,
     generics: &Generics,
 ) -> Generics {
     let generics = add_bound(
         type_contents,
         generics,
         |f| !f.form_field.is_skipped(),
-        &parse_quote!(swim_common::form::ValidatedForm),
+        &parse_quote!(swim_common::form::ValueSchema),
     );
 
     add_bound(
diff --git a/swim_common/form_derive/src/validated_form/vf_parser.rs b/swim_common/form_derive/src/validated_form/vf_parser.rs
index 5b474959f..07da601e9 100644
--- a/swim_common/form_derive/src/validated_form/vf_parser.rs
+++ b/swim_common/form_derive/src/validated_form/vf_parser.rs
@@ -46,22 +46,22 @@ pub const OR_PATH: Symbol = Symbol("or");
 pub const NOT_PATH: Symbol = Symbol("not");
 
 #[derive(Debug)]
-pub struct ValidatedFormDescriptor {
+pub struct ValueSchemaDescriptor {
     pub label: Label,
     pub schema: StandardSchema,
     pub all_items: bool,
     pub form_descriptor: FormDescriptor,
 }
 
-impl ValidatedFormDescriptor {
-    /// Builds a [`ValidatedFormDescriptor`] for the provided [`DeriveInput`]. An errors encountered
+impl ValueSchemaDescriptor {
+    /// Builds a [`ValueSchemaDescriptor`] for the provided [`DeriveInput`]. An errors encountered
     /// while parsing the [`DeriveInput`] will be added to the [`Context`].
     pub fn from(
         context: &mut Context,
         attributes: Vec<NestedMeta>,
         kind: CompoundTypeKind,
         form_descriptor: FormDescriptor,
-    ) -> ValidatedFormDescriptor {
+    ) -> ValueSchemaDescriptor {
         let mut schema_opt = None;
         let mut all_items = false;
 
@@ -130,7 +130,7 @@ impl ValidatedFormDescriptor {
             _ => context.error_spanned_by(meta, "Unknown schema container attribute"),
         });
 
-        ValidatedFormDescriptor {
+        ValueSchemaDescriptor {
             label: form_descriptor.label.clone(),
             schema: schema_opt.unwrap_or(StandardSchema::None),
             all_items,
@@ -352,17 +352,17 @@ impl ToTokens for StandardSchema {
 }
 
 /// Converts between `TypeContents<'f, FormDescriptor, FormField<'f>>` and
-/// `TypeContents<'f, ValidatedFormDescriptor, ValidatedField<'f>>`. Parsing any attributes of the
+/// `TypeContents<'f, ValueSchemaDescriptor, ValidatedField<'f>>`. Parsing any attributes of the
 /// path `#[form(schema(..))]`.
 pub fn type_contents_to_validated<'f>(
     ctx: &mut Context,
     type_contents: TypeContents<'f, FormDescriptor, FormField<'f>>,
-) -> TypeContents<'f, ValidatedFormDescriptor, ValidatedField<'f>> {
+) -> TypeContents<'f, ValueSchemaDescriptor, ValidatedField<'f>> {
     match type_contents {
         TypeContents::Struct(repr) => TypeContents::Struct({
             let attrs = repr.input.attrs.get_attributes(ctx, FORM_PATH);
             let descriptor =
-                ValidatedFormDescriptor::from(ctx, attrs, repr.compound_type, repr.descriptor);
+                ValueSchemaDescriptor::from(ctx, attrs, repr.compound_type, repr.descriptor);
 
             StructRepr {
                 input: repr.input,
@@ -376,7 +376,7 @@ pub fn type_contents_to_validated<'f>(
                 .into_iter()
                 .map(|variant| {
                     let attrs = variant.syn_variant.attrs.get_attributes(ctx, FORM_PATH);
-                    let descriptor = ValidatedFormDescriptor::from(
+                    let descriptor = ValueSchemaDescriptor::from(
                         ctx,
                         attrs,
                         variant.compound_type,
@@ -409,7 +409,7 @@ fn map_fields_to_validated<'f, T>(
     loc: &T,
     context: &mut Context,
     fields: Vec<FormField<'f>>,
-    descriptor: &ValidatedFormDescriptor,
+    descriptor: &ValueSchemaDescriptor,
 ) -> Vec<ValidatedField<'f>>
 where
     T: ToTokens,
@@ -427,7 +427,7 @@ where
             let initial_schema = match &form_field.original.ty {
                 Type::Path(path) => {
                     let path = quote! {
-                        <#path as swim_common::form::ValidatedForm>
+                        <#path as swim_common::form::ValueSchema>
                     };
 
                     StandardSchema::Type(path)
diff --git a/swim_common/src/form/impls.rs b/swim_common/src/form/impls.rs
index ddb48b617..c53e0d015 100644
--- a/swim_common/src/form/impls.rs
+++ b/swim_common/src/form/impls.rs
@@ -17,7 +17,7 @@ use std::sync::Arc;
 
 use num_bigint::{BigInt, BigUint};
 
-use crate::form::ValidatedForm;
+use crate::form::ValueSchema;
 use crate::model::blob::Blob;
 use crate::model::schema::slot::SlotSchema;
 use crate::model::schema::{ItemSchema, StandardSchema};
@@ -27,55 +27,55 @@ use std::collections::{BTreeMap, HashMap};
 use std::hash::Hash;
 use std::mem::size_of;
 
-impl ValidatedForm for Blob {
+impl ValueSchema for Blob {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Data)
     }
 }
 
-impl ValidatedForm for BigInt {
+impl ValueSchema for BigInt {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::BigInt)
     }
 }
 
-impl ValidatedForm for BigUint {
+impl ValueSchema for BigUint {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::BigUint)
     }
 }
 
-impl ValidatedForm for f64 {
+impl ValueSchema for f64 {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Float64)
     }
 }
 
-impl ValidatedForm for i32 {
+impl ValueSchema for i32 {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Int32)
     }
 }
 
-impl ValidatedForm for i64 {
+impl ValueSchema for i64 {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Int64)
     }
 }
 
-impl ValidatedForm for u32 {
+impl ValueSchema for u32 {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::UInt32)
     }
 }
 
-impl ValidatedForm for u64 {
+impl ValueSchema for u64 {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::UInt64)
     }
 }
 
-impl ValidatedForm for usize {
+impl ValueSchema for usize {
     fn schema() -> StandardSchema {
         match size_of::<usize>() {
             4 => StandardSchema::OfKind(ValueKind::UInt32),
@@ -85,69 +85,69 @@ impl ValidatedForm for usize {
     }
 }
 
-impl ValidatedForm for bool {
+impl ValueSchema for bool {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Boolean)
     }
 }
 
-impl ValidatedForm for Text {
+impl ValueSchema for Text {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Text)
     }
 }
 
-impl<V> ValidatedForm for Option<V>
+impl<V> ValueSchema for Option<V>
 where
-    V: ValidatedForm,
+    V: ValueSchema,
 {
     fn schema() -> StandardSchema {
         StandardSchema::Or(vec![V::schema(), StandardSchema::OfKind(ValueKind::Extant)])
     }
 }
 
-impl ValidatedForm for String {
+impl ValueSchema for String {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Text)
     }
 }
 
-impl ValidatedForm for () {
+impl ValueSchema for () {
     fn schema() -> StandardSchema {
         StandardSchema::OfKind(ValueKind::Extant)
     }
 }
 
-impl<V> ValidatedForm for Cell<V>
+impl<V> ValueSchema for Cell<V>
 where
-    V: ValidatedForm + Copy,
+    V: ValueSchema + Copy,
 {
     fn schema() -> StandardSchema {
         StandardSchema::Or(vec![V::schema(), StandardSchema::OfKind(ValueKind::Extant)])
     }
 }
 
-impl<V> ValidatedForm for RefCell<V>
+impl<V> ValueSchema for RefCell<V>
 where
-    V: ValidatedForm + Copy,
+    V: ValueSchema + Copy,
 {
     fn schema() -> StandardSchema {
         StandardSchema::Or(vec![V::schema(), StandardSchema::OfKind(ValueKind::Extant)])
     }
 }
 
-impl<V> ValidatedForm for Box<V>
+impl<V> ValueSchema for Box<V>
 where
-    V: ValidatedForm,
+    V: ValueSchema,
 {
     fn schema() -> StandardSchema {
         V::schema()
     }
 }
 
-impl<V> ValidatedForm for Arc<V>
+impl<V> ValueSchema for Arc<V>
 where
-    V: ValidatedForm,
+    V: ValueSchema,
 {
     fn schema() -> StandardSchema {
         V::schema()
@@ -157,10 +157,10 @@ where
 macro_rules! impl_seq_val_form {
     ($ty:ident < V $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident $(+ $bound2:ident)*)* >) => {
 
-        impl<V $(, $typaram)*> ValidatedForm for $ty<V $(, $typaram)*>
+        impl<V $(, $typaram)*> ValueSchema for $ty<V $(, $typaram)*>
         where
-            V: ValidatedForm $(+ $tbound1 $(+ $tbound2)*)*,
-            $($typaram: ValidatedForm + $bound $(+ $bound2)*,)*
+            V: ValueSchema $(+ $tbound1 $(+ $tbound2)*)*,
+            $($typaram: ValueSchema + $bound $(+ $bound2)*,)*
         {
             fn schema() -> StandardSchema {
                 StandardSchema::AllItems(Box::new(ItemSchema::ValueItem(V::schema())))
@@ -171,7 +171,7 @@ macro_rules! impl_seq_val_form {
 
 impl_seq_val_form!(Vec<V>);
 
-impl<K: Ord + ValidatedForm, V: ValidatedForm> ValidatedForm for BTreeMap<K, V> {
+impl<K: Ord + ValueSchema, V: ValueSchema> ValueSchema for BTreeMap<K, V> {
     fn schema() -> StandardSchema {
         StandardSchema::AllItems(Box::new(ItemSchema::Field(SlotSchema::new(
             K::schema(),
@@ -180,7 +180,7 @@ impl<K: Ord + ValidatedForm, V: ValidatedForm> ValidatedForm for BTreeMap<K, V>
     }
 }
 
-impl<K: Eq + Hash + ValidatedForm, V: ValidatedForm, H> ValidatedForm for HashMap<K, V, H> {
+impl<K: Eq + Hash + ValueSchema, V: ValueSchema, H> ValueSchema for HashMap<K, V, H> {
     fn schema() -> StandardSchema {
         StandardSchema::AllItems(Box::new(ItemSchema::Field(SlotSchema::new(
             K::schema(),
diff --git a/swim_common/src/form/mod.rs b/swim_common/src/form/mod.rs
index 5a34908b2..107fbebf6 100644
--- a/swim_common/src/form/mod.rs
+++ b/swim_common/src/form/mod.rs
@@ -16,7 +16,7 @@
 
 #[doc(hidden)]
 #[allow(unused_imports)]
-pub use form_derive::{Form, ValidatedForm};
+pub use form_derive::{Form, ValueSchema};
 
 use crate::form::structural::read::recognizer::{MappedRecognizer, RecognizerReadable};
 use crate::form::structural::read::{ReadError, StructuralReadable};
@@ -324,7 +324,7 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// See `StandardSchema` for details of schema variants.
 ///
-/// # How can I implement `ValidatedForm`?
+/// # How can I implement `ValueSchema`?
 /// # Structures
 /// Given the following `struct` and its expected value:
 ///
@@ -352,7 +352,7 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// is:
 /// ```
 /// use swim_common::model::{Attr, Item, Value, ValueKind};
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::schema::{StandardSchema, ItemSchema, Schema};
 /// use swim_common::model::schema::attr::AttrSchema;
 /// use swim_common::model::schema::slot::SlotSchema;
@@ -362,7 +362,7 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///     name: String,
 /// }
 ///
-/// impl ValidatedForm for Cat {
+/// impl ValueSchema for Cat {
 ///     fn schema() -> StandardSchema {
 ///        StandardSchema::HeadAttribute {
 ///            schema: Box::new(AttrSchema::named(
@@ -393,11 +393,11 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// ```
 ///
 /// # Enumerations
-/// Implementing `ValidatedForm` for enumerations works the same way as structures except that the
+/// Implementing `ValueSchema` for enumerations works the same way as structures except that the
 /// variants are logically OR'd together as a schema.
 /// ```
 /// use swim_common::model::{Attr, Item, Value, ValueKind};
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::schema::{StandardSchema, ItemSchema, Schema};
 /// use swim_common::model::schema::attr::AttrSchema;
 /// use swim_common::model::schema::slot::SlotSchema;
@@ -409,7 +409,7 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///     Pasta,
 /// }
 ///
-/// impl ValidatedForm for Food {
+/// impl ValueSchema for Food {
 ///     fn schema() -> StandardSchema {
 ///         StandardSchema::Or(vec![
 ///             StandardSchema::HeadAttribute {
@@ -453,9 +453,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// assert!(Food::schema().matches(&food));
 /// ```
 ///
-/// # Deriving `ValidatedForm`
-/// The `ValidatedForm` trait can also be used with `#[derive]` if all of the fields implement
-/// `ValidatedForm` and the implementor also implements `Form` (as required by the `ValidatedForm`
+/// # Deriving `ValueSchema`
+/// The `ValueSchema` trait can also be used with `#[derive]` if all of the fields implement
+/// `ValueSchema` and the implementor also implements `Form` (as required by the `ValueSchema`
 /// trait).
 ///
 /// The derive macro supports all of the `StandardSchema` variants in a Snake Case format except
@@ -465,18 +465,18 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// Derived schemas mandate that all fields are present and exhaustive validation is performed.
 ///
 /// ## Usage
-/// Any `struct` or `enum` annotated with `#[derive(ValidatedForm)]` will have a schema derived for
+/// Any `struct` or `enum` annotated with `#[derive(ValueSchema)]` will have a schema derived for
 /// it based on its fields. Fields not attributed with `#[form(schema(..)]` will use the type's
-/// implementation of `ValidatedForm`.
+/// implementation of `ValueSchema`.
 ///
 /// ```
 /// use swim_common::model::{Attr, Item, Value, ValueKind};
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::schema::{StandardSchema, ItemSchema, Schema};
 /// use swim_common::model::schema::attr::AttrSchema;
 /// use swim_common::model::schema::slot::SlotSchema;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// #[form(tag = "Structure")]
 /// struct S {
 ///     a: i32,
@@ -508,19 +508,19 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// ```
 ///
 /// ## Attributes
-/// The `ValidatedForm` macro supports attributes in the path of `#[form(schema(..))]`.
+/// The `ValueSchema` macro supports attributes in the path of `#[form(schema(..))]`.
 ///
 /// The derive macro supports all the attributes that the `Form` derive macro supports. With the
 /// exception of any field marked as `#[form(skip)]` may not also contain a schema.
 ///
-/// Similar to the `Form` derive, `ValidatedForm` derivation supports attributes at `struct`,
+/// Similar to the `Form` derive, `ValueSchema` derivation supports attributes at `struct`,
 /// variant, and field level placement. Detail on attributes that support this is listed below.
 ///
 /// ### anything
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// #[form(schema(anything))]
 /// struct S {
 ///     a: i32,
@@ -533,9 +533,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### nothing
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// #[form(schema(nothing))]
 /// struct S {
 ///     a: i32,
@@ -548,10 +548,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### num_attrs
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::Value;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(num_attrs = 5))]
 ///     value: Value
@@ -561,10 +561,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### num_items
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::Value;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(num_items = 5))]
 ///     value: Value
@@ -574,10 +574,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### of_kind
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::{Value, ValueKind};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(of_kind(ValueKind::Int32)))]
 ///     value: Value
@@ -587,14 +587,14 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### equal
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::Value;
 ///
 /// fn equals_i32_max() -> Value {
 ///     Value::Int32Value(i32::max_value())
 /// }
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(equal = "equals_i32_max"))]
 ///     value: i32
@@ -605,9 +605,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### text
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(text = "Swim"))]
 ///     string: String
@@ -617,9 +617,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### non_nan
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(non_nan))]
 ///     f: f64
@@ -629,9 +629,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### finite
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(finite))]
 ///     f: f64
@@ -651,9 +651,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// for deriving ranges.
 ///
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(int_range = "0..=10"))]
 ///     range: i32,
@@ -665,10 +665,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// writes the argument as a layout
 ///
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::ValueKind;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// #[form(schema(all_items(of_kind(ValueKind::Int32))))]
 /// struct S {
 ///     a: i32,
@@ -678,10 +678,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// ```
 /// Is equivalent to:
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::ValueKind;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(of_kind(ValueKind::Int32)))]
 ///     a: i32,
@@ -694,10 +694,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### and
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::ValueKind;
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(and(of_kind(ValueKind::Text), text = "swim")))]
 ///     company: String
@@ -707,10 +707,10 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### or
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 /// use swim_common::model::{Value, ValueKind};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(or(of_kind(ValueKind::Int32), of_kind(ValueKind::Int64))))]
 ///     value: Value
@@ -720,9 +720,9 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 ///
 /// ### not
 /// ```
-/// use swim_common::form::{Form, ValidatedForm};
+/// use swim_common::form::{Form, ValueSchema};
 ///
-/// #[derive(Form, ValidatedForm)]
+/// #[derive(Form, ValueSchema)]
 /// struct S {
 ///     #[form(schema(not(int_range = "0..=10")))]
 ///     range: i32,
@@ -730,13 +730,13 @@ impl<T: StructuralReadable + StructuralWritable> Form for T {}
 /// ```
 /// Negates the result of a schema.
 ///
-pub trait ValidatedForm {
+pub trait ValueSchema {
     /// A schema for the form. If the schema returns true for a `Value` the form should be able
     /// to create an instance of the type from the `Value` without generating an error.
     fn schema() -> StandardSchema;
 }
 
-impl ValidatedForm for Value {
+impl ValueSchema for Value {
     fn schema() -> StandardSchema {
         StandardSchema::Anything
     }
diff --git a/swim_common/src/model/time/mod.rs b/swim_common/src/model/time/mod.rs
index 74c1aed03..984c712f2 100644
--- a/swim_common/src/model/time/mod.rs
+++ b/swim_common/src/model/time/mod.rs
@@ -19,7 +19,7 @@ use crate::form::structural::read::recognizer::{
 };
 use crate::form::structural::read::ReadError;
 use crate::form::structural::write::{PrimitiveWriter, StructuralWritable, StructuralWriter};
-use crate::form::ValidatedForm;
+use crate::form::ValueSchema;
 use crate::model::schema::StandardSchema;
 use crate::model::ValueKind;
 use chrono::{DateTime, LocalResult, TimeZone, Utc};
@@ -147,7 +147,7 @@ impl Recognizer for TimestampRecognizer {
     fn reset(&mut self) {}
 }
 
-impl ValidatedForm for Timestamp {
+impl ValueSchema for Timestamp {
     fn schema() -> StandardSchema {
         StandardSchema::Or(vec![
             StandardSchema::OfKind(ValueKind::Int64),
diff --git a/swim_warp/src/model/map.rs b/swim_warp/src/model/map.rs
index 7f4c4756c..5e5038027 100644
--- a/swim_warp/src/model/map.rs
+++ b/swim_warp/src/model/map.rs
@@ -14,11 +14,11 @@
 
 use std::sync::Arc;
 use swim_common::form::Form;
-use swim_common::form::ValidatedForm;
+use swim_common::form::ValueSchema;
 use swim_common::model::Value;
 
 /// Updates that can be applied to a map lane.
-#[derive(Debug, PartialEq, Eq, Form, ValidatedForm, Clone)]
+#[derive(Debug, PartialEq, Eq, Form, ValueSchema, Clone)]
 pub enum MapUpdate<K, V> {
     #[form(tag = "update")]
     Update(#[form(header, name = "key")] K, #[form(body)] Arc<V>),


Test patch:
diff --git a/swim_client/src/downlink/model/map/tests.rs b/swim_client/src/downlink/model/map/tests.rs
index 945479efc..d00562fbb 100644
--- a/swim_client/src/downlink/model/map/tests.rs
+++ b/swim_client/src/downlink/model/map/tests.rs
@@ -16,7 +16,7 @@ use num_bigint::{BigInt, BigUint};
 
 use super::*;
 use swim_common::form::structural::read::ReadError;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::Schema;
 use swim_common::model::{Attr, Item};
 
@@ -239,7 +239,7 @@ pub fn map_modification_schema() {
         vec![Item::slot("a", true)],
     );
 
-    let schema = <UntypedMapModification<Value> as ValidatedForm>::schema();
+    let schema = <UntypedMapModification<Value> as ValueSchema>::schema();
 
     assert!(schema.matches(&clear));
     assert!(schema.matches(&take));
diff --git a/swim_client/src/downlink/state_machine/command/tests/mod.rs b/swim_client/src/downlink/state_machine/command/tests/mod.rs
index 26367b137..00fb2f549 100644
--- a/swim_client/src/downlink/state_machine/command/tests/mod.rs
+++ b/swim_client/src/downlink/state_machine/command/tests/mod.rs
@@ -14,7 +14,7 @@
 
 use super::*;
 use crate::downlink::Command;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::ValueKind;
 
 #[test]
diff --git a/swim_client/src/downlink/typed/command/tests.rs b/swim_client/src/downlink/typed/command/tests.rs
index dc372e7d3..2f42d9c9f 100644
--- a/swim_client/src/downlink/typed/command/tests.rs
+++ b/swim_client/src/downlink/typed/command/tests.rs
@@ -18,7 +18,7 @@ use crate::downlink::Command;
 use crate::downlink::DownlinkConfig;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use swim_common::form::ValidatedForm;
+use swim_common::form::ValueSchema;
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::sink::item::ItemSender;
@@ -29,7 +29,7 @@ struct Components<T> {
     command_rx: mpsc::Receiver<Command<Value>>,
 }
 
-fn make_command_downlink<T: ValidatedForm>() -> Components<T> {
+fn make_command_downlink<T: ValueSchema>() -> Components<T> {
     let (command_tx, command_rx) = mpsc::channel(8);
     let sender = swim_common::sink::item::for_mpsc_sender(command_tx).map_err_into();
 
diff --git a/swim_client/src/downlink/typed/event/tests.rs b/swim_client/src/downlink/typed/event/tests.rs
index 6daf8830c..0a5785768 100644
--- a/swim_client/src/downlink/typed/event/tests.rs
+++ b/swim_client/src/downlink/typed/event/tests.rs
@@ -25,7 +25,7 @@ use std::convert::TryInto;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
 use swim_common::form::structural::read::ReadError;
-use swim_common::form::ValidatedForm;
+use swim_common::form::ValueSchema;
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::routing::RoutingError;
@@ -267,7 +267,7 @@ struct Components<T> {
     command_rx: mpsc::Receiver<Command<()>>,
 }
 
-fn make_event_downlink<T: ValidatedForm>() -> Components<T> {
+fn make_event_downlink<T: ValueSchema>() -> Components<T> {
     let (update_tx, update_rx) = mpsc::channel(8);
     let (command_tx, command_rx) = mpsc::channel(8);
     let sender = swim_common::sink::item::for_mpsc_sender(command_tx).map_err_into();
diff --git a/swim_client/src/downlink/typed/map/tests.rs b/swim_client/src/downlink/typed/map/tests.rs
index 464d6f33a..d870a1e37 100644
--- a/swim_client/src/downlink/typed/map/tests.rs
+++ b/swim_client/src/downlink/typed/map/tests.rs
@@ -25,7 +25,7 @@ use futures::future::join;
 use im::OrdMap;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use swim_common::form::ValidatedForm;
+use swim_common::form::ValueSchema;
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::routing::RoutingError;
@@ -524,7 +524,7 @@ struct Components<K, V> {
     command_rx: mpsc::Receiver<Command<UntypedMapModification<Value>>>,
 }
 
-fn make_map_downlink<K: ValidatedForm, V: ValidatedForm>() -> Components<K, V> {
+fn make_map_downlink<K: ValueSchema, V: ValueSchema>() -> Components<K, V> {
     let (update_tx, update_rx) = mpsc::channel(8);
     let (command_tx, command_rx) = mpsc::channel(8);
     let sender = swim_common::sink::item::for_mpsc_sender(command_tx).map_err_into();
diff --git a/swim_client/src/downlink/typed/value/tests.rs b/swim_client/src/downlink/typed/value/tests.rs
index cc40fce59..d07942433 100644
--- a/swim_client/src/downlink/typed/value/tests.rs
+++ b/swim_client/src/downlink/typed/value/tests.rs
@@ -22,7 +22,7 @@ use crate::downlink::{DownlinkConfig, DownlinkError};
 use futures::future::join;
 use std::num::NonZeroUsize;
 use std::sync::Arc;
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::schema::StandardSchema;
 use swim_common::model::Value;
 use swim_common::routing::RoutingError;
@@ -208,7 +208,7 @@ struct Components<T> {
     command_rx: mpsc::Receiver<Command<SharedValue>>,
 }
 
-fn make_value_downlink<T: Form + ValidatedForm>(init: T) -> Components<T> {
+fn make_value_downlink<T: Form + ValueSchema>(init: T) -> Components<T> {
     let init_value = init.into_value();
 
     let (update_tx, update_rx) = mpsc::channel(8);
diff --git a/swim_common/src/form/tests/derive/validated_form/all_items_op_arg_count.rs b/swim_common/src/form/tests/derive/validated_form/all_items_op_arg_count.rs
index d99009b07..60280d0df 100644
--- a/swim_common/src/form/tests/derive/validated_form/all_items_op_arg_count.rs
+++ b/swim_common/src/form/tests/derive/validated_form/all_items_op_arg_count.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(all_items(num_items = 5, num_attrs = 5)))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/all_items_skipped.rs b/swim_common/src/form/tests/derive/validated_form/all_items_skipped.rs
index 90962bdaf..6bbb30967 100644
--- a/swim_common/src/form/tests/derive/validated_form/all_items_skipped.rs
+++ b/swim_common/src/form/tests/derive/validated_form/all_items_skipped.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S {
         #[form(skip)]
diff --git a/swim_common/src/form/tests/derive/validated_form/all_items_unit.rs b/swim_common/src/form/tests/derive/validated_form/all_items_unit.rs
index 4a82d44de..cac9fe486 100644
--- a/swim_common/src/form/tests/derive/validated_form/all_items_unit.rs
+++ b/swim_common/src/form/tests/derive/validated_form/all_items_unit.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(num_items = 5)))]
     struct S;
 }
diff --git a/swim_common/src/form/tests/derive/validated_form/and_op_arg_count.rs b/swim_common/src/form/tests/derive/validated_form/and_op_arg_count.rs
index 87ce450c8..1efd89a72 100644
--- a/swim_common/src/form/tests/derive/validated_form/and_op_arg_count.rs
+++ b/swim_common/src/form/tests/derive/validated_form/and_op_arg_count.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(and(num_items = 5)))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/enum_body_with_schema.rs b/swim_common/src/form/tests/derive/validated_form/enum_body_with_schema.rs
index d679ab84a..864d5c3c0 100644
--- a/swim_common/src/form/tests/derive/validated_form/enum_body_with_schema.rs
+++ b/swim_common/src/form/tests/derive/validated_form/enum_body_with_schema.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum E {
         #[form(tag = "Enumeration")]
         A {
diff --git a/swim_common/src/form/tests/derive/validated_form/generic_no_default.rs b/swim_common/src/form/tests/derive/validated_form/generic_no_default.rs
index 04b2af79a..e8cf3197e 100644
--- a/swim_common/src/form/tests/derive/validated_form/generic_no_default.rs
+++ b/swim_common/src/form/tests/derive/validated_form/generic_no_default.rs
@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use swim_common::form::{Form, ValidatedForm};
+use swim_common::form::{Form, ValueSchema};
 use swim_common::model::ValueKind;
 
 fn main() {
     struct Invalid;
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S<F> {
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/generic_no_default.stderr b/swim_common/src/form/tests/derive/validated_form/generic_no_default.stderr
index 49cc675c5..0dd9815e2 100644
--- a/swim_common/src/form/tests/derive/validated_form/generic_no_default.stderr
+++ b/swim_common/src/form/tests/derive/validated_form/generic_no_default.stderr
@@ -21,12 +21,12 @@ error[E0599]: the method `as_value` exists for struct `S<main::Invalid>`, but it
 error[E0277]: the trait bound `F: Default` is not satisfied
   --> $DIR/generic_no_default.rs:21:14
    |
-21 |     #[derive(Form, ValidatedForm)]
+21 |     #[derive(Form, ValueSchema)]
    |              ^^^^ the trait `Default` is not implemented for `F`
    |
    = note: required by `std::default::Default::default`
    = note: this error originates in the derive macro `Form` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: consider further restricting this bound
    |
-21 |     #[derive(Form + std::default::Default, ValidatedForm)]
+21 |     #[derive(Form + std::default::Default, ValueSchema)]
    |                   ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/swim_common/src/form/tests/derive/validated_form/invalid_container_of_kind.rs b/swim_common/src/form/tests/derive/validated_form/invalid_container_of_kind.rs
index 00dfa3463..a4fcfd863 100644
--- a/swim_common/src/form/tests/derive/validated_form/invalid_container_of_kind.rs
+++ b/swim_common/src/form/tests/derive/validated_form/invalid_container_of_kind.rs
@@ -16,7 +16,7 @@ use form_derive::*;
 use swim_common::model::ValueKind;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::ThisIsntValid))))]
     struct S {
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/invalid_range.rs b/swim_common/src/form/tests/derive/validated_form/invalid_range.rs
index ea3c1cf49..38a1c16d8 100644
--- a/swim_common/src/form/tests/derive/validated_form/invalid_range.rs
+++ b/swim_common/src/form/tests/derive/validated_form/invalid_range.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(int_range = "0...1.."))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/not_op_arg_count.rs b/swim_common/src/form/tests/derive/validated_form/not_op_arg_count.rs
index 57854e723..07c0e7cf7 100644
--- a/swim_common/src/form/tests/derive/validated_form/not_op_arg_count.rs
+++ b/swim_common/src/form/tests/derive/validated_form/not_op_arg_count.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(not(num_items = 5, num_attrs = 100)))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/nothing_attr_on_field.rs b/swim_common/src/form/tests/derive/validated_form/nothing_attr_on_field.rs
index 91c27aaaf..f6cf387b4 100644
--- a/swim_common/src/form/tests/derive/validated_form/nothing_attr_on_field.rs
+++ b/swim_common/src/form/tests/derive/validated_form/nothing_attr_on_field.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(nothing))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/or_op_arg_count.rs b/swim_common/src/form/tests/derive/validated_form/or_op_arg_count.rs
index 5a5872b38..f93eaf1fd 100644
--- a/swim_common/src/form/tests/derive/validated_form/or_op_arg_count.rs
+++ b/swim_common/src/form/tests/derive/validated_form/or_op_arg_count.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(or(num_items = 5)))]
         a: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/schema_skipped_field.rs b/swim_common/src/form/tests/derive/validated_form/schema_skipped_field.rs
index 48614f068..1d0477fc6 100644
--- a/swim_common/src/form/tests/derive/validated_form/schema_skipped_field.rs
+++ b/swim_common/src/form/tests/derive/validated_form/schema_skipped_field.rs
@@ -15,7 +15,7 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(skip, schema(num_items = 1))]
         f: i32,
diff --git a/swim_common/src/form/tests/derive/validated_form/struct_body_with_schema.rs b/swim_common/src/form/tests/derive/validated_form/struct_body_with_schema.rs
index 4a5f65f3e..a2e4cd6b5 100644
--- a/swim_common/src/form/tests/derive/validated_form/struct_body_with_schema.rs
+++ b/swim_common/src/form/tests/derive/validated_form/struct_body_with_schema.rs
@@ -15,6 +15,6 @@
 use form_derive::*;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S(#[form(body, schema(equal = "i64_eq"))] i64);
 }
diff --git a/swim_common/src/form/tests/derive/validated_form/trailing_schema.rs b/swim_common/src/form/tests/derive/validated_form/trailing_schema.rs
index 7f56997e8..ddaf4071f 100644
--- a/swim_common/src/form/tests/derive/validated_form/trailing_schema.rs
+++ b/swim_common/src/form/tests/derive/validated_form/trailing_schema.rs
@@ -16,7 +16,7 @@ use form_derive::*;
 use swim_common::model::Value;
 
 fn main() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(num_items = 2, num_attrs = 3))]
         a: Value,
diff --git a/swim_common/src/form/tests/validated.rs b/swim_common/src/form/tests/validated.rs
index a57884f9e..198c19c3b 100644
--- a/swim_common/src/form/tests/validated.rs
+++ b/swim_common/src/form/tests/validated.rs
@@ -17,7 +17,7 @@ use num_traits::Float;
 
 use crate::form::structural::Tag;
 use crate::form::Form;
-use crate::form::ValidatedForm;
+use crate::form::ValueSchema;
 use crate::model::schema::attr::AttrSchema;
 use crate::model::schema::slot::SlotSchema;
 use crate::model::schema::text::TextSchema;
@@ -36,7 +36,7 @@ mod swim_common {
 
 #[test]
 fn test_tag() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S;
 
     let expected_schema = StandardSchema::HeadAttribute {
@@ -59,7 +59,7 @@ fn test_tag() {
 
 #[test]
 fn all_items_named() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S {
         a: i32,
@@ -116,7 +116,7 @@ fn all_items_named() {
 
 #[test]
 fn all_items_tuple() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S(i32, i64);
 
@@ -157,7 +157,7 @@ fn all_items_tuple() {
 
 #[test]
 fn all_items_new_type() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S(i32);
 
@@ -192,7 +192,7 @@ fn all_items_new_type() {
 
 #[test]
 fn text() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(text = "swim"))]
         a: String,
@@ -228,7 +228,7 @@ fn text() {
 
 #[test]
 fn num_items_attrs() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(and(num_items = 2, num_attrs = 3)))]
         a: Value,
@@ -273,7 +273,7 @@ fn num_items_attrs() {
 
 #[test]
 fn num_items() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(num_items = 2))]
         a: Value,
@@ -315,7 +315,7 @@ fn num_items() {
 
 #[test]
 fn num_attrs() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(num_attrs = 3))]
         a: Value,
@@ -355,7 +355,7 @@ fn and() {
         Value::text("text")
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(and(of_kind(ValueKind::Text), equal = "s_value")))]
         a: String,
@@ -398,7 +398,7 @@ fn field_equal() {
         Value::Int32Value(1)
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(equal = "field_expected"))]
         a: Value,
@@ -443,7 +443,7 @@ fn field_equal() {
 
 #[test]
 fn not() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(not(of_kind(ValueKind::Text))))]
         a: Value,
@@ -489,7 +489,7 @@ fn or() {
         Value::text("text")
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(or(of_kind(ValueKind::Int32), equal = "s_value")))]
         a: String,
@@ -540,7 +540,7 @@ fn generic_value() {
         Value::Int32Value(i32::max_value())
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S<F> {
         #[form(schema(equal = "expected"))]
         f: F,
@@ -583,7 +583,7 @@ fn generic_value() {
 
 #[test]
 fn tuple_struct() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S(i32, i64, String);
 
     let expected_schema = StandardSchema::HeadAttribute {
@@ -611,7 +611,7 @@ fn tuple_struct_attrs() {
         Value::Int64Value(i64::max_value())
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S(
         #[form(schema(of_kind(ValueKind::Int32)))] i32,
         #[form(schema(equal = "int_eq"))] i64,
@@ -642,7 +642,7 @@ fn tuple_struct_attrs() {
 
 #[test]
 fn unit_struct() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S;
 
     let expected_schema = StandardSchema::HeadAttribute {
@@ -662,7 +662,7 @@ fn unit_struct() {
 
 #[test]
 fn field_anything() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         a: i32,
         #[form(schema(anything))]
@@ -707,7 +707,7 @@ fn field_anything() {
 
 #[test]
 fn field_non_nan() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(non_nan))]
         f: f64,
@@ -752,7 +752,7 @@ fn field_non_nan() {
 
 #[test]
 fn field_finite() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(finite))]
         f: f64,
@@ -797,7 +797,7 @@ fn field_finite() {
 
 #[test]
 fn complex() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(or(
             and(of_kind(ValueKind::Record), num_attrs = 1, num_items = 2),
@@ -862,7 +862,7 @@ fn complex() {
 
 #[test]
 fn int_range_inclusive() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(int_range = "0..=10"))]
         f: i64,
@@ -897,7 +897,7 @@ fn int_range_inclusive() {
 
 #[test]
 fn uint_range_inclusive() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(uint_range = "0..=10"))]
         f: u64,
@@ -931,7 +931,7 @@ fn uint_range_inclusive() {
 
 #[test]
 fn int_range() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(int_range = "0..10"))]
         f: i64,
@@ -967,7 +967,7 @@ fn int_range() {
 
 #[test]
 fn float_range_inclusive() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(float_range = "0.0..=10.1"))]
         f: f64,
@@ -1001,7 +1001,7 @@ fn float_range_inclusive() {
 
 #[test]
 fn float_range() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(float_range = "0..10"))]
         f: f64,
@@ -1037,7 +1037,7 @@ fn float_range() {
 
 #[test]
 fn uint_range() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(uint_range = "0..10"))]
         f: u64,
@@ -1072,7 +1072,7 @@ fn uint_range() {
 
 #[test]
 fn big_int_range_inclusive() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(big_int_range = "123456..=789101112"))]
         f: BigInt,
@@ -1130,7 +1130,7 @@ fn big_int_range_inclusive() {
 
 #[test]
 fn big_int_range() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(schema(big_int_range = "100..300"))]
         f: BigInt,
@@ -1191,7 +1191,7 @@ fn big_int_range() {
 
 #[test]
 fn container_anything() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(anything))]
     struct S {
         a: i32,
@@ -1237,7 +1237,7 @@ fn container_anything() {
 
 #[test]
 fn container_nothing() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(nothing))]
     struct S {
         a: i32,
@@ -1287,7 +1287,7 @@ fn form_header_body() {
         Value::Int32Value(i32::max_value())
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         a: i32,
         #[form(header_body, schema(equal = "eq"))]
@@ -1318,7 +1318,7 @@ fn form_header_body() {
 
 #[test]
 fn form_attr() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         a: i32,
         #[form(attr, schema(int_range = "0..=11"))]
@@ -1358,7 +1358,7 @@ fn form_attr() {
 
 #[test]
 fn form_header() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         #[form(header_body)]
         a: i32,
@@ -1398,7 +1398,7 @@ fn form_header() {
 
 #[test]
 fn form_body() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         a: i32,
         #[form(body)]
@@ -1429,7 +1429,7 @@ fn form_body() {
 
 #[test]
 fn form_single_enum() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum E {
         A,
     }
@@ -1455,7 +1455,7 @@ fn form_single_enum() {
 
 #[test]
 fn form_enum_tag() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum E {
         #[form(tag = "Enumeration")]
         A,
@@ -1482,7 +1482,7 @@ fn form_enum_tag() {
 
 #[test]
 fn form_enum_variants() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum E {
         UnitEnum,
         NewTypeEnum(i32),
@@ -1587,7 +1587,7 @@ fn form_enum_variants() {
 
 #[test]
 fn form_enum_attrs() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum E {
         #[form(tag = "Enumeration")]
         A {
@@ -1644,7 +1644,7 @@ fn form_enum_attrs() {
 
 #[test]
 fn test_vector() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         v: Vec<i32>,
     }
@@ -1664,7 +1664,7 @@ fn test_vector() {
             items: vec![(
                 ItemSchema::Field(SlotSchema::new(
                     StandardSchema::text("v"),
-                    <Vec<i32> as ValidatedForm>::schema(),
+                    <Vec<i32> as ValueSchema>::schema(),
                 )),
                 true,
             )],
@@ -1679,7 +1679,7 @@ fn test_vector() {
 
 #[test]
 fn test_hash_map() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct S {
         v: HashMap<String, i32>,
     }
@@ -1705,7 +1705,7 @@ fn test_hash_map() {
             items: vec![(
                 ItemSchema::Field(SlotSchema::new(
                     StandardSchema::text("v"),
-                    <HashMap<String, i32> as ValidatedForm>::schema(),
+                    <HashMap<String, i32> as ValueSchema>::schema(),
                 )),
                 true,
             )],
@@ -1720,7 +1720,7 @@ fn test_hash_map() {
 
 #[test]
 fn test_nested() {
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     struct Parent {
         a: i32,
         b: Child,
@@ -1728,7 +1728,7 @@ fn test_nested() {
         e: f64,
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     enum Child {
         ChildA,
         ChildB { c: i32, d: f64 },
@@ -1820,7 +1820,7 @@ fn tagged() {
         Trace,
     }
 
-    #[derive(Form, ValidatedForm)]
+    #[derive(Form, ValueSchema)]
     #[form(schema(all_items(of_kind(ValueKind::Int32))))]
     struct S {
         #[form(tag)]
@@ -1884,7 +1884,7 @@ fn tagged() {
 
 #[test]
 pub fn map_modification_schema() {
-    #[derive(Debug, PartialEq, Eq, Form, ValidatedForm, Clone)]
+    #[derive(Debug, PartialEq, Eq, Form, ValueSchema, Clone)]
     pub enum ValidatedMapUpdate<K, V> {
         #[form(tag = "update")]
         Update(#[form(header, name = "key")] K, #[form(body)] Arc<V>),