diff --git a/.github/workflows/continuous-integration.yml b/.github/workflows/continuous-integration.yml
index df614760..ab31b9b0 100644
--- a/.github/workflows/continuous-integration.yml
+++ b/.github/workflows/continuous-integration.yml
@@ -40,7 +40,7 @@ jobs:
       matrix:
         os: [macOS-latest, ubuntu-latest, windows-latest]
         toolchain:
-          - 1.43.0 # Minimum.
+          - 1.51.0 # Minimum.
           - stable
           - beta
           - nightly
@@ -58,4 +58,4 @@ jobs:
       - uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --manifest-path=plexus/Cargo.toml --all-features --verbose
\ No newline at end of file
+          args: --manifest-path=plexus/Cargo.toml --all-features --verbose
diff --git a/pictor/src/pipeline.rs b/pictor/src/pipeline.rs
index 62a9aa03..30e7405f 100644
--- a/pictor/src/pipeline.rs
+++ b/pictor/src/pipeline.rs
@@ -93,12 +93,12 @@ where
     }
 }
 
-impl<T> Into<Vector4<T>> for Color4<T>
+impl<T> From<Color4<T>> for Vector4<T>
 where
     T: Scalar,
 {
-    fn into(self) -> Vector4<T> {
-        self.0
+    fn from(color: Color4<T>) -> Self {
+        color.0
     }
 }
 
@@ -340,14 +340,15 @@ impl Application for RenderApplication {
 
     fn react(&mut self, event: WindowEvent) -> Reaction {
         match event {
-            WindowEvent::KeyboardInput { input, .. } => match input {
-                KeyboardInput {
-                    virtual_keycode: Some(VirtualKeyCode::Escape),
-                    state: ElementState::Pressed,
-                    ..
-                } => Abort,
-                _ => Continue,
-            },
+            WindowEvent::KeyboardInput {
+                input:
+                    KeyboardInput {
+                        virtual_keycode: Some(VirtualKeyCode::Escape),
+                        state: ElementState::Pressed,
+                        ..
+                    },
+                ..
+            } => Abort,
             _ => Continue,
         }
     }
diff --git a/plexus/Cargo.toml b/plexus/Cargo.toml
index 728d8f3b..b91dddd2 100644
--- a/plexus/Cargo.toml
+++ b/plexus/Cargo.toml
@@ -48,9 +48,9 @@ geometry-ultraviolet = ["theon/geometry-ultraviolet"]
 unstable = []
 
 [dependencies]
-approx = "^0.3.0"
+approx = "^0.4.0"
 ahash = "^0.6.0"
-arrayvec = "^0.5.0"
+arrayvec = "^0.6.0"
 decorum = "^0.3.1"
 derivative = "^2.1.1"
 itertools = "^0.9.0"
diff --git a/plexus/src/buffer/builder.rs b/plexus/src/buffer/builder.rs
index 30c2e41b..0365976d 100644
--- a/plexus/src/buffer/builder.rs
+++ b/plexus/src/buffer/builder.rs
@@ -1,9 +1,10 @@
 use num::{Integer, NumCast, Unsigned};
 use std::hash::Hash;
-use typenum::{self, NonZero};
+use typenum::NonZero;
 
 use crate::buffer::{BufferError, MeshBuffer};
 use crate::builder::{FacetBuilder, MeshBuilder, SurfaceBuilder};
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::geometry::{FromGeometry, IntoGeometry};
 use crate::index::{Flat, Grouping, IndexBuffer};
 use crate::primitive::Topological;
@@ -46,11 +47,12 @@ where
     type Input = ();
 }
 
-impl<A, N, G> FacetBuilder<N> for BufferBuilder<Flat<A, N>, G>
+impl<K, G, const N: usize> FacetBuilder<K> for BufferBuilder<Flat<K, N>, G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Hash + Integer + Unsigned,
-    Vec<N>: IndexBuffer<Flat<A, N>>,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    K: Copy + Hash + Integer + Unsigned,
+    Vec<K>: IndexBuffer<Flat<K, N>>,
 {
     type Facet = ();
     type Key = ();
@@ -58,16 +60,19 @@ where
     fn insert_facet<T, U>(&mut self, keys: T, _: U) -> Result<Self::Key, Self::Error>
     where
         Self::Facet: FromGeometry<U>,
-        T: AsRef<[N]>,
+        T: AsRef<[K]>,
     {
         let keys = keys.as_ref();
-        if keys.len() == A::USIZE {
+        if keys.len() == N {
             self.indices.extend(keys.iter());
             Ok(())
         }
         else {
+            // TODO: These numbers do not necessarily represent arity (i.e., the
+            //       number of edges of each topological structure). Use a
+            //       different error variant to express this.
             Err(BufferError::ArityConflict {
-                expected: A::USIZE,
+                expected: N,
                 actual: keys.len(),
             })
         }
diff --git a/plexus/src/buffer/mod.rs b/plexus/src/buffer/mod.rs
index a0165ad6..1d6c132c 100644
--- a/plexus/src/buffer/mod.rs
+++ b/plexus/src/buffer/mod.rs
@@ -92,12 +92,13 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::iter::FromIterator;
 use std::vec;
-use theon::adjunct::{FromItems, Map};
+use theon::adjunct::Map;
 use thiserror::Error;
 use typenum::{self, NonZero, Unsigned as _, U3, U4};
 
 use crate::buffer::builder::BufferBuilder;
 use crate::builder::{Buildable, MeshBuilder};
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::encoding::{FaceDecoder, FromEncoding, VertexDecoder};
 use crate::geometry::{FromGeometry, IntoGeometry};
 use crate::index::{
@@ -109,7 +110,7 @@ use crate::primitive::{
     BoundedPolygon, IntoIndexed, IntoPolygons, Polygonal, Tetragon, Topological, Trigon,
     UnboundedPolygon,
 };
-use crate::{Arity, DynamicArity, MeshArity, Monomorphic, StaticArity};
+use crate::{Arity, DynamicArity, MeshArity, Monomorphic, StaticArity, TryFromIterator};
 
 /// Errors concerning raw buffers and [`MeshBuffer`]s.
 ///
@@ -223,13 +224,14 @@ pub trait FromRawBuffersWithArity<N, G>: Sized {
 
 // TODO: Provide a similar trait for index buffers instead. `MeshBuffer` could
 //       use such a trait to provide this API.
-pub trait IntoFlatIndex<A, G>
+pub trait IntoFlatIndex<G, const N: usize>
 where
-    A: NonZero + typenum::Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
 {
     type Item: Copy + Integer + Unsigned;
 
-    fn into_flat_index(self) -> MeshBuffer<Flat<A, Self::Item>, G>;
+    fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, N>, G>;
 }
 
 // TODO: Provide a similar trait for index buffers instead. `MeshBuffer` could
@@ -258,7 +260,7 @@ where
 /// The `R` type parameter specifies the [`Grouping`] of the index buffer. See
 /// the [`index`] module documention for more information.
 ///
-/// [`Grouping`]: crate::buffer::Grouping
+/// [`Grouping`]: crate::index::Grouping
 /// [`index`]: crate::index
 #[derive(Debug)]
 pub struct MeshBuffer<R, G>
@@ -419,15 +421,16 @@ where
     }
 }
 
-impl<A, N, G> DynamicArity for MeshBuffer<Flat<A, N>, G>
+impl<T, G, const N: usize> DynamicArity for MeshBuffer<Flat<T, N>, G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
-    type Dynamic = <Flat<A, N> as StaticArity>::Static;
+    type Dynamic = <Flat<T, N> as StaticArity>::Static;
 
     fn arity(&self) -> Self::Dynamic {
-        Flat::<A, N>::ARITY
+        Flat::<T, N>::ARITY
     }
 }
 
@@ -476,10 +479,11 @@ where
     const ARITY: Self::Static = R::ARITY;
 }
 
-impl<A, N, G> MeshBuffer<Flat<A, N>, G>
+impl<T, G, const N: usize> MeshBuffer<Flat<T, N>, G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + NumCast + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + NumCast + Unsigned,
 {
     /// Appends the contents of a flat `MeshBuffer` into another `MeshBuffer`.
     /// The source buffer is drained.
@@ -491,9 +495,9 @@ where
     where
         G: FromGeometry<H>,
         R: Grouping,
-        R::Group: Into<<Flat<A, N> as Grouping>::Group>,
+        R::Group: Into<<Flat<T, N> as Grouping>::Group>,
     {
-        let offset = N::from(self.vertices.len()).ok_or(BufferError::IndexOverflow)?;
+        let offset = T::from(self.vertices.len()).ok_or(BufferError::IndexOverflow)?;
         self.vertices.extend(
             buffer
                 .vertices
@@ -637,11 +641,12 @@ where
     }
 }
 
-impl<A, N, M, G, H> FromRawBuffers<M, H> for MeshBuffer<Flat<A, N>, G>
+impl<T, U, G, H, const N: usize> FromRawBuffers<U, H> for MeshBuffer<Flat<T, N>, G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + NumCast + Unsigned,
-    M: Copy + Integer + NumCast + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + NumCast + Unsigned,
+    U: Copy + Integer + NumCast + Unsigned,
     G: FromGeometry<H>,
 {
     type Error = BufferError;
@@ -686,14 +691,14 @@ where
     /// ```
     fn from_raw_buffers<I, J>(indices: I, vertices: J) -> Result<Self, BufferError>
     where
-        I: IntoIterator<Item = M>,
+        I: IntoIterator<Item = U>,
         J: IntoIterator<Item = H>,
     {
         let indices = indices
             .into_iter()
-            .map(|index| <N as NumCast>::from(index).ok_or(BufferError::IndexOverflow))
+            .map(|index| <T as NumCast>::from(index).ok_or(BufferError::IndexOverflow))
             .collect::<Result<Vec<_>, _>>()?;
-        if indices.len() % A::USIZE != 0 {
+        if indices.len() % N != 0 {
             Err(BufferError::IndexUnaligned)
         }
         else {
@@ -701,7 +706,7 @@ where
                 .into_iter()
                 .map(|vertex| vertex.into_geometry())
                 .collect();
-            let len = N::from(vertices.len()).unwrap();
+            let len = T::from(vertices.len()).unwrap();
             if indices.iter().any(|index| *index >= len) {
                 Err(BufferError::IndexOutOfBounds)
             }
@@ -774,19 +779,20 @@ where
     }
 }
 
-impl<A, N, G> IntoFlatIndex<A, G> for MeshBuffer<Flat<A, N>, G>
+impl<T, G, const N: usize> IntoFlatIndex<G, N> for MeshBuffer<Flat<T, N>, G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
-    type Item = N;
+    type Item = T;
 
-    fn into_flat_index(self) -> MeshBuffer<Flat<A, Self::Item>, G> {
+    fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, N>, G> {
         self
     }
 }
 
-impl<N, G> IntoFlatIndex<U3, G> for MeshBuffer<Trigon<N>, G>
+impl<N, G> IntoFlatIndex<G, 3> for MeshBuffer<Trigon<N>, G>
 where
     N: Copy + Integer + Unsigned,
 {
@@ -821,7 +827,7 @@ where
     ///     // ...
     /// }
     /// ```
-    fn into_flat_index(self) -> MeshBuffer<Flat<U3, Self::Item>, G> {
+    fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, 3>, G> {
         let MeshBuffer { indices, vertices } = self;
         MeshBuffer {
             indices: indices
@@ -833,7 +839,7 @@ where
     }
 }
 
-impl<N, G> IntoFlatIndex<U4, G> for MeshBuffer<Tetragon<N>, G>
+impl<N, G> IntoFlatIndex<G, 4> for MeshBuffer<Tetragon<N>, G>
 where
     N: Copy + Integer + Unsigned,
 {
@@ -868,7 +874,7 @@ where
     ///     // ...
     /// }
     /// ```
-    fn into_flat_index(self) -> MeshBuffer<Flat<U4, Self::Item>, G> {
+    fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, 4>, G> {
         let MeshBuffer { indices, vertices } = self;
         MeshBuffer {
             indices: indices
@@ -901,7 +907,7 @@ where
             .into_iter()
             .map(|chunk| {
                 // These conversions should never fail.
-                Trigon::from_items(chunk.map(|index| {
+                Trigon::try_from_iter(chunk.map(|index| {
                     let index = <usize as NumCast>::from(index).expect("index overflow");
                     vertices[index].clone()
                 }))
@@ -960,7 +966,7 @@ where
             .into_iter()
             .map(|chunk| {
                 // These conversions should never fail.
-                Tetragon::from_items(chunk.map(|index| {
+                Tetragon::try_from_iter(chunk.map(|index| {
                     let index = <usize as NumCast>::from(index).expect("index overflow");
                     vertices[index].clone()
                 }))
@@ -1086,8 +1092,8 @@ where
             .into_iter()
             .chunks(U3::USIZE)
             .into_iter()
-            .map(<Self::Item as Grouping>::Group::from_items)
-            .collect::<Option<Vec<_>>>()
+            .map(<Self::Item as Grouping>::Group::try_from_iter)
+            .collect::<Result<Vec<_>, _>>()
             .expect("inconsistent index buffer");
         MeshBuffer { indices, vertices }
     }
@@ -1134,8 +1140,8 @@ where
             .into_iter()
             .chunks(U4::USIZE)
             .into_iter()
-            .map(<Self::Item as Grouping>::Group::from_items)
-            .collect::<Option<Vec<_>>>()
+            .map(<Self::Item as Grouping>::Group::try_from_iter)
+            .collect::<Result<Vec<_>, _>>()
             .expect("inconsistent index buffer");
         MeshBuffer { indices, vertices }
     }
diff --git a/plexus/src/constant.rs b/plexus/src/constant.rs
new file mode 100644
index 00000000..94571edd
--- /dev/null
+++ b/plexus/src/constant.rs
@@ -0,0 +1,44 @@
+//! Morphisms between constant generics and numeric types.
+//!
+//! This module provides conversions between `typenum`'s unsigned integer types
+//! and `usize` constant generics. These conversions are necessary to perform
+//! static computations and comparisons, which cannot yet be done using constant
+//! generics alone at the time of writing (e.g., `{N >= 3}`).
+//!
+//! See discussion on the [Rust internals
+//! forum](https://internals.rust-lang.org/t/const-generics-where-restrictions/12742/7).
+
+// TODO: Move this into the `theon` crate as part of its public API.
+
+pub type ConstantOf<N> = <N as ToConstant>::Output;
+pub type TypeOf<const N: usize> = <Constant<N> as ToType>::Output;
+
+pub struct Constant<const N: usize>;
+
+pub trait ToConstant {
+    type Output;
+}
+
+pub trait ToType {
+    type Output;
+}
+
+macro_rules! impl_morphisms {
+    (types => $($n:ident),*$(,)?) => (
+        use typenum::Unsigned;
+
+        $(
+            impl ToConstant for typenum::$n {
+                type Output = Constant<{ typenum::$n::USIZE }>;
+            }
+
+            impl ToType for Constant<{ typenum::$n::USIZE }> {
+                type Output = typenum::$n;
+            }
+        )*
+    );
+}
+impl_morphisms!(types =>
+    U0, U1, U2, U3, U4, U5, U6, U7, U8, U9, U10, U11, U12, U13, U14, U15, U16, U17, U18, U19, U21,
+    U22, U23, U24, U25, U26, U27, U28, U29, U30, U31, U32,
+);
diff --git a/plexus/src/graph/edge.rs b/plexus/src/graph/edge.rs
index 382e2303..c29236e6 100644
--- a/plexus/src/graph/edge.rs
+++ b/plexus/src/graph/edge.rs
@@ -118,9 +118,9 @@ impl From<(VertexKey, VertexKey)> for ArcKey {
     }
 }
 
-impl Into<(VertexKey, VertexKey)> for ArcKey {
-    fn into(self) -> (VertexKey, VertexKey) {
-        (self.0, self.1)
+impl From<ArcKey> for (VertexKey, VertexKey) {
+    fn from(key: ArcKey) -> Self {
+        (key.0, key.1)
     }
 }
 
@@ -1067,29 +1067,29 @@ where
     }
 }
 
-impl<B, M, G> Hash for ArcView<B>
+impl<B, M, G> From<ArcView<B>> for View<B, Arc<G>>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Arc<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.inner.hash(state);
+    fn from(arc: ArcView<B>) -> Self {
+        let ArcView { inner, .. } = arc;
+        inner
     }
 }
 
-impl<B, M, G> Into<View<B, Arc<G>>> for ArcView<B>
+impl<B, M, G> Hash for ArcView<B>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Arc<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn into(self) -> View<B, Arc<G>> {
-        let ArcView { inner, .. } = self;
-        inner
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
     }
 }
 
@@ -1483,29 +1483,29 @@ where
     }
 }
 
-impl<B, M, G> Hash for EdgeView<B>
+impl<B, M, G> From<EdgeView<B>> for View<B, Edge<G>>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Edge<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.inner.hash(state);
+    fn from(edge: EdgeView<B>) -> Self {
+        let EdgeView { inner, .. } = edge;
+        inner
     }
 }
 
-impl<B, M, G> Into<View<B, Edge<G>>> for EdgeView<B>
+impl<B, M, G> Hash for EdgeView<B>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Edge<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn into(self) -> View<B, Edge<G>> {
-        let EdgeView { inner, .. } = self;
-        inner
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
     }
 }
 
@@ -1635,7 +1635,7 @@ where
     B::Target: AsStorage<Vertex<<B::Target as Parametric>::Data>> + Parametric,
 {
     storage: B,
-    inner: <ArrayVec<[VertexKey; 2]> as IntoIterator>::IntoIter,
+    inner: <ArrayVec<VertexKey, 2> as IntoIterator>::IntoIter,
 }
 
 impl<B, M, G> VertexCirculator<B>
@@ -1731,7 +1731,7 @@ where
     B::Target: AsStorage<Face<<B::Target as Parametric>::Data>> + Parametric,
 {
     storage: B,
-    inner: <ArrayVec<[FaceKey; 2]> as IntoIterator>::IntoIter,
+    inner: <ArrayVec<FaceKey, 2> as IntoIterator>::IntoIter,
 }
 
 impl<B, M, G> FaceCirculator<B>
@@ -1784,7 +1784,7 @@ where
                     .and_then(|opposite| opposite.face)
                     .into_iter(),
             )
-            .collect::<ArrayVec<_>>()
+            .collect::<ArrayVec<_, 2>>()
             .into_iter();
         let (storage, _) = arc.unbind();
         FaceCirculator { storage, inner }
diff --git a/plexus/src/graph/face.rs b/plexus/src/graph/face.rs
index b90602b7..72083389 100644
--- a/plexus/src/graph/face.rs
+++ b/plexus/src/graph/face.rs
@@ -993,29 +993,29 @@ where
     }
 }
 
-impl<B, M, G> Hash for FaceView<B>
+impl<B, M, G> From<FaceView<B>> for View<B, Face<G>>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Face<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.inner.hash(state);
+    fn from(face: FaceView<B>) -> Self {
+        let FaceView { inner, .. } = face;
+        inner
     }
 }
 
-impl<B, M, G> Into<View<B, Face<G>>> for FaceView<B>
+impl<B, M, G> Hash for FaceView<B>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Face<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn into(self) -> View<B, Face<G>> {
-        let FaceView { inner, .. } = self;
-        inner
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
     }
 }
 
diff --git a/plexus/src/graph/geometry.rs b/plexus/src/graph/geometry.rs
index 52e5a210..c4ae958c 100644
--- a/plexus/src/graph/geometry.rs
+++ b/plexus/src/graph/geometry.rs
@@ -7,7 +7,6 @@
 // necessary, constraints are specified there so that they do not pollute user
 // code.
 
-use theon::adjunct::FromItems;
 use theon::ops::{Cross, Interpolate, Project};
 use theon::query::Plane;
 use theon::space::{EuclideanSpace, FiniteDimensional, InnerSpace, Vector, VectorSpace};
@@ -21,7 +20,8 @@ use crate::graph::edge::{Arc, ArcView, Edge, ToArc};
 use crate::graph::face::{Face, ToRing};
 use crate::graph::mutation::Consistent;
 use crate::graph::vertex::{Vertex, VertexView};
-use crate::graph::{GraphError, OptionExt as _};
+use crate::graph::{GraphError, OptionExt as _, ResultExt as _};
+use crate::IteratorExt as _;
 
 pub type VertexPosition<G> = Position<<G as GraphData>::Vertex>;
 
@@ -120,9 +120,11 @@ where
         B::Target:
             AsStorage<Arc<Self>> + AsStorage<Vertex<Self>> + Consistent + Parametric<Data = Self>,
     {
-        let (a, b) =
-            FromItems::from_items(arc.adjacent_vertices().map(|vertex| *vertex.position()))
-                .expect_consistent();
+        let (a, b) = arc
+            .adjacent_vertices()
+            .map(|vertex| *vertex.position())
+            .try_collect()
+            .expect_consistent();
         let c = *arc.next_arc().destination_vertex().position();
         let ab = a - b;
         let cb = c - b;
@@ -163,9 +165,11 @@ where
         T: ToArc<B>,
     {
         let arc = edge.into_arc();
-        let (a, b) =
-            FromItems::from_items(arc.adjacent_vertices().map(|vertex| *vertex.position()))
-                .unwrap();
+        let (a, b) = arc
+            .adjacent_vertices()
+            .map(|vertex| *vertex.position())
+            .try_collect()
+            .expect_consistent();
         Ok(a.midpoint(b))
     }
 }
@@ -229,9 +233,12 @@ where
         T: ToRing<B>,
     {
         let ring = ring.into_ring();
-        let (a, b) =
-            FromItems::from_items(ring.vertices().take(2).map(|vertex| *vertex.position()))
-                .expect_consistent();
+        let (a, b) = ring
+            .vertices()
+            .take(2)
+            .map(|vertex| *vertex.position())
+            .try_collect()
+            .expect_consistent();
         let c = G::centroid(ring)?;
         let ab = a - b;
         let bc = b - c;
diff --git a/plexus/src/graph/mod.rs b/plexus/src/graph/mod.rs
index 5a95e316..273dcaf3 100644
--- a/plexus/src/graph/mod.rs
+++ b/plexus/src/graph/mod.rs
@@ -257,7 +257,6 @@ mod vertex;
 
 use decorum::cmp::IntrinsicOrd;
 use decorum::R64;
-use itertools::Itertools;
 use num::{Integer, NumCast, ToPrimitive, Unsigned};
 use smallvec::SmallVec;
 use std::borrow::Borrow;
@@ -267,15 +266,16 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::iter::FromIterator;
 use std::vec;
-use theon::adjunct::{FromItems, Map};
+use theon::adjunct::Map;
 use theon::query::Aabb;
 use theon::space::{EuclideanSpace, Scalar};
 use theon::{AsPosition, AsPositionMut};
 use thiserror::Error;
-use typenum::{self, NonZero};
+use typenum::NonZero;
 
 use crate::buffer::{BufferError, FromRawBuffers, FromRawBuffersWithArity, MeshBuffer};
 use crate::builder::{Buildable, FacetBuilder, MeshBuilder, SurfaceBuilder};
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::encoding::{FaceDecoder, FromEncoding, VertexDecoder};
 use crate::entity::storage::prelude::*;
 use crate::entity::storage::{AsStorage, AsStorageMut, AsStorageOf, Key, StorageTarget};
@@ -1283,6 +1283,16 @@ where
     }
 }
 
+impl<G> From<MeshGraph<G>> for OwnedCore<G>
+where
+    G: GraphData,
+{
+    fn from(graph: MeshGraph<G>) -> Self {
+        let MeshGraph { core, .. } = graph;
+        core
+    }
+}
+
 impl<E, G> FromEncoding<E> for MeshGraph<G>
 where
     E: FaceDecoder + VertexDecoder,
@@ -1450,6 +1460,8 @@ where
         I: IntoIterator<Item = N>,
         J: IntoIterator<Item = H>,
     {
+        use itertools::Itertools;
+
         if arity < 3 {
             return Err(GraphError::ArityNonPolygonal);
         }
@@ -1482,23 +1494,6 @@ where
     }
 }
 
-impl<G> Parametric for MeshGraph<G>
-where
-    G: GraphData,
-{
-    type Data = G;
-}
-
-impl<G> Into<OwnedCore<G>> for MeshGraph<G>
-where
-    G: GraphData,
-{
-    fn into(self) -> OwnedCore<G> {
-        let MeshGraph { core, .. } = self;
-        core
-    }
-}
-
 impl<G> IntoPolygons for MeshGraph<G>
 where
     G: GraphData,
@@ -1507,18 +1502,29 @@ where
     type Polygon = UnboundedPolygon<G::Vertex>;
 
     fn into_polygons(self) -> Self::Output {
+        use crate::IteratorExt as _;
+
         self.faces()
             .map(|face| {
                 // The arity of a face in a graph must be polygonal (three or
                 // higher) so this should never fail.
-                let vertices = face.adjacent_vertices().map(|vertex| vertex.get().clone());
-                UnboundedPolygon::from_items(vertices).expect_consistent()
+                face.adjacent_vertices()
+                    .map(|vertex| vertex.get().clone())
+                    .try_collect()
+                    .expect_consistent()
             })
             .collect::<Vec<_>>()
             .into_iter()
     }
 }
 
+impl<G> Parametric for MeshGraph<G>
+where
+    G: GraphData,
+{
+    type Data = G;
+}
+
 impl<G> StaticArity for MeshGraph<G>
 where
     G: GraphData,
@@ -1528,10 +1534,11 @@ where
     const ARITY: Self::Static = (3, None);
 }
 
-impl<A, N, H, G> TryFrom<MeshBuffer<Flat<A, N>, H>> for MeshGraph<G>
+impl<T, H, G, const A: usize> TryFrom<MeshBuffer<Flat<T, A>, H>> for MeshGraph<G>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + NumCast + Unsigned,
+    Constant<A>: ToType,
+    TypeOf<A>: NonZero,
+    T: Copy + Integer + NumCast + Unsigned,
     H: Clone,
     G: GraphData,
     G::Vertex: FromGeometry<H>,
@@ -1571,7 +1578,7 @@ where
     ///
     /// [`MeshBuffer`]: crate::buffer::MeshBuffer
     /// [`MeshGraph`]: crate::graph::MeshGraph
-    fn try_from(buffer: MeshBuffer<Flat<A, N>, H>) -> Result<Self, Self::Error> {
+    fn try_from(buffer: MeshBuffer<Flat<T, A>, H>) -> Result<Self, Self::Error> {
         let arity = buffer.arity();
         let (indices, vertices) = buffer.into_raw_buffers();
         MeshGraph::from_raw_buffers_with_arity(indices, vertices, arity)
diff --git a/plexus/src/graph/vertex.rs b/plexus/src/graph/vertex.rs
index 81bd5ccb..be6e46db 100644
--- a/plexus/src/graph/vertex.rs
+++ b/plexus/src/graph/vertex.rs
@@ -689,29 +689,29 @@ where
     }
 }
 
-impl<B, M, G> Hash for VertexView<B>
+impl<B, M, G> From<VertexView<B>> for View<B, Vertex<G>>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Vertex<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn hash<H>(&self, state: &mut H)
-    where
-        H: Hasher,
-    {
-        self.inner.hash(state);
+    fn from(vertex: VertexView<B>) -> Self {
+        let VertexView { inner, .. } = vertex;
+        inner
     }
 }
 
-impl<B, M, G> Into<View<B, Vertex<G>>> for VertexView<B>
+impl<B, M, G> Hash for VertexView<B>
 where
     B: Reborrow<Target = M>,
     M: AsStorage<Vertex<G>> + Parametric<Data = G>,
     G: GraphData,
 {
-    fn into(self) -> View<B, Vertex<G>> {
-        let VertexView { inner, .. } = self;
-        inner
+    fn hash<H>(&self, state: &mut H)
+    where
+        H: Hasher,
+    {
+        self.inner.hash(state);
     }
 }
 
diff --git a/plexus/src/index.rs b/plexus/src/index.rs
index f38748c6..0d3253e2 100644
--- a/plexus/src/index.rs
+++ b/plexus/src/index.rs
@@ -84,8 +84,9 @@ use std::fmt::Debug;
 use std::hash::Hash;
 use std::marker::PhantomData;
 use theon::adjunct::Map;
-use typenum::{NonZero, U3, U4};
+use typenum::NonZero;
 
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::primitive::decompose::IntoVertices;
 use crate::primitive::Topological;
 use crate::{Monomorphic, StaticArity};
@@ -118,12 +119,13 @@ where
     type Index: Copy + Integer + Unsigned;
 }
 
-impl<A, N> IndexBuffer<Flat<A, N>> for Vec<N>
+impl<T, const N: usize> IndexBuffer<Flat<T, N>> for Vec<T>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
-    type Index = N;
+    type Index = T;
 }
 
 impl<P> IndexBuffer<P> for Vec<P>
@@ -143,11 +145,12 @@ where
     fn push(&mut self, index: P);
 }
 
-impl<A, N, P> Push<Flat<A, N>, P> for Vec<N>
+impl<T, P, const N: usize> Push<Flat<T, N>, P> for Vec<T>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
-    P: Monomorphic + IntoVertices + Topological<Vertex = N>,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
+    P: Monomorphic + IntoVertices + Topological<Vertex = T>,
 {
     fn push(&mut self, index: P) {
         for index in index.into_vertices() {
@@ -174,13 +177,18 @@ pub trait Grouping: StaticArity {
 
 /// Flat index buffer meta-grouping.
 ///
-/// Describes a flat index buffer with a constant arity. Arity is specified
-/// using a type constant from the [`typenum`] crate.
+/// Describes a flat index buffer with a constant arity. The number of vertices
+/// in the indexed topological structures is specified using a constant
+/// parameter `N`, which represents the number of grouped elements in the index
+/// buffer. For example, `Flat<_, 3>` describes an index buffer with indices in
+/// implicit and contiguous groups of three. Note that this constant may be
+/// distinct from the arity of the indexed topological structures (i.e., if `N`
+/// is less than three, then arity is `N - 1` and may be zero.).
 ///
 /// Unlike structured groupings, this meta-grouping is needed to associate an
-/// index type with an arity. For example, `Vec<usize>` implements both
-/// `IndexBuffer<Flat3<usize>>` (a triangular buffer) and
-/// `IndexBuffer<Flat4<usize>>` (a quadrilateral buffer).
+/// index type with an implicit grouping and arity. For example, `Vec<usize>`
+/// implements both `IndexBuffer<Flat<usize, 3>>` (a triangular buffer) and
+/// `IndexBuffer<Flat<usize, 4>>` (a quadrilateral buffer).
 ///
 /// See the [`index`] module documention for more information about index
 /// buffers.
@@ -193,55 +201,56 @@ pub trait Grouping: StaticArity {
 /// use plexus::buffer::MeshBuffer;
 /// use plexus::index::Flat;
 /// use plexus::prelude::*;
-/// use plexus::U3;
 ///
-/// let mut buffer = MeshBuffer::<Flat<U3, usize>, (f64, f64, f64)>::default();
+/// let mut buffer = MeshBuffer::<Flat<usize, 3>, (f64, f64, f64)>::default();
 /// ```
 ///
-/// [`typenum`]: https://crates.io/crates/typenum
-///
 /// [`MeshBuffer`]: crate::buffer::MeshBuffer
 /// [`index`]: crate::index
 #[derive(Debug)]
-pub struct Flat<A = U3, N = usize>
+pub struct Flat<T, const N: usize>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
-    phantom: PhantomData<(A, N)>,
+    phantom: PhantomData<T>,
 }
 
-impl<A, N> Grouping for Flat<A, N>
+impl<T, const N: usize> Grouping for Flat<T, N>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
     /// The elements of flat index buffers are indices. These indices are
-    /// implicitly grouped by the arity of the buffer (`A`).
-    type Group = N;
+    /// implicitly grouped by the arity of the buffer (`N`).
+    type Group = T;
 }
 
-impl<A, N> Monomorphic for Flat<A, N>
+impl<T, const N: usize> Monomorphic for Flat<T, N>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
 }
 
-impl<A, N> StaticArity for Flat<A, N>
+impl<T, const N: usize> StaticArity for Flat<T, N>
 where
-    A: NonZero + typenum::Unsigned,
-    N: Copy + Integer + Unsigned,
+    Constant<N>: ToType,
+    TypeOf<N>: NonZero,
+    T: Copy + Integer + Unsigned,
 {
     type Static = usize;
 
-    const ARITY: Self::Static = A::USIZE;
+    const ARITY: Self::Static = crate::n_arity(N);
 }
 
 /// Alias for a flat and triangular index buffer.
-pub type Flat3<N = usize> = Flat<U3, N>;
+pub type Flat3<T = usize> = Flat<T, 3>;
 /// Alias for a flat and quadrilateral index buffer.
-pub type Flat4<N = usize> = Flat<U4, N>;
+pub type Flat4<T = usize> = Flat<T, 4>;
 
 /// Structured index buffer grouping.
 ///
diff --git a/plexus/src/lib.rs b/plexus/src/lib.rs
index 44600cb7..2955c15b 100644
--- a/plexus/src/lib.rs
+++ b/plexus/src/lib.rs
@@ -18,6 +18,7 @@
 
 pub mod buffer;
 pub mod builder;
+pub mod constant;
 pub mod encoding;
 mod entity;
 pub mod geometry;
@@ -27,14 +28,13 @@ pub mod integration;
 pub mod primitive;
 mod transact;
 
+use arrayvec::ArrayVec;
 use itertools::{self, Itertools, MinMaxResult, MultiPeek};
 use std::borrow::Borrow;
 use std::fmt::Debug;
 
 use crate::entity::view::ClosedView;
 
-pub use typenum::{U2, U3, U4};
-
 pub mod prelude {
     //! Re-exports of commonly used types and traits.
     //!
@@ -238,6 +238,66 @@ impl Arity for MeshArity {
     }
 }
 
+pub trait TryFromIterator<T>: Sized {
+    type Error;
+
+    fn try_from_iter<I>(items: I) -> Result<Self, Self::Error>
+    where
+        I: Iterator<Item = T>;
+}
+
+impl<T, const N: usize> TryFromIterator<T> for [T; N] {
+    type Error = ();
+
+    fn try_from_iter<I>(items: I) -> Result<Self, Self::Error>
+    where
+        I: Iterator<Item = T>,
+    {
+        items
+            .has_exactly(N)
+            .and_then(|items| items.collect::<ArrayVec<T, N>>().into_inner().ok())
+            .ok_or(())
+    }
+}
+
+macro_rules! count {
+    ($x:tt $($xs:tt)*) => (1usize + count!($($xs)*));
+    () => (0usize);
+}
+macro_rules! substitute {
+    ($_t:tt, $with:ty) => {
+        $with
+    };
+}
+macro_rules! impl_try_from_iterator {
+    (tuples => ($($i:ident),+)) => (
+        #[allow(non_snake_case)]
+        impl<T> TryFromIterator<T> for ($(substitute!(($i), T),)+) {
+            type Error = ();
+
+            fn try_from_iter<I>(items: I) -> Result<Self, Self::Error>
+            where
+                I: Iterator<Item = T>,
+            {
+                use $crate::IteratorExt as _;
+
+                items
+                    .has_exactly(count!($($i)*))
+                    .map(|mut items| {
+                        $(let $i = items.next().unwrap();)*
+                        ($($i,)*)
+                    })
+                    .ok_or(())
+            }
+        }
+    );
+}
+impl_try_from_iterator!(tuples => (A, B));
+impl_try_from_iterator!(tuples => (A, B, C));
+impl_try_from_iterator!(tuples => (A, B, C, D));
+impl_try_from_iterator!(tuples => (A, B, C, D, E));
+impl_try_from_iterator!(tuples => (A, B, C, D, E, F));
+
 /// Extension methods for types implementing [`Iterator`].
 ///
 /// [`Iterator`]: std::iter::Iterator
@@ -329,12 +389,26 @@ pub trait IteratorExt: Iterator + Sized {
     /// }
     /// ```
     fn has_at_least(self, n: usize) -> Option<MultiPeek<Self>> {
-        let mut peekable = itertools::multipeek(self);
-        for _ in 0..n {
-            peekable.peek()?;
-        }
-        peekable.reset_peek();
-        Some(peekable)
+        peek_n(self, n).map(|mut peekable| {
+            peekable.reset_peek();
+            peekable
+        })
+    }
+
+    fn has_exactly(self, n: usize) -> Option<MultiPeek<Self>> {
+        peek_n(self, n).and_then(|mut peekable| {
+            peekable.peek().is_none().then(|| {
+                peekable.reset_peek();
+                peekable
+            })
+        })
+    }
+
+    fn try_collect<T>(self) -> Result<T, T::Error>
+    where
+        T: TryFromIterator<Self::Item>,
+    {
+        T::try_from_iter(self)
     }
 }
 
@@ -386,13 +460,13 @@ where
 
     fn next(&mut self) -> Option<Self::Item> {
         let next = self.input.next();
-        match (self.previous.clone(), next.or_else(|| self.first.take())) {
-            (Some(a), Some(b)) => {
+        self.previous
+            .clone()
+            .zip(next.or_else(|| self.first.take()))
+            .map(|(a, b)| {
                 self.previous = Some(b.clone());
-                Some((a, b))
-            }
-            _ => None,
-        }
+                (a, b)
+            })
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
@@ -440,3 +514,29 @@ where
         self.input.size_hint()
     }
 }
+
+fn peek_n<I>(input: I, n: usize) -> Option<MultiPeek<I>>
+where
+    I: Iterator,
+{
+    let mut peekable = itertools::multipeek(input);
+    for _ in 0..n {
+        peekable.peek()?;
+    }
+    Some(peekable)
+}
+
+/// Computes the arity of a polygon with `n` vertices.
+///
+/// For `n` greater than two, these values are the same and well-formed. For `n`
+/// less than three, the polygon is degenerate (a digon, monogon, or zerogon),
+/// all of which are assigned an arity of one. Note that some topological types
+/// do not allow `n` being one nor zero.
+const fn n_arity(n: usize) -> usize {
+    if n < 3 {
+        1
+    }
+    else {
+        n
+    }
+}
diff --git a/plexus/src/primitive/cube.rs b/plexus/src/primitive/cube.rs
index da2520b2..dae0abdd 100644
--- a/plexus/src/primitive/cube.rs
+++ b/plexus/src/primitive/cube.rs
@@ -33,12 +33,12 @@ use crate::primitive::Tetragon;
 
 #[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
 pub enum Plane {
-    XY,  // front
-    NXY, // back
-    YZ,  // right
-    NYZ, // left
-    XZ,  // bottom
-    NXZ, // top
+    Xy,  // front
+    Nxy, // back
+    Yz,  // right
+    Nyz, // left
+    Xz,  // bottom
+    Nxz, // top
 }
 
 impl Plane {
@@ -50,12 +50,12 @@ impl Plane {
         S: Basis + FiniteDimensional<N = U3> + InnerSpace,
     {
         match *self {
-            Plane::XY => Unit::<S>::z(),   // front
-            Plane::NXY => -Unit::<S>::z(), // back
-            Plane::YZ => Unit::<S>::x(),   // right
-            Plane::NYZ => -Unit::<S>::x(), // left
-            Plane::XZ => -Unit::<S>::y(),  // bottom
-            Plane::NXZ => Unit::<S>::y(),  // top
+            Plane::Xy => Unit::<S>::z(),   // front
+            Plane::Nxy => -Unit::<S>::z(), // back
+            Plane::Yz => Unit::<S>::x(),   // right
+            Plane::Nyz => -Unit::<S>::x(), // left
+            Plane::Xz => -Unit::<S>::y(),  // bottom
+            Plane::Nxz => Unit::<S>::y(),  // top
         }
     }
 }
@@ -249,12 +249,12 @@ impl AttributeVertexGenerator<Plane> for Cube {
 
     fn vertex_from(&self, _: &Self::State, index: usize) -> Self::Output {
         match index {
-            0 => Plane::XY,  // front
-            1 => Plane::YZ,  // right
-            2 => Plane::NXZ, // top
-            3 => Plane::NYZ, // left
-            4 => Plane::XZ,  // bottom
-            5 => Plane::NXY, // back
+            0 => Plane::Xy,  // front
+            1 => Plane::Yz,  // right
+            2 => Plane::Nxz, // top
+            3 => Plane::Nyz, // left
+            4 => Plane::Xz,  // bottom
+            5 => Plane::Nxy, // back
             _ => panic!(),
         }
     }
diff --git a/plexus/src/primitive/decompose.rs b/plexus/src/primitive/decompose.rs
index 0725f8d6..5f2ce314 100644
--- a/plexus/src/primitive/decompose.rs
+++ b/plexus/src/primitive/decompose.rs
@@ -70,11 +70,12 @@
 use arrayvec::ArrayVec;
 use std::collections::VecDeque;
 use std::iter::IntoIterator;
-use theon::adjunct::IntoItems;
 use theon::ops::Interpolate;
+use typenum::{Cmp, Greater, U1};
 
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::primitive::{
-    BoundedPolygon, Edge, Polygonal, Tetragon, Topological, Trigon, UnboundedPolygon,
+    BoundedPolygon, Edge, NGon, Polygonal, Tetragon, Topological, Trigon, UnboundedPolygon,
 };
 use crate::IteratorExt as _;
 
@@ -172,16 +173,15 @@ pub trait IntoVertices: Topological {
 
 impl<T> IntoVertices for T
 where
-    T: IntoItems + Topological,
+    T: Topological,
 {
-    type Output = <T as IntoItems>::Output;
+    type Output = <T as IntoIterator>::IntoIter;
 
     fn into_vertices(self) -> Self::Output {
-        self.into_items()
+        self.into_iter()
     }
 }
 
-// TODO: Use a macro to implement this for all `NGon`s.
 pub trait IntoEdges: Topological {
     type Output: IntoIterator<Item = Edge<Self::Vertex>>;
 
@@ -201,47 +201,35 @@ pub trait IntoSubdivisions: Polygonal {
 }
 
 pub trait IntoTetrahedrons: Polygonal {
-    fn into_tetrahedrons(self) -> ArrayVec<[Trigon<Self::Vertex>; 4]>;
-}
-
-impl<T> IntoEdges for Edge<T> {
-    type Output = Option<Edge<Self::Vertex>>;
-
-    fn into_edges(self) -> Self::Output {
-        Some(self)
-    }
-}
-
-impl<T> IntoEdges for Trigon<T>
-where
-    T: Clone,
-{
-    type Output = ArrayVec<[Edge<Self::Vertex>; 3]>;
-
-    fn into_edges(self) -> Self::Output {
-        let [a, b, c] = self.into_array();
-        ArrayVec::from([
-            Edge::new(a.clone(), b.clone()),
-            Edge::new(b, c.clone()),
-            Edge::new(c, a),
-        ])
-    }
+    fn into_tetrahedrons(self) -> ArrayVec<Trigon<Self::Vertex>, 4>;
 }
 
-impl<T> IntoEdges for Tetragon<T>
+impl<G, const N: usize> IntoEdges for NGon<G, N>
 where
-    T: Clone,
+    G: Clone,
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U1, Output = Greater>,
 {
-    type Output = ArrayVec<[Edge<Self::Vertex>; 4]>;
+    // TODO: As of Rust 1.51.1, it is not possible to constrain constant
+    //       generics nor use them in expressions. If and when this is possible,
+    //       do not implement this trait for degenerate `NGon`s and use use an
+    //       `ArrayVec<Edge<Self::Vertex>, {if N == 2 { 1 } else { N }}>` as
+    //       output.
+    type Output = Vec<Edge<Self::Vertex>>;
 
     fn into_edges(self) -> Self::Output {
-        let [a, b, c, d] = self.into_array();
-        ArrayVec::from([
-            Edge::new(a.clone(), b.clone()),
-            Edge::new(b, c.clone()),
-            Edge::new(c, d.clone()),
-            Edge::new(d, a),
-        ])
+        if N == 2 {
+            // At the time of writing, it is not possible to specialize this
+            // case for `NGon<G, 2>` nor prove to the compiler that `Self` is of
+            // type `Edge<G>` when the condition `N == 2` is `true`.
+            vec![self.into_iter().try_collect().unwrap()]
+        }
+        else {
+            self.into_iter()
+                .perimeter()
+                .map(|(a, b)| Edge::new(a, b))
+                .collect()
+        }
     }
 }
 
@@ -274,7 +262,7 @@ where
 }
 
 impl<T> IntoTrigons for Trigon<T> {
-    type Output = ArrayVec<[Trigon<Self::Vertex>; 1]>;
+    type Output = ArrayVec<Trigon<Self::Vertex>, 1>;
 
     fn into_trigons(self) -> Self::Output {
         ArrayVec::from([self])
@@ -285,7 +273,7 @@ impl<T> IntoTrigons for Tetragon<T>
 where
     T: Clone,
 {
-    type Output = ArrayVec<[Trigon<Self::Vertex>; 2]>;
+    type Output = ArrayVec<Trigon<Self::Vertex>, 2>;
 
     fn into_trigons(self) -> Self::Output {
         let [a, b, c, d] = self.into_array();
@@ -311,7 +299,7 @@ impl<T> IntoSubdivisions for Trigon<T>
 where
     T: Clone + Interpolate<Output = T>,
 {
-    type Output = ArrayVec<[Trigon<Self::Vertex>; 2]>;
+    type Output = ArrayVec<Trigon<Self::Vertex>, 2>;
 
     fn into_subdivisions(self) -> Self::Output {
         let [a, b, c] = self.into_array();
@@ -324,7 +312,7 @@ impl<T> IntoSubdivisions for Tetragon<T>
 where
     T: Clone + Interpolate<Output = T>,
 {
-    type Output = ArrayVec<[Tetragon<Self::Vertex>; 4]>;
+    type Output = ArrayVec<Tetragon<Self::Vertex>, 4>;
 
     fn into_subdivisions(self) -> Self::Output {
         let [a, b, c, d] = self.into_array();
@@ -346,7 +334,7 @@ impl<T> IntoTetrahedrons for Tetragon<T>
 where
     T: Clone + Interpolate<Output = T>,
 {
-    fn into_tetrahedrons(self) -> ArrayVec<[Trigon<Self::Vertex>; 4]> {
+    fn into_tetrahedrons(self) -> ArrayVec<Trigon<Self::Vertex>, 4> {
         let [a, b, c, d] = self.into_array();
         let ac = a.clone().midpoint(c.clone()); // Diagonal.
         ArrayVec::from([
@@ -451,7 +439,7 @@ where
 
 pub trait Tetrahedrons<T>: Sized {
     #[allow(clippy::type_complexity)]
-    fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, ArrayVec<[Trigon<T>; 4]>>;
+    fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, ArrayVec<Trigon<T>, 4>>;
 }
 
 impl<I, T> Tetrahedrons<T> for I
@@ -460,7 +448,7 @@ where
     T: Clone + Interpolate<Output = T>,
 {
     #[allow(clippy::type_complexity)]
-    fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, ArrayVec<[Trigon<T>; 4]>> {
+    fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, ArrayVec<Trigon<T>, 4>> {
         Decompose::new(self, Tetragon::into_tetrahedrons)
     }
 }
diff --git a/plexus/src/primitive/mod.rs b/plexus/src/primitive/mod.rs
index 940603b5..46ad651f 100644
--- a/plexus/src/primitive/mod.rs
+++ b/plexus/src/primitive/mod.rs
@@ -25,7 +25,7 @@
 //!
 //! | Type               | Morphism    | Arity        | Map | Zip | Tessellate |
 //! |--------------------|-------------|--------------|-----|-----|------------|
-//! | `NGon`             | Monomorphic | $[2,12]$     | Yes | Yes | Yes        |
+//! | `NGon`             | Monomorphic | $1,[3,32]$   | Yes | Yes | Yes        |
 //! | `BoundedPolygon`   | Polymorphic | $[3,4]$      | Yes | No  | Yes        |
 //! | `UnboundedPolygon` | Polymorphic | $[3,\infin)$ | Yes | No  | No         |
 //!
@@ -43,7 +43,7 @@
 //! traits. [`UnboundedPolygon`] is most flexible and can represent any
 //! arbitrary polygon, but does not support any tessellation features.
 //!
-//! [`Edge`]s are always represented as `NGon<[_; 2]>`.
+//! [`Edge`]s are always represented as `NGon<_, 2>`.
 //!
 //! # Examples
 //!
@@ -85,13 +85,14 @@ pub mod decompose;
 pub mod generate;
 pub mod sphere;
 
-use arrayvec::{Array, ArrayVec};
+use arrayvec::ArrayVec;
 use decorum::Real;
 use fool::BoolExt as _;
 use itertools::izip;
 use itertools::structs::Zip as OuterZip; // Avoid collision with `Zip`.
 use num::{Integer, One, Signed, Unsigned, Zero};
 use smallvec::{smallvec, SmallVec};
+use std::array;
 use std::convert::TryInto;
 use std::fmt::{self, Debug, Formatter};
 use std::marker::PhantomData;
@@ -101,12 +102,12 @@ use theon::ops::Cross;
 use theon::query::{Intersection, Line, LineLine, LinePlane, Plane, Unit};
 use theon::space::{EuclideanSpace, FiniteDimensional, Scalar, Vector, VectorSpace};
 use theon::{AsPosition, AsPositionMut, Position};
-use typenum::type_operators::Cmp;
-use typenum::{Greater, U2, U3};
+use typenum::{Cmp, Greater, U1, U2, U3};
 
+use crate::constant::{Constant, ToType, TypeOf};
 use crate::geometry::partition::PointPartition;
 use crate::primitive::decompose::IntoVertices;
-use crate::{DynamicArity, IteratorExt as _, Monomorphic, StaticArity};
+use crate::{DynamicArity, IteratorExt as _, Monomorphic, StaticArity, TryFromIterator};
 
 /// Topological structure.
 ///
@@ -413,62 +414,104 @@ where
 /// `NGon` represents a polygonal structure as an array. Each array element
 /// represents vertex data in order with adjacent elements being connected by an
 /// implicit undirected edge. For example, an `NGon` with three vertices
-/// (`NGon<[T; 3]>`) would represent a trigon (triangle). Generally these
-/// elements are labeled $A$, $B$, $C$, etc.
+/// (`NGon<_, 3>`) would represent a trigon (triangle). Generally these elements
+/// are labeled $A$, $B$, $C$, etc. Note that the constant parameter `N`
+/// represents the number of the `NGon`'s vertices and **not** the number of its
+/// edges (arity).
 ///
 /// `NGon`s with less than three vertices are a degenerate case. An `NGon` with
-/// two vertices (`NGon<[T; 2]>`) is considered a _monogon_ despite common
-/// definitions specifying a single vertex. Such an `NGon` is not considered a
-/// _digon_, as it represents a single undirected edge rather than two distinct
-/// (but collapsed) edges. Single-vertex `NGon`s are unsupported. See the `Edge`
-/// type definition.
+/// two vertices (`NGon<_, 2>`) is considered a _monogon_ and is used to
+/// represent edges. Such an `NGon` is not considered a _digon_, as it
+/// represents a single undirected edge rather than two distinct (but collapsed)
+/// edges. Note that the polygonal types [`BoundedPolygon`] and
+/// [`UnboundedPolygon`] never represent edges. See the [`Edge`] type
+/// definition.
+///
+/// `NGon`s with one or zero vertices are unsupported and lack various trait
+/// implementations.
 ///
 /// See the [module][`primitive`] documentation for more information.
 ///
+/// [`BoundedPolygon`]: crate::primitive::BoundedPolygon
+/// [`Edge`]: crate::primitive::Edge
 /// [`primitive`]: crate::primitive
+/// [`UnboundedPolygon`]: crate::primitive::UnboundedPolygon
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub struct NGon<A>(pub A)
-where
-    A: Array;
+pub struct NGon<G, const N: usize>(pub [G; N]);
 
-impl<A> NGon<A>
-where
-    A: Array,
-{
-    pub fn into_array(self) -> A {
+impl<G, const N: usize> NGon<G, N> {
+    pub fn into_array(self) -> [G; N] {
         self.0
     }
+
+    pub fn positions(&self) -> NGon<&Position<G>, N>
+    where
+        G: AsPosition,
+    {
+        if let Ok(array) = self
+            .as_ref()
+            .iter()
+            .map(|vertex| vertex.as_position())
+            .collect::<ArrayVec<_, N>>()
+            .into_inner()
+        {
+            array.into()
+        }
+        else {
+            panic!()
+        }
+    }
 }
 
-impl<A> AsRef<[<A as Array>::Item]> for NGon<A>
-where
-    A: Array,
-{
-    fn as_ref(&self) -> &[A::Item] {
-        self.0.as_slice()
+impl<'a, G, const N: usize> NGon<&'a G, N> {
+    pub fn cloned(self) -> NGon<G, N>
+    where
+        G: Clone,
+    {
+        self.map(|vertex| vertex.clone())
+    }
+}
+
+impl<G, const N: usize> AsRef<[G]> for NGon<G, N> {
+    fn as_ref(&self) -> &[G] {
+        &self.0
     }
 }
 
-impl<A> AsMut<[<A as Array>::Item]> for NGon<A>
+impl<G, const N: usize> AsMut<[G]> for NGon<G, N> {
+    fn as_mut(&mut self) -> &mut [G] {
+        &mut self.0
+    }
+}
+
+impl<G, const N: usize> Adjunct for NGon<G, N> {
+    type Item = G;
+}
+
+impl<G, const N: usize> Converged for NGon<G, N>
 where
-    A: Array,
+    G: Copy,
 {
-    fn as_mut(&mut self) -> &mut [A::Item] {
-        self.0.as_mut_slice()
+    fn converged(vertex: G) -> Self {
+        NGon([vertex; N])
     }
 }
 
-impl<A> Adjunct for NGon<A>
+impl<G, const N: usize> DynamicArity for NGon<G, N>
 where
-    A: Array,
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U1, Output = Greater>,
 {
-    type Item = A::Item;
+    type Dynamic = usize;
+
+    fn arity(&self) -> Self::Dynamic {
+        <Self as StaticArity>::ARITY
+    }
 }
 
-impl<A> Fold for NGon<A>
+impl<G, const N: usize> Fold for NGon<G, N>
 where
-    Self: Topological + IntoItems,
-    A: Array,
+    Self: Topological,
 {
     fn fold<U, F>(self, mut seed: U, mut f: F) -> U
     where
@@ -481,225 +524,168 @@ where
     }
 }
 
-impl<A> From<A> for NGon<A>
-where
-    A: Array,
-{
-    fn from(array: A) -> Self {
+impl<G, const N: usize> From<[G; N]> for NGon<G, N> {
+    fn from(array: [G; N]) -> Self {
         NGon(array)
     }
 }
 
-impl<A> FromItems for NGon<A>
-where
-    A: Array,
-{
+impl<G, const N: usize> FromItems for NGon<G, N> {
     fn from_items<I>(items: I) -> Option<Self>
     where
         I: IntoIterator<Item = Self::Item>,
     {
-        items
-            .into_iter()
-            .collect::<ArrayVec<A>>()
-            .into_inner()
-            .ok()
-            .map(NGon)
+        items.into_iter().try_collect().ok()
     }
 }
 
-impl<A> Index<usize> for NGon<A>
-where
-    A: Array + AsRef<[<A as Array>::Item]>,
-{
-    type Output = A::Item;
+impl<G, const N: usize> Index<usize> for NGon<G, N> {
+    type Output = G;
 
     fn index(&self, index: usize) -> &Self::Output {
         self.0.as_ref().index(index)
     }
 }
 
-impl<A> IndexMut<usize> for NGon<A>
-where
-    A: Array + AsRef<[<A as Array>::Item]> + AsMut<[<A as Array>::Item]>,
-{
+impl<G, const N: usize> IndexMut<usize> for NGon<G, N> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         self.0.as_mut().index_mut(index)
     }
 }
 
-impl<A> IntoItems for NGon<A>
-where
-    A: Array,
-{
-    type Output = ArrayVec<A>;
+impl<G, const N: usize> IntoItems for NGon<G, N> {
+    type Output = <Self as IntoIterator>::IntoIter;
 
     fn into_items(self) -> Self::Output {
-        ArrayVec::from(self.into_array())
+        self.into_iter()
     }
 }
 
-impl<A> IntoIterator for NGon<A>
-where
-    A: Array,
-{
-    type Item = <A as Array>::Item;
-    type IntoIter = <<Self as IntoItems>::Output as IntoIterator>::IntoIter;
+impl<G, const N: usize> IntoIterator for NGon<G, N> {
+    type Item = G;
+    type IntoIter = array::IntoIter<G, N>;
 
     fn into_iter(self) -> Self::IntoIter {
-        self.into_items().into_iter()
+        array::IntoIter::new(self.into_array())
     }
 }
 
-macro_rules! impl_monomorphic_ngon {
-    (length => $n:expr) => (
-        impl<T> Monomorphic for NGon<[T; $n]> {}
+impl<G, H, const N: usize> Map<H> for NGon<G, N> {
+    type Output = NGon<H, N>;
+
+    fn map<F>(self, f: F) -> Self::Output
+    where
+        F: FnMut(Self::Item) -> H,
+    {
+        (self.into_iter().map(f)).try_collect().unwrap()
+    }
+}
 
-        impl<T> StaticArity for NGon<[T; $n]> {
-            type Static = usize;
+impl<G, const N: usize> Monomorphic for NGon<G, N>
+where
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U1, Output = Greater>,
+{
+}
 
-            const ARITY: Self::Static = $n;
-        }
+impl<G, const N: usize> Polygonal for NGon<G, N>
+where
+    // The compiler cannot deduce that the bounds on `TypeOf<N>` are a strict
+    // subset of the similar bounds on the `Topological` implementation, so an
+    // explicit bound on `Self` is required.
+    Self: Topological,
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U2, Output = Greater>,
+{
+}
 
-        impl<T> Polygonal for NGon<[T; $n]> {}
-    );
-    (lengths => $($n:expr),*$(,)?) => (
-        impl<T> Monomorphic for NGon<[T; 2]> {}
+impl<G, const N: usize> StaticArity for NGon<G, N>
+where
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U1, Output = Greater>,
+{
+    type Static = usize;
 
-        impl<T> StaticArity for NGon<[T; 2]> {
-            type Static = usize;
+    const ARITY: Self::Static = crate::n_arity(N);
+}
 
-            const ARITY: Self::Static = 1;
-        }
+impl<G, const N: usize> Topological for NGon<G, N>
+where
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U1, Output = Greater>,
+{
+    type Vertex = G;
 
-        $(impl_monomorphic_ngon!(length => $n);)*
-    );
+    fn try_from_slice<I>(vertices: I) -> Option<Self>
+    where
+        Self::Vertex: Copy,
+        I: AsRef<[Self::Vertex]>,
+    {
+        vertices.as_ref().try_into().map(NGon).ok()
+    }
 }
-impl_monomorphic_ngon!(lengths => 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 
-macro_rules! impl_zip_ngon {
-    (length => $n:expr) => (
-        impl_zip_ngon!(length => $n, items => (A, B));
-        impl_zip_ngon!(length => $n, items => (A, B, C));
-        impl_zip_ngon!(length => $n, items => (A, B, C, D));
-        impl_zip_ngon!(length => $n, items => (A, B, C, D, E));
-        impl_zip_ngon!(length => $n, items => (A, B, C, D, E, F));
-    );
-    (length => $n:expr, items => ($($i:ident),*)) => (
-        #[allow(non_snake_case)]
-        impl<$($i),*> Zip for ($(NGon<[$i; $n]>),*) {
-            type Output = NGon<[($($i),*); $n]>;
+impl<G, const N: usize> TryFromIterator<G> for NGon<G, N> {
+    type Error = ();
 
-            fn zip(self) -> Self::Output {
-                let ($($i,)*) = self;
-                FromItems::from_items(izip!($($i.into_items()),*)).unwrap()
-            }
-        }
-    );
+    fn try_from_iter<I>(vertices: I) -> Result<Self, Self::Error>
+    where
+        I: Iterator<Item = G>,
+    {
+        vertices
+            .collect::<ArrayVec<G, N>>()
+            .into_inner()
+            .map(NGon)
+            .map_err(|_| ())
+    }
 }
 
-// TODO: Some inherent functions are not documented to avoid bloat.
-macro_rules! impl_ngon {
-    (length => $n:expr) => (
-        impl<T> NGon<[T; $n]> {
-            #[doc(hidden)]
-            pub fn positions(&self) -> NGon<[&Position<T>; $n]>
-            where
-                T: AsPosition,
-            {
-                if let Ok(array) = self
-                    .as_ref()
-                    .iter()
-                    .map(|vertex| vertex.as_position())
-                    .collect::<ArrayVec<[_; $n]>>()
-                    .into_inner()
-                {
-                    array.into()
-                }
-                else {
-                    panic!()
-                }
-            }
-        }
+impl<G, H, const N: usize> ZipMap<H> for NGon<G, N> {
+    type Output = NGon<H, N>;
 
-        impl<'a, T> NGon<[&'a T; $n]> {
-            #[doc(hidden)]
-            pub fn cloned(self) -> NGon<[T; $n]>
-            where
-                T: Clone,
-            {
-                self.map(|vertex| vertex.clone())
-            }
-        }
+    fn zip_map<F>(self, other: Self, mut f: F) -> Self::Output
+    where
+        F: FnMut(Self::Item, Self::Item) -> H,
+    {
+        (self.into_iter().zip(other).map(|(a, b)| f(a, b)))
+            .try_collect()
+            .unwrap()
+    }
+}
 
-        impl<T> Converged for NGon<[T; $n]>
+macro_rules! impl_zip_ngon {
+    (ngons => ($($i:ident),*)) => (
+        #[allow(non_snake_case)]
+        impl<$($i),*, const N: usize> Zip for ($(NGon<$i, N>),*)
         where
-            T: Copy,
+            Constant<N>: ToType,
+            TypeOf<N>: Cmp<U1, Output = Greater>,
         {
-            fn converged(item: T) -> Self {
-                NGon([item; $n])
-            }
-        }
-
-        impl<T> DynamicArity for NGon<[T; $n]> {
-            type Dynamic = usize;
-
-            fn arity(&self) -> Self::Dynamic {
-                <Self as StaticArity>::ARITY
-            }
-        }
-
-        impl<T, U> Map<U> for NGon<[T; $n]> {
-            type Output = NGon<[U; $n]>;
+            type Output = NGon<($($i),*), N>;
 
-            fn map<F>(self, f: F) -> Self::Output
-            where
-                F: FnMut(Self::Item) -> U,
-            {
-                FromItems::from_items(self.into_iter().map(f)).unwrap()
-            }
-        }
-
-        impl<T> Topological for NGon<[T; $n]> {
-            type Vertex = T;
-
-            fn try_from_slice<U>(vertices: U) -> Option<Self>
-            where
-                Self::Vertex: Copy,
-                U: AsRef<[Self::Vertex]>,
-            {
-                vertices.as_ref().try_into().map(NGon).ok()
-            }
-        }
-
-        impl_zip_ngon!(length => $n);
-
-        impl<T, U> ZipMap<U> for NGon<[T; $n]> {
-            type Output = NGon<[U; $n]>;
-
-            fn zip_map<F>(self, other: Self, mut f: F) -> Self::Output
-            where
-                F: FnMut(Self::Item, Self::Item) -> U,
-            {
-                FromItems::from_items(self.into_iter().zip(other).map(|(a, b)| f(a, b))).unwrap()
+            fn zip(self) -> Self::Output {
+                let ($($i,)*) = self;
+                (izip!($($i.into_iter()),*)).try_collect().unwrap()
             }
         }
     );
-    (lengths => $($n:expr),*$(,)?) => (
-        $(impl_ngon!(length => $n);)*
-    );
 }
-impl_ngon!(lengths => 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+impl_zip_ngon!(ngons => (A, B));
+impl_zip_ngon!(ngons => (A, B, C));
+impl_zip_ngon!(ngons => (A, B, C, D));
+impl_zip_ngon!(ngons => (A, B, C, D, E));
+impl_zip_ngon!(ngons => (A, B, C, D, E, F));
 
-pub type Edge<T> = NGon<[T; 2]>;
+pub type Edge<G> = NGon<G, 2>;
 
-impl<T> Edge<T> {
-    pub fn new(a: T, b: T) -> Self {
+impl<G> Edge<G> {
+    pub fn new(a: G, b: G) -> Self {
         NGon([a, b])
     }
 
-    pub fn line(&self) -> Option<Line<Position<T>>>
+    pub fn line(&self) -> Option<Line<Position<G>>>
     where
-        T: AsPosition,
+        G: AsPosition,
     {
         let [origin, endpoint] = self.positions().cloned().into_array();
         Unit::try_from_inner(endpoint - origin).map(|direction| Line { origin, direction })
@@ -707,19 +693,21 @@ impl<T> Edge<T> {
 
     pub fn is_bisected(&self, other: &Self) -> bool
     where
-        T: AsPosition,
-        Position<T>: FiniteDimensional<N = U2>,
+        G: AsPosition,
+        Position<G>: FiniteDimensional<N = U2>,
     {
-        let is_disjoint = |line: Line<Position<T>>, [a, b]: [Position<T>; 2]| {
-            fool::zip((line.partition(a), line.partition(b)))
+        let is_disjoint = |line: Line<Position<G>>, [a, b]: [Position<G>; 2]| {
+            line.partition(a)
+                .zip(line.partition(b))
                 .map(|(pa, pb)| pa != pb)
                 .unwrap_or(false)
         };
-        fool::zip((self.line(), other.line()))
-            .map(|(l1, l2)| {
-                let l1 = is_disjoint(l1, other.positions().cloned().into_array());
-                let l2 = is_disjoint(l2, self.positions().cloned().into_array());
-                l1 && l2
+        self.line()
+            .zip(other.line())
+            .map(|(left, right)| {
+                let left = is_disjoint(left, other.positions().cloned().into_array());
+                let right = is_disjoint(right, self.positions().cloned().into_array());
+                left && right
             })
             .unwrap_or(false)
     }
@@ -778,13 +766,15 @@ where
     //       edge's endpoints by the other edge's line. That's probably more
     //       expensive than is necessary.
     fn intersection(&self, other: &Edge<T>) -> Option<Self::Output> {
-        fool::zip((self.line(), other.line())).and_then(|(l1, l2)| match l1.intersection(&l2) {
-            Some(LineLine::Point(point)) => self
-                .is_bisected(other)
-                .then_some_ext(EdgeEdge::Point(point)),
-            Some(LineLine::Line(_)) => todo!(),
-            _ => None,
-        })
+        self.line()
+            .zip(other.line())
+            .and_then(|(left, right)| match left.intersection(&right) {
+                Some(LineLine::Point(point)) => self
+                    .is_bisected(other)
+                    .then_some_ext(EdgeEdge::Point(point)),
+                Some(LineLine::Line(_)) => todo!(),
+                _ => None,
+            })
     }
 }
 
@@ -801,29 +791,29 @@ impl<T> Rotate for Edge<T> {
 }
 
 /// Triangle.
-pub type Trigon<T> = NGon<[T; 3]>;
+pub type Trigon<G> = NGon<G, 3>;
 
-impl<T> Trigon<T> {
-    pub fn new(a: T, b: T, c: T) -> Self {
+impl<G> Trigon<G> {
+    pub fn new(a: G, b: G, c: G) -> Self {
         NGon([a, b, c])
     }
 
     #[allow(clippy::many_single_char_names)]
-    pub fn plane(&self) -> Option<Plane<Position<T>>>
+    pub fn plane(&self) -> Option<Plane<Position<G>>>
     where
-        T: AsPosition,
-        Position<T>: EuclideanSpace + FiniteDimensional<N = U3>,
-        Vector<Position<T>>: Cross<Output = Vector<Position<T>>>,
+        G: AsPosition,
+        Position<G>: EuclideanSpace + FiniteDimensional<N = U3>,
+        Vector<Position<G>>: Cross<Output = Vector<Position<G>>>,
     {
         let [a, b, c] = self.positions().cloned().into_array();
         let v = a - b;
         let u = a - c;
         Unit::try_from_inner(v.cross(u))
-            .map(move |normal| Plane::<Position<T>> { origin: a, normal })
+            .map(move |normal| Plane::<Position<G>> { origin: a, normal })
     }
 }
 
-impl<T> Rotate for Trigon<T> {
+impl<G> Rotate for Trigon<G> {
     fn rotate(self, n: isize) -> Self {
         let n = umod(n, Self::ARITY as isize);
         if n == 1 {
@@ -841,15 +831,15 @@ impl<T> Rotate for Trigon<T> {
 }
 
 /// Quadrilateral.
-pub type Tetragon<T> = NGon<[T; 4]>;
+pub type Tetragon<G> = NGon<G, 4>;
 
-impl<T> Tetragon<T> {
-    pub fn new(a: T, b: T, c: T, d: T) -> Self {
+impl<G> Tetragon<G> {
+    pub fn new(a: G, b: G, c: G, d: G) -> Self {
         NGon([a, b, c, d])
     }
 }
 
-impl<T> Rotate for Tetragon<T> {
+impl<G> Rotate for Tetragon<G> {
     #[allow(clippy::many_single_char_names)]
     fn rotate(self, n: isize) -> Self {
         let n = umod(n, Self::ARITY as isize);
@@ -883,13 +873,13 @@ impl<T> Rotate for Tetragon<T> {
 /// [`primitive`]: crate::primitive
 /// [`NGon`]: crate::primitive::NGon
 #[derive(Clone, Copy, Debug, PartialEq)]
-pub enum BoundedPolygon<T> {
-    N3(Trigon<T>),
-    N4(Tetragon<T>),
+pub enum BoundedPolygon<G> {
+    N3(Trigon<G>),
+    N4(Tetragon<G>),
 }
 
-impl<T> AsRef<[T]> for BoundedPolygon<T> {
-    fn as_ref(&self) -> &[T] {
+impl<G> AsRef<[G]> for BoundedPolygon<G> {
+    fn as_ref(&self) -> &[G] {
         match *self {
             BoundedPolygon::N3(ref trigon) => trigon.as_ref(),
             BoundedPolygon::N4(ref tetragon) => tetragon.as_ref(),
@@ -897,8 +887,8 @@ impl<T> AsRef<[T]> for BoundedPolygon<T> {
     }
 }
 
-impl<T> AsMut<[T]> for BoundedPolygon<T> {
-    fn as_mut(&mut self) -> &mut [T] {
+impl<G> AsMut<[G]> for BoundedPolygon<G> {
+    fn as_mut(&mut self) -> &mut [G] {
         match *self {
             BoundedPolygon::N3(ref mut trigon) => trigon.as_mut(),
             BoundedPolygon::N4(ref mut tetragon) => tetragon.as_mut(),
@@ -906,22 +896,22 @@ impl<T> AsMut<[T]> for BoundedPolygon<T> {
     }
 }
 
-impl<T> Adjunct for BoundedPolygon<T> {
-    type Item = T;
+impl<G> Adjunct for BoundedPolygon<G> {
+    type Item = G;
 }
 
-impl<T> DynamicArity for BoundedPolygon<T> {
+impl<G> DynamicArity for BoundedPolygon<G> {
     type Dynamic = usize;
 
     fn arity(&self) -> Self::Dynamic {
         match *self {
-            BoundedPolygon::N3(..) => Trigon::<T>::ARITY,
-            BoundedPolygon::N4(..) => Tetragon::<T>::ARITY,
+            BoundedPolygon::N3(..) => Trigon::<G>::ARITY,
+            BoundedPolygon::N4(..) => Tetragon::<G>::ARITY,
         }
     }
 }
 
-impl<T> Fold for BoundedPolygon<T> {
+impl<G> Fold for BoundedPolygon<G> {
     fn fold<U, F>(self, mut seed: U, mut f: F) -> U
     where
         F: FnMut(U, Self::Item) -> U,
@@ -933,32 +923,32 @@ impl<T> Fold for BoundedPolygon<T> {
     }
 }
 
-impl<T> From<[T; 3]> for BoundedPolygon<T> {
-    fn from(array: [T; 3]) -> Self {
+impl<G> From<[G; 3]> for BoundedPolygon<G> {
+    fn from(array: [G; 3]) -> Self {
         BoundedPolygon::N3(array.into())
     }
 }
 
-impl<T> From<[T; 4]> for BoundedPolygon<T> {
-    fn from(array: [T; 4]) -> Self {
+impl<G> From<[G; 4]> for BoundedPolygon<G> {
+    fn from(array: [G; 4]) -> Self {
         BoundedPolygon::N4(array.into())
     }
 }
 
-impl<T> From<Trigon<T>> for BoundedPolygon<T> {
-    fn from(trigon: Trigon<T>) -> Self {
+impl<G> From<Trigon<G>> for BoundedPolygon<G> {
+    fn from(trigon: Trigon<G>) -> Self {
         BoundedPolygon::N3(trigon)
     }
 }
 
-impl<T> From<Tetragon<T>> for BoundedPolygon<T> {
-    fn from(tetragon: Tetragon<T>) -> Self {
+impl<G> From<Tetragon<G>> for BoundedPolygon<G> {
+    fn from(tetragon: Tetragon<G>) -> Self {
         BoundedPolygon::N4(tetragon)
     }
 }
 
-impl<T> Index<usize> for BoundedPolygon<T> {
-    type Output = T;
+impl<G> Index<usize> for BoundedPolygon<G> {
+    type Output = G;
 
     fn index(&self, index: usize) -> &Self::Output {
         match *self {
@@ -968,7 +958,7 @@ impl<T> Index<usize> for BoundedPolygon<T> {
     }
 }
 
-impl<T> IndexMut<usize> for BoundedPolygon<T> {
+impl<G> IndexMut<usize> for BoundedPolygon<G> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         match *self {
             BoundedPolygon::N3(ref mut trigon) => trigon.index_mut(index),
@@ -977,8 +967,8 @@ impl<T> IndexMut<usize> for BoundedPolygon<T> {
     }
 }
 
-impl<T> IntoItems for BoundedPolygon<T> {
-    type Output = SmallVec<[T; 4]>;
+impl<G> IntoItems for BoundedPolygon<G> {
+    type Output = SmallVec<[G; 4]>;
 
     fn into_items(self) -> Self::Output {
         match self {
@@ -988,8 +978,8 @@ impl<T> IntoItems for BoundedPolygon<T> {
     }
 }
 
-impl<T> IntoIterator for BoundedPolygon<T> {
-    type Item = T;
+impl<G> IntoIterator for BoundedPolygon<G> {
+    type Item = G;
     type IntoIter = <<Self as IntoItems>::Output as IntoIterator>::IntoIter;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -1011,9 +1001,9 @@ impl<T, U> Map<U> for BoundedPolygon<T> {
     }
 }
 
-impl<T> Polygonal for BoundedPolygon<T> {}
+impl<G> Polygonal for BoundedPolygon<G> {}
 
-impl<T> Rotate for BoundedPolygon<T> {
+impl<G> Rotate for BoundedPolygon<G> {
     fn rotate(self, n: isize) -> Self {
         match self {
             BoundedPolygon::N3(trigon) => BoundedPolygon::N3(trigon.rotate(n)),
@@ -1022,19 +1012,19 @@ impl<T> Rotate for BoundedPolygon<T> {
     }
 }
 
-impl<T> StaticArity for BoundedPolygon<T> {
+impl<G> StaticArity for BoundedPolygon<G> {
     type Static = (usize, usize);
 
     const ARITY: Self::Static = (3, 4);
 }
 
-impl<T> Topological for BoundedPolygon<T> {
-    type Vertex = T;
+impl<G> Topological for BoundedPolygon<G> {
+    type Vertex = G;
 
-    fn try_from_slice<U>(vertices: U) -> Option<Self>
+    fn try_from_slice<I>(vertices: I) -> Option<Self>
     where
         Self::Vertex: Copy,
-        U: AsRef<[Self::Vertex]>,
+        I: AsRef<[Self::Vertex]>,
     {
         let vertices = vertices.as_ref();
         match vertices.len() {
@@ -1059,51 +1049,51 @@ impl<T> Topological for BoundedPolygon<T> {
 /// [`BoundedPolygon`]: crate::primitive::BoundedPolygon
 /// [`NGon`]: crate::primitive::NGon
 #[derive(Clone, Debug, PartialEq)]
-pub struct UnboundedPolygon<T>(SmallVec<[T; 4]>);
+pub struct UnboundedPolygon<G>(SmallVec<[G; 4]>);
 
-impl<T> UnboundedPolygon<T> {
-    pub fn trigon(a: T, b: T, c: T) -> Self {
+impl<G> UnboundedPolygon<G> {
+    pub fn trigon(a: G, b: G, c: G) -> Self {
         UnboundedPolygon(smallvec![a, b, c])
     }
 
-    pub fn tetragon(a: T, b: T, c: T, d: T) -> Self {
+    pub fn tetragon(a: G, b: G, c: G, d: G) -> Self {
         UnboundedPolygon(smallvec![a, b, c, d])
     }
 
-    pub fn positions(&self) -> UnboundedPolygon<&Position<T>>
+    pub fn positions(&self) -> UnboundedPolygon<&Position<G>>
     where
-        T: AsPosition,
+        G: AsPosition,
     {
         UnboundedPolygon(self.0.iter().map(|vertex| vertex.as_position()).collect())
     }
 }
 
-impl<'a, T> UnboundedPolygon<&'a T>
+impl<'a, G> UnboundedPolygon<&'a G>
 where
-    T: Clone,
+    G: Clone,
 {
-    pub fn cloned(self) -> UnboundedPolygon<T> {
+    pub fn cloned(self) -> UnboundedPolygon<G> {
         self.map(|vertex| vertex.clone())
     }
 }
 
-impl<T> Adjunct for UnboundedPolygon<T> {
-    type Item = T;
+impl<G> Adjunct for UnboundedPolygon<G> {
+    type Item = G;
 }
 
-impl<T> AsRef<[T]> for UnboundedPolygon<T> {
-    fn as_ref(&self) -> &[T] {
+impl<G> AsRef<[G]> for UnboundedPolygon<G> {
+    fn as_ref(&self) -> &[G] {
         self.0.as_ref()
     }
 }
 
-impl<T> AsMut<[T]> for UnboundedPolygon<T> {
-    fn as_mut(&mut self) -> &mut [T] {
+impl<G> AsMut<[G]> for UnboundedPolygon<G> {
+    fn as_mut(&mut self) -> &mut [G] {
         self.0.as_mut()
     }
 }
 
-impl<T> DynamicArity for UnboundedPolygon<T> {
+impl<G> DynamicArity for UnboundedPolygon<G> {
     type Dynamic = usize;
 
     fn arity(&self) -> Self::Dynamic {
@@ -1111,52 +1101,60 @@ impl<T> DynamicArity for UnboundedPolygon<T> {
     }
 }
 
-impl<T> From<BoundedPolygon<T>> for UnboundedPolygon<T>
+impl<G> From<BoundedPolygon<G>> for UnboundedPolygon<G>
 where
-    T: Clone,
+    G: Clone,
 {
-    fn from(polygon: BoundedPolygon<T>) -> Self {
+    fn from(polygon: BoundedPolygon<G>) -> Self {
         UnboundedPolygon(SmallVec::from(polygon.as_ref()))
     }
 }
 
-impl<T> FromItems for UnboundedPolygon<T> {
+impl<G, const N: usize> From<NGon<G, N>> for UnboundedPolygon<G>
+where
+    Constant<N>: ToType,
+    TypeOf<N>: Cmp<U2, Output = Greater>,
+    G: Clone,
+{
+    fn from(ngon: NGon<G, N>) -> Self {
+        UnboundedPolygon(SmallVec::from(ngon.as_ref()))
+    }
+}
+
+impl<G> FromItems for UnboundedPolygon<G> {
     fn from_items<I>(items: I) -> Option<Self>
     where
         I: IntoIterator<Item = Self::Item>,
     {
-        items
-            .into_iter()
-            .has_at_least(3)
-            .map(|items| UnboundedPolygon(items.collect()))
+        items.into_iter().try_collect().ok()
     }
 }
 
-impl<T> Index<usize> for UnboundedPolygon<T> {
-    type Output = T;
+impl<G> Index<usize> for UnboundedPolygon<G> {
+    type Output = G;
 
     fn index(&self, index: usize) -> &Self::Output {
         self.0.index(index)
     }
 }
 
-impl<T> IndexMut<usize> for UnboundedPolygon<T> {
+impl<G> IndexMut<usize> for UnboundedPolygon<G> {
     fn index_mut(&mut self, index: usize) -> &mut Self::Output {
         self.0.index_mut(index)
     }
 }
 
-impl<T> IntoItems for UnboundedPolygon<T> {
-    type Output = SmallVec<[T; 4]>;
+impl<G> IntoItems for UnboundedPolygon<G> {
+    type Output = SmallVec<[G; 4]>;
 
     fn into_items(self) -> Self::Output {
         self.0
     }
 }
 
-impl<T> IntoIterator for UnboundedPolygon<T> {
-    type IntoIter = <SmallVec<[T; 4]> as IntoIterator>::IntoIter;
-    type Item = T;
+impl<G> IntoIterator for UnboundedPolygon<G> {
+    type IntoIter = <SmallVec<[G; 4]> as IntoIterator>::IntoIter;
+    type Item = G;
 
     fn into_iter(self) -> Self::IntoIter {
         self.0.into_iter()
@@ -1174,21 +1172,21 @@ impl<T, U> Map<U> for UnboundedPolygon<T> {
     }
 }
 
-impl<T> Polygonal for UnboundedPolygon<T> {}
+impl<G> Polygonal for UnboundedPolygon<G> {}
 
-impl<T> StaticArity for UnboundedPolygon<T> {
+impl<G> StaticArity for UnboundedPolygon<G> {
     type Static = (usize, Option<usize>);
 
     const ARITY: Self::Static = (3, None);
 }
 
-impl<T> Topological for UnboundedPolygon<T> {
-    type Vertex = T;
+impl<G> Topological for UnboundedPolygon<G> {
+    type Vertex = G;
 
-    fn try_from_slice<U>(vertices: U) -> Option<Self>
+    fn try_from_slice<I>(vertices: I) -> Option<Self>
     where
         Self::Vertex: Copy,
-        U: AsRef<[Self::Vertex]>,
+        I: AsRef<[Self::Vertex]>,
     {
         let vertices = vertices.as_ref();
         if vertices.len() > 2 {
@@ -1200,22 +1198,19 @@ impl<T> Topological for UnboundedPolygon<T> {
     }
 }
 
-macro_rules! impl_unbounded_polygon {
-    (length => $n:expr) => (
-        impl<T> From<NGon<[T; $n]>> for UnboundedPolygon<T>
-        where
-            T: Clone,
-        {
-            fn from(ngon: NGon<[T; $n]>) -> Self {
-                UnboundedPolygon(SmallVec::from(ngon.as_ref()))
-            }
-        }
-    );
-    (lengths => $($n:expr),*$(,)?) => (
-        $(impl_unbounded_polygon!(length => $n);)*
-    );
+impl<G> TryFromIterator<G> for UnboundedPolygon<G> {
+    type Error = ();
+
+    fn try_from_iter<I>(vertices: I) -> Result<Self, Self::Error>
+    where
+        I: Iterator<Item = G>,
+    {
+        vertices
+            .has_at_least(3)
+            .map(|items| UnboundedPolygon(items.collect()))
+            .ok_or(())
+    }
 }
-impl_unbounded_polygon!(lengths => 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
 
 /// Zips the vertices of [`Topological`] types from multiple iterators into a
 /// single iterator.
@@ -1281,7 +1276,7 @@ where
 /// the polygon.
 ///
 /// [`Polygonal`]: crate::primitive::Polygonal
-fn angles<'a, P>(polygon: &'a P) -> impl 'a + Clone + Iterator<Item = Scalar<Position<P::Vertex>>>
+fn angles<P>(polygon: &P) -> impl '_ + Clone + Iterator<Item = Scalar<Position<P::Vertex>>>
 where
     P: Polygonal,
     P::Vertex: AsPosition,
diff --git a/plexus/src/primitive/sphere.rs b/plexus/src/primitive/sphere.rs
index 51d2d2ef..7002ca81 100644
--- a/plexus/src/primitive/sphere.rs
+++ b/plexus/src/primitive/sphere.rs
@@ -318,7 +318,6 @@ where
 mod tests {
     use nalgebra::Point3;
     use std::collections::BTreeSet;
-    use std::iter::FromIterator;
 
     use crate::prelude::*;
     use crate::primitive::generate::Position;
@@ -351,12 +350,11 @@ mod tests {
     fn position_index_to_vertex_mapping() {
         assert_eq!(
             5,
-            BTreeSet::from_iter(
-                UvSphere::new(3, 2)
-                    .indexing_polygons::<Position>() // 18 vertices, 5 indices.
-                    .vertices()
-            )
-            .len()
+            UvSphere::new(3, 2)
+                .indexing_polygons::<Position>() // 18 vertices, 5 indices.
+                .vertices()
+                .collect::<BTreeSet<_>>()
+                .len()
         )
     }
 }