diff --git a/packages/uischema/src/optics.rs b/packages/uischema/src/optics.rs
deleted file mode 100644
index 6db5688..0000000
--- a/packages/uischema/src/optics.rs
+++ /dev/null
@@ -1,168 +0,0 @@
-pub type Get<S, A> = Box<dyn Fn(S) -> A>;
-pub type Apply<S, A> = Box<dyn Fn(A) -> S>;
-pub type Set<S, A> = Box<dyn Fn(S, A) -> S>;
-pub type GetOption<S, A> = Box<dyn Fn(S) -> Option<A>>;
-
-pub struct Iso<S, A> {
-    get: Get<S, A>,
-    apply: Apply<S, A>,
-}
-
-impl<S> Iso<S, S> {
-    pub fn id() -> Self {
-        Self {
-            get: Box::new(|s| s),
-            apply: Box::new(|s| s),
-        }
-    }
-}
-
-impl<S, A> Iso<S, A>
-where
-    S: 'static,
-    A: 'static,
-{
-    pub fn map_invariant<B>(
-        self,
-        covariant: impl Fn(A) -> B + 'static,
-        contravariant: impl Fn(B) -> A + 'static,
-    ) -> Iso<S, B> {
-        let Self { get, apply } = self;
-        Iso {
-            get: Box::new(move |s| covariant(get(s))),
-            apply: Box::new(move |b| apply(contravariant(b))),
-        }
-    }
-
-    pub fn lens(self) -> Lens<S, A> {
-        let Self { get, apply } = self;
-        Lens {
-            get,
-            set: Box::new(move |_s, a| apply(a)),
-        }
-    }
-}
-
-pub struct Lens<S, A> {
-    get: Get<S, A>,
-    set: Set<S, A>,
-}
-
-impl<S: 'static> Lens<S, S> {
-    pub fn id() -> Self {
-        Self {
-            get: Box::new(|s| s),
-            set: Box::new(|_s, a| a),
-        }
-    }
-}
-
-impl<S, A> Lens<S, A>
-where
-    S: 'static,
-    A: 'static,
-{
-    pub fn map_invariant<B>(
-        self,
-        covariant: impl Fn(A) -> B + 'static,
-        contravariant: impl Fn(B) -> A + 'static,
-    ) -> Lens<S, B> {
-        let Self { get, set } = self;
-        Lens {
-            get: Box::new(move |s| covariant(get(s))),
-            set: Box::new(move |s, b| set(s, contravariant(b))),
-        }
-    }
-
-    pub fn prism(self) -> Prism<S, A> {
-        let Self { get, set } = self;
-        Prism {
-            get_option: Box::new(move |s| Some(get(s))),
-            set,
-        }
-    }
-}
-
-pub struct Prism<S, A> {
-    get_option: GetOption<S, A>,
-    set: Set<S, A>,
-}
-
-impl<S: 'static> Prism<S, S> {
-    pub fn id() -> Self {
-        Self {
-            get_option: Box::new(|s| Some(s)),
-            set: Box::new(|_s, a| a),
-        }
-    }
-}
-
-impl<S, A> Prism<S, A>
-where
-    S: 'static,
-    A: 'static,
-{
-    pub fn map_invariant<B>(
-        self,
-        covariant: impl Fn(A) -> B + 'static,
-        contravariant: impl Fn(B) -> A + 'static,
-    ) -> Prism<S, B> {
-        let Self { get_option, set } = self;
-        Prism {
-            get_option: Box::new(move |s| get_option(s).map(&covariant)),
-            set: Box::new(move |s, b| set(s, contravariant(b))),
-        }
-    }
-
-    pub fn optional(self) -> Optional<S, A> {
-        let Self { get_option, set } = self;
-        Optional {
-            get_option,
-            replace: set,
-        }
-    }
-}
-
-pub struct Optional<S, A> {
-    get_option: GetOption<S, A>,
-    replace: Set<S, A>,
-}
-
-impl<S: 'static> Optional<S, S> {
-    pub fn id() -> Self {
-        Self {
-            get_option: Box::new(|s| Some(s)),
-            replace: Box::new(|_s, a| a),
-        }
-    }
-}
-
-impl<S, A> Optional<S, A>
-where
-    S: 'static,
-    A: 'static,
-{
-    pub fn map_invariant<B>(
-        self,
-        covariant: impl Fn(A) -> B + 'static,
-        contravariant: impl Fn(B) -> A + 'static,
-    ) -> Optional<S, B> {
-        let Self {
-            get_option,
-            replace,
-        } = self;
-        Optional {
-            get_option: Box::new(move |s| get_option(s).map(&covariant)),
-            replace: Box::new(move |s, b| replace(s, contravariant(b))),
-        }
-    }
-}
-
-pub trait Traversal<S, A> {
-    type Traversable: Iterator<Item = A>;
-
-    fn get_all(s: S) -> Self::Traversable;
-    fn modify_all<F>(f: F) -> fn(S) -> S
-    where
-        F: Fn(A) -> A;
-}
diff --git a/packages/uischema/src/optics/iso.rs b/packages/uischema/src/optics/iso.rs
new file mode 100644
index 0000000..41a8652
--- /dev/null
+++ b/packages/uischema/src/optics/iso.rs
@@ -0,0 +1,190 @@
+pub mod traits {
+    pub trait IsoRef {
+        type Source;
+        type Target;
+
+        fn get_ref(&self, source: Self::Source) -> Self::Target;
+    }
+
+    pub trait IsoMut: IsoRef {
+        fn get_mut(&mut self, source: Self::Source) -> Self::Target;
+    }
+
+    pub trait Iso: IsoMut {
+        fn get(self, source: Self::Source) -> Self::Target;
+    }
+}
+
+pub mod impls {
+    use super::traits::{IsoMut, IsoRef};
+    use std::marker::PhantomData;
+
+    #[derive(Debug)]
+    pub struct IsoId<S> {
+        phantom: PhantomData<S>,
+    }
+
+    impl<S> IsoId<S> {
+        pub fn new() -> Self {
+            Self::default()
+        }
+
+        pub fn map<G, B>(self, closure: G) -> Map<Self, G>
+        where
+            G: Fn(S) -> B,
+        {
+            Map {
+                iso: self,
+                f: closure,
+            }
+        }
+
+        pub fn compose<V>(self, second: V) -> IsoCompose<Self, V>
+        where
+            V: IsoRef<Source = S>,
+        {
+            IsoCompose {
+                first: self,
+                second,
+            }
+        }
+    }
+
+    impl<S> Default for IsoId<S> {
+        fn default() -> Self {
+            Self {
+                phantom: PhantomData,
+            }
+        }
+    }
+
+    impl<S> IsoRef for IsoId<S> {
+        type Source = S;
+        type Target = S;
+
+        fn get_ref(&self, source: Self::Source) -> Self::Target {
+            source
+        }
+    }
+
+    impl<S> IsoMut for IsoId<S> {
+        fn get_mut(&mut self, source: Self::Source) -> Self::Target {
+            self.get_ref(source)
+        }
+    }
+
+    pub struct Map<I, F> {
+        iso: I,
+        f: F,
+    }
+
+    impl<I, F, A> Map<I, F>
+    where
+        I: IsoRef<Target = A>,
+    {
+        pub fn map<G, B>(self, closure: G) -> Map<Self, G>
+        where
+            G: Fn(A) -> B,
+        {
+            Map {
+                iso: self,
+                f: closure,
+            }
+        }
+
+        pub fn compose<V>(self, second: V) -> IsoCompose<Self, V>
+        where
+            V: IsoRef<Source = A>,
+        {
+            IsoCompose {
+                first: self,
+                second,
+            }
+        }
+    }
+
+    impl<I, F, A, B> IsoRef for Map<I, F>
+    where
+        I: IsoRef<Target = A>,
+        F: Fn(A) -> B,
+    {
+        type Source = I::Source;
+        type Target = B;
+
+        fn get_ref(&self, source: Self::Source) -> Self::Target {
+            let a = self.iso.get_ref(source);
+            (self.f)(a)
+        }
+    }
+
+    impl<I, F, A, B> IsoMut for Map<I, F>
+    where
+        I: IsoRef<Target = A>,
+        F: Fn(A) -> B,
+    {
+        fn get_mut(&mut self, source: Self::Source) -> Self::Target {
+            let a = self.iso.get_ref(source);
+            (self.f)(a)
+        }
+    }
+
+    pub struct IsoCompose<I, V> {
+        first: I,
+        second: V,
+    }
+
+    impl<I, V, A> IsoCompose<I, V>
+    where
+        I: IsoRef<Target = A>,
+    {
+        pub fn map<G, B>(self, closure: G) -> Map<Self, G>
+        where
+            G: Fn(A) -> B,
+        {
+            Map {
+                iso: self,
+                f: closure,
+            }
+        }
+    }
+
+    impl<I, V> IsoCompose<I, V>
+    where
+        V: IsoRef,
+    {
+        pub fn compose<W>(self, second: W) -> IsoCompose<Self, W>
+        where
+            W: IsoRef<Source = V::Target>,
+        {
+            IsoCompose {
+                first: self,
+                second,
+            }
+        }
+    }
+
+    impl<I, V, A> IsoRef for IsoCompose<I, V>
+    where
+        I: IsoRef<Target = A>,
+        V: IsoRef<Source = A>,
+    {
+        type Source = I::Source;
+        type Target = V::Target;
+
+        fn get_ref(&self, source: Self::Source) -> Self::Target {
+            let a = self.first.get_ref(source);
+            self.second.get_ref(a)
+        }
+    }
+
+    impl<I, V, A> IsoMut for IsoCompose<I, V>
+    where
+        I: IsoMut<Target = A>,
+        V: IsoMut<Source = A>,
+    {
+        fn get_mut(&mut self, source: Self::Source) -> Self::Target {
+            let a = self.first.get_ref(source);
+            self.second.get_ref(a)
+        }
+    }
+}
diff --git a/packages/uischema/src/optics/lens.rs b/packages/uischema/src/optics/lens.rs
new file mode 100644
index 0000000..0de9a6b
--- /dev/null
+++ b/packages/uischema/src/optics/lens.rs
@@ -0,0 +1,2 @@
+pub mod traits {}
+pub mod impls {}
diff --git a/packages/uischema/src/optics/mod.rs b/packages/uischema/src/optics/mod.rs
new file mode 100644
index 0000000..0d649af
--- /dev/null
+++ b/packages/uischema/src/optics/mod.rs
@@ -0,0 +1,5 @@
+mod iso;
+mod lens;
+mod optional;
+mod prism;
+mod traversal;
diff --git a/packages/uischema/src/optics/optional.rs b/packages/uischema/src/optics/optional.rs
new file mode 100644
index 0000000..0de9a6b
--- /dev/null
+++ b/packages/uischema/src/optics/optional.rs
@@ -0,0 +1,2 @@
+pub mod traits {}
+pub mod impls {}
diff --git a/packages/uischema/src/optics/prism.rs b/packages/uischema/src/optics/prism.rs
new file mode 100644
index 0000000..0de9a6b
--- /dev/null
+++ b/packages/uischema/src/optics/prism.rs
@@ -0,0 +1,2 @@
+pub mod traits {}
+pub mod impls {}
diff --git a/packages/uischema/src/optics/traversal.rs b/packages/uischema/src/optics/traversal.rs
new file mode 100644
index 0000000..0de9a6b
--- /dev/null
+++ b/packages/uischema/src/optics/traversal.rs
@@ -0,0 +1,2 @@
+pub mod traits {}
+pub mod impls {}
diff --git a/packages/uischema/src/output.rs b/packages/uischema/src/output.rs
index fa5286d..5cbf220 100644
--- a/packages/uischema/src/output.rs
+++ b/packages/uischema/src/output.rs
@@ -1,19 +1,17 @@
 // first thing I think of is JS values go in, js values come out
 // a hashmap
 
-use std::collections::HashMap;
 
-use wasm_bindgen::JsValue;
 
-use crate::{optics::Optional};
+use std::collections::HashMap;
 
 // #/**/*
-pub struct Scope(String);
 
 // so we send this map back to the client, how will the client like that?
-pub struct OptionalsByScope(HashMap<Scope, Optional<JsValue, JsValue>>);
+// send traversal fns
+pub struct OptionalsByScope(HashMap<String, ()>);
 
-// need Schema to get the scopes
-// Validate Schema against UISchema
-// fn UISchema -> (Scope, Value) -> Data -> Data
-// fn (UISchema -> Scopes) -> (Scope, Value) -> Data -> Data
+enum Step {
+    Object(String),
+    Array,
+}