SYMBOL INDEX (1716 symbols across 50 files)

FILE: benches/subdivide.rs
  constant DEPTH (line 9) | const DEPTH: usize = 8;
  type E3 (line 11) | type E3 = Point3<f64>;
  type Ambo (line 13) | pub trait Ambo<G> {
    method ambo (line 15) | fn ambo(self) -> Self;
  function ambo (line 25) | fn ambo(self) -> Self {
  function tetragon (line 45) | fn tetragon() -> MeshGraph<E3> {
  function subdivide (line 55) | fn subdivide(mut graph: MeshGraph<E3>) {
  function benchmark (line 66) | fn benchmark(criterion: &mut Criterion) {

FILE: examples/sphere/src/main.rs
  type E3 (line 9) | type E3 = Point3<f32>;
  function main (line 11) | fn main() {

FILE: examples/subdivide/src/main.rs
  type E3 (line 10) | type E3 = Point3<f32>;
  type Ambo (line 12) | pub trait Ambo<G>: ClosedView {
    method ambo (line 14) | fn ambo(self) -> Self;
  function ambo (line 24) | fn ambo(self) -> Self {
  function main (line 44) | fn main() {

FILE: examples/teapot/src/main.rs
  type E3 (line 7) | type E3 = Point3<f32>;
  function main (line 9) | fn main() {

FILE: pictor/src/camera.rs
  type Projection (line 16) | pub enum Projection {
    method perspective (line 22) | pub fn perspective(aspect: f32, fov: f32, near: f32, far: f32) -> Self {
    method orthographic (line 26) | pub fn orthographic(left: f32, right: f32, bottom: f32, top: f32, near...
    method as_ref (line 32) | fn as_ref(&self) -> &Matrix4<f32> {
  type Camera (line 41) | pub struct Camera {
    method look_at (line 47) | pub fn look_at(&mut self, from: &Point3<f32>, to: &Point3<f32>) {
    method reproject (line 51) | pub fn reproject(&mut self, surface: &SurfaceConfiguration) {
    method transform (line 64) | pub fn transform(&self) -> Matrix4<f32> {
    method from (line 70) | fn from(projection: Projection) -> Self {

FILE: pictor/src/harness.rs
  type Executor (line 15) | struct Executor {
    method new (line 21) | pub fn new() -> Self {
    method flush (line 27) | pub fn flush(&mut self) {
    method spawner (line 31) | pub fn spawner(&self) -> &impl LocalSpawn {
  type Activity (line 37) | struct Activity<T> {
  function bind_and_configure (line 47) | pub fn bind_and_configure(window: Window, configuration: T::Configuratio...
  type Harness (line 60) | struct Harness<T, F> {
  function redraw (line 70) | fn redraw(&mut self) {
  function resize (line 83) | fn resize(&mut self, dimensions: PhysicalSize<u32>) {
  function resumed (line 102) | fn resumed(&mut self, reactor: &ActiveEventLoop) {
  function suspended (line 110) | fn suspended(&mut self, _reactor: &ActiveEventLoop) {
  function window_event (line 114) | fn window_event(&mut self, reactor: &ActiveEventLoop, _: WindowId, event...
  type Reaction (line 138) | pub enum Reaction {
  type ConfigureStage (line 144) | pub trait ConfigureStage {
    method device (line 145) | fn device(&self) -> &wgpu::Device;
    method queue (line 147) | fn queue(&self) -> &wgpu::Queue;
    method surface_configuration (line 149) | fn surface_configuration(&self) -> &wgpu::SurfaceConfiguration;
  type RenderStage (line 152) | pub trait RenderStage {
    method device (line 153) | fn device(&self) -> &wgpu::Device;
    method queue (line 155) | fn queue(&self) -> &wgpu::Queue;
  type Application (line 158) | pub trait Application: 'static + Sized {
    method configure (line 162) | fn configure(
    method react (line 167) | fn react(&mut self, event: WindowEvent) -> Reaction {
    method resize (line 172) | fn resize(&mut self, stage: &impl ConfigureStage);
    method render (line 174) | fn render(
  function run (line 182) | pub fn run<T, F>(f: F)

FILE: pictor/src/pipeline.rs
  type Color4 (line 29) | pub struct Color4<T>(pub Vector4<T>)
  function white (line 37) | pub fn white() -> Self
  function random (line 44) | pub fn random() -> Self
  function as_ref (line 59) | fn as_ref(&self) -> &Vector4<T> {
  method default (line 68) | fn default() -> Self {
  function from (line 77) | fn from(vector: Vector4<T>) -> Self {
  function from (line 86) | fn from(color: Color4<T>) -> Self {
  type Vertex (line 95) | pub struct Vertex {
  method hash (line 104) | fn hash<H>(&self, state: &mut H)
  method eq (line 115) | fn eq(&self, other: &Self) -> bool {
  type RenderConfiguration (line 130) | struct RenderConfiguration {
  type RenderApplication (line 137) | struct RenderApplication {
    method configure_depth_buffer (line 150) | fn configure_depth_buffer(stage: &impl ConfigureStage) -> wgpu::Textur...
  type Configuration (line 172) | type Configuration = RenderConfiguration;
  type Error (line 173) | type Error = ();
  method configure (line 175) | fn configure(
  method react (line 350) | fn react(&mut self, event: WindowEvent) -> Reaction {
  method resize (line 365) | fn resize(&mut self, stage: &impl ConfigureStage) {
  method render (line 375) | fn render(&mut self, stage: &impl RenderStage, view: &wgpu::TextureView,...
  function render_mesh_buffer_with (line 414) | pub fn render_mesh_buffer_with<F>(from: Point3<f32>, to: Point3<f32>, mu...

FILE: pictor/src/renderer.rs
  type Renderer (line 7) | pub struct Renderer<'window> {
  function try_from_window (line 17) | pub async fn try_from_window<T>(window: T) -> Result<Self, ()>
  method device (line 59) | fn device(&self) -> &wgpu::Device {
  method queue (line 63) | fn queue(&self) -> &wgpu::Queue {
  method surface_configuration (line 67) | fn surface_configuration(&self) -> &wgpu::SurfaceConfiguration {
  method device (line 73) | fn device(&self) -> &wgpu::Device {
  method queue (line 77) | fn queue(&self) -> &wgpu::Queue {

FILE: plexus/src/buffer/builder.rs
  type VertexKey (line 19) | pub type VertexKey<R> = <Vec<<R as Grouping>::Group> as IndexBuffer<R>>:...
  type BufferBuilder (line 21) | pub struct BufferBuilder<R, G>
  method default (line 34) | fn default() -> Self {
  type Input (line 47) | type Input = ();
  type Facet (line 57) | type Facet = ();
  type Key (line 58) | type Key = ();
  function insert_facet (line 60) | fn insert_facet<T, U>(&mut self, keys: T, _: U) -> Result<Self::Key, Sel...
  type Facet (line 88) | type Facet = ();
  type Key (line 89) | type Key = ();
  function insert_facet (line 91) | fn insert_facet<T, U>(&mut self, keys: T, _: U) -> Result<Self::Key, Sel...
  type Builder (line 113) | type Builder = Self;
  type Vertex (line 115) | type Vertex = G;
  type Facet (line 116) | type Facet = ();
  method surface_with (line 118) | fn surface_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
  type Builder (line 135) | type Builder = Self;
  type Key (line 136) | type Key = VertexKey<R>;
  type Vertex (line 138) | type Vertex = G;
  type Facet (line 139) | type Facet = ();
  method facets_with (line 141) | fn facets_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
  method insert_vertex (line 149) | fn insert_vertex<T>(&mut self, data: T) -> Result<Self::Key, Self::Error>
  type Commit (line 165) | type Commit = MeshBuffer<R, G>;
  type Abort (line 166) | type Abort = ();
  type Error (line 167) | type Error = BufferError;
  function commit (line 169) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 174) | fn abort(self) -> Self::Abort {}

FILE: plexus/src/buffer/mod.rs
  type BufferError (line 119) | pub enum BufferError {
  type MeshBuffer3 (line 166) | pub type MeshBuffer3<N, G> = MeshBuffer<Trigon<N>, G>;
  type MeshBuffer4 (line 178) | pub type MeshBuffer4<N, G> = MeshBuffer<Tetragon<N>, G>;
  type MeshBufferN (line 184) | pub type MeshBufferN<N, G> = MeshBuffer<UnboundedPolygon<N>, G>;
  type FromRawBuffers (line 187) | pub trait FromRawBuffers<N, G>: Sized {
    method from_raw_buffers (line 197) | fn from_raw_buffers<I, J>(indices: I, vertices: J) -> Result<Self, Sel...
  type FromRawBuffersWithArity (line 204) | pub trait FromRawBuffersWithArity<N, G>: Sized {
    method from_raw_buffers_with_arity (line 215) | fn from_raw_buffers_with_arity<I, J>(
  type IntoFlatIndex (line 227) | pub trait IntoFlatIndex<G, const N: usize>
    method into_flat_index (line 234) | fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, N>, G>;
  type IntoStructuredIndex (line 239) | pub trait IntoStructuredIndex<G>
    method into_structured_index (line 245) | fn into_structured_index(self) -> MeshBuffer<Self::Item, G>;
  type MeshBuffer (line 266) | pub struct MeshBuffer<R, G>
  function from_raw_buffers_unchecked (line 279) | pub(in crate::buffer) fn from_raw_buffers_unchecked(
  function new (line 296) | pub fn new() -> Self {
  function into_raw_buffers (line 306) | pub fn into_raw_buffers(self) -> (Vec<R::Group>, Vec<G>) {
  function map_vertices (line 337) | pub fn map_vertices<H, F>(self, f: F) -> MeshBuffer<R, H>
  function as_index_slice (line 349) | pub fn as_index_slice(&self) -> &[R::Group] {
  function as_vertex_slice (line 354) | pub fn as_vertex_slice(&self) -> &[G] {
  type Builder (line 400) | type Builder = BufferBuilder<R, G>;
  type Error (line 401) | type Error = BufferError;
  type Vertex (line 403) | type Vertex = G;
  type Facet (line 404) | type Facet = ();
  method builder (line 406) | fn builder() -> Self::Builder {
  method default (line 416) | fn default() -> Self {
  type Dynamic (line 430) | type Dynamic = <Flat<T, N> as StaticArity>::Static;
  method arity (line 432) | fn arity(&self) -> Self::Dynamic {
  type Dynamic (line 442) | type Dynamic = <P as StaticArity>::Static;
  method arity (line 444) | fn arity(&self) -> Self::Dynamic {
  type Dynamic (line 453) | type Dynamic = MeshArity;
  method arity (line 455) | fn arity(&self) -> Self::Dynamic {
  type Dynamic (line 464) | type Dynamic = MeshArity;
  method arity (line 466) | fn arity(&self) -> Self::Dynamic {
  type Static (line 477) | type Static = <R as StaticArity>::Static;
  constant ARITY (line 479) | const ARITY: Self::Static = R::ARITY;
  function append (line 494) | pub fn append<R, H>(&mut self, buffer: &mut MeshBuffer<R, H>) -> Result<...
  function append (line 524) | pub fn append<R, H>(&mut self, buffer: &mut MeshBuffer<R, H>) -> Result<...
  function from (line 559) | fn from(polygon: P) -> Self {
  type Error (line 582) | type Error = <Self as FromRawBuffers<P, G>>::Error;
  function from_encoding (line 584) | fn from_encoding(
  type Error (line 612) | type Error = <Self as FromRawBuffers<R::Group, G>>::Error;
  function from_indexer (line 614) | fn from_indexer<I, M>(input: I, indexer: M) -> Result<Self, Self::Error>
  function from_iter (line 636) | fn from_iter<I>(input: I) -> Self
  type Error (line 652) | type Error = BufferError;
  function from_raw_buffers (line 692) | fn from_raw_buffers<I, J>(indices: I, vertices: J) -> Result<Self, Buffe...
  type Error (line 726) | type Error = BufferError;
  function from_raw_buffers (line 756) | fn from_raw_buffers<I, J>(indices: I, vertices: J) -> Result<Self, Buffe...
  type Item (line 788) | type Item = T;
  function into_flat_index (line 790) | fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, N>, G> {
  type Item (line 799) | type Item = N;
  function into_flat_index (line 830) | fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, 3>, G> {
  type Item (line 846) | type Item = N;
  function into_flat_index (line 877) | fn into_flat_index(self) -> MeshBuffer<Flat<Self::Item, 4>, G> {
  type Output (line 895) | type Output = vec::IntoIter<Self::Polygon>;
  type Polygon (line 896) | type Polygon = Trigon<G>;
  method into_polygons (line 902) | fn into_polygons(self) -> Self::Output {
  type Output (line 927) | type Output = vec::IntoIter<Self::Polygon>;
  type Polygon (line 928) | type Polygon = Tetragon<G>;
  method into_polygons (line 961) | fn into_polygons(self) -> Self::Output {
  type Output (line 989) | type Output = vec::IntoIter<Self::Polygon>;
  type Polygon (line 990) | type Polygon = <P::Group as Map<G>>::Output;
  method into_polygons (line 1023) | fn into_polygons(self) -> Self::Output {
  type Item (line 1044) | type Item = P;
  function into_structured_index (line 1046) | fn into_structured_index(self) -> MeshBuffer<Self::Item, G> {
  type Item (line 1056) | type Item = Trigon<N>;
  function into_structured_index (line 1089) | fn into_structured_index(self) -> MeshBuffer<Self::Item, G> {
  type Item (line 1107) | type Item = Tetragon<N>;
  function into_structured_index (line 1137) | fn into_structured_index(self) -> MeshBuffer<Self::Item, G> {
  type E3 (line 1164) | type E3 = Point3<R64>;
  function collect_into_flat_buffer (line 1167) | fn collect_into_flat_buffer() {
  function collect_into_bounded_buffer (line 1178) | fn collect_into_bounded_buffer() {
  function collect_into_unbounded_buffer (line 1188) | fn collect_into_unbounded_buffer() {
  function append_structured_buffers (line 1200) | fn append_structured_buffers() {
  function convert_mesh_to_buffer_by_vertex (line 1217) | fn convert_mesh_to_buffer_by_vertex() {
  function convert_mesh_to_buffer_by_face (line 1228) | fn convert_mesh_to_buffer_by_face() {

FILE: plexus/src/builder.rs
  type Buildable (line 74) | pub trait Buildable: Sized {
    method builder (line 101) | fn builder() -> Self::Builder;
  type MeshBuilder (line 123) | pub trait MeshBuilder: ClosedInput {
    method surface_with (line 135) | fn surface_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
    method build (line 150) | fn build(self) -> Result<Self::Commit, Self::Error> {
  type SurfaceBuilder (line 155) | pub trait SurfaceBuilder: ClosedInput {
    method facets_with (line 175) | fn facets_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
    method insert_vertex (line 186) | fn insert_vertex<T>(&mut self, data: T) -> Result<Self::Key, Self::Error>
  type FacetBuilder (line 191) | pub trait FacetBuilder<K>: ClosedInput
    method insert_facet (line 210) | fn insert_facet<T, U>(&mut self, keys: T, data: U) -> Result<Self::Key...

FILE: plexus/src/constant.rs
  type ConstantOf (line 13) | pub type ConstantOf<N> = <N as ToConstant>::Output;
  type TypeOf (line 14) | pub type TypeOf<const N: usize> = <Constant<N> as ToType>::Output;
  type Constant (line 16) | pub struct Constant<const N: usize>;
  type ToConstant (line 18) | pub trait ToConstant {
  type ToType (line 22) | pub trait ToType {

FILE: plexus/src/encoding/mod.rs
  type VertexDecoder (line 23) | pub trait VertexDecoder {
  type FaceDecoder (line 28) | pub trait FaceDecoder {
  type FromEncoding (line 37) | pub trait FromEncoding<E>: Sized
    method from_encoding (line 43) | fn from_encoding(

FILE: plexus/src/encoding/ply.rs
  type Header (line 70) | pub type Header = KeyMap<ElementDefinition>;
  type Payload (line 71) | pub type Payload = KeyMap<Vec<Element>>;
  type Element (line 72) | pub type Element = KeyMap<Property>;
  type Ply (line 74) | pub struct Ply {
    method parse (line 80) | pub fn parse(mut read: impl Read) -> io::Result<Self> {
  type PlyError (line 92) | pub enum PlyError {
    method from (line 110) | fn from(error: io::Error) -> Self {
  type ElementExt (line 115) | pub trait ElementExt {
    method scalar (line 116) | fn scalar<K, T>(&self, key: K) -> Result<T, PlyError>
    method list (line 121) | fn list<K, T, I>(&self, key: K) -> Result<I, PlyError>
    method scalar (line 129) | fn scalar<K, T>(&self, key: K) -> Result<T, PlyError>
    method list (line 140) | fn list<K, T, I>(&self, key: K) -> Result<I, PlyError>
  type PropertyExt (line 153) | pub trait PropertyExt {
    method into_scalar (line 154) | fn into_scalar<T>(self) -> Result<T, PlyError>
    method into_list (line 158) | fn into_list<T, I>(self) -> Result<I, PlyError>
    method into_scalar (line 165) | fn into_scalar<T>(self) -> Result<T, PlyError>
    method into_list (line 182) | fn into_list<T, I>(self) -> Result<I, PlyError>
  type VertexElementDecoder (line 201) | pub trait VertexElementDecoder {
    method decode_vertex_elements (line 202) | fn decode_vertex_elements<'a>(
  type VertexPropertyDecoder (line 211) | pub trait VertexPropertyDecoder: VertexDecoder {
    method decode_vertex_properties (line 212) | fn decode_vertex_properties<'a, I>(
    method decode_vertex_properties (line 352) | fn decode_vertex_properties<'a, I>(
  type FaceElementDecoder (line 221) | pub trait FaceElementDecoder {
    method decode_face_elements (line 222) | fn decode_face_elements<'a>(
  type FacePropertyDecoder (line 231) | pub trait FacePropertyDecoder: FaceDecoder {
    method decode_face_properties (line 232) | fn decode_face_properties<'a, I>(
    method decode_face_properties (line 322) | fn decode_face_properties<'a, I>(
  type FromPly (line 241) | pub trait FromPly<E>: Sized {
    method from_ply (line 242) | fn from_ply(decoder: E, read: impl Read) -> Result<(Self, Ply), PlyErr...
  method from_ply (line 250) | fn from_ply(decoder: E, mut read: impl Read) -> Result<(Self, Ply), PlyE...
  type ToPly (line 261) | pub trait ToPly<E> {
    method to_ply (line 262) | fn to_ply(
  type DecodePosition (line 270) | pub trait DecodePosition<N>: FiniteDimensional<N = N> + Sized
    method decode_position (line 274) | fn decode_position(element: &Element) -> Result<Self, PlyError>;
  method decode_position (line 281) | fn decode_position(element: &Element) -> Result<Self, PlyError> {
  method decode_position (line 291) | fn decode_position(element: &Element) -> Result<Self, PlyError> {
  type PositionEncoding (line 301) | pub struct PositionEncoding<T> {
  method default (line 306) | fn default() -> Self {
  type Output (line 314) | type Output = Vec<(Self::Index, Self::Face)>;
  type Index (line 315) | type Index = SmallVec<[usize; 4]>;
  type Face (line 316) | type Face = ();
  type Output (line 341) | type Output = Vec<Self::Vertex>;
  type Vertex (line 342) | type Vertex = T;
  function decode_elements (line 367) | pub fn decode_elements<'a, K>(
  function decode_vertex_properties (line 386) | pub fn decode_vertex_properties<E>(
  function decode_face_properties (line 399) | pub fn decode_face_properties<E>(
  function num_cast_scalar (line 412) | fn num_cast_scalar<T, U>(value: T) -> Result<U, PlyError>
  function num_cast_list (line 420) | fn num_cast_list<T, U, I>(values: Vec<T>) -> Result<I, PlyError>
  type E3 (line 441) | type E3 = Point3<f64>;
  function decode_into_buffer (line 444) | fn decode_into_buffer() {
  function decode_into_graph (line 455) | fn decode_into_graph() {

FILE: plexus/src/entity/borrow.rs
  type Reborrow (line 1) | pub trait Reborrow {
    method reborrow (line 4) | fn reborrow(&self) -> &Self::Target;
    type Target (line 16) | type Target = T;
    method reborrow (line 18) | fn reborrow(&self) -> &Self::Target {
    type Target (line 24) | type Target = T;
    method reborrow (line 26) | fn reborrow(&self) -> &Self::Target {
  type ReborrowMut (line 7) | pub trait ReborrowMut: Reborrow {
    method reborrow_mut (line 8) | fn reborrow_mut(&mut self) -> &mut Self::Target;
    method reborrow_mut (line 32) | fn reborrow_mut(&mut self) -> &mut Self::Target {
  type ReborrowInto (line 11) | pub trait ReborrowInto<'a>: Reborrow {
    method reborrow_into (line 12) | fn reborrow_into(self) -> &'a Self::Target;
  function reborrow_into (line 38) | fn reborrow_into(self) -> &'a Self::Target {
  function reborrow_into (line 44) | fn reborrow_into(self) -> &'a Self::Target {

FILE: plexus/src/entity/dijkstra.rs
  type MetricTree (line 12) | pub type MetricTree<K, Q> = HashMap<K, (Option<K>, Q)>;
  type KeyedMetric (line 16) | struct KeyedMetric<K, Q>(
  function metrics_with (line 23) | pub fn metrics_with<'a, M, T, Q, F>(
  function decreasing_summand (line 97) | fn decreasing_summand() {
  function logical_metrics (line 111) | fn logical_metrics() {
  function euclidean_distance_metrics (line 130) | fn euclidean_distance_metrics() {

FILE: plexus/src/entity/mod.rs
  type EntityError (line 12) | pub enum EntityError {
  type Entity (line 19) | pub trait Entity: Sized {
  type Payload (line 24) | pub trait Payload: Entity {
    method get (line 27) | fn get(&self) -> &Self::Data;
    method get_mut (line 29) | fn get_mut(&mut self) -> &mut Self::Data;

FILE: plexus/src/entity/storage/hash.rs
  type HashStorage (line 20) | pub struct HashStorage<E, R = (), P = Static>
  function shrink_to_fit (line 38) | pub fn shrink_to_fit(&mut self) {
  function as_storage (line 48) | fn as_storage(&self) -> &StorageTarget<E> {
  function as_storage (line 58) | fn as_storage(&self) -> &StorageTarget<E> {
  function as_storage (line 69) | fn as_storage(&self) -> &StorageTarget<E> {
  function as_storage_mut (line 79) | fn as_storage_mut(&mut self) -> &mut StorageTarget<E> {
  function as_storage_mut (line 89) | fn as_storage_mut(&mut self) -> &mut StorageTarget<E> {
  function as_storage_mut (line 100) | fn as_storage_mut(&mut self) -> &mut StorageTarget<E> {
  method default (line 111) | fn default() -> Self {
  type Target (line 126) | type Target<'a> = dyn 'a + DependentStorage<E> where E: 'a;
  type Target (line 135) | type Target<'a> = dyn 'a + IndependentStorage<E> where E: 'a;
  type Target (line 145) | type Target<'a> = Self where E: 'a;
  function len (line 155) | fn len(&self) -> usize {
  function iter (line 159) | fn iter(&self) -> Box<dyn '_ + Iterator<Item = (E::Key, &'_ E)>> {
  function iter_mut (line 167) | fn iter_mut(&mut self) -> Box<dyn '_ + Iterator<Item = (E::Key, &'_ mut ...
  function get (line 186) | fn get(&self, key: &E::Key) -> Option<&E> {
  function get_mut (line 190) | fn get_mut(&mut self, key: &E::Key) -> Option<&mut E> {
  function insert (line 202) | fn insert(&mut self, entity: E) -> E::Key {
  function insert_with_key (line 215) | fn insert_with_key(&mut self, key: &E::Key, entity: E) -> Option<E> {
  function remove (line 227) | fn remove(&mut self, key: &E::Key) -> Option<E> {

FILE: plexus/src/entity/storage/mod.rs
  type StorageTarget (line 13) | pub type StorageTarget<'a, E> = <<E as Entity>::Storage as Dispatch<E>>:...
  type InnerKey (line 15) | pub type InnerKey<K> = <K as Key>::Inner;
  type Key (line 17) | pub trait Key: Copy + Eq + Hash + Sized {
    method from_inner (line 20) | fn from_inner(key: Self::Inner) -> Self;
    method into_inner (line 22) | fn into_inner(self) -> Self::Inner;
  type Keyer (line 25) | pub trait Keyer<K>: Clone + Default
    method next (line 29) | fn next(&mut self) -> K::Inner;
  type IncrementalKeyer (line 33) | pub struct IncrementalKeyer {
    method next (line 41) | fn next(&mut self) -> K::Inner {
  type Dispatch (line 49) | pub trait Dispatch<E>
  type Mode (line 58) | pub trait Mode {}
  type Static (line 60) | pub enum Static {}
  type Dynamic (line 64) | pub enum Dynamic {}
  type Enumerate (line 72) | pub trait Enumerate<E>
    method len (line 76) | fn len(&self) -> usize;
    method iter (line 78) | fn iter(&self) -> Box<dyn '_ + Iterator<Item = (E::Key, &'_ E)>>;
    method iter_mut (line 80) | fn iter_mut(&mut self) -> Box<dyn '_ + Iterator<Item = (E::Key, &'_ mu...
  type Get (line 85) | pub trait Get<E>
    method get (line 89) | fn get(&self, key: &E::Key) -> Option<&E>;
    method get_mut (line 91) | fn get_mut(&mut self, key: &E::Key) -> Option<&mut E>;
    method contains_key (line 93) | fn contains_key(&self, key: &E::Key) -> bool {
  type Insert (line 98) | pub trait Insert<E>
    method insert (line 102) | fn insert(&mut self, entity: E) -> E::Key;
  type InsertWithKey (line 105) | pub trait InsertWithKey<E>
    method insert_with_key (line 109) | fn insert_with_key(&mut self, key: &E::Key, entity: E) -> Option<E>;
  type Remove (line 112) | pub trait Remove<E>
    method remove (line 116) | fn remove(&mut self, key: &E::Key) -> Option<E>;
  type Storage (line 119) | pub trait Storage<E>: AsStorage<E> + AsStorageMut<E> + Enumerate<E> + Ge...
  type DependentStorage (line 132) | pub trait DependentStorage<E>: InsertWithKey<E> + Storage<E>
  type IndependentStorage (line 145) | pub trait IndependentStorage<E>: Insert<E> + Storage<E>
  type Fuse (line 158) | pub trait Fuse<M, T>
    method fuse (line 165) | fn fuse(self, source: M) -> Self::Output;
  type AsStorage (line 173) | pub trait AsStorage<E>
    method as_storage (line 177) | fn as_storage(&self) -> &StorageTarget<E>;
  function as_storage (line 185) | fn as_storage(&self) -> &StorageTarget<E> {
  function as_storage (line 195) | fn as_storage(&self) -> &StorageTarget<E> {
  type AsStorageMut (line 200) | pub trait AsStorageMut<E>: AsStorage<E>
    method as_storage_mut (line 204) | fn as_storage_mut(&mut self) -> &mut StorageTarget<E>;
  function as_storage_mut (line 212) | fn as_storage_mut(&mut self) -> &mut StorageTarget<E> {
  type AsStorageOf (line 217) | pub trait AsStorageOf {
    method as_storage_of (line 218) | fn as_storage_of<E>(&self) -> &StorageTarget<E>
    method as_storage_mut_of (line 226) | fn as_storage_mut_of<E>(&mut self) -> &mut StorageTarget<E>

FILE: plexus/src/entity/traverse.rs
  type Breadth (line 9) | pub enum Breadth {}
    type Buffer (line 57) | type Buffer = VecDeque<T>;
  type Depth (line 10) | pub enum Depth {}
    type Buffer (line 61) | type Buffer = Vec<T>;
  type Buffer (line 12) | pub trait Buffer<R, T>: Default + Extend<T>
    method push (line 16) | fn push(&mut self, item: T);
    method pop (line 17) | fn pop(&mut self) -> Option<T>;
  function push (line 21) | fn push(&mut self, item: T) {
  function pop (line 25) | fn pop(&mut self) -> Option<T> {
  function push (line 31) | fn push(&mut self, item: T) {
  function pop (line 35) | fn pop(&mut self) -> Option<T> {
  type Order (line 52) | pub trait Order<T>: Sized {
  type Adjacency (line 64) | pub trait Adjacency: ClosedView {
    method adjacency (line 67) | fn adjacency(&self) -> Self::Output;
  type Traversal (line 71) | pub struct Traversal<B, T, R = Depth>
  method clone (line 92) | fn clone(&self) -> Self {
  function from (line 109) | fn from(view: T) -> Self {
  type Item (line 129) | type Item = T;
  method next (line 131) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 141) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Trace (line 153) | pub trait Trace<T> {
    method insert (line 166) | fn insert(&mut self, breadcrumb: T) -> bool;
  type TraceFirst (line 179) | pub struct TraceFirst<T>
  function insert (line 190) | fn insert(&mut self, breadcrumb: T) -> bool {
  type TraceAny (line 208) | pub struct TraceAny<T>
  function insert (line 219) | fn insert(&mut self, breadcrumb: T) -> bool {

FILE: plexus/src/entity/view.rs
  type ClosedView (line 8) | pub trait ClosedView {
    method key (line 12) | fn key(&self) -> Self::Key;
    type Key (line 241) | type Key = E::Key;
    type Entity (line 242) | type Entity = E;
    method key (line 244) | fn key(&self) -> Self::Key {
    type Key (line 376) | type Key = E::Key;
    type Entity (line 377) | type Entity = E;
    method key (line 379) | fn key(&self) -> Self::Key {
  type Bind (line 15) | pub trait Bind<B>: ClosedView + Sized
    method bind (line 19) | fn bind(storage: B, key: Self::Key) -> Option<Self>;
  method bind (line 30) | fn bind(storage: B, key: Self::Key) -> Option<Self> {
  type Rebind (line 35) | pub trait Rebind<B, T>: ClosedView
    method rebind (line 40) | fn rebind(self, key: T::Key) -> Option<T>;
  method rebind (line 50) | fn rebind(self, key: T::Key) -> Option<T> {
  type Unbind (line 55) | pub trait Unbind<B>: ClosedView
    method unbind (line 59) | fn unbind(self) -> (B, Self::Key);
  method unbind (line 68) | fn unbind(self) -> (B, Self::Key) {
  type View (line 73) | pub struct View<B, E>
  function bind (line 89) | pub fn bind(storage: B, key: E::Key) -> Option<Self> {
  function bind_unchecked (line 97) | pub fn bind_unchecked(storage: B, key: E::Key) -> Self {
  function bind_into (line 101) | pub fn bind_into<T>(storage: B, key: E::Key) -> Option<T>
  function unbind (line 108) | pub fn unbind(self) -> (B, E::Key) {
  function rebind (line 113) | pub fn rebind<T>(self, key: T::Key) -> Option<View<B, T>>
  function rebind_into (line 122) | pub fn rebind_into<T, U>(self, key: U::Key) -> Option<T>
  function get (line 131) | pub fn get(&self) -> &E::Data
  function key (line 138) | pub fn key(&self) -> E::Key {
  function to_ref (line 142) | pub fn to_ref(&self) -> View<&B::Target, E> {
  function as_entity (line 146) | fn as_entity(&self) -> &E {
  function to_mut_unchecked (line 171) | pub fn to_mut_unchecked(&mut self) -> View<&mut B::Target, E> {
  function get_mut (line 182) | pub fn get_mut(&mut self) -> &mut E::Data
  function as_entity_mut (line 189) | fn as_entity_mut(&mut self) -> &mut E {
  function into_ref (line 204) | pub fn into_ref(self) -> View<&'a B::Target, E> {
  function as_ref (line 216) | fn as_ref(&self) -> &E::Key {
  method clone (line 227) | fn clone(&self) -> Self {
  type Target (line 263) | type Target = E;
  method deref (line 265) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 276) | fn deref_mut(&mut self) -> &mut Self::Target {
  method hash (line 295) | fn hash<H>(&self, state: &mut H)
  method eq (line 309) | fn eq(&self, other: &Self) -> bool {
  type Orphan (line 314) | pub struct Orphan<'a, E>
  function bind (line 327) | pub fn bind<M>(storage: &'a mut M, key: E::Key) -> Option<Self>
  function bind_unchecked (line 335) | pub fn bind_unchecked(data: &'a mut E::Data, key: E::Key) -> Self {
  function bind_into (line 339) | pub fn bind_into<T, M>(storage: &'a mut M, key: E::Key) -> Option<T>
  function get (line 348) | pub fn get(&self) -> &E::Data {
  function get_mut (line 352) | pub fn get_mut(&mut self) -> &mut E::Data {
  function key (line 356) | pub fn key(&self) -> E::Key {
  function as_ref (line 366) | fn as_ref(&self) -> &E::Key {
  function from (line 390) | fn from(view: View<&'a mut M, E>) -> Self {
  method hash (line 412) | fn hash<H>(&self, state: &mut H)
  method eq (line 425) | fn eq(&self, other: &Self) -> bool {

FILE: plexus/src/geometry/mod.rs
  type FromGeometry (line 17) | pub trait FromGeometry<T> {
    method from_geometry (line 18) | fn from_geometry(other: T) -> Self;
  method from_geometry (line 22) | fn from_geometry(other: T) -> Self {
  function from_geometry (line 32) | fn from_geometry(_: T) -> Self {}
  method from_geometry (line 40) | fn from_geometry(_: ()) -> Self {
  type UnitGeometry (line 70) | pub trait UnitGeometry {}
  type IntoGeometry (line 72) | pub trait IntoGeometry<T> {
    method into_geometry (line 73) | fn into_geometry(self) -> T;
  method into_geometry (line 80) | fn into_geometry(self) -> U {
  type Metric (line 85) | pub trait Metric: Eq + One + Ord + Zero {}

FILE: plexus/src/geometry/partition.rs
  type BinaryPartition (line 13) | pub enum BinaryPartition {
  type PointPartition (line 18) | pub trait PointPartition<S>
    method partition (line 22) | fn partition(&self, point: S) -> Option<BinaryPartition>;
  method partition (line 30) | fn partition(&self, point: S) -> Option<BinaryPartition> {
  function partition (line 45) | fn partition(&self, point: S) -> Option<BinaryPartition> {
  function partition (line 72) | fn partition(&self, point: S) -> Option<BinaryPartition> {

FILE: plexus/src/graph/builder.rs
  type GraphBuilder (line 12) | pub struct GraphBuilder<G>
  method default (line 23) | fn default() -> Self {
  type Input (line 34) | type Input = ();
  type Builder (line 41) | type Builder = Self;
  type Vertex (line 43) | type Vertex = G::Vertex;
  type Facet (line 44) | type Facet = G::Face;
  method surface_with (line 46) | fn surface_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
  type Commit (line 59) | type Commit = MeshGraph<G>;
  type Abort (line 60) | type Abort = ();
  type Error (line 61) | type Error = GraphError;
  function commit (line 63) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 68) | fn abort(self) -> Self::Abort {}
  type Builder (line 75) | type Builder = Self;
  type Key (line 76) | type Key = VertexKey;
  type Vertex (line 78) | type Vertex = G::Vertex;
  type Facet (line 79) | type Facet = G::Face;
  method facets_with (line 81) | fn facets_with<F, T, E>(&mut self, f: F) -> Result<T, Self::Error>
  method insert_vertex (line 89) | fn insert_vertex<T>(&mut self, data: T) -> Result<Self::Key, Self::Error>
  type Facet (line 101) | type Facet = G::Face;
  type Key (line 102) | type Key = FaceKey;
  function insert_facet (line 104) | fn insert_facet<T, U>(&mut self, keys: T, data: U) -> Result<Self::Key, ...

FILE: plexus/src/graph/core.rs
  type OwnedCore (line 11) | pub type OwnedCore<G> = Core<
  type Core (line 40) | pub struct Core<G, V = (), A = (), E = (), F = ()>
  function empty (line 55) | pub fn empty() -> Self {
  function unfuse (line 70) | pub fn unfuse(self) -> (V, A, E, F) {
  function as_storage (line 87) | fn as_storage(&self) -> &StorageTarget<Vertex<G>> {
  function as_storage (line 97) | fn as_storage(&self) -> &StorageTarget<Arc<G>> {
  function as_storage (line 107) | fn as_storage(&self) -> &StorageTarget<Edge<G>> {
  function as_storage (line 117) | fn as_storage(&self) -> &StorageTarget<Face<G>> {
  function as_storage_mut (line 127) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Vertex<G>> {
  function as_storage_mut (line 137) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Arc<G>> {
  function as_storage_mut (line 147) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Edge<G>> {
  function as_storage_mut (line 157) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Face<G>> {
  method default (line 170) | fn default() -> Self {
  type Output (line 186) | type Output = Core<G, V, A, E, F>;
  function fuse (line 188) | fn fuse(self, vertices: V) -> Self::Output {
  type Output (line 207) | type Output = Core<G, V, A, E, F>;
  function fuse (line 209) | fn fuse(self, arcs: A) -> Self::Output {
  type Output (line 231) | type Output = Core<G, V, A, E, F>;
  function fuse (line 233) | fn fuse(self, edges: E) -> Self::Output {
  type Output (line 255) | type Output = Core<G, V, A, E, F>;
  function fuse (line 257) | fn fuse(self, faces: F) -> Self::Output {
  type Data (line 278) | type Data = G;

FILE: plexus/src/graph/data.rs
  type Data (line 3) | pub type Data<M> = <M as Parametric>::Data;
  type GraphData (line 66) | pub trait GraphData: Sized {
    type Vertex (line 74) | type Vertex = ();
    type Arc (line 75) | type Arc = ();
    type Edge (line 76) | type Edge = ();
    type Face (line 77) | type Face = ();
    type Vertex (line 84) | type Vertex = Self;
    type Arc (line 85) | type Arc = ();
    type Edge (line 86) | type Edge = ();
    type Face (line 87) | type Face = ();
    type Vertex (line 94) | type Vertex = Self;
    type Arc (line 95) | type Arc = ();
    type Edge (line 96) | type Edge = ();
    type Face (line 97) | type Face = ();
    type Vertex (line 104) | type Vertex = Self;
    type Arc (line 105) | type Arc = ();
    type Edge (line 106) | type Edge = ();
    type Face (line 107) | type Face = ();
    type Vertex (line 114) | type Vertex = Self;
    type Arc (line 115) | type Arc = ();
    type Edge (line 116) | type Edge = ();
    type Face (line 117) | type Face = ();
  type Parametric (line 120) | pub trait Parametric {
    type Data (line 129) | type Data = <B::Target as Parametric>::Data;

FILE: plexus/src/graph/edge.rs
  type Mutation (line 28) | type Mutation<M> = mutation::Mutation<Immediate<M>>;
  type ToArc (line 30) | pub trait ToArc<B>: Sized
    method into_arc (line 35) | fn into_arc(self) -> ArcView<B>;
    method arc (line 37) | fn arc(&self) -> ArcView<&B::Target>;
  type Arc (line 49) | pub struct Arc<G>
  function new (line 70) | pub fn new(data: G::Arc) -> Self {
  type Data (line 93) | type Data = G::Arc;
  method get (line 95) | fn get(&self) -> &Self::Data {
  method get_mut (line 99) | fn get_mut(&mut self) -> &mut Self::Data {
  type ArcKey (line 106) | pub struct ArcKey(VertexKey, VertexKey);
    method into_opposite (line 109) | pub(in crate::graph) fn into_opposite(self) -> ArcKey {
    method from (line 116) | fn from(key: (VertexKey, VertexKey)) -> Self {
  function from (line 122) | fn from(key: ArcKey) -> Self {
  type Inner (line 128) | type Inner = (VertexKey, VertexKey);
  method from_inner (line 130) | fn from_inner(key: Self::Inner) -> Self {
  method into_inner (line 134) | fn into_inner(self) -> Self::Inner {
  type ArcView (line 187) | pub struct ArcView<B>
  function to_ref (line 200) | pub fn to_ref(&self) -> ArcView<&M> {
  function is_boundary_arc (line 207) | pub fn is_boundary_arc(&self) -> bool {
  function to_mut_unchecked (line 221) | pub(in crate::graph) fn to_mut_unchecked(&mut self) -> ArcView<&mut M> {
  function into_ref (line 265) | pub fn into_ref(self) -> ArcView<&'a M> {
  function get (line 276) | pub fn get<'a>(&'a self) -> &'a G::Arc
  function get_mut (line 290) | pub fn get_mut<'a>(&'a mut self) -> &'a mut G::Arc
  function into_reachable_boundary_arc (line 305) | pub(in crate::graph) fn into_reachable_boundary_arc(self) -> Option<Self> {
  function into_reachable_opposite_arc (line 315) | pub(in crate::graph) fn into_reachable_opposite_arc(self) -> Option<Self> {
  function into_reachable_next_arc (line 320) | pub(in crate::graph) fn into_reachable_next_arc(self) -> Option<Self> {
  function into_reachable_previous_arc (line 325) | pub(in crate::graph) fn into_reachable_previous_arc(self) -> Option<Self> {
  function into_ring (line 338) | pub fn into_ring(self) -> Ring<B> {
  function into_boundary_arc (line 343) | pub fn into_boundary_arc(self) -> Option<Self> {
  function into_opposite_arc (line 350) | pub fn into_opposite_arc(self) -> Self {
  function into_next_arc (line 357) | pub fn into_next_arc(self) -> Self {
  function into_previous_arc (line 364) | pub fn into_previous_arc(self) -> Self {
  function ring (line 369) | pub fn ring(&self) -> Ring<&M> {
  function boundary_arc (line 374) | pub fn boundary_arc(&self) -> Option<ArcView<&M>> {
  function opposite_arc (line 379) | pub fn opposite_arc(&self) -> ArcView<&M> {
  function next_arc (line 384) | pub fn next_arc(&self) -> ArcView<&M> {
  function previous_arc (line 389) | pub fn previous_arc(&self) -> ArcView<&M> {
  function into_reachable_source_vertex (line 401) | pub(in crate::graph) fn into_reachable_source_vertex(self) -> Option<Ver...
  function into_reachable_destination_vertex (line 406) | pub(in crate::graph) fn into_reachable_destination_vertex(self) -> Optio...
  function into_path (line 418) | pub fn into_path(self) -> Path<'static, B> {
  function path (line 424) | pub fn path(&self) -> Path<&M> {
  function into_source_vertex (line 429) | pub fn into_source_vertex(self) -> VertexView<B> {
  function into_destination_vertex (line 434) | pub fn into_destination_vertex(self) -> VertexView<B> {
  function source_vertex (line 439) | pub fn source_vertex(&self) -> VertexView<&M> {
  function destination_vertex (line 444) | pub fn destination_vertex(&self) -> VertexView<&M> {
  function into_reachable_edge (line 456) | pub(in crate::graph) fn into_reachable_edge(self) -> Option<EdgeView<B>> {
  function into_edge (line 469) | pub fn into_edge(self) -> EdgeView<B> {
  function edge (line 474) | pub fn edge(&self) -> EdgeView<&M> {
  function into_reachable_face (line 486) | pub(in crate::graph) fn into_reachable_face(self) -> Option<FaceView<B>> {
  function into_face (line 501) | pub fn into_face(self) -> Option<FaceView<B>> {
  function face (line 508) | pub fn face(&self) -> Option<FaceView<&M>> {
  function normal (line 519) | pub fn normal(&self) -> Vector<VertexPosition<G>>
  function midpoint (line 538) | pub fn midpoint(&self) -> VertexPosition<G>
  function into_adjacent_vertices (line 553) | pub fn into_adjacent_vertices(
  function adjacent_vertices (line 567) | pub fn adjacent_vertices(
  function into_adjacent_faces (line 580) | pub fn into_adjacent_faces(self) -> impl Clone + ExactSizeIterator<Item ...
  function adjacent_faces (line 592) | pub fn adjacent_faces(&self) -> impl Clone + ExactSizeIterator<Item = Fa...
  function into_adjacent_vertex_orphans (line 601) | pub fn into_adjacent_vertex_orphans(
  function adjacent_vertex_orphans (line 614) | pub fn adjacent_vertex_orphans(
  function into_adjacent_face_orphans (line 625) | pub fn into_adjacent_face_orphans(
  function adjacent_face_orphans (line 638) | pub fn adjacent_face_orphans(&mut self) -> impl ExactSizeIterator<Item =...
  function split_with (line 690) | pub fn split_with<F>(self, f: F) -> VertexView<&'a mut M>
  function split_at_midpoint (line 746) | pub fn split_at_midpoint(self) -> VertexView<&'a mut M>
  function bridge (line 835) | pub fn bridge(
  function extrude_with_offset (line 900) | pub fn extrude_with_offset<T>(self, offset: T) -> Result<Self, GraphError>
  function extrude_with_translation (line 922) | pub fn extrude_with_translation(
  function extrude_with (line 945) | pub fn extrude_with<F>(self, f: F) -> Result<Self, GraphError>
  function remove (line 966) | pub fn remove(self) -> Option<VertexView<&'a mut M>> {
  function borrow (line 984) | fn borrow(&self) -> &ArcKey {
  method clone (line 996) | fn clone(&self) -> Self {
  type Key (line 1009) | type Key = ArcKey;
  type Entity (line 1010) | type Entity = Arc<G>;
  method key (line 1013) | fn key(&self) -> Self::Key {
  type Target (line 1033) | type Target = Arc<G>;
  method deref (line 1035) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1046) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 1065) | fn from(ring: Ring<B>) -> Self {
  function from (line 1076) | fn from(view: View<B, Arc<G>>) -> Self {
  function from (line 1087) | fn from(arc: ArcView<B>) -> Self {
  method hash (line 1099) | fn hash<H>(&self, state: &mut H)
  method eq (line 1113) | fn eq(&self, other: &Self) -> bool {
  function into_arc (line 1124) | fn into_arc(self) -> ArcView<B> {
  function arc (line 1128) | fn arc(&self) -> ArcView<&M> {
  type ArcOrphan (line 1134) | pub struct ArcOrphan<'a, G>
  function get (line 1145) | pub fn get(&self) -> &G::Arc {
  function get_mut (line 1149) | pub fn get_mut(&mut self) -> &mut G::Arc {
  function borrow (line 1158) | fn borrow(&self) -> &ArcKey {
  type Key (line 1167) | type Key = ArcKey;
  type Entity (line 1168) | type Entity = Arc<G>;
  method key (line 1170) | fn key(&self) -> Self::Key {
  function from (line 1181) | fn from(arc: ArcView<&'a mut M>) -> Self {
  function from (line 1190) | fn from(inner: Orphan<'a, Arc<G>>) -> Self {
  function from (line 1199) | fn from(view: View<&'a mut M, Arc<M::Data>>) -> Self {
  method hash (line 1208) | fn hash<H>(&self, state: &mut H)
  method eq (line 1220) | fn eq(&self, other: &Self) -> bool {
  type Edge (line 1228) | pub struct Edge<G>
  function new (line 1243) | pub fn new(arc: ArcKey, data: G::Edge) -> Self {
  type Data (line 1260) | type Data = G::Edge;
  method get (line 1262) | fn get(&self) -> &Self::Data {
  method get_mut (line 1266) | fn get_mut(&mut self) -> &mut Self::Data {
  type EdgeKey (line 1273) | pub struct EdgeKey(u64);
  type Inner (line 1276) | type Inner = u64;
  method from_inner (line 1278) | fn from_inner(key: Self::Inner) -> Self {
  method into_inner (line 1282) | fn into_inner(self) -> Self::Inner {
  type EdgeView (line 1295) | pub struct EdgeView<B>
  function to_ref (line 1308) | pub fn to_ref(&self) -> EdgeView<&M> {
  function into_ref (line 1319) | pub fn into_ref(self) -> EdgeView<&'a M> {
  function get (line 1330) | pub fn get<'a>(&'a self) -> &'a G::Edge
  function get_mut (line 1344) | pub fn get_mut<'a>(&'a mut self) -> &'a mut G::Edge
  function into_reachable_arc (line 1359) | pub(in crate::graph) fn into_reachable_arc(self) -> Option<ArcView<B>> {
  function into_arc (line 1371) | pub fn into_arc(self) -> ArcView<B> {
  function arc (line 1375) | pub fn arc(&self) -> ArcView<&M> {
  function is_boundary_edge (line 1379) | pub fn is_boundary_edge(&self) -> bool {
  function midpoint (line 1395) | pub fn midpoint(&self) -> VertexPosition<G>
  function borrow (line 1409) | fn borrow(&self) -> &EdgeKey {
  method clone (line 1421) | fn clone(&self) -> Self {
  type Key (line 1434) | type Key = EdgeKey;
  type Entity (line 1435) | type Entity = Edge<G>;
  method key (line 1438) | fn key(&self) -> Self::Key {
  type Target (line 1458) | type Target = Edge<G>;
  method deref (line 1460) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 1471) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 1490) | fn from(view: View<B, Edge<G>>) -> Self {
  function from (line 1501) | fn from(edge: EdgeView<B>) -> Self {
  method hash (line 1513) | fn hash<H>(&self, state: &mut H)
  method eq (line 1527) | fn eq(&self, other: &Self) -> bool {
  function into_arc (line 1538) | fn into_arc(self) -> ArcView<B> {
  function arc (line 1542) | fn arc(&self) -> ArcView<&M> {
  type EdgeOrphan (line 1548) | pub struct EdgeOrphan<'a, G>
  function get (line 1559) | pub fn get(&self) -> &G::Edge {
  function get_mut (line 1563) | pub fn get_mut(&mut self) -> &mut G::Edge {
  function borrow (line 1572) | fn borrow(&self) -> &EdgeKey {
  type Key (line 1581) | type Key = EdgeKey;
  type Entity (line 1582) | type Entity = Edge<G>;
  method key (line 1584) | fn key(&self) -> Self::Key {
  function from (line 1595) | fn from(edge: EdgeView<&'a mut M>) -> Self {
  function from (line 1604) | fn from(inner: Orphan<'a, Edge<G>>) -> Self {
  function from (line 1613) | fn from(view: View<&'a mut M, Edge<M::Data>>) -> Self {
  method hash (line 1622) | fn hash<H>(&self, state: &mut H)
  method eq (line 1634) | fn eq(&self, other: &Self) -> bool {
  type VertexCirculator (line 1639) | pub struct VertexCirculator<B>
  type Entity (line 1654) | type Entity = Vertex<G>;
    type Key (line 85) | type Key = ArcKey;
    type Storage (line 86) | type Storage = HashStorage<Self>;
    type Key (line 1252) | type Key = EdgeKey;
    type Storage (line 1253) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1656) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  function from (line 1667) | fn from(arc: ArcView<B>) -> Self {
  method clone (line 1683) | fn clone(&self) -> Self {
  type Item (line 1705) | type Item = VertexView<&'a M>;
  method next (line 1707) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1711) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1720) | type Item = VertexOrphan<'a, M::Data>;
  method next (line 1722) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1726) | fn size_hint(&self) -> (usize, Option<usize>) {
  function target (line 1735) | fn target(&mut self) -> &mut M {
  function target (line 1744) | fn target(&self) -> &'a M {
  type FaceCirculator (line 1749) | pub struct FaceCirculator<B>
  type Entity (line 1764) | type Entity = Face<G>;
    type Key (line 85) | type Key = ArcKey;
    type Storage (line 86) | type Storage = HashStorage<Self>;
    type Key (line 1252) | type Key = EdgeKey;
    type Storage (line 1253) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1766) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 1777) | fn clone(&self) -> Self {
  function from (line 1800) | fn from(arc: ArcView<B>) -> Self {
  type Item (line 1821) | type Item = FaceView<&'a M>;
  method next (line 1823) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1827) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1836) | type Item = FaceOrphan<'a, M::Data>;
  method next (line 1838) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1842) | fn size_hint(&self) -> (usize, Option<usize>) {
  function target (line 1851) | fn target(&mut self) -> &mut M {
  function target (line 1860) | fn target(&self) -> &'a M {
  type E2 (line 1878) | type E2 = Point2<R64>;
  type E3 (line 1879) | type E3 = Point3<R64>;
  function find_arc (line 1881) | fn find_arc<G, T>(graph: &MeshGraph<G>, data: (T, T)) -> Option<ArcKey>
  function extrude_arc (line 1903) | fn extrude_arc() {
  function bridge_arcs (line 1922) | fn bridge_arcs() {
  function split_edge (line 1948) | fn split_edge() {
  function remove_edge (line 1969) | fn remove_edge() {

FILE: plexus/src/graph/face.rs
  type Mutation (line 38) | type Mutation<M> = mutation::Mutation<Immediate<M>>;
  type ToRing (line 40) | pub trait ToRing<B>: DynamicArity<Dynamic = usize> + Sized
    method into_ring (line 45) | fn into_ring(self) -> Ring<B>;
    method ring (line 47) | fn ring(&self) -> Ring<&B::Target>;
  type Face (line 53) | pub struct Face<G>
  function new (line 68) | pub fn new(arc: ArcKey, data: G::Face) -> Self {
  type Data (line 85) | type Data = G::Face;
  method get (line 87) | fn get(&self) -> &Self::Data {
  method get_mut (line 91) | fn get_mut(&mut self) -> &mut Self::Data {
  type FaceKey (line 98) | pub struct FaceKey(u64);
  type Inner (line 101) | type Inner = u64;
  method from_inner (line 103) | fn from_inner(key: Self::Inner) -> Self {
  method into_inner (line 107) | fn into_inner(self) -> Self::Inner {
  type FaceView (line 124) | pub struct FaceView<B>
  function to_ref (line 137) | pub fn to_ref(&self) -> FaceView<&M> {
  function to_mut_unchecked (line 150) | fn to_mut_unchecked(&mut self) -> FaceView<&mut M> {
  function into_ref (line 191) | pub fn into_ref(self) -> FaceView<&'a M> {
  function get (line 202) | pub fn get<'a>(&'a self) -> &'a G::Face
  function get_mut (line 216) | pub fn get_mut<'a>(&'a mut self) -> &'a mut G::Face
  function into_reachable_arc (line 231) | pub(in crate::graph) fn into_reachable_arc(self) -> Option<ArcView<B>> {
  function into_ring (line 244) | pub fn into_ring(self) -> Ring<B> {
  function into_arc (line 249) | pub fn into_arc(self) -> ArcView<B> {
  function ring (line 254) | pub fn ring(&self) -> Ring<&M> {
  function arc (line 259) | pub fn arc(&self) -> ArcView<&M> {
  function centroid (line 274) | pub fn centroid(&self) -> VertexPosition<G>
  function normal (line 282) | pub fn normal(&self) -> Result<Vector<VertexPosition<G>>, GraphError>
  function plane (line 290) | pub fn plane(&self) -> Result<Plane<VertexPosition<G>>, GraphError>
  function flatten (line 317) | pub fn flatten(&mut self) -> Result<(), GraphError>
  function into_adjacent_arcs (line 351) | pub fn into_adjacent_arcs(self) -> impl Clone + Iterator<Item = ArcView<...
  function into_adjacent_faces (line 355) | pub fn into_adjacent_faces(self) -> impl Clone + Iterator<Item = FaceVie...
  function adjacent_arcs (line 367) | pub fn adjacent_arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::...
  function adjacent_faces (line 372) | pub fn adjacent_faces(&self) -> impl Clone + Iterator<Item = FaceView<&B...
  function into_adjacent_vertices (line 388) | pub fn into_adjacent_vertices(self) -> impl Clone + Iterator<Item = Vert...
  function adjacent_vertices (line 404) | pub fn adjacent_vertices(&self) -> impl Clone + Iterator<Item = VertexVi...
  function into_adjacent_arc_orphans (line 413) | pub fn into_adjacent_arc_orphans(self) -> impl Iterator<Item = ArcOrphan...
  function adjacent_arc_orphans (line 424) | pub fn adjacent_arc_orphans(&mut self) -> impl Iterator<Item = ArcOrphan...
  function into_adjacent_face_orphans (line 433) | pub fn into_adjacent_face_orphans(self) -> impl Iterator<Item = FaceOrph...
  function adjacent_face_orphans (line 444) | pub fn adjacent_face_orphans(&mut self) -> impl Iterator<Item = FaceOrph...
  function into_adjacent_vertex_orphans (line 457) | pub fn into_adjacent_vertex_orphans(self) -> impl Iterator<Item = Vertex...
  function adjacent_vertex_orphans (line 472) | pub fn adjacent_vertex_orphans(&mut self) -> impl Iterator<Item = Vertex...
  function traverse_by_breadth (line 488) | pub fn traverse_by_breadth(&self) -> impl Clone + Iterator<Item = FaceVi...
  function traverse_by_depth (line 497) | pub fn traverse_by_depth(&self) -> impl Clone + Iterator<Item = FaceView...
  function split (line 556) | pub fn split(
  function merge (line 624) | pub fn merge(self, destination: impl Into<Selector<FaceKey>>) -> Result<...
  function bridge (line 663) | pub fn bridge(self, destination: FaceKey) -> Result<(), GraphError> {
  function triangulate (line 680) | pub fn triangulate(self) -> Self {
  function poke_with (line 732) | pub fn poke_with<F>(self, f: F) -> VertexView<&'a mut M>
  function poke_at_centroid (line 750) | pub fn poke_at_centroid(self) -> VertexView<&'a mut M>
  function poke_with_offset (line 802) | pub fn poke_with_offset<T>(self, offset: T) -> Result<VertexView<&'a mut...
  function extrude_with_offset (line 824) | pub fn extrude_with_offset<T>(self, offset: T) -> Result<Self, GraphError>
  function extrude_with_translation (line 841) | pub fn extrude_with_translation(self, translation: Vector<VertexPosition...
  function extrude_with (line 858) | pub fn extrude_with<F>(self, f: F) -> Self
  function remove (line 875) | pub fn remove(self) -> Option<Ring<&'a mut M>> {
  type Output (line 894) | type Output = SmallVec<[Self::Key; 8]>;
  method adjacency (line 896) | fn adjacency(&self) -> Self::Output {
  function borrow (line 906) | fn borrow(&self) -> &FaceKey {
  method clone (line 918) | fn clone(&self) -> Self {
  type Key (line 931) | type Key = FaceKey;
  type Entity (line 932) | type Entity = Face<G>;
  method key (line 935) | fn key(&self) -> Self::Key {
  type Target (line 955) | type Target = Face<G>;
  method deref (line 957) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 968) | fn deref_mut(&mut self) -> &mut Self::Target {
  type Dynamic (line 979) | type Dynamic = usize;
  method arity (line 983) | fn arity(&self) -> Self::Dynamic {
  function from (line 1002) | fn from(view: View<B, Face<G>>) -> Self {
  function from (line 1013) | fn from(face: FaceView<B>) -> Self {
  method hash (line 1025) | fn hash<H>(&self, state: &mut H)
  method eq (line 1039) | fn eq(&self, other: &Self) -> bool {
  type Static (line 1050) | type Static = <MeshGraph<G> as StaticArity>::Static;
  constant ARITY (line 1052) | const ARITY: Self::Static = MeshGraph::<G>::ARITY;
  function into_ring (line 1061) | fn into_ring(self) -> Ring<B> {
  function ring (line 1065) | fn ring(&self) -> Ring<&M> {
  type FaceOrphan (line 1071) | pub struct FaceOrphan<'a, G>
  function get (line 1082) | pub fn get(&self) -> &G::Face {
  function get_mut (line 1086) | pub fn get_mut(&mut self) -> &mut G::Face {
  type Key (line 1095) | type Key = FaceKey;
  type Entity (line 1096) | type Entity = Face<G>;
  method key (line 1098) | fn key(&self) -> Self::Key {
  function from (line 1109) | fn from(face: FaceView<&'a mut M>) -> Self {
  function from (line 1118) | fn from(inner: Orphan<'a, Face<G>>) -> Self {
  function from (line 1127) | fn from(view: View<&'a mut M, Face<M::Data>>) -> Self {
  method eq (line 1136) | fn eq(&self, other: &Self) -> bool {
  type Ring (line 1151) | pub struct Ring<B>
  function to_ref (line 1165) | pub fn to_ref(&self) -> Ring<&M> {
  function to_mut_unchecked (line 1179) | fn to_mut_unchecked(&mut self) -> Ring<&mut M> {
  function into_ref (line 1190) | pub fn into_ref(self) -> Ring<&'a M> {
  function into_arc (line 1202) | pub fn into_arc(self) -> ArcView<B> {
  function arc (line 1207) | pub fn arc(&self) -> ArcView<&M> {
  function into_path (line 1218) | pub fn into_path(self) -> Path<'static, B> {
  function path (line 1222) | pub fn path(&self) -> Path<'static, &M> {
  function shortest_logical_metric (line 1233) | pub fn shortest_logical_metric(
  function into_face (line 1272) | pub fn into_face(self) -> Option<FaceView<B>> {
  function face (line 1281) | pub fn face(&self) -> Option<FaceView<&M>> {
  function into_arcs (line 1292) | pub fn into_arcs(self) -> impl Clone + Iterator<Item = ArcView<&'a M>> {
  function arcs (line 1304) | pub fn arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::Target>> {
  function into_vertices (line 1315) | pub fn into_vertices(self) -> impl Clone + Iterator<Item = VertexView<&'...
  function vertices (line 1327) | pub fn vertices(&self) -> impl Clone + Iterator<Item = VertexView<&B::Ta...
  function into_arc_orphans (line 1336) | pub fn into_arc_orphans(self) -> impl Iterator<Item = ArcOrphan<'a, M::D...
  function arc_orphans (line 1347) | pub fn arc_orphans(&mut self) -> impl Iterator<Item = ArcOrphan<Data<B>>> {
  function into_vertex_orphans (line 1356) | pub fn into_vertex_orphans(self) -> impl Iterator<Item = VertexOrphan<'a...
  function vertex_orphans (line 1367) | pub fn vertex_orphans(&mut self) -> impl Iterator<Item = VertexOrphan<Da...
  function get_or_insert_face (line 1381) | pub fn get_or_insert_face(self) -> FaceView<&'a mut M> {
  function get_or_insert_face_with (line 1392) | pub fn get_or_insert_face_with<F>(self, f: F) -> FaceView<&'a mut M>
  type Dynamic (line 1421) | type Dynamic = usize;
  method arity (line 1425) | fn arity(&self) -> Self::Dynamic {
  function from (line 1436) | fn from(arc: ArcView<B>) -> Self {
  method eq (line 1447) | fn eq(&self, other: &Self) -> bool {
  type Static (line 1459) | type Static = <MeshGraph<G> as StaticArity>::Static;
  constant ARITY (line 1461) | const ARITY: Self::Static = MeshGraph::<G>::ARITY;
  function into_ring (line 1470) | fn into_ring(self) -> Ring<B> {
  function ring (line 1474) | fn ring(&self) -> Ring<&M> {
  type VertexCirculator (line 1479) | pub struct VertexCirculator<B>
  type Entity (line 1493) | type Entity = Vertex<G>;
    type Key (line 77) | type Key = FaceKey;
    type Storage (line 78) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1495) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 1510) | fn clone(&self) -> Self {
  function from (line 1523) | fn from(inner: ArcCirculator<B>) -> Self {
  type Item (line 1533) | type Item = VertexView<&'a M>;
  method next (line 1535) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1539) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1550) | type Item = VertexOrphan<'a, M::Data>;
  method next (line 1552) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1556) | fn size_hint(&self) -> (usize, Option<usize>) {
  function target (line 1567) | fn target(&mut self) -> &mut M {
  function target (line 1576) | fn target(&self) -> &'a M {
  type ArcCirculator (line 1581) | pub struct ArcCirculator<B>
  type Entity (line 1597) | type Entity = Arc<G>;
    type Key (line 77) | type Key = FaceKey;
    type Storage (line 78) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1599) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 1619) | fn clone(&self) -> Self {
  function from (line 1634) | fn from(ring: Ring<B>) -> Self {
  type Item (line 1649) | type Item = ArcView<&'a M>;
  method next (line 1651) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1655) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Item (line 1666) | type Item = ArcOrphan<'a, M::Data>;
  method next (line 1668) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 1672) | fn size_hint(&self) -> (usize, Option<usize>) {
  function target (line 1683) | fn target(&mut self) -> &mut M {
  function target (line 1693) | fn target(&self) -> &'a M {
  type FaceCirculator (line 1698) | pub struct FaceCirculator<B>
  type Entity (line 1712) | type Entity = Face<G>;
    type Key (line 77) | type Key = FaceKey;
    type Storage (line 78) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1714) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 1742) | fn clone(&self) -> Self {
  function from (line 1755) | fn from(inner: ArcCirculator<B>) -> Self {
  type Item (line 1765) | type Item = FaceView<&'a M>;
  method next (line 1767) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 1776) | type Item = FaceOrphan<'a, M::Data>;
  method next (line 1778) | fn next(&mut self) -> Option<Self::Item> {
  function target (line 1787) | fn target(&mut self) -> &mut M {
  function target (line 1797) | fn target(&self) -> &'a M {
  type E2 (line 1815) | type E2 = Point2<R64>;
  type E3 (line 1816) | type E3 = Point3<R64>;
  function circulate_over_arcs (line 1819) | fn circulate_over_arcs() {
  function circulate_over_faces (line 1830) | fn circulate_over_faces() {
  function remove_face (line 1842) | fn remove_face() {
  function split_face (line 1865) | fn split_face() {
  function extrude_face (line 1888) | fn extrude_face() {
  function merge_faces (line 1920) | fn merge_faces() {
  function poke_face (line 1950) | fn poke_face() {
  function triangulate_mesh (line 1972) | fn triangulate_mesh() {
  function logical_metrics (line 1988) | fn logical_metrics() {

FILE: plexus/src/graph/geometry.rs
  type VertexPosition (line 26) | pub type VertexPosition<G> = Position<<G as GraphData>::Vertex>;
  type VertexCentroid (line 28) | pub trait VertexCentroid: GraphData
    method centroid (line 32) | fn centroid<B>(vertex: VertexView<B>) -> Result<VertexPosition<Self>, ...
    method centroid (line 44) | fn centroid<B>(vertex: VertexView<B>) -> Result<VertexPosition<Self>, ...
  type VertexNormal (line 59) | pub trait VertexNormal: FaceNormal
    method normal (line 63) | fn normal<B>(vertex: VertexView<B>) -> Result<Vector<VertexPosition<Se...
    method normal (line 78) | fn normal<B>(vertex: VertexView<B>) -> Result<Vector<VertexPosition<Se...
  type ArcNormal (line 99) | pub trait ArcNormal: GraphData
    method normal (line 103) | fn normal<B>(arc: ArcView<B>) -> Result<Vector<VertexPosition<Self>>, ...
    method normal (line 117) | fn normal<B>(arc: ArcView<B>) -> Result<Vector<VertexPosition<Self>>, ...
  type EdgeMidpoint (line 136) | pub trait EdgeMidpoint: GraphData
    method midpoint (line 140) | fn midpoint<B, T>(edge: T) -> Result<VertexPosition<Self>, GraphError>
    method midpoint (line 157) | fn midpoint<B, T>(edge: T) -> Result<VertexPosition<Self>, GraphError>
  type FaceCentroid (line 177) | pub trait FaceCentroid: GraphData
    method centroid (line 181) | fn centroid<B, T>(ring: T) -> Result<VertexPosition<Self>, GraphError>
    method centroid (line 194) | fn centroid<B, T>(ring: T) -> Result<VertexPosition<Self>, GraphError>
  type FaceNormal (line 209) | pub trait FaceNormal: GraphData
    method normal (line 213) | fn normal<B, T>(ring: T) -> Result<Vector<VertexPosition<Self>>, Graph...
    method normal (line 228) | fn normal<B, T>(ring: T) -> Result<Vector<VertexPosition<Self>>, Graph...
  type FacePlane (line 249) | pub trait FacePlane: GraphData
    method plane (line 254) | fn plane<B, T>(ring: T) -> Result<Plane<VertexPosition<Self>>, GraphEr...

FILE: plexus/src/graph/mod.rs
  type Mutation (line 315) | type Mutation<M> = mutation::Mutation<Immediate<M>>;
  type GraphError (line 321) | pub enum GraphError {
    method from (line 360) | fn from(error: BufferError) -> Self {
    method from (line 371) | fn from(error: EntityError) -> Self {
  type OptionExt (line 379) | trait OptionExt<T> {
    method expect_consistent (line 380) | fn expect_consistent(self) -> T;
  function expect_consistent (line 384) | fn expect_consistent(self) -> T {
  type ResultExt (line 389) | trait ResultExt<T, E> {
    method expect_consistent (line 390) | fn expect_consistent(self) -> T
  function expect_consistent (line 396) | fn expect_consistent(self) -> T
  type Circulator (line 404) | trait Circulator<B>
    method next (line 411) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key>;
  type ViewCirculator (line 414) | trait ViewCirculator<'a, M>: Circulator<&'a M>
    method target (line 418) | fn target(&self) -> &'a M;
    method bind_next_view (line 420) | fn bind_next_view<T>(&mut self) -> Option<T>
  type OrphanCirculator (line 429) | trait OrphanCirculator<'a, M>: Circulator<&'a mut M>
    method target (line 433) | fn target(&mut self) -> &mut M;
    method bind_next_orphan (line 455) | unsafe fn bind_next_orphan<T>(&mut self) -> Option<T>
  type Selector (line 514) | pub enum Selector<K> {
  function key_or_else (line 522) | pub fn key_or_else<E, F>(self, f: F) -> Result<K, GraphError>
  function index_or_else (line 535) | pub fn index_or_else<E, F>(self, f: F) -> Result<usize, GraphError>
  function from (line 551) | fn from(key: K) -> Self {
  function from (line 557) | fn from(index: usize) -> Self {
  type GraphKey (line 563) | pub enum GraphKey {
    method from (line 571) | fn from(key: VertexKey) -> Self {
    method from (line 577) | fn from(key: ArcKey) -> Self {
    method from (line 583) | fn from(key: EdgeKey) -> Self {
    method from (line 589) | fn from(key: FaceKey) -> Self {
  type MeshGraph (line 613) | pub struct MeshGraph<G = (R64, R64, R64)>
  function new (line 633) | pub fn new() -> Self {
  function vertex_count (line 638) | pub fn vertex_count(&self) -> usize {
  function vertex (line 643) | pub fn vertex(&self, key: VertexKey) -> Option<VertexView<&Self>> {
  function vertex_mut (line 648) | pub fn vertex_mut(&mut self, key: VertexKey) -> Option<VertexView<&mut S...
  function vertices (line 654) | pub fn vertices(&self) -> impl Iterator<Item = VertexView<&Self>> {
  function vertex_orphans (line 664) | pub fn vertex_orphans(&mut self) -> impl Iterator<Item = VertexOrphan<G>> {
  function arc_count (line 673) | pub fn arc_count(&self) -> usize {
  function arc (line 678) | pub fn arc(&self, key: ArcKey) -> Option<ArcView<&Self>> {
  function arc_mut (line 683) | pub fn arc_mut(&mut self, key: ArcKey) -> Option<ArcView<&mut Self>> {
  function arcs (line 689) | pub fn arcs(&self) -> impl Iterator<Item = ArcView<&Self>> {
  function arc_orphans (line 699) | pub fn arc_orphans(&mut self) -> impl Iterator<Item = ArcOrphan<G>> {
  function edge_count (line 708) | pub fn edge_count(&self) -> usize {
  function edge (line 713) | pub fn edge(&self, key: EdgeKey) -> Option<EdgeView<&Self>> {
  function edge_mut (line 718) | pub fn edge_mut(&mut self, key: EdgeKey) -> Option<EdgeView<&mut Self>> {
  function edges (line 724) | pub fn edges(&self) -> impl Iterator<Item = EdgeView<&Self>> {
  function edge_orphans (line 734) | pub fn edge_orphans(&mut self) -> impl Iterator<Item = EdgeOrphan<G>> {
  function face_count (line 743) | pub fn face_count(&self) -> usize {
  function face (line 748) | pub fn face(&self, key: FaceKey) -> Option<FaceView<&Self>> {
  function face_mut (line 753) | pub fn face_mut(&mut self, key: FaceKey) -> Option<FaceView<&mut Self>> {
  function faces (line 759) | pub fn faces(&self) -> impl Iterator<Item = FaceView<&Self>> {
  function face_orphans (line 769) | pub fn face_orphans(&mut self) -> impl Iterator<Item = FaceOrphan<G>> {
  function path (line 782) | pub fn path<I>(&self, keys: I) -> Result<Path<'static, &Self>, GraphError>
  function path_mut (line 795) | pub fn path_mut<I>(&mut self, keys: I) -> Result<Path<'static, &mut Self...
  function aabb (line 804) | pub fn aabb(&self) -> Aabb<VertexPosition<G>>
  function triangulate (line 820) | pub fn triangulate(&mut self) {
  function smooth (line 865) | pub fn smooth<T>(&mut self, factor: T)
  function split_at_path (line 924) | pub fn split_at_path(path: Path<&mut Self>) -> Result<(), GraphError> {
  function disjoint_subgraph_vertices (line 967) | pub fn disjoint_subgraph_vertices(&self) -> impl ExactSizeIterator<Item ...
  function into_disjoint_subgraphs (line 985) | pub fn into_disjoint_subgraphs(self) -> Vec<Self> {
  function shrink_to_fit (line 991) | pub fn shrink_to_fit(&mut self) {
  function to_mesh_by_vertex (line 1042) | pub fn to_mesh_by_vertex<B>(&self) -> Result<B, B::Error>
  function to_mesh_by_vertex_with (line 1063) | pub fn to_mesh_by_vertex_with<B, F>(&self, mut f: F) -> Result<B, B::Error>
  function to_mesh_by_face (line 1103) | pub fn to_mesh_by_face<B>(&self) -> Result<B, B::Error>
  function to_mesh_by_face_with (line 1166) | pub fn to_mesh_by_face_with<B, F>(&self, mut f: F) -> Result<B, B::Error>
  function as_storage (line 1193) | fn as_storage(&self) -> &StorageTarget<Vertex<G>> {
  function as_storage (line 1202) | fn as_storage(&self) -> &StorageTarget<Arc<G>> {
  function as_storage (line 1211) | fn as_storage(&self) -> &StorageTarget<Edge<G>> {
  function as_storage (line 1220) | fn as_storage(&self) -> &StorageTarget<Face<G>> {
  function as_storage_mut (line 1229) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Vertex<G>> {
  function as_storage_mut (line 1238) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Arc<G>> {
  function as_storage_mut (line 1247) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Edge<G>> {
  function as_storage_mut (line 1256) | fn as_storage_mut(&mut self) -> &mut StorageTarget<Face<G>> {
  type Builder (line 1298) | type Builder = GraphBuilder<G>;
  type Error (line 1299) | type Error = GraphError;
  type Vertex (line 1301) | type Vertex = G::Vertex;
  type Facet (line 1302) | type Facet = G::Face;
  method builder (line 1304) | fn builder() -> Self::Builder {
  method default (line 1315) | fn default() -> Self {
  type Dynamic (line 1324) | type Dynamic = MeshArity;
  method arity (line 1326) | fn arity(&self) -> Self::Dynamic {
  function from (line 1337) | fn from(polygon: P) -> Self {
  function from (line 1348) | fn from(core: OwnedCore<G>) -> Self {
  function from (line 1357) | fn from(graph: MeshGraph<G>) -> Self {
  type Error (line 1370) | type Error = GraphError;
  function from_encoding (line 1372) | fn from_encoding(
  type Error (line 1402) | type Error = GraphError;
  function from_indexer (line 1404) | fn from_indexer<I, N>(input: I, indexer: N) -> Result<Self, Self::Error>
  function from_iter (line 1436) | fn from_iter<I>(input: I) -> Self
  type Error (line 1451) | type Error = GraphError;
  function from_raw_buffers (line 1453) | fn from_raw_buffers<I, J>(indices: I, vertices: J) -> Result<Self, Self:...
  type Error (line 1482) | type Error = GraphError;
  function from_raw_buffers_with_arity (line 1517) | fn from_raw_buffers_with_arity<I, J>(
  type Output (line 1564) | type Output = vec::IntoIter<Self::Polygon>;
  type Polygon (line 1565) | type Polygon = UnboundedPolygon<G::Vertex>;
  method into_polygons (line 1567) | fn into_polygons(self) -> Self::Output {
  type Data (line 1588) | type Data = G;
  type Static (line 1595) | type Static = (usize, Option<usize>);
  constant ARITY (line 1597) | const ARITY: Self::Static = (3, None);
  type Error (line 1609) | type Error = GraphError;
  function try_from (line 1644) | fn try_from(buffer: MeshBuffer<Flat<T, A>, H>) -> Result<Self, Self::Err...
  type Error (line 1659) | type Error = GraphError;
  function try_from (line 1693) | fn try_from(buffer: MeshBuffer<P, H>) -> Result<Self, Self::Error> {
  type E2 (line 1712) | type E2 = Point2<R64>;
  type E3 (line 1713) | type E3 = Point3<R64>;
  function collect (line 1716) | fn collect() {
  function iterate (line 1727) | fn iterate() {
  function isolate_disjoint_subgraphs (line 1747) | fn isolate_disjoint_subgraphs() {
  function non_manifold_error_deferred (line 1777) | fn non_manifold_error_deferred() {
  function error_on_non_manifold (line 1788) | fn error_on_non_manifold() {
  function read_write_mutable_circulator (line 1804) | fn read_write_mutable_circulator() {

FILE: plexus/src/graph/mutation/edge.rs
  type CompositeEdge (line 19) | pub type CompositeEdge<G> = (Edge<G>, (Arc<G>, Arc<G>));
  type CompositeEdgeData (line 20) | pub type CompositeEdgeData<G> = (
  type CompositeEdgeKey (line 24) | pub type CompositeEdgeKey = (EdgeKey, (ArcKey, ArcKey));
  type ModalCore (line 26) | type ModalCore<P> = Core<
  type RefCore (line 33) | type RefCore<'a, G> = Core<
  type EdgeMutation (line 41) | pub struct EdgeMutation<P>
  function to_ref_core (line 54) | pub fn to_ref_core(&self) -> RefCore<Data<P::Graph>> {
  function connect_adjacent_arcs (line 61) | pub fn connect_adjacent_arcs(&mut self, ab: ArcKey, bc: ArcKey) -> Resul...
  function disconnect_next_arc (line 67) | pub fn disconnect_next_arc(&mut self, ab: ArcKey) -> Result<Option<ArcKe...
  function disconnect_previous_arc (line 76) | pub fn disconnect_previous_arc(&mut self, ab: ArcKey) -> Result<Option<A...
  function connect_arc_to_edge (line 85) | pub fn connect_arc_to_edge(&mut self, ab: ArcKey, ab_ba: EdgeKey) -> Res...
  function connect_arc_to_face (line 89) | pub fn connect_arc_to_face(&mut self, ab: ArcKey, abc: FaceKey) -> Resul...
  function disconnect_arc_from_face (line 93) | pub fn disconnect_arc_from_face(&mut self, ab: ArcKey) -> Result<Option<...
  function with_arc_mut (line 97) | fn with_arc_mut<T, F>(&mut self, ab: ArcKey, mut f: F) -> Result<T, Grap...
  function as_storage (line 115) | fn as_storage(&self) -> &StorageTarget<Arc<Data<P::Graph>>> {
  function as_storage (line 124) | fn as_storage(&self) -> &StorageTarget<Edge<Data<P::Graph>>> {
  function bypass (line 133) | fn bypass(self) -> Self::Commit {
  type Target (line 148) | type Target = VertexMutation<P>;
  method deref (line 150) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 159) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 168) | fn from(core: ModalCore<P>) -> Self {
  type Commit (line 181) | type Commit = ModalCore<Immediate<M>>;
  type Abort (line 182) | type Abort = ();
  type Error (line 183) | type Error = GraphError;
  function commit (line 185) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 201) | fn abort(self) -> Self::Abort {}
  type ArcRemoveCache (line 204) | struct ArcRemoveCache {
    method from_arc (line 212) | pub fn from_arc<B>(arc: ArcView<B>) -> Result<Self, GraphError>
  type EdgeRemoveCache (line 244) | pub struct EdgeRemoveCache {
    method from_arc (line 253) | pub fn from_arc<B>(arc: ArcView<B>) -> Result<Self, GraphError>
  type EdgeSplitCache (line 276) | pub struct EdgeSplitCache {
    method from_arc (line 285) | pub fn from_arc<B>(arc: ArcView<B>) -> Result<Self, GraphError>
  type ArcBridgeCache (line 319) | pub struct ArcBridgeCache {
    method from_arc (line 327) | pub fn from_arc<B>(arc: ArcView<B>, destination: ArcKey) -> Result<Sel...
    method from_storage (line 370) | pub fn from_storage<B>(
  type ArcExtrudeCache (line 386) | pub struct ArcExtrudeCache {
    method from_arc (line 391) | pub fn from_arc<B>(arc: ArcView<B>) -> Result<Self, GraphError>
  function get_or_insert_with (line 409) | pub fn get_or_insert_with<N, P, F>(
  function remove (line 475) | pub fn remove<N, P>(
  function split_with (line 543) | pub fn split_with<N, P, F>(
  function bridge (line 648) | pub fn bridge<N, P>(mut mutation: N, cache: ArcBridgeCache) -> Result<Fa...
  function extrude_with (line 661) | pub fn extrude_with<N, P, F>(

FILE: plexus/src/graph/mutation/face.rs
  type ModalCore (line 21) | type ModalCore<P> = Core<
  type RefCore (line 28) | pub type RefCore<'a, G> = Core<
  type FaceMutation (line 36) | pub struct FaceMutation<P>
  function to_ref_core (line 48) | pub fn to_ref_core(&self) -> RefCore<Data<P::Graph>> {
  function connect_face_to_arc (line 54) | pub fn connect_face_to_arc(&mut self, ab: ArcKey, abc: FaceKey) -> Resul...
  function connect_face_interior (line 58) | fn connect_face_interior(&mut self, arcs: &[ArcKey], face: FaceKey) -> R...
  function disconnect_face_interior (line 66) | fn disconnect_face_interior(&mut self, arcs: &[ArcKey]) -> Result<(), Gr...
  function connect_face_exterior (line 73) | fn connect_face_exterior(
  function with_face_mut (line 131) | fn with_face_mut<T, F>(&mut self, abc: FaceKey, mut f: F) -> Result<T, G...
  function as_storage (line 148) | fn as_storage(&self) -> &StorageTarget<Face<Data<P::Graph>>> {
  function bypass (line 157) | fn bypass(self) -> Self::Commit {
  type Target (line 172) | type Target = EdgeMutation<P>;
  method deref (line 174) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 183) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 192) | fn from(core: ModalCore<P>) -> Self {
  type Commit (line 205) | type Commit = ModalCore<Immediate<M>>;
  type Abort (line 206) | type Abort = ();
  type Error (line 207) | type Error = GraphError;
  function commit (line 210) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 219) | fn abort(self) -> Self::Abort {}
  type FaceInsertCache (line 222) | pub struct FaceInsertCache {
    method from_ring (line 231) | pub fn from_ring<B, T>(ring: T) -> Result<Self, GraphError>
    method from_storage (line 246) | pub fn from_storage<B, K>(storage: B, perimeter: K) -> Result<Self, Gr...
  type FaceRemoveCache (line 317) | pub struct FaceRemoveCache {
    method from_face (line 324) | pub fn from_face<B>(face: FaceView<B>) -> Result<Self, GraphError>
  type FaceSplitCache (line 341) | pub struct FaceSplitCache {
    method from_face (line 348) | pub fn from_face<B>(
  type FacePokeCache (line 420) | pub struct FacePokeCache {
    method from_face (line 426) | pub fn from_face<B>(face: FaceView<B>) -> Result<Self, GraphError>
  type FaceBridgeCache (line 443) | pub struct FaceBridgeCache {
    method from_face (line 450) | pub fn from_face<B>(face: FaceView<B>, destination: FaceKey) -> Result...
  type FaceExtrudeCache (line 479) | pub struct FaceExtrudeCache {
    method from_face (line 485) | pub fn from_face<B>(face: FaceView<B>) -> Result<Self, GraphError>
  function insert_with (line 501) | pub fn insert_with<N, P, F>(
  function remove (line 548) | pub fn remove<N, P>(
  function split (line 568) | pub fn split<N, P>(mut mutation: N, cache: FaceSplitCache) -> Result<Arc...
  function poke_with (line 584) | pub fn poke_with<N, P, F>(
  function bridge (line 607) | pub fn bridge<N, P>(mut mutation: N, cache: FaceBridgeCache) -> Result<(...
  function extrude_with (line 633) | pub fn extrude_with<N, P, F>(

FILE: plexus/src/graph/mutation/mod.rs
  type Consistent (line 44) | pub trait Consistent {}
  type Mode (line 50) | pub trait Mode {
    type Graph (line 69) | type Graph = M;
    type VertexStorage (line 70) | type VertexStorage = <Vertex<Data<M>> as Entity>::Storage;
    type ArcStorage (line 71) | type ArcStorage = <Arc<Data<M>> as Entity>::Storage;
    type EdgeStorage (line 72) | type EdgeStorage = <Edge<Data<M>> as Entity>::Storage;
    type FaceStorage (line 73) | type FaceStorage = <Face<Data<M>> as Entity>::Storage;
  type Immediate (line 58) | pub struct Immediate<M>
  type Mutation (line 77) | pub struct Mutation<P>
  function as_ref (line 90) | fn as_ref(&self) -> &Self {
  function as_mut (line 100) | fn as_mut(&mut self) -> &mut Self {
  function as_storage (line 110) | fn as_storage(&self) -> &StorageTarget<Arc<Data<P::Graph>>> {
  function as_storage (line 120) | fn as_storage(&self) -> &StorageTarget<Edge<Data<P::Graph>>> {
  function as_storage (line 130) | fn as_storage(&self) -> &StorageTarget<Face<Data<P::Graph>>> {
  function as_storage (line 140) | fn as_storage(&self) -> &StorageTarget<Vertex<Data<P::Graph>>> {
  function bypass (line 149) | fn bypass(self) -> Self::Commit {
  type Target (line 160) | type Target = FaceMutation<P>;
  method deref (line 162) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 172) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 181) | fn from(graph: M) -> Self {
  type Data (line 193) | type Data = Data<P::Graph>;
  type Commit (line 200) | type Commit = M;
  type Abort (line 201) | type Abort = ();
  type Error (line 202) | type Error = GraphError;
  function commit (line 204) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 208) | fn abort(self) -> Self::Abort {}
  type Mutable (line 211) | pub trait Mutable:

FILE: plexus/src/graph/mutation/path.rs
  type PathExtrudeCache (line 17) | pub struct PathExtrudeCache {
    method from_path (line 23) | pub fn from_path<B>(path: Path<B>) -> Result<Self, GraphError>
  function extrude_contour_with (line 43) | pub fn extrude_contour_with<N, P, F>(

FILE: plexus/src/graph/mutation/vertex.rs
  type ModalCore (line 13) | type ModalCore<P> = Core<Data<<P as Mode>::Graph>, <P as Mode>::VertexSt...
  type RefCore (line 14) | type RefCore<'a, G> = Core<G, &'a StorageTarget<'a, Vertex<G>>, (), (), ...
  type VertexMutation (line 16) | pub struct VertexMutation<P>
  function to_ref_core (line 27) | pub fn to_ref_core(&self) -> RefCore<Data<P::Graph>> {
  function connect_outgoing_arc (line 31) | pub fn connect_outgoing_arc(&mut self, a: VertexKey, ab: ArcKey) -> Resu...
  function disconnect_outgoing_arc (line 35) | pub fn disconnect_outgoing_arc(&mut self, a: VertexKey) -> Result<Option...
  function with_vertex_mut (line 39) | fn with_vertex_mut<T, F>(&mut self, a: VertexKey, mut f: F) -> Result<T,...
  function as_storage (line 56) | fn as_storage(&self) -> &StorageTarget<Vertex<Data<P::Graph>>> {
  function bypass (line 65) | fn bypass(self) -> Self::Commit {
  function from (line 77) | fn from(core: ModalCore<P>) -> Self {
  type Commit (line 87) | type Commit = ModalCore<Immediate<M>>;
  type Abort (line 88) | type Abort = ();
  type Error (line 89) | type Error = GraphError;
  function commit (line 91) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 104) | fn abort(self) -> Self::Abort {}
  type VertexRemoveCache (line 107) | pub struct VertexRemoveCache {
    method from_vertex (line 112) | pub fn from_vertex<B>(vertex: VertexView<B>) -> Result<Self, GraphError>
  function insert (line 122) | pub fn insert<N, P>(mut mutation: N, data: <Data<P::Graph> as GraphData>...
  function remove (line 135) | pub fn remove<N, P>(

FILE: plexus/src/graph/path.rs
  type Mutation (line 20) | type Mutation<M> = mutation::Mutation<Immediate<M>>;
  type Path (line 38) | pub struct Path<'k, B>
  function bind (line 56) | pub(in crate::graph) fn bind<I>(storage: B, keys: I) -> Result<Self, Gra...
  function bind_unchecked (line 76) | fn bind_unchecked<I>(storage: B, keys: I) -> Self
  function to_ref (line 92) | pub fn to_ref(&self) -> Path<&M> {
  function into_opposite_path (line 100) | pub fn into_opposite_path(self) -> Path<'static, B> {
  function opposite_path (line 109) | pub fn opposite_path(&self) -> Path<'static, &M> {
  function push_back (line 129) | pub fn push_back(
  function push_previous_arc (line 171) | pub fn push_previous_arc(&mut self) -> Result<ArcKey, GraphError> {
  function pop_back (line 181) | pub fn pop_back(&mut self) -> Option<ArcKey> {
  function push_front (line 207) | pub fn push_front(
  function push_next_arc (line 250) | pub fn push_next_arc(&mut self) -> Result<ArcKey, GraphError> {
  function pop_front (line 260) | pub fn pop_front(&mut self) -> Option<ArcKey> {
  function back (line 271) | pub fn back(&self) -> VertexView<&M> {
  function front (line 277) | pub fn front(&self) -> VertexView<&M> {
  function shortest_metric_with (line 282) | pub fn shortest_metric_with<Q, F>(
  function is_open (line 304) | pub fn is_open(&self) -> bool {
  function is_closed (line 312) | pub fn is_closed(&self) -> bool {
  function terminals (line 317) | fn terminals(&self) -> (VertexKey, VertexKey) {
  function shortest_subpath_terminals (line 323) | fn shortest_subpath_terminals(
  function into_ref (line 368) | pub fn into_ref(self) -> Path<'k, &'a M> {
  function split (line 397) | pub fn split(
  function vertices (line 435) | pub fn vertices(&self) -> impl Clone + Iterator<Item = VertexView<&B::Ta...
  function arcs (line 448) | pub fn arcs(&self) -> impl Clone + ExactSizeIterator<Item = ArcView<&B::...
  function extrude_contour_with (line 483) | pub fn extrude_contour_with<F>(self, f: F) -> Result<FaceView<&'a mut M>...
  function extrude_surface_with (line 497) | pub fn extrude_surface_with<F>(self, f: F) -> Result<Self, GraphError>
  function from (line 512) | fn from(ring: Ring<B>) -> Self {
  method eq (line 525) | fn eq(&self, other: &Self) -> bool {
  function truncate (line 531) | fn truncate<T>(
  type E2 (line 555) | type E2 = Point2<f64>;
  function open_close (line 558) | fn open_close() {
  function logical_metrics (line 584) | fn logical_metrics() {
  function split (line 611) | fn split() {

FILE: plexus/src/graph/vertex.rs
  type Mutation (line 32) | type Mutation<M> = mutation::Mutation<Immediate<M>>;
  type Vertex (line 37) | pub struct Vertex<G>
  function new (line 52) | pub fn new(data: G::Vertex) -> Self {
  type Data (line 69) | type Data = G::Vertex;
  method get (line 71) | fn get(&self) -> &Self::Data {
  method get_mut (line 75) | fn get_mut(&mut self) -> &mut Self::Data {
  type VertexKey (line 82) | pub struct VertexKey(u64);
  type Inner (line 85) | type Inner = u64;
  method from_inner (line 87) | fn from_inner(key: Self::Inner) -> Self {
  method into_inner (line 91) | fn into_inner(self) -> Self::Inner {
  type VertexView (line 101) | pub struct VertexView<B>
  function to_ref (line 114) | pub fn to_ref(&self) -> VertexView<&M> {
  function to_mut_unchecked (line 127) | fn to_mut_unchecked(&mut self) -> VertexView<&mut M> {
  function into_ref (line 167) | pub fn into_ref(self) -> VertexView<&'a M> {
  function get (line 178) | pub fn get<'a>(&'a self) -> &'a G::Vertex
  function position (line 185) | pub fn position<'a>(&'a self) -> &'a VertexPosition<G>
  function get_mut (line 200) | pub fn get_mut<'a>(&'a mut self) -> &'a mut G::Vertex
  function into_reachable_outgoing_arc (line 215) | pub(in crate::graph) fn into_reachable_outgoing_arc(self) -> Option<ArcV...
  function into_outgoing_arc (line 228) | pub fn into_outgoing_arc(self) -> ArcView<B> {
  function outgoing_arc (line 233) | pub fn outgoing_arc(&self) -> ArcView<&M> {
  function shortest_path (line 237) | pub fn shortest_path(&self, key: VertexKey) -> Result<Path<'static, &M>,...
  function into_shortest_path (line 241) | pub fn into_shortest_path(self, key: VertexKey) -> Result<Path<'static, ...
  function shortest_path_with (line 245) | pub fn shortest_path_with<Q, F>(
  function into_shortest_path_with (line 257) | pub fn into_shortest_path_with<Q, F>(
  function valence (line 284) | pub fn valence(&self) -> usize {
  function centroid (line 288) | pub fn centroid(&self) -> VertexPosition<G>
  function normal (line 307) | pub fn normal(&self) -> Result<Vector<VertexPosition<G>>, GraphError>
  function into_reachable_incoming_arcs (line 323) | pub(in crate::graph) fn into_reachable_incoming_arcs(
  function into_reachable_outgoing_arcs (line 330) | pub(in crate::graph) fn into_reachable_outgoing_arcs(
  function reachable_incoming_arcs (line 346) | pub(in crate::graph) fn reachable_incoming_arcs(
  function reachable_outgoing_arcs (line 352) | pub(in crate::graph) fn reachable_outgoing_arcs(
  function into_adjacent_vertices (line 365) | pub fn into_adjacent_vertices(self) -> impl Clone + Iterator<Item = Vert...
  function into_incoming_arcs (line 369) | pub fn into_incoming_arcs(self) -> impl Clone + Iterator<Item = ArcView<...
  function into_outgoing_arcs (line 373) | pub fn into_outgoing_arcs(self) -> impl Clone + Iterator<Item = ArcView<...
  function adjacent_vertices (line 384) | pub fn adjacent_vertices(&self) -> impl Clone + Iterator<Item = VertexVi...
  function incoming_arcs (line 392) | pub fn incoming_arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::...
  function outgoing_arcs (line 400) | pub fn outgoing_arcs(&self) -> impl Clone + Iterator<Item = ArcView<&B::...
  function traverse_by_breadth (line 409) | pub fn traverse_by_breadth(&self) -> impl Clone + Iterator<Item = Vertex...
  function traverse_by_depth (line 418) | pub fn traverse_by_depth(&self) -> impl Clone + Iterator<Item = VertexVi...
  function into_adjacent_faces (line 434) | pub fn into_adjacent_faces(self) -> impl Clone + Iterator<Item = FaceVie...
  function adjacent_faces (line 453) | pub fn adjacent_faces(&self) -> impl Clone + Iterator<Item = FaceView<&B...
  function into_adjacent_vertex_orphans (line 462) | pub fn into_adjacent_vertex_orphans(self) -> impl Iterator<Item = Vertex...
  function adjacent_vertex_orphans (line 472) | pub fn adjacent_vertex_orphans(&mut self) -> impl Iterator<Item = Vertex...
  function into_incoming_arc_orphans (line 481) | pub fn into_incoming_arc_orphans(self) -> impl Iterator<Item = ArcOrphan...
  function incoming_arc_orphans (line 495) | pub fn incoming_arc_orphans(&mut self) -> impl Iterator<Item = ArcOrphan...
  function into_adjacent_face_orphans (line 508) | pub fn into_adjacent_face_orphans(self) -> impl Iterator<Item = FaceOrph...
  function adjacent_face_orphans (line 526) | pub fn adjacent_face_orphans(&mut self) -> impl Iterator<Item = FaceOrph...
  function remove (line 574) | pub fn remove(self) {
  type Output (line 592) | type Output = SmallVec<[Self::Key; 8]>;
  method adjacency (line 594) | fn adjacency(&self) -> Self::Output {
  function borrow (line 604) | fn borrow(&self) -> &VertexKey {
  method clone (line 616) | fn clone(&self) -> Self {
  type Key (line 629) | type Key = VertexKey;
  type Entity (line 630) | type Entity = Vertex<G>;
  method key (line 632) | fn key(&self) -> Self::Key {
  type Target (line 652) | type Target = Vertex<G>;
  method deref (line 654) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 665) | fn deref_mut(&mut self) -> &mut Self::Target {
  function from (line 684) | fn from(view: View<B, Vertex<G>>) -> Self {
  function from (line 695) | fn from(vertex: VertexView<B>) -> Self {
  method hash (line 707) | fn hash<H>(&self, state: &mut H)
  method eq (line 721) | fn eq(&self, other: &Self) -> bool {
  type VertexOrphan (line 727) | pub struct VertexOrphan<'a, G>
  function position (line 738) | pub fn position(&self) -> &VertexPosition<G>
  function get (line 750) | pub fn get(&self) -> &G::Vertex {
  function get_mut (line 754) | pub fn get_mut(&mut self) -> &mut G::Vertex {
  function borrow (line 763) | fn borrow(&self) -> &VertexKey {
  type Key (line 772) | type Key = VertexKey;
  type Entity (line 773) | type Entity = Vertex<G>;
  method key (line 775) | fn key(&self) -> Self::Key {
  function from (line 786) | fn from(inner: Orphan<'a, Vertex<G>>) -> Self {
  function from (line 795) | fn from(view: View<&'a mut M, Vertex<M::Data>>) -> Self {
  function from (line 804) | fn from(vertex: VertexView<&'a mut M>) -> Self {
  method hash (line 813) | fn hash<H>(&self, state: &mut H)
  method eq (line 825) | fn eq(&self, other: &Self) -> bool {
  type VertexCirculator (line 830) | pub struct VertexCirculator<P, B>
  type Entity (line 846) | type Entity = Vertex<G>;
    type Key (line 61) | type Key = VertexKey;
    type Storage (line 62) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 848) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 863) | fn clone(&self) -> Self {
  function from (line 877) | fn from(inner: ArcCirculator<P, B>) -> Self {
  type Item (line 887) | type Item = VertexView<&'a M>;
  method next (line 889) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 898) | type Item = VertexOrphan<'a, M::Data>;
  method next (line 900) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 909) | type Item = VertexOrphan<'a, M::Data>;
  method next (line 911) | fn next(&mut self) -> Option<Self::Item> {
  function target (line 921) | fn target(&mut self) -> &mut M {
  function target (line 931) | fn target(&self) -> &'a M {
  type ArcCirculator (line 936) | pub struct ArcCirculator<P, B>
  type Entity (line 954) | type Entity = Arc<G>;
    type Key (line 61) | type Key = VertexKey;
    type Storage (line 62) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 956) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 982) | fn clone(&self) -> Self {
  function from (line 998) | fn from(vertex: VertexView<B>) -> Self {
  type Item (line 1014) | type Item = ArcView<&'a M>;
  method next (line 1016) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 1025) | type Item = ArcOrphan<'a, M::Data>;
  method next (line 1027) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 1036) | type Item = ArcOrphan<'a, M::Data>;
  method next (line 1038) | fn next(&mut self) -> Option<Self::Item> {
  function target (line 1048) | fn target(&mut self) -> &mut M {
  function target (line 1058) | fn target(&self) -> &'a M {
  type FaceCirculator (line 1063) | pub struct FaceCirculator<P, B>
  type Entity (line 1079) | type Entity = Face<G>;
    type Key (line 61) | type Key = VertexKey;
    type Storage (line 62) | type Storage = HashStorage<Self, IncrementalKeyer>;
  function next (line 1081) | fn next(&mut self) -> Option<<Self::Entity as Entity>::Key> {
  method clone (line 1110) | fn clone(&self) -> Self {
  function from (line 1124) | fn from(inner: ArcCirculator<P, B>) -> Self {
  type Item (line 1134) | type Item = FaceView<&'a M>;
  method next (line 1136) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 1145) | type Item = FaceOrphan<'a, M::Data>;
  method next (line 1147) | fn next(&mut self) -> Option<Self::Item> {
  type Item (line 1156) | type Item = FaceOrphan<'a, M::Data>;
  method next (line 1158) | fn next(&mut self) -> Option<Self::Item> {
  function target (line 1168) | fn target(&mut self) -> &mut M {
  function target (line 1178) | fn target(&self) -> &'a M {
  type E3 (line 1195) | type E3 = Point3<R64>;
  function circulate_over_arcs (line 1198) | fn circulate_over_arcs() {
  function reachable_shortest_path (line 1211) | fn reachable_shortest_path() {
  function unreachable_shortest_path (line 1227) | fn unreachable_shortest_path() {
  function traverse_by_breadth (line 1252) | fn traverse_by_breadth() {
  function traverse_by_depth (line 1262) | fn traverse_by_depth() {

FILE: plexus/src/index.rs
  type BufferOf (line 94) | pub(crate) type BufferOf<R> = Vec<<R as Grouping>::Group>;
  type IndexOf (line 95) | pub(crate) type IndexOf<R> = <BufferOf<R> as IndexBuffer<R>>::Index;
  type IndexBuffer (line 109) | pub trait IndexBuffer<R>
  type Index (line 128) | type Index = T;
  type Index (line 136) | type Index = P::Vertex;
  type Push (line 139) | pub trait Push<R, P>: IndexBuffer<R>
    method push (line 145) | fn push(&mut self, index: P);
  function push (line 155) | fn push(&mut self, index: P) {
  function push (line 169) | fn push(&mut self, index: Q) {
  type Grouping (line 174) | pub trait Grouping: StaticArity {
    type Group (line 228) | type Group = T;
    type Group (line 283) | type Group = P;
  type Flat (line 211) | pub struct Flat<T, const N: usize>
  type Static (line 245) | type Static = usize;
  constant ARITY (line 247) | const ARITY: Self::Static = crate::n_arity(N);
  type Flat3 (line 251) | pub type Flat3<T = usize> = Flat<T, 3>;
  type Flat4 (line 253) | pub type Flat4<T = usize> = Flat<T, 4>;
  type Indexer (line 290) | pub trait Indexer<T, K>
    method index (line 299) | fn index<F>(&mut self, vertex: T::Vertex, f: F) -> (usize, Option<T::V...
  type HashIndexer (line 337) | pub struct HashIndexer<T, K>
  function new (line 353) | pub fn new() -> Self {
  method default (line 367) | fn default() -> Self {
  function index (line 377) | fn index<F>(&mut self, input: T::Vertex, f: F) -> (usize, Option<T::Vert...
  type LruIndexer (line 424) | pub struct LruIndexer<T, K>
  function new (line 441) | pub fn new() -> Self {
  function with_capacity (line 449) | pub fn with_capacity(capacity: usize) -> Self {
  function find (line 459) | fn find(&self, key: &K) -> Option<(usize, usize)> {
  method default (line 473) | fn default() -> Self {
  function index (line 483) | fn index<F>(&mut self, input: T::Vertex, f: F) -> (usize, Option<T::Vert...
  type GroupedIndexVertices (line 518) | pub trait GroupedIndexVertices<R, P>: Sized
    method index_vertices_with (line 523) | fn index_vertices_with<N, K, F>(self, indexer: N, f: F) -> (Vec<R::Gro...
    method index_vertices (line 528) | fn index_vertices<N>(self, indexer: N) -> (Vec<R::Group>, Vec<P::Vertex>)
  method index_vertices_with (line 545) | fn index_vertices_with<N, K, F>(self, mut indexer: N, f: F) -> (Vec<R::G...
  type IndexVertices (line 602) | pub trait IndexVertices<P>
    method index_vertices_with (line 608) | fn index_vertices_with<R, N, K, F>(self, indexer: N, f: F) -> (Vec<R::...
    method index_vertices (line 643) | fn index_vertices<R, N>(self, indexer: N) -> (Vec<R::Group>, Vec<P::Ve...
  type FromIndexer (line 660) | pub trait FromIndexer<P, Q>: Sized
    method from_indexer (line 667) | fn from_indexer<I, N>(input: I, indexer: N) -> Result<Self, Self::Error>
  type CollectWithIndexer (line 684) | pub trait CollectWithIndexer<P, Q>
    method collect_with_indexer (line 718) | fn collect_with_indexer<T, N>(self, indexer: N) -> Result<T, T::Error>
  method collect_with_indexer (line 730) | fn collect_with_indexer<T, N>(self, indexer: N) -> Result<T, T::Error>

FILE: plexus/src/integration/cgmath.rs
  function from_geometry (line 15) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 25) | fn from_geometry(other: Vector2<T>) -> Self {
  function from_geometry (line 35) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 49) | fn from_geometry(other: Vector3<T>) -> Self {
  function from_geometry (line 63) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 73) | fn from_geometry(other: Point2<T>) -> Self {
  function from_geometry (line 85) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 99) | fn from_geometry(other: Point3<T>) -> Self {
  type Vertex (line 112) | type Vertex = Self;
  type Arc (line 113) | type Arc = ();
  type Edge (line 114) | type Edge = ();
  type Face (line 115) | type Face = ();
  type Vertex (line 122) | type Vertex = Self;
  type Arc (line 123) | type Arc = ();
  type Edge (line 124) | type Edge = ();
  type Face (line 125) | type Face = ();

FILE: plexus/src/integration/glam.rs
  method from_geometry (line 9) | fn from_geometry(other: (f32, f32)) -> Self {
  method from_geometry (line 15) | fn from_geometry(other: (f32, f32, f32)) -> Self {
  method from_geometry (line 21) | fn from_geometry(other: (f32, f32, f32)) -> Self {
  type Vertex (line 27) | type Vertex = Self;
  type Arc (line 28) | type Arc = ();
  type Edge (line 29) | type Edge = ();
  type Face (line 30) | type Face = ();
  type Vertex (line 34) | type Vertex = Self;
  type Arc (line 35) | type Arc = ();
  type Edge (line 36) | type Edge = ();
  type Face (line 37) | type Face = ();
  type Vertex (line 41) | type Vertex = Self;
  type Arc (line 42) | type Arc = ();
  type Edge (line 43) | type Edge = ();
  type Face (line 44) | type Face = ();

FILE: plexus/src/integration/mint.rs
  function from_geometry (line 15) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 28) | fn from_geometry(other: Vector2<T>) -> Self {
  function from_geometry (line 38) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 52) | fn from_geometry(other: Vector3<T>) -> Self {
  function from_geometry (line 66) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 79) | fn from_geometry(other: Point2<T>) -> Self {
  function from_geometry (line 91) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 105) | fn from_geometry(other: Point3<T>) -> Self {
  type Vertex (line 118) | type Vertex = Self;
  type Arc (line 119) | type Arc = ();
  type Edge (line 120) | type Edge = ();
  type Face (line 121) | type Face = ();
  type Vertex (line 128) | type Vertex = Self;
  type Arc (line 129) | type Arc = ();
  type Edge (line 130) | type Edge = ();
  type Face (line 131) | type Face = ();

FILE: plexus/src/integration/nalgebra.rs
  function from_geometry (line 18) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 28) | fn from_geometry(other: Vector2<T>) -> Self {
  function from_geometry (line 39) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 53) | fn from_geometry(other: Vector3<T>) -> Self {
  function from_geometry (line 68) | fn from_geometry(other: (U, U)) -> Self {
  function from_geometry (line 78) | fn from_geometry(other: Point2<T>) -> Self {
  function from_geometry (line 89) | fn from_geometry(other: (U, U, U)) -> Self {
  function from_geometry (line 103) | fn from_geometry(other: Point3<T>) -> Self {
  type Vertex (line 120) | type Vertex = Self;
  type Arc (line 121) | type Arc = ();
  type Edge (line 122) | type Edge = ();
  type Face (line 123) | type Face = ();

FILE: plexus/src/integration/ultraviolet.rs
  method from_geometry (line 9) | fn from_geometry(other: (f32, f32)) -> Self {
  method from_geometry (line 15) | fn from_geometry(other: (f32, f32, f32)) -> Self {
  type Vertex (line 21) | type Vertex = Self;
  type Arc (line 22) | type Arc = ();
  type Edge (line 23) | type Edge = ();
  type Face (line 24) | type Face = ();
  type Vertex (line 28) | type Vertex = Self;
  type Arc (line 29) | type Arc = ();
  type Edge (line 30) | type Edge = ();
  type Face (line 31) | type Face = ();

FILE: plexus/src/lib.rs
  type Arity (line 105) | pub trait Arity: Copy {
    method into_interval (line 106) | fn into_interval(self) -> (usize, Option<usize>);
    method into_interval (line 111) | fn into_interval(self) -> (usize, Option<usize>) {
    method into_interval (line 121) | fn into_interval(self) -> (usize, Option<usize>) {
    method into_interval (line 134) | fn into_interval(self) -> (usize, Option<usize>) {
    method into_interval (line 227) | fn into_interval(self) -> (usize, Option<usize>) {
  type StaticArity (line 146) | pub trait StaticArity {
    constant ARITY (line 149) | const ARITY: Self::Static;
  type DynamicArity (line 159) | pub trait DynamicArity: StaticArity {
    method arity (line 162) | fn arity(&self) -> Self::Dynamic;
  type Monomorphic (line 178) | pub trait Monomorphic: StaticArity<Static = usize> {}
  type MeshArity (line 189) | pub enum MeshArity {
    method from_components (line 208) | pub fn from_components<T, I>(components: I) -> Self
  type TryFromIterator (line 235) | pub trait TryFromIterator<T>: Sized {
    method try_from_iter (line 238) | fn try_from_iter<I>(items: I) -> Result<Self, Self::Error>
  type Error (line 244) | type Error = ();
  function try_from_iter (line 246) | fn try_from_iter<I>(items: I) -> Result<Self, Self::Error>
  type IteratorExt (line 301) | pub trait IteratorExt: Iterator + Sized {
    method perimeter (line 307) | fn perimeter(self) -> Perimeter<Self>
    method keys (line 356) | fn keys(self) -> Keys<Self>
    method has_at_least (line 388) | fn has_at_least(self, n: usize) -> Option<MultiPeek<Self>> {
    method has_exactly (line 395) | fn has_exactly(self, n: usize) -> Option<MultiPeek<Self>> {
    method try_collect (line 404) | fn try_collect<T>(self) -> Result<T, T::Error>
  type Perimeter (line 425) | pub struct Perimeter<I>
  function new (line 440) | fn new(mut input: I) -> Self {
  type Item (line 456) | type Item = (I::Item, I::Item);
  method next (line 458) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 469) | fn size_hint(&self) -> (usize, Option<usize>) {
  type Keys (line 481) | pub struct Keys<I>
  function new (line 494) | fn new(input: I) -> Self {
  type Item (line 504) | type Item = <I::Item as ClosedView>::Key;
  method next (line 506) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 510) | fn size_hint(&self) -> (usize, Option<usize>) {
  function peek_n (line 515) | fn peek_n<I>(input: I, n: usize) -> Option<MultiPeek<I>>
  function n_arity (line 532) | const fn n_arity(n: usize) -> usize {

FILE: plexus/src/primitive/cube.rs
  type Plane (line 35) | pub enum Plane {
    method normal (line 45) | pub fn normal<S>(self) -> Unit<S>
  type Bounds (line 63) | pub struct Bounds<S>
  function with_radius (line 75) | pub fn with_radius(radius: Scalar<S>) -> Self {
  function with_width (line 82) | pub fn with_width(width: Scalar<S>) -> Self {
  function unit_radius (line 86) | pub fn unit_radius() -> Self {
  function unit_width (line 90) | pub fn unit_width() -> Self {
  method default (line 99) | fn default() -> Self {
  type Cube (line 105) | pub struct Cube;
    method new (line 108) | pub fn new() -> Self {
    type State (line 129) | type State = ();
    type Output (line 136) | type Output = Unit<Vector<S>>;
    method vertex_count (line 138) | fn vertex_count(&self) -> usize {
    method vertex_from (line 142) | fn vertex_from(&self, _: &Self::State, index: usize) -> Self::Output {
    type Output (line 151) | type Output = Tetragon<Unit<Vector<S>>>;
    method polygon_from (line 153) | fn polygon_from(&self, state: &Self::State, index: usize) -> Self::Out...
    type Output (line 160) | type Output = Tetragon<usize>;
    method indexing_polygon (line 162) | fn indexing_polygon(&self, index: usize) -> Self::Output {
    type State (line 172) | type State = Bounds<S>;
    type Output (line 179) | type Output = S;
    method vertex_count (line 181) | fn vertex_count(&self) -> usize {
    method vertex_from (line 185) | fn vertex_from(&self, state: &Self::State, index: usize) -> Self::Outp...
    type Output (line 212) | type Output = Tetragon<S>;
    method polygon_from (line 214) | fn polygon_from(&self, state: &Self::State, index: usize) -> Self::Out...
    type Output (line 221) | type Output = Tetragon<usize>;
    method indexing_polygon (line 223) | fn indexing_polygon(&self, index: usize) -> Self::Output {
    type State (line 237) | type State = ();
    type Output (line 241) | type Output = Plane;
    method vertex_count (line 243) | fn vertex_count(&self) -> usize {
    method vertex_from (line 247) | fn vertex_from(&self, _: &Self::State, index: usize) -> Self::Output {
    type Output (line 261) | type Output = Tetragon<Plane>;
    method polygon_from (line 263) | fn polygon_from(&self, state: &Self::State, index: usize) -> Self::Out...
    type Output (line 270) | type Output = Tetragon<usize>;
    method indexing_polygon (line 272) | fn indexing_polygon(&self, index: usize) -> Self::Output {
  method default (line 114) | fn default() -> Self {
  method polygon_count (line 120) | fn polygon_count(&self) -> usize {

FILE: plexus/src/primitive/decompose.rs
  type Decompose (line 82) | pub struct Decompose<I, P, Q, R>
  function new (line 95) | pub(in crate::primitive) fn new(input: I, f: fn(P) -> R) -> Self {
  function remap (line 135) | pub fn remap(self, n: usize) -> Decompose<impl Iterator<Item = P>, P, P,...
  type Item (line 146) | type Item = Q;
  method next (line 148) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 162) | fn size_hint(&self) -> (usize, Option<usize>) {
  type IntoVertices (line 168) | pub trait IntoVertices: Topological {
    method into_vertices (line 171) | fn into_vertices(self) -> Self::Output;
    type Output (line 178) | type Output = <T as IntoIterator>::IntoIter;
    method into_vertices (line 180) | fn into_vertices(self) -> Self::Output {
  type IntoEdges (line 185) | pub trait IntoEdges: Topological {
    method into_edges (line 188) | fn into_edges(self) -> Self::Output;
    type Output (line 218) | type Output = Vec<Edge<Self::Vertex>>;
    method into_edges (line 220) | fn into_edges(self) -> Self::Output {
    type Output (line 240) | type Output = Vec<Edge<Self::Vertex>>;
    method into_edges (line 242) | fn into_edges(self) -> Self::Output {
    type Output (line 254) | type Output = Vec<Edge<Self::Vertex>>;
    method into_edges (line 256) | fn into_edges(self) -> Self::Output {
  type IntoTrigons (line 191) | pub trait IntoTrigons: Polygonal {
    method into_trigons (line 194) | fn into_trigons(self) -> Self::Output;
    type Output (line 265) | type Output = ArrayVec<Trigon<Self::Vertex>, 1>;
    method into_trigons (line 267) | fn into_trigons(self) -> Self::Output {
    type Output (line 276) | type Output = ArrayVec<Trigon<Self::Vertex>, 2>;
    method into_trigons (line 278) | fn into_trigons(self) -> Self::Output {
    type Output (line 288) | type Output = Vec<Trigon<Self::Vertex>>;
    method into_trigons (line 290) | fn into_trigons(self) -> Self::Output {
  type IntoSubdivisions (line 197) | pub trait IntoSubdivisions: Polygonal {
    method into_subdivisions (line 200) | fn into_subdivisions(self) -> Self::Output;
    type Output (line 302) | type Output = ArrayVec<Trigon<Self::Vertex>, 2>;
    method into_subdivisions (line 304) | fn into_subdivisions(self) -> Self::Output {
    type Output (line 315) | type Output = ArrayVec<Tetragon<Self::Vertex>, 4>;
    method into_subdivisions (line 317) | fn into_subdivisions(self) -> Self::Output {
    type Output (line 353) | type Output = Vec<Self>;
    method into_subdivisions (line 355) | fn into_subdivisions(self) -> Self::Output {
  type IntoTetrahedrons (line 203) | pub trait IntoTetrahedrons: Polygonal {
    method into_tetrahedrons (line 204) | fn into_tetrahedrons(self) -> ArrayVec<Trigon<Self::Vertex>, 4>;
    method into_tetrahedrons (line 337) | fn into_tetrahedrons(self) -> ArrayVec<Trigon<Self::Vertex>, 4> {
  type Vertices (line 371) | pub trait Vertices<P>: Sized
    method vertices (line 375) | fn vertices(self) -> Decompose<Self, P, P::Vertex, P::Output>;
  method vertices (line 383) | fn vertices(self) -> Decompose<Self, P, P::Vertex, P::Output> {
  type Edges (line 388) | pub trait Edges<P>: Sized
    method edges (line 392) | fn edges(self) -> Decompose<Self, P, Edge<P::Vertex>, P::Output>;
  method edges (line 401) | fn edges(self) -> Decompose<Self, P, Edge<P::Vertex>, P::Output> {
  type Triangulate (line 406) | pub trait Triangulate<P>: Sized
    method triangulate (line 410) | fn triangulate(self) -> Decompose<Self, P, Trigon<P::Vertex>, P::Output>;
  method triangulate (line 418) | fn triangulate(self) -> Decompose<Self, P, Trigon<P::Vertex>, P::Output> {
  type Subdivide (line 423) | pub trait Subdivide<P>: Sized
    method subdivide (line 427) | fn subdivide(self) -> Decompose<Self, P, P, P::Output>;
  method subdivide (line 435) | fn subdivide(self) -> Decompose<Self, P, P, P::Output> {
  type Tetrahedrons (line 440) | pub trait Tetrahedrons<T>: Sized {
    method tetrahedrons (line 441) | fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, Array...
  method tetrahedrons (line 449) | fn tetrahedrons(self) -> Decompose<Self, Tetragon<T>, Trigon<T>, ArrayVe...
  function remap (line 454) | fn remap<I, P, R, F>(n: usize, ngons: I, f: F) -> Vec<P>

FILE: plexus/src/primitive/generate.rs
  type Attribute (line 62) | pub trait Attribute {}
  type Normal (line 94) | pub struct Normal<S = ()> {
  type Position (line 132) | pub struct Position<S = ()> {
  type Generate (line 139) | pub struct Generate<'a, G, S, P>
  function new (line 153) | fn new(generator: &'a G, state: S, n: usize, f: fn(&'a G, &S, usize) -> ...
  type Item (line 167) | type Item = P;
  method next (line 169) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 175) | fn size_hint(&self) -> (usize, Option<usize>) {
  type PolygonGenerator (line 180) | pub trait PolygonGenerator {
    method polygon_count (line 181) | fn polygon_count(&self) -> usize;
  type AttributeGenerator (line 184) | pub trait AttributeGenerator<A>
  type AttributePolygonGenerator (line 191) | pub trait AttributePolygonGenerator<A>: AttributeGenerator<A> + PolygonG...
    method polygon_from (line 197) | fn polygon_from(&self, state: &Self::State, index: usize) -> Self::Out...
  type AttributeVertexGenerator (line 200) | pub trait AttributeVertexGenerator<A>: AttributeGenerator<A>
    method vertex_count (line 206) | fn vertex_count(&self) -> usize;
    method vertex_from (line 208) | fn vertex_from(&self, state: &Self::State, index: usize) -> Self::Output;
  type IndexingPolygonGenerator (line 211) | pub trait IndexingPolygonGenerator<A>: PolygonGenerator
    method indexing_polygon (line 217) | fn indexing_polygon(&self, index: usize) -> Self::Output;
  type Generator (line 221) | pub trait Generator: Sized {
    method vertices (line 258) | fn vertices<A>(
    method vertices_from (line 268) | fn vertices_from<A>(
    method polygons (line 300) | fn polygons<A>(
    method polygons_from (line 310) | fn polygons_from<A>(
    method indexing_polygons (line 357) | fn indexing_polygons<A>(&self) -> Generate<Self, (), Self::Output>

FILE: plexus/src/primitive/mod.rs
  type Topological (line 118) | pub trait Topological:
    method try_from_slice (line 128) | fn try_from_slice<T>(vertices: T) -> Option<Self>
    method embed_into_e3_xy (line 160) | fn embed_into_e3_xy<P>(ngon: P, z: Scalar<Self::Vertex>) -> Self
    method embed_into_e3_xy_with (line 170) | fn embed_into_e3_xy_with<P, F>(ngon: P, z: Scalar<Position<Self::Verte...
    method embed_into_e3_plane (line 214) | fn embed_into_e3_plane<P>(ngon: P, plane: Plane<Self::Vertex>) -> Self
    method embed_into_e3_plane_with (line 224) | fn embed_into_e3_plane_with<P, F>(ngon: P, _: Plane<Position<Self::Ver...
    method project_into_plane (line 243) | fn project_into_plane(mut self, plane: Plane<Position<Self::Vertex>>) ...
    method edges (line 268) | fn edges(&self) -> Vec<Edge<&Self::Vertex>> {
    type Vertex (line 620) | type Vertex = G;
    method try_from_slice (line 622) | fn try_from_slice<I>(vertices: I) -> Option<Self>
    type Vertex (line 1027) | type Vertex = G;
    method try_from_slice (line 1029) | fn try_from_slice<I>(vertices: I) -> Option<Self>
    type Vertex (line 1189) | type Vertex = G;
    method try_from_slice (line 1191) | fn try_from_slice<I>(vertices: I) -> Option<Self>
  type Polygonal (line 292) | pub trait Polygonal: Topological {
    method is_convex (line 297) | fn is_convex(&self) -> bool
  type IntoIndexed (line 316) | pub trait IntoIndexed<N>: Polygonal
    method into_indexed (line 322) | fn into_indexed(self) -> Self::Indexed;
  type Indexed (line 331) | type Indexed = Q;
  method into_indexed (line 333) | fn into_indexed(self) -> Self::Indexed {
  type IntoPolygons (line 343) | pub trait IntoPolygons: Sized {
    method into_polygons (line 347) | fn into_polygons(self) -> Self::Output;
  type Rotate (line 350) | pub trait Rotate {
    method rotate (line 352) | fn rotate(self, n: isize) -> Self;
    method rotate (line 787) | fn rotate(self, n: isize) -> Self {
    method rotate (line 821) | fn rotate(self, n: isize) -> Self {
    method rotate (line 849) | fn rotate(self, n: isize) -> Self {
    method rotate (line 1012) | fn rotate(self, n: isize) -> Self {
  type Zip (line 355) | pub trait Zip {
    method zip (line 358) | fn zip(self) -> Self::Output;
  type MapVertices (line 361) | pub trait MapVertices<T, U>: Sized {
    method map_vertices (line 362) | fn map_vertices<F>(self, f: F) -> InteriorMap<Self, U, F>
  method map_vertices (line 373) | fn map_vertices<F>(self, f: F) -> InteriorMap<Self, U, F>
  type InteriorMap (line 381) | pub struct InteriorMap<I, T, F> {
  function new (line 388) | fn new(input: I, f: F) -> Self {
  type Item (line 404) | type Item = <I::Item as Map<T>>::Output;
  method next (line 406) | fn next(&mut self) -> Option<Self::Item> {
  method size_hint (line 410) | fn size_hint(&self) -> (usize, Option<usize>) {
  type NGon (line 443) | pub struct NGon<G, const N: usize>(pub [G; N]);
  function into_array (line 446) | pub fn into_array(self) -> [G; N] {
  function positions (line 450) | pub fn positions(&self) -> NGon<&Position<G>, N>
  function cloned (line 470) | pub fn cloned(self) -> NGon<G, N>
  function as_ref (line 479) | fn as_ref(&self) -> &[G] {
  function as_mut (line 485) | fn as_mut(&mut self) -> &mut [G] {
  type Item (line 491) | type Item = G;
  method converged (line 498) | fn converged(vertex: G) -> Self {
  type Dynamic (line 508) | type Dynamic = usize;
  method arity (line 510) | fn arity(&self) -> Self::Dynamic {
  method fold (line 519) | fn fold<U, F>(self, mut seed: U, mut f: F) -> U
  function from (line 531) | fn from(array: [G; N]) -> Self {
  method from_items (line 537) | fn from_items<I>(items: I) -> Option<Self>
  type Output (line 546) | type Output = G;
  function index (line 548) | fn index(&self, index: usize) -> &Self::Output {
  function index_mut (line 554) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  type Output (line 560) | type Output = <Self as IntoIterator>::IntoIter;
  method into_items (line 562) | fn into_items(self) -> Self::Output {
  type Item (line 568) | type Item = G;
  type IntoIter (line 569) | type IntoIter = array::IntoIter<G, N>;
  method into_iter (line 571) | fn into_iter(self) -> Self::IntoIter {
  type Output (line 577) | type Output = NGon<H, N>;
  function map (line 579) | fn map<F>(self, f: F) -> Self::Output
  type Static (line 610) | type Static = usize;
  constant ARITY (line 612) | const ARITY: Self::Static = crate::n_arity(N);
  type Error (line 632) | type Error = ();
  function try_from_iter (line 634) | fn try_from_iter<I>(vertices: I) -> Result<Self, Self::Error>
  type Output (line 647) | type Output = NGon<H, N>;
  function zip_map (line 649) | fn zip_map<F>(self, other: Self, mut f: F) -> Self::Output
  type Edge (line 684) | pub type Edge<G> = NGon<G, 2>;
  function new (line 687) | pub fn new(a: G, b: G) -> Self {
  function line (line 691) | pub fn line(&self) -> Option<Line<Position<G>>>
  function is_bisected (line 699) | pub fn is_bisected(&self, other: &Self) -> bool
  type EdgeEdge (line 723) | pub enum EdgeEdge<S>
  function into_point (line 735) | pub fn into_point(self) -> Option<S> {
  function into_edge (line 742) | pub fn into_edge(self) -> Option<Edge<S>> {
  method fmt (line 755) | fn fmt(&self, formatter: &mut Formatter) -> Result<(), fmt::Error> {
  type Output (line 768) | type Output = EdgeEdge<Position<T>>;
  function intersection (line 773) | fn intersection(&self, other: &Edge<T>) -> Option<Self::Output> {
  type Trigon (line 799) | pub type Trigon<G> = NGon<G, 3>;
  function new (line 802) | pub fn new(a: G, b: G, c: G) -> Self {
  function plane (line 806) | pub fn plane(&self) -> Option<Plane<Position<G>>>
  type Tetragon (line 838) | pub type Tetragon<G> = NGon<G, 4>;
  function new (line 841) | pub fn new(a: G, b: G, c: G, d: G) -> Self {
  type BoundedPolygon (line 881) | pub enum BoundedPolygon<G> {
  function as_ref (line 887) | fn as_ref(&self) -> &[G] {
  function as_mut (line 896) | fn as_mut(&mut self) -> &mut [G] {
  type Item (line 905) | type Item = G;
  type Dynamic (line 909) | type Dynamic = usize;
  method arity (line 911) | fn arity(&self) -> Self::Dynamic {
  method fold (line 920) | fn fold<U, F>(self, mut seed: U, mut f: F) -> U
  function from (line 932) | fn from(array: [G; 3]) -> Self {
  function from (line 938) | fn from(array: [G; 4]) -> Self {
  function from (line 944) | fn from(trigon: Trigon<G>) -> Self {
  function from (line 950) | fn from(tetragon: Tetragon<G>) -> Self {
  type Output (line 956) | type Output = G;
  function index (line 958) | fn index(&self, index: usize) -> &Self::Output {
  function index_mut (line 967) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  type Output (line 976) | type Output = SmallVec<[G; 4]>;
  method into_items (line 978) | fn into_items(self) -> Self::Output {
  type Item (line 987) | type Item = G;
  type IntoIter (line 988) | type IntoIter = <<Self as IntoItems>::Output as IntoIterator>::IntoIter;
  method into_iter (line 990) | fn into_iter(self) -> Self::IntoIter {
  type Output (line 996) | type Output = BoundedPolygon<U>;
  function map (line 998) | fn map<F>(self, f: F) -> Self::Output
  type Static (line 1021) | type Static = (usize, usize);
  constant ARITY (line 1023) | const ARITY: Self::Static = (3, 4);
  type UnboundedPolygon (line 1057) | pub struct UnboundedPolygon<G>(SmallVec<[G; 4]>);
  function trigon (line 1060) | pub fn trigon(a: G, b: G, c: G) -> Self {
  function tetragon (line 1064) | pub fn tetragon(a: G, b: G, c: G, d: G) -> Self {
  function positions (line 1068) | pub fn positions(&self) -> UnboundedPolygon<&Position<G>>
  function cloned (line 1080) | pub fn cloned(self) -> UnboundedPolygon<G> {
  type Item (line 1086) | type Item = G;
  function as_ref (line 1090) | fn as_ref(&self) -> &[G] {
  function as_mut (line 1096) | fn as_mut(&mut self) -> &mut [G] {
  type Dynamic (line 1102) | type Dynamic = usize;
  method arity (line 1104) | fn arity(&self) -> Self::Dynamic {
  function from (line 1113) | fn from(polygon: BoundedPolygon<G>) -> Self {
  function from (line 1124) | fn from(ngon: NGon<G, N>) -> Self {
  method from_items (line 1130) | fn from_items<I>(items: I) -> Option<Self>
  type Output (line 1139) | type Output = G;
  function index (line 1141) | fn index(&self, index: usize) -> &Self::Output {
  function index_mut (line 1147) | fn index_mut(&mut self, index: usize) -> &mut Self::Output {
  type Output (line 1153) | type Output = SmallVec<[G; 4]>;
  method into_items (line 1155) | fn into_items(self) -> Self::Output {
  type IntoIter (line 1161) | type IntoIter = <SmallVec<[G; 4]> as IntoIterator>::IntoIter;
  type Item (line 1162) | type Item = G;
  method into_iter (line 1164) | fn into_iter(self) -> Self::IntoIter {
  type Output (line 1170) | type Output = UnboundedPolygon<U>;
  function map (line 1172) | fn map<F>(self, f: F) -> Self::Output
  type Static (line 1183) | type Static = (usize, Option<usize>);
  constant ARITY (line 1185) | const ARITY: Self::Static = (3, None);
  type Error (line 1207) | type Error = ();
  function try_from_iter (line 1209) | fn try_from_iter<I>(vertices: I) -> Result<Self, Self::Error>
  function zip_vertices (line 1259) | pub fn zip_vertices<T, U>(
  function angles (line 1284) | fn angles<P>(polygon: &P) -> impl '_ + Clone + Iterator<Item = Scalar<Po...
  function umod (line 1317) | fn umod<T>(n: T, m: T) -> T
  type E2 (line 1332) | type E2 = Point2<f64>;
  function convexity (line 1335) | fn convexity() {

FILE: plexus/src/primitive/sphere.rs
  type Bounds (line 44) | pub struct Bounds<S>
  function with_radius (line 55) | pub fn with_radius(radius: Scalar<S>) -> Self {
  function with_width (line 59) | pub fn with_width(width: Scalar<S>) -> Self {
  function unit_radius (line 63) | pub fn unit_radius() -> Self {
  function unit_width (line 67) | pub fn unit_width() -> Self {
  method default (line 76) | fn default() -> Self {
  type UvSphere (line 82) | pub struct UvSphere {
    method new (line 88) | pub fn new(nu: usize, nv: usize) -> Self {
    method vertex_with_position_from (line 95) | fn vertex_with_position_from<S>(
    method index_for_position (line 117) | fn index_for_position(&self, u: usize, v: usize) -> usize {
    method map_polygon_index (line 129) | fn map_polygon_index(&self, index: usize) -> (usize, usize) {
    type State (line 150) | type State = ();
    type Output (line 158) | type Output = Unit<Vector<S>>;
    method vertex_count (line 160) | fn vertex_count(&self) -> usize {
    method vertex_from (line 164) | fn vertex_from(&self, _: &Self::State, index: usize) -> Self::Output {
    type Output (line 176) | type Output = BoundedPolygon<Unit<Vector<S>>>;
    method polygon_from (line 178) | fn polygon_from(&self, _: &Self::State, index: usize) -> Self::Output {
    type Output (line 187) | type Output = BoundedPolygon<usize>;
    method indexing_polygon (line 189) | fn indexing_polygon(&self, index: usize) -> Self::Output {
    type State (line 198) | type State = Bounds<S>;
    type Output (line 206) | type Output = S;
    method vertex_count (line 208) | fn vertex_count(&self) -> usize {
    method vertex_from (line 212) | fn vertex_from(&self, state: &Self::State, index: usize) -> Self::Outp...
    type Output (line 232) | type Output = BoundedPolygon<S>;
    method polygon_from (line 234) | fn polygon_from(&self, state: &Self::State, index: usize) -> Self::Out...
    type Output (line 287) | type Output = BoundedPolygon<usize>;
    method indexing_polygon (line 289) | fn indexing_polygon(&self, index: usize) -> Self::Output {
  method default (line 135) | fn default() -> Self {
  method polygon_count (line 141) | fn polygon_count(&self) -> usize {
  function into_scalar (line 315) | fn into_scalar<T, S>(value: T) -> Scalar<S>
  type E3 (line 332) | type E3 = Point3<f64>;
  function vertex_count (line 335) | fn vertex_count() {
  function polygon_vertex_count (line 345) | fn polygon_vertex_count() {
  function position_index_to_vertex_mapping (line 356) | fn position_index_to_vertex_mapping() {

FILE: plexus/src/transact.rs
  type Transact (line 4) | pub trait Transact<T = ()>: Sized {
    method commit (line 9) | fn commit(self) -> Result<Self::Commit, (Self::Abort, Self::Error)>;
    method commit_with (line 14) | fn commit_with<F, U, E>(mut self, f: F) -> Result<(Self::Commit, U), (...
    method abort (line 25) | fn abort(self) -> Self::Abort;
  type Bypass (line 28) | pub trait Bypass<T>: Transact<T> {
    method bypass (line 29) | fn bypass(self) -> Self::Commit;
  type BypassOrCommit (line 32) | pub trait BypassOrCommit<T>: Bypass<T> {
    method bypass_or_commit (line 33) | fn bypass_or_commit(self) -> Result<Self::Commit, (Self::Abort, Self::...
    method bypass_or_commit_with (line 38) | fn bypass_or_commit_with<F, X, E>(
  method bypass_or_commit (line 52) | fn bypass_or_commit(self) -> Result<T::Commit, (T::Abort, T::Error)> {
  method bypass_or_commit_with (line 56) | fn bypass_or_commit_with<F, X, E>(self, f: F) -> Result<(T::Commit, X), ...
  method bypass_or_commit (line 70) | fn bypass_or_commit(self) -> Result<T::Commit, (T::Abort, T::Error)> {
  method bypass_or_commit_with (line 74) | fn bypass_or_commit_with<F, X, E>(
  type Mutate (line 89) | pub trait Mutate<T>: Transact<T, Commit = T> {
    method replace (line 90) | fn replace(target: &mut T, replacement: T) -> Swapped<T, Self>
    method take (line 97) | fn take(target: &mut T) -> Swapped<T, Self>
  type ClosedInput (line 108) | pub trait ClosedInput: Transact<<Self as ClosedInput>::Input> {
  type Drain (line 112) | trait Drain<T> {
    method as_option_mut (line 113) | fn as_option_mut(&mut self) -> &mut Option<T>;
    method drain (line 115) | fn drain(&mut self) -> T {
    method undrain (line 119) | fn undrain(&mut self, value: T) {
    method try_swap_or (line 129) | fn try_swap_or<F, U, E>(&mut self, value: T, mut f: F) -> Result<U, E>
  type Swapped (line 146) | pub struct Swapped<'a, T, M>
  function replace (line 157) | pub fn replace(target: &'a mut T, replacement: T) -> Self {
  function take (line 164) | pub fn take(target: &'a mut T) -> Self
  function drain_and_commit (line 171) | fn drain_and_commit(
  function drain_and_abort (line 184) | fn drain_and_abort(&mut self) -> &'a mut T {
  function drain_and_bypass (line 195) | pub fn drain_and_bypass(&mut self) -> &'a mut T {
  function as_ref (line 206) | fn as_ref(&self) -> &M {
  function as_mut (line 215) | fn as_mut(&mut self) -> &mut M {
  function bypass (line 224) | fn bypass(mut self) -> Self::Commit {
  function as_option_mut (line 235) | fn as_option_mut(&mut self) -> &mut Option<(&'a mut T, M)> {
  method drop (line 244) | fn drop(&mut self) {
  function from (line 254) | fn from(target: &'a mut T) -> Self {
  type Commit (line 263) | type Commit = &'a mut T;
  type Abort (line 264) | type Abort = &'a mut T;
  type Error (line 265) | type Error = <M as Transact<T>>::Error;
  function commit (line 267) | fn commit(mut self) -> Result<Self::Commit, (Self::Abort, Self::Error)> {
  function abort (line 273) | fn abort(mut self) -> Self::Abort {