src/controls/button.rs

@@ -20,7 +20,7 @@ impl<FD: FormToolData> Default for ButtonData<FD> {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn button(
         mut self,
         builder: impl Fn(ButtonBuilder<FD, FS>) -> ButtonBuilder<FD, FS>,

src/controls/checkbox.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
+use super::{ControlBuilder, ControlData, ControlRenderData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct CheckboxData {
     pub(crate) name: String,
@@ -22,10 +23,12 @@ impl ControlData for CheckboxData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn checkbox<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, CheckboxData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, CheckboxData, FDT>,
+        ) -> ControlBuilder<FD, FS, CheckboxData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/custom.rs

@@ -1,7 +1,7 @@
-use super::{BuilderFn, ControlBuilder, ControlData};
+use super::{ControlBuilder, ControlData};
 use crate::{styles::FormStyle, FormBuilder, FormToolData};
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn custom<CC: ControlData, FDT: Clone + PartialEq + 'static>(
         mut self,
         control_data: CC,
@@ -15,7 +15,7 @@ impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
 
     pub fn custom_default<CC: Default + ControlData, FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, CC, FDT>, CX>,
+        builder: impl Fn(ControlBuilder<FD, FS, CC, FDT>) -> ControlBuilder<FD, FS, CC, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/group.rs

@@ -2,17 +2,11 @@ use super::ValidationCb;
 use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{CollectView, RwSignal};
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
-    pub fn group(
+    pub fn group(mut self, builder: impl Fn(FormBuilder<FD, FS>) -> FormBuilder<FD, FS>) -> Self {
-        mut self,
+        let mut group_builder = FormBuilder::new();
-        builder: impl Fn(FormBuilder<FD, FS, CX>) -> FormBuilder<FD, FS, CX>,
-    ) -> Self {
-        let mut group_builder = FormBuilder::new(self.cx);
         group_builder = builder(group_builder);
 
-        // Take context back
-        self.cx = group_builder.cx;
-
         for validation in group_builder.validations {
             self.validations.push(validation);
         }

src/controls/heading.rs

@@ -1,4 +1,4 @@
-use super::{BuilderFn, ControlRenderData, VanityControlBuilder, VanityControlData};
+use super::{ControlRenderData, VanityControlBuilder, VanityControlData};
 use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::View;
 
@@ -17,10 +17,12 @@ impl VanityControlData for HeadingData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn heading(
         self,
-        builder: impl BuilderFn<VanityControlBuilder<FD, FS, HeadingData>, CX>,
+        builder: impl Fn(
+            VanityControlBuilder<FD, FS, HeadingData>,
+        ) -> VanityControlBuilder<FD, FS, HeadingData>,
     ) -> Self {
         self.new_vanity(builder)
     }

src/controls/hidden.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
+use super::{ControlBuilder, ControlData, ControlRenderData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct HiddenData;
 
@@ -19,10 +20,12 @@ impl ControlData for HiddenData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn hidden<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, HiddenData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, HiddenData, FDT>,
+        ) -> ControlBuilder<FD, FS, HiddenData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/mod.rs

@@ -18,7 +18,6 @@ pub mod submit;
 pub mod text_area;
 pub mod text_input;
 
-pub trait BuilderFn<B, CX>: Fn(B, &CX) -> B {}
 pub trait ValidationFn<FDT>: Fn(&FDT) -> Result<(), String> + 'static {}
 pub trait ValidationCb: Fn() -> bool + 'static {}
 pub trait ParseFn<CR, FDT>: Fn(CR) -> Result<FDT, String> + 'static {}
@@ -31,7 +30,6 @@ pub trait RenderFn<FS, FD>:
 }
 
 // implement the traits for all valid types
-impl<B, CX, T> BuilderFn<B, CX> for T where T: Fn(B, &CX) -> B {}
 impl<FDT, T> ValidationFn<FDT> for T where T: Fn(&FDT) -> Result<(), String> + 'static {}
 impl<T> ValidationCb for T where T: Fn() -> bool + 'static {}
 impl<CR, FDT, F> ParseFn<CR, FDT> for F where F: Fn(CR) -> Result<FDT, String> + 'static {}

src/controls/output.rs

@@ -1,9 +1,8 @@
-use super::{
-    BuilderFn, ControlRenderData, GetterVanityControlData, VanityControlBuilder, VanityControlData,
-};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
+use super::{ControlRenderData, GetterVanityControlData, VanityControlBuilder, VanityControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct OutputData;
 
@@ -18,10 +17,12 @@ impl VanityControlData for OutputData {
 }
 impl GetterVanityControlData for OutputData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn output(
         self,
-        builder: impl BuilderFn<VanityControlBuilder<FD, FS, OutputData>, CX>,
+        builder: impl Fn(
+            VanityControlBuilder<FD, FS, OutputData>,
+        ) -> VanityControlBuilder<FD, FS, OutputData>,
     ) -> Self {
         self.new_vanity(builder)
     }

src/controls/radio_buttons.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
+use super::{ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct RadioButtonsData {
     pub(crate) name: String,
@@ -24,10 +25,12 @@ impl ControlData for RadioButtonsData {
 }
 impl ValidatedControlData for RadioButtonsData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn radio_buttons<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, RadioButtonsData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, RadioButtonsData, FDT>,
+        ) -> ControlBuilder<FD, FS, RadioButtonsData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/select.rs

@@ -1,4 +1,4 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
+use super::{ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
 use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
@@ -27,10 +27,12 @@ impl ControlData for SelectData {
 }
 impl ValidatedControlData for SelectData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn select<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, SelectData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, SelectData, FDT>,
+        ) -> ControlBuilder<FD, FS, SelectData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/slider.rs

@@ -1,8 +1,10 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
-use leptos::{Signal, View};
 use std::ops::RangeInclusive;
 
+use leptos::{Signal, View};
+
+use super::{ControlBuilder, ControlData, ControlRenderData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct SliderData {
     pub(crate) name: String,
@@ -36,10 +38,12 @@ impl ControlData for SliderData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn slider<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, SliderData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, SliderData, FDT>,
+        ) -> ControlBuilder<FD, FS, SliderData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/spacer.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlRenderData, VanityControlBuilder, VanityControlData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{prelude::Signal, View};
 
+use super::{ControlRenderData, VanityControlBuilder, VanityControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct SpacerData {
     pub(crate) height: Option<String>,
@@ -17,10 +18,12 @@ impl VanityControlData for SpacerData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn spacer(
         self,
-        builder: impl BuilderFn<VanityControlBuilder<FD, FS, SpacerData>, CX>,
+        builder: impl Fn(
+            VanityControlBuilder<FD, FS, SpacerData>,
+        ) -> VanityControlBuilder<FD, FS, SpacerData>,
     ) -> Self {
         self.new_vanity(builder)
     }

src/controls/stepper.rs

@@ -1,8 +1,10 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
-use leptos::{Signal, View};
 use std::ops::RangeInclusive;
 
+use leptos::{Signal, View};
+
+use super::{ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct StepperData {
     pub(crate) name: String,
@@ -27,10 +29,12 @@ impl ControlData for StepperData {
 }
 impl ValidatedControlData for StepperData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn stepper<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, StepperData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, StepperData, FDT>,
+        ) -> ControlBuilder<FD, FS, StepperData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/submit.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlRenderData, VanityControlBuilder, VanityControlData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{prelude::Signal, View};
 
+use super::{ControlRenderData, VanityControlBuilder, VanityControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 pub struct SubmitData {
     pub(crate) text: String,
@@ -17,10 +18,12 @@ impl VanityControlData for SubmitData {
     }
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn submit(
         self,
-        builder: impl BuilderFn<VanityControlBuilder<FD, FS, SubmitData>, CX>,
+        builder: impl Fn(
+            VanityControlBuilder<FD, FS, SubmitData>,
+        ) -> VanityControlBuilder<FD, FS, SubmitData>,
     ) -> Self {
         self.new_vanity(builder)
     }

src/controls/text_area.rs

@@ -1,4 +1,4 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
+use super::{ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
 use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
@@ -23,10 +23,12 @@ impl ControlData for TextAreaData {
 }
 impl ValidatedControlData for TextAreaData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn text_area<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, TextAreaData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, TextAreaData, FDT>,
+        ) -> ControlBuilder<FD, FS, TextAreaData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/controls/text_input.rs

@@ -1,7 +1,8 @@
-use super::{BuilderFn, ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
-use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
 use leptos::{Signal, View};
 
+use super::{ControlBuilder, ControlData, ControlRenderData, ValidatedControlData};
+use crate::{form::FormToolData, form_builder::FormBuilder, styles::FormStyle};
+
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct TextInputData {
     pub(crate) name: String,
@@ -38,10 +39,12 @@ impl ControlData for TextInputData {
 }
 impl ValidatedControlData for TextInputData {}
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     pub fn text_input<FDT: Clone + PartialEq + 'static>(
         self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, TextInputData, FDT>, CX>,
+        builder: impl Fn(
+            ControlBuilder<FD, FS, TextInputData, FDT>,
+        ) -> ControlBuilder<FD, FS, TextInputData, FDT>,
     ) -> Self {
         self.new_control(builder)
     }

src/form.rs

@@ -40,16 +40,15 @@ pub struct Form<FD: FormToolData> {
 
 impl<FD: FormToolData> Form<FD> {
     /// Gets the [`Validator`] for this form.
-    pub fn validator(&self) -> FormValidator<FD> {
+    pub fn validator(self) -> FormValidator<FD> {
         FormValidator {
-            validations: self.validations.clone(),
+            validations: self.validations,
         }
     }
 
     /// Validates the [`ToolFormData`], returning the result
     pub fn validate(&self) -> Result<(), String> {
-        let validator = self.validator();
+        self.fd.get_untracked().validate()
-        validator.validate(&self.fd.get_untracked())
     }
 
     /// Gets the view associated with this [`Form`].
@@ -81,7 +80,6 @@ impl<FD: FormToolData> IntoView for Form<FD> {
 /// to physically lay out a form, and how that data should be parsed and validated.
 pub trait FormToolData: Clone + 'static {
     type Style: FormStyle;
-    type Context: 'static;
 
     /// Defines how the form should be layed out and how the data should be parsed and validated.
     ///
@@ -90,9 +88,7 @@ pub trait FormToolData: Clone + 'static {
     /// Uses the given form builder to specify what fields should be present
     /// in the form, what properties those fields should have, and how that
     /// data should be parsed and checked.
-    fn build_form(
+    fn build_form(fb: FormBuilder<Self, Self::Style>) -> FormBuilder<Self, Self::Style>;
-        fb: FormBuilder<Self, Self::Style, Self::Context>,
-    ) -> FormBuilder<Self, Self::Style, Self::Context>;
 
     /// Constructs a [`Form`] for this [`FormToolData`] type.
     ///
@@ -100,13 +96,8 @@ pub trait FormToolData: Clone + 'static {
     /// [`Form`](leptos_router::Form)
     /// component. Call [`get_action_form`]\() to get the
     /// [`ActionForm`](leptos_router::ActionForm) version.
-    fn get_form(
+    fn get_form(self, action: impl ToString, style: Self::Style) -> Form<Self> {
-        self,
+        let builder = FormBuilder::new();
-        action: impl ToString,
-        style: Self::Style,
-        context: Self::Context,
-    ) -> Form<Self> {
-        let builder = FormBuilder::new(context);
         let builder = Self::build_form(builder);
         builder.build_plain_form(action.to_string(), self, style)
     }
@@ -121,14 +112,13 @@ pub trait FormToolData: Clone + 'static {
         self,
         action: Action<ServFn, Result<ServFn::Output, ServerFnError<ServFn::Error>>>,
         style: Self::Style,
-        context: Self::Context,
     ) -> Form<Self>
     where
         ServFn: DeserializeOwned + ServerFn<InputEncoding = PostUrl> + 'static,
         <<ServFn::Client as Client<ServFn::Error>>::Request as ClientReq<ServFn::Error>>::FormData:
             From<FormData>,
     {
-        let builder = FormBuilder::new(context);
+        let builder = FormBuilder::new();
         let builder = Self::build_form(builder);
         builder.build_action_form(action, self, style)
     }
@@ -141,18 +131,18 @@ pub trait FormToolData: Clone + 'static {
     ///
     /// However, the code to render the views are not configured out, it
     /// simply doesn't run, so the view needs to compile even on the server.
-    fn get_validator(context: Self::Context) -> FormValidator<Self> {
+    fn get_validator() -> FormValidator<Self> {
-        let builder = FormBuilder::new(context);
+        let builder = FormBuilder::new();
         let builder = Self::build_form(builder);
         builder.validator()
     }
 
     /// Validates this [`FormToolData`] struct.
     ///
-    /// This is shorthand for creating a validator with [`get_validator`]
+    /// This is shorthand for creating a validator with [`get_validator`]\()
-    /// and then calling `validator.validate(&self, context)`.
+    /// and then calling `validator.validate(&self)`.
-    fn validate(&self, context: Self::Context) -> Result<(), String> {
+    fn validate(&self) -> Result<(), String> {
-        let validator = Self::get_validator(context);
+        let validator = Self::get_validator();
         validator.validate(self)
     }
 }

src/form_builder.rs

@@ -1,8 +1,8 @@
 use crate::{
     controls::{
-        BuilderFn, BuiltControlData, BuiltVanityControlData, ControlBuilder, ControlData,
+        BuiltControlData, BuiltVanityControlData, ControlBuilder, ControlData, ControlRenderData,
-        ControlRenderData, FieldSetter, ParseFn, RenderFn, ValidationCb, ValidationFn,
+        FieldSetter, ParseFn, RenderFn, ValidationCb, ValidationFn, VanityControlBuilder,
-        VanityControlBuilder, VanityControlData,
+        VanityControlData,
     },
     form::{Form, FormToolData, FormValidator},
     styles::FormStyle,
@@ -19,13 +19,7 @@ use web_sys::{FormData, SubmitEvent};
 /// A builder for laying out forms.
 ///
 /// This builder allows you to specify what components should make up the form.
-///
+pub struct FormBuilder<FD: FormToolData, FS: FormStyle> {
-/// ### Type Parameters
-/// - `FD`: FormToolData - Your form data
-/// - `FS`: FormStyle - The form style you are using
-/// - `CX`: Context - A user defined context that you are rendering the form in
-pub struct FormBuilder<FD: FormToolData, FS: FormStyle, CX: 'static> {
-    pub(crate) cx: CX,
     /// The list of [`ValidationFn`]s.
     pub(crate) validations: Vec<Rc<dyn ValidationFn<FD>>>,
     /// The list of functions that will render the form.
@@ -34,11 +28,10 @@ pub struct FormBuilder<FD: FormToolData, FS: FormStyle, CX: 'static> {
     pub(crate) styles: Vec<FS::StylingAttributes>,
 }
 
-impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
+impl<FD: FormToolData, FS: FormStyle> FormBuilder<FD, FS> {
     /// Creates a new [`FormBuilder`]
-    pub(crate) fn new(cx: CX) -> Self {
+    pub(crate) fn new() -> FormBuilder<FD, FS> {
         FormBuilder {
-            cx,
             validations: Vec::new(),
             render_fns: Vec::new(),
             styles: Vec::new(),
@@ -52,20 +45,20 @@ impl<FD: FormToolData, FS: FormStyle, CX: 'static> FormBuilder<FD, FS, CX> {
 
     pub(crate) fn new_vanity<C: VanityControlData + Default>(
         mut self,
-        builder: impl BuilderFn<VanityControlBuilder<FD, FS, C>, CX>,
+        builder: impl Fn(VanityControlBuilder<FD, FS, C>) -> VanityControlBuilder<FD, FS, C>,
     ) -> Self {
         let vanity_builder = VanityControlBuilder::new(C::default());
-        let control = builder(vanity_builder, &self.cx);
+        let control = builder(vanity_builder);
         self.add_vanity(control);
         self
     }
 
     pub(crate) fn new_control<C: ControlData + Default, FDT: Clone + PartialEq + 'static>(
         mut self,
-        builder: impl BuilderFn<ControlBuilder<FD, FS, C, FDT>, CX>,
+        builder: impl Fn(ControlBuilder<FD, FS, C, FDT>) -> ControlBuilder<FD, FS, C, FDT>,
     ) -> Self {
         let control_builder = ControlBuilder::new(C::default());
-        let control = builder(control_builder, &self.cx);
+        let control = builder(control_builder);
         self.add_control(control);
         self
     }