fix warnings & format

math/fib/src/main.rs

@@ -1,8 +1,7 @@
-
 use std::{
     fs::File,
     io::{Read, Write},
-    os::unix::io::FromRawFd
+    os::unix::io::FromRawFd,
 };
 
 fn fib(n: u64) -> u64 {
@@ -26,26 +25,32 @@ fn main() {
 
     nested::magic_header();
 
-    eprintln!("
+    eprintln!(
-interface (Sequence ℕ) 0 1");
+        "
+interface (Sequence ℕ) 0 1"
+    );
 
     let mut f0 = unsafe { File::from_raw_fd(0) };
-    eprintln!("
+    eprintln!(
+        "
 >0: n
   ( ℕ )
   ( MachineInt )
   ( MachineWord )
   ( Stream MachineSyllab )
-");
+"
+    );
 
     let mut f1 = unsafe { File::from_raw_fd(1) };
-    eprintln!("
+    eprintln!(
+        "
 <1: n'th fibonacci number
   ( ℕ )
   ( MachineInt )
   ( MachineWord )
   ( Stream MachineSyllab )
-");
+"
+    );
 
     nested::magic_header();
 
@@ -55,4 +60,3 @@ interface (Sequence ℕ) 0 1");
     bytes = fib(n).to_le_bytes();
     f1.write(&bytes).expect("");
 }
-

math/int2str/src/main.rs

@@ -1,9 +1,4 @@
-
+use std::{fs::File, io::Read, os::unix::io::FromRawFd};
-use std::{
-    fs::File,
-    io::{Read},
-    os::unix::io::FromRawFd
-};
 
 fn main() {
     nested::magic_header();
@@ -11,15 +6,18 @@ fn main() {
     nested::magic_header();
 
     let mut f0 = unsafe { File::from_raw_fd(0) };
-    eprintln!("
+    eprintln!(
+        "
 >0:
   ( ℕ )
   ( MachineInt )
   ( MachineWord )
   ( Stream MachineSyllab )
-");
+"
+    );
 
-    eprintln!("
+    eprintln!(
+        "
 <1:
   ( ℕ )
   ( PositionalInt 10 BigEndian )
@@ -27,7 +25,8 @@ fn main() {
   ( Sequence UTF-8-Char )
   ( Stream UTF-8-Char )
   ( Stream MachineSyllab )
-");
+"
+    );
 
     nested::magic_header();
 
@@ -35,4 +34,3 @@ fn main() {
     f0.read_exact(&mut bytes).expect("");
     println!("{}", u64::from_le_bytes(bytes));
 }
-

math/radix_transform/src/main.rs

@@ -1,55 +1,68 @@
-
+use nested::{
-use {
+    core::{TypeDict, ViewPort},
-    nested::{
+    integer::RadixProjection,
-        core::{
+    vec::VecBuffer,
-            ViewPort,
-            TypeDict
-        },
-        vec::{VecBuffer},
-        integer::{RadixProjection}
-    }
 };
 
 #[async_std::main]
 async fn main() {
     let mut td = TypeDict::new();
     for tn in vec![
-        "MachineWord", "MachineInt", "MachineSyllab",
+        "MachineWord",
-        "Vec", "Stream", "Json",
+        "MachineInt",
-        "Sequence", "UTF-8-Char",
+        "MachineSyllab",
-        "PositionalInt", "Digit", "LittleEndian", "BigEndian",
+        "Vec",
-        "DiffStream", "ℕ",
+        "Stream",
-        "$src_radix", "$dst_radix"
+        "Json",
-    ] { td.add_typename(tn.into()); }
+        "Sequence",
+        "UTF-8-Char",
+        "PositionalInt",
+        "Digit",
+        "LittleEndian",
+        "BigEndian",
+        "DiffStream",
+        "ℕ",
+        "$src_radix",
+        "$dst_radix",
+    ] {
+        td.add_typename(tn.into());
+    }
 
     let radix_types = vec![
         td.type_term_from_str("( ℕ )").unwrap(),
-        td.type_term_from_str("( PositionalInt 10 LittleEndian )").unwrap(),
+        td.type_term_from_str("( PositionalInt 10 LittleEndian )")
+            .unwrap(),
         td.type_term_from_str("( Sequence ( Digit 10 ) )").unwrap(),
         td.type_term_from_str("( Sequence UTF-8-Char )").unwrap(),
-        td.type_term_from_str("( Sequence MachineSyllab )").unwrap()
+        td.type_term_from_str("( Sequence MachineSyllab )").unwrap(),
     ];
 
     let src_types = vec![
         td.type_term_from_str("( ℕ )").unwrap(),
-        td.type_term_from_str("( PositionalInt $src_radix LittleEndian )").unwrap(),
+        td.type_term_from_str("( PositionalInt $src_radix LittleEndian )")
-        td.type_term_from_str("( Sequence ( Digit $src_radix ) )").unwrap(),
+            .unwrap(),
+        td.type_term_from_str("( Sequence ( Digit $src_radix ) )")
+            .unwrap(),
         td.type_term_from_str("( Sequence MachineInt )").unwrap(),
-        td.type_term_from_str("( DiffStream ( Vec MachineInt ) )").unwrap(),
+        td.type_term_from_str("( DiffStream ( Vec MachineInt ) )")
+            .unwrap(),
         td.type_term_from_str("( Json )").unwrap(),
         td.type_term_from_str("( Stream UTF-8-Char )").unwrap(),
-        td.type_term_from_str("( Stream MachineSyllab )").unwrap()
+        td.type_term_from_str("( Stream MachineSyllab )").unwrap(),
     ];
 
     let dst_types = vec![
         td.type_term_from_str("( ℕ )").unwrap(),
-        td.type_term_from_str("( PositionalInt $dst_radix LittleEndian )").unwrap(),
+        td.type_term_from_str("( PositionalInt $dst_radix LittleEndian )")
-        td.type_term_from_str("( Sequence ( Digit $dst_radix ) )").unwrap(),
+            .unwrap(),
+        td.type_term_from_str("( Sequence ( Digit $dst_radix ) )")
+            .unwrap(),
         td.type_term_from_str("( Sequence MachineInt )").unwrap(),
-        td.type_term_from_str("( DiffStream ( Vec MachineInt ) )").unwrap(),
+        td.type_term_from_str("( DiffStream ( Vec MachineInt ) )")
+            .unwrap(),
         td.type_term_from_str("( Json )").unwrap(),
         td.type_term_from_str("( Stream UTF-8-Char )").unwrap(),
-        td.type_term_from_str("( Stream MachineSyllab )").unwrap()
+        td.type_term_from_str("( Stream MachineSyllab )").unwrap(),
     ];
 
     nested::magic_header();
@@ -99,27 +112,26 @@ async fn main() {
         src_radix,
         dst_radix,
         src_digits_port.outer().to_sequence(),
-        dst_digits_port.inner()
+        dst_digits_port.inner(),
     );
 
     // output dst digits
     let writer = {
-        use std::{
+        use std::os::unix::io::FromRawFd;
-            os::unix::io::FromRawFd
-        };
 
-        dst_digits_port.outer().serialize_json(unsafe { std::fs::File::from_raw_fd(1) })
+        dst_digits_port
+            .outer()
+            .serialize_json(unsafe { std::fs::File::from_raw_fd(1) })
     };
 
     // start reading src digits
     {
-        use async_std::{
+        use async_std::os::unix::io::FromRawFd;
-            os::unix::io::FromRawFd
-        };
 
-        src_digits.from_json(unsafe { async_std::fs::File::from_raw_fd(0) }).await;
+        src_digits
+            .from_json(unsafe { async_std::fs::File::from_raw_fd(0) })
+            .await;
     }
 
     drop(writer);
 }
-

math/str2int/src/main.rs

@@ -1,8 +1,7 @@
-
 use std::{
     fs::File,
     io::{Read, Write},
-    os::unix::io::FromRawFd
+    os::unix::io::FromRawFd,
 };
 
 fn main() {
@@ -10,16 +9,19 @@ fn main() {
     eprintln!("       Parse MachineInt from String");
     nested::magic_header();
 
-    eprintln!("
+    eprintln!(
+        "
 $1: radix
   ( ℕ )
   ( PositionalInt 10 BigEndian )
   ( Sequence ( Digit 10 ) )
   ( Sequence UTF-8-Char )
   ( Sequence MachineSyllab )
-");
+"
+    );
 
-    eprintln!("
+    eprintln!(
+        "
 >0: n
   ( ℕ )
   ( PositionalInt $radix BigEndian )
@@ -27,15 +29,18 @@ $1: radix
   ( Sequence UTF-8-Char )
   ( Stream UTF-8-Char )
   ( Stream MachineSyllab )
-");
+"
+    );
 
-    eprintln!("
+    eprintln!(
+        "
 <1: n
   ( ℕ )
   ( MachineInt )
   ( MachineWord )
   ( Stream MachineSyllab )
-");
+"
+    );
 
     nested::magic_header();
 
@@ -55,6 +60,10 @@ $1: radix
     let mut chars = Vec::new();
     f0.read_to_end(&mut chars).expect("");
     chars.retain(|c| (*c as char).is_alphanumeric());
-    f1.write(&u64::from_str_radix(&String::from_utf8_lossy(&chars), radix).unwrap().to_le_bytes()).expect("");
+    f1.write(
+        &u64::from_str_radix(&String::from_utf8_lossy(&chars), radix)
+            .unwrap()
+            .to_le_bytes(),
+    )
+    .expect("");
 }
-

nested/src/bimap.rs

@@ -1,20 +1,17 @@
-use std::{
+use std::{collections::HashMap, hash::Hash};
-    collections::HashMap,
-    hash::Hash
-};
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct Bimap<V: Eq + Hash, Λ: Eq + Hash> {
-    pub mλ: HashMap::<V, Λ>,
+    pub mλ: HashMap<V, Λ>,
-    pub my: HashMap::<Λ, V>
+    pub my: HashMap<Λ, V>,
 }
 
 impl<V: Eq + Hash + Clone, Λ: Eq + Hash + Clone> Bimap<V, Λ> {
     pub fn new() -> Self {
         Bimap {
             mλ: HashMap::new(),
-            my: HashMap::new()
+            my: HashMap::new(),
         }
     }
 
@@ -25,4 +22,3 @@ impl<V: Eq + Hash + Clone, Λ: Eq + Hash + Clone> Bimap<V, Λ> {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

nested/src/core/channel.rs

@@ -1,23 +1,17 @@
 use {
+    crate::core::Observer,
+    async_std::stream::Stream,
     core::{
-        task::{Poll, Context, Waker},
+        pin::Pin,
-        pin::Pin
+        task::{Context, Poll, Waker},
     },
     std::{
-        sync::{Arc, Mutex},
         collections::HashSet,
-        hash::Hash
+        hash::Hash,
+        sync::{Arc, Mutex},
     },
-    async_std::{
-        stream::Stream
-    },
-
-    crate::{
-        core::{Observer}
-    }
 };
 
-
 /*\
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                   Traits
@@ -27,14 +21,15 @@ pub trait ChannelData : Default + IntoIterator + Send + Sync {
     fn channel_insert(&mut self, x: Self::Item);
 }
 
-
 /*\
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                Queue Channel
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                     \*/
 impl<T> ChannelData for Vec<T>
-where T: Send + Sync {
+where
+    T: Send + Sync,
+{
     fn channel_insert(&mut self, x: T) {
         self.push(x);
     }
@@ -46,7 +41,9 @@ where T: Send + Sync {
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                     \*/
 impl<T> ChannelData for HashSet<T>
-where T: Eq + Hash + Send + Sync {
+where
+    T: Eq + Hash + Send + Sync,
+{
     fn channel_insert(&mut self, x: T) {
         self.insert(x);
     }
@@ -58,7 +55,9 @@ where T: Eq + Hash + Send + Sync {
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                     \*/
 impl<T> ChannelData for Option<T>
-where T: Send + Sync {
+where
+    T: Send + Sync,
+{
     fn channel_insert(&mut self, x: T) {
         *self = Some(x);
     }
@@ -73,7 +72,7 @@ struct ChannelState<Data: ChannelData> {
     send_buf: Option<Data>,
     recv_iter: Option<Data::IntoIter>,
     num_senders: usize,
-    waker: Option<Waker>
+    waker: Option<Waker>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -84,7 +83,9 @@ pub struct ChannelReceiver<Data: ChannelData>(Arc<Mutex<ChannelState<Data>>>);
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<Data: ChannelData> ChannelSender<Data>
-where Data::IntoIter: Send + Sync {
+where
+    Data::IntoIter: Send + Sync,
+{
     pub fn send(&self, msg: Data::Item) {
         let mut state = self.0.lock().unwrap();
 
@@ -102,7 +103,10 @@ where Data::IntoIter: Send + Sync {
 
 use crate::core::View;
 impl<V: View + ?Sized, Data: ChannelData<Item = V::Msg>> Observer<V> for ChannelSender<Data>
-where V::Msg: Clone, Data::IntoIter: Send + Sync {
+where
+    V::Msg: Clone,
+    Data::IntoIter: Send + Sync,
+{
     fn notify(&mut self, msg: &V::Msg) {
         self.send(msg.clone());
     }
@@ -164,15 +168,12 @@ impl<Data: ChannelData> std::future::Future for ChannelRead<Data> {
 impl<Data: ChannelData> Stream for ChannelReceiver<Data> {
     type Item = Data::Item;
 
-    fn poll_next(
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        self: Pin<&mut Self>,
-        cx: &mut Context<'_>
-    ) -> Poll<Option<Self::Item>> {
         let mut state = self.0.lock().unwrap();
 
         if let Some(recv_iter) = state.recv_iter.as_mut() {
             if let Some(val) = recv_iter.next() {
-                return Poll::Ready(Some(val))
+                return Poll::Ready(Some(val));
             } else {
                 state.recv_iter = None
             }
@@ -201,13 +202,14 @@ pub fn channel<Data: ChannelData>() -> (ChannelSender<Data>, ChannelReceiver<Dat
         send_buf: None,
         recv_iter: None,
         num_senders: 1,
-        waker: None
+        waker: None,
     }));
 
     (ChannelSender(state.clone()), ChannelReceiver(state))
 }
 
-pub fn set_channel<T: Eq + Hash + Send + Sync>() -> (ChannelSender<HashSet<T>>, ChannelReceiver<HashSet<T>>) {
+pub fn set_channel<T: Eq + Hash + Send + Sync>(
+) -> (ChannelSender<HashSet<T>>, ChannelReceiver<HashSet<T>>) {
     channel::<HashSet<T>>()
 }
 
@@ -215,7 +217,7 @@ pub fn queue_channel<T: Send + Sync>() -> (ChannelSender<Vec<T>>, ChannelReceive
     channel::<Vec<T>>()
 }
 
-pub fn singleton_channel<T: Send + Sync>() -> (ChannelSender<Option<T>>, ChannelReceiver<Option<T>>) {
+pub fn singleton_channel<T: Send + Sync>() -> (ChannelSender<Option<T>>, ChannelReceiver<Option<T>>)
+{
     channel::<Option<T>>()
 }
-

nested/src/core/context.rs

@@ -1,19 +1,12 @@
 use {
+    crate::core::{
+        type_term::{TypeDict, TypeTerm},
+        AnyOuterViewPort, OuterViewPort, View,
+    },
     std::{
         collections::HashMap,
-        sync::{Arc, RwLock}
+        sync::{Arc, RwLock},
     },
-    crate::{
-        core::{
-            type_term::{
-                TypeTerm,
-                TypeDict
-            },
-            View,
-            OuterViewPort,
-            AnyOuterViewPort
-        }
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -21,37 +14,31 @@ use {
 #[derive(Clone)]
 pub struct ReprTree {
     port: Option<AnyOuterViewPort>,
-    branches: HashMap<TypeTerm, Arc<RwLock<ReprTree>>>
+    branches: HashMap<TypeTerm, Arc<RwLock<ReprTree>>>,
 }
 
 impl ReprTree {
     pub fn new() -> Self {
         ReprTree {
             port: None,
-            branches: HashMap::new()
+            branches: HashMap::new(),
         }
     }
 
-    pub fn new_leaf(
+    pub fn new_leaf(port: AnyOuterViewPort) -> Arc<RwLock<Self>> {
-        port: AnyOuterViewPort
-    ) -> Arc<RwLock<Self>> {
         let mut tree = ReprTree::new();
         tree.insert_leaf(vec![].into_iter(), port);
         Arc::new(RwLock::new(tree))
     }
 
-    pub fn insert_branch(
+    pub fn insert_branch(&mut self, type_tag: TypeTerm, repr: Arc<RwLock<ReprTree>>) {
-        &mut self,
-        type_tag: TypeTerm,
-        repr: Arc<RwLock<ReprTree>>
-    ) {
         self.branches.insert(type_tag, repr);
     }
 
     pub fn insert_leaf(
         &mut self,
         mut type_ladder: impl Iterator<Item = TypeTerm>,
-        port: AnyOuterViewPort
+        port: AnyOuterViewPort,
     ) {
         if let Some(type_term) = type_ladder.next() {
             if let Some(next_repr) = self.branches.get(&type_term) {
@@ -72,39 +59,45 @@ impl ReprTree {
 #[derive(Clone)]
 pub struct Object {
     pub type_tag: TypeTerm,
-    pub repr: Arc<RwLock<ReprTree>>
+    pub repr: Arc<RwLock<ReprTree>>,
 }
 
 impl Object {
-    pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>> where V::Msg: Clone {
+    pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>>
-        Some(self.repr.read().unwrap().port.clone()?.downcast::<V>().ok().unwrap())
+    where
+        V::Msg: Clone,
+    {
+        Some(
+            self.repr
+                .read()
+                .unwrap()
+                .port
+                .clone()?
+                .downcast::<V>()
+                .ok()
+                .unwrap(),
+        )
     }
 
     pub fn downcast(&self, dst_type: TypeTerm) -> Option<Object> {
         if let Some(repr) = self.repr.read().unwrap().branches.get(&dst_type) {
             Some(Object {
                 type_tag: dst_type,
-                repr: repr.clone()
+                repr: repr.clone(),
             })
         } else {
             None
         }
     }
 
-    fn downcast_ladder(
+    fn downcast_ladder(&self, repr_ladder: impl Iterator<Item = TypeTerm>) -> Option<Object> {
-        &self,
+        repr_ladder.fold(Some(self.clone()), |s, t| s?.downcast(t.clone()))
-        repr_ladder: impl Iterator<Item = TypeTerm>
-    ) -> Option<Object> {
-        repr_ladder.fold(
-            Some(self.clone()),
-            |s, t| s?.downcast(t.clone())
-        )
     }
 
     pub fn add_iso_repr(
         &self,
         type_ladder: impl Iterator<Item = TypeTerm>,
-        morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>
+        morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>,
     ) {
         let mut cur_repr = self.repr.clone();
 
@@ -117,21 +110,21 @@ impl Object {
                 let mut obj = None;
 
                 for src_type in cur_repr.read().unwrap().branches.keys() {
-                    if let Some(ctor) = morphism_constructors.get(
+                    if let Some(ctor) = morphism_constructors.get(&MorphismType {
-                        &MorphismType {
                         mode: MorphismMode::Iso,
                         src_type: src_type.clone(),
-                            dst_type: dst_type.clone()
+                        dst_type: dst_type.clone(),
-                        }
+                    }) {
-                    ) {
+                        let new_obj = ctor(Object {
-                        let new_obj = ctor(
-                            Object {
                             type_tag: src_type.clone(),
-                                repr: cur_repr.read().unwrap()
+                            repr: cur_repr
+                                .read()
+                                .unwrap()
                                 .branches
-                                    .get(&src_type).unwrap().clone()
+                                .get(&src_type)
-                            }
+                                .unwrap()
-                        );
+                                .clone(),
+                        });
 
                         assert!(new_obj.type_tag == dst_type);
 
@@ -141,7 +134,10 @@ impl Object {
                 }
 
                 if let Some(obj) = obj {
-                    cur_repr.write().unwrap().insert_branch(obj.type_tag, obj.repr);
+                    cur_repr
+                        .write()
+                        .unwrap()
+                        .insert_branch(obj.type_tag, obj.repr);
                 } else {
                     panic!("could not find matching isomorphism!");
                 }
@@ -152,7 +148,7 @@ impl Object {
     pub fn add_mono_repr<'a>(
         &self,
         type_ladder: impl Iterator<Item = TypeTerm>,
-        morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>
+        morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>,
     ) {
         let mut cur_type = self.type_tag.clone();
         let mut cur_repr = self.repr.clone();
@@ -163,24 +159,27 @@ impl Object {
                 cur_type = dst_type;
                 cur_repr = next_repr.clone();
             } else {
-                if let Some(constructor) = morphism_constructors.get(
+                if let Some(constructor) = morphism_constructors.get(&MorphismType {
-                    &MorphismType {
                     mode: MorphismMode::Mono,
                     src_type: cur_type.clone(),
-                        dst_type: dst_type.clone()
+                    dst_type: dst_type.clone(),
-                    }
+                }) {
-                ) {
+                    let new_obj = constructor(Object {
-                    let new_obj = constructor(
-                        Object {
                         type_tag: cur_type.clone(),
-                            repr: cur_repr.read().unwrap()
+                        repr: cur_repr
+                            .read()
+                            .unwrap()
                             .branches
-                                .get(&cur_type).unwrap().clone()
+                            .get(&cur_type)
-                        }
+                            .unwrap()
-                    );
+                            .clone(),
+                    });
 
                     assert!(new_obj.type_tag == dst_type);
-                    cur_repr.write().unwrap().insert_branch(new_obj.type_tag.clone(), new_obj.repr.clone());
+                    cur_repr
+                        .write()
+                        .unwrap()
+                        .insert_branch(new_obj.type_tag.clone(), new_obj.repr.clone());
 
                     cur_type = new_obj.type_tag;
                     cur_repr = new_obj.repr;
@@ -193,7 +192,7 @@ impl Object {
     pub fn epi_cast<'a>(
         &self,
         _type_ladder: impl Iterator<Item = TypeTerm>,
-        _morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>
+        _morphism_constructors: &HashMap<MorphismType, Box<dyn Fn(Object) -> Object>>,
     ) {
         // todo
     }
@@ -220,14 +219,14 @@ pub enum MorphismMode {
     Epi,
 
     /// Any other function
-    Any
+    Any,
 }
 
 #[derive(Clone, Hash, PartialEq, Eq)]
 pub struct MorphismType {
     pub mode: MorphismMode,
     pub src_type: TypeTerm,
-    pub dst_type: TypeTerm
+    pub dst_type: TypeTerm,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -237,7 +236,7 @@ pub struct Context {
     default_constructors: HashMap<TypeTerm, Box<dyn Fn() -> Object + Send + Sync>>,
     morphism_constructors: HashMap<MorphismType, Box<dyn Fn(Object) -> Object + Send + Sync>>,
     objects: HashMap<String, Object>,
-    parent: Option<Arc<RwLock<Context>>>
+    parent: Option<Arc<RwLock<Context>>>,
 }
 
 impl Context {
@@ -247,7 +246,7 @@ impl Context {
             default_constructors: HashMap::new(),
             morphism_constructors: HashMap::new(),
             objects: HashMap::new(),
-            parent
+            parent,
         }
     }
 
@@ -266,17 +265,13 @@ impl Context {
     pub fn add_morphism(
         &mut self,
         morph_type: MorphismType,
-        morph_fn: Box<dyn Fn(Object) -> Object + Send + Sync>
+        morph_fn: Box<dyn Fn(Object) -> Object + Send + Sync>,
     ) {
         self.morphism_constructors.insert(morph_type, morph_fn);
     }
 
     /// adds an object without any representations
-    pub fn add_obj(
+    pub fn add_obj(&mut self, name: String, typename: &str) {
-        &mut self,
-        name: String,
-        typename: &str
-    ) {
         let type_tag = self.type_dict.type_term_from_str(typename).unwrap();
 
         self.objects.insert(
@@ -286,16 +281,13 @@ impl Context {
             } else {
                 Object {
                     type_tag,
-                    repr: Arc::new(RwLock::new(ReprTree::new()))
+                    repr: Arc::new(RwLock::new(ReprTree::new())),
-                }
                 }
+            },
         );
     }
 
-    pub fn get_obj(
+    pub fn get_obj(&self, name: &String) -> Option<Object> {
-        &self,
-        name: &String
-    ) -> Option<Object> {
         if let Some(obj) = self.objects.get(name) {
             Some(obj.clone())
         } else if let Some(parent) = self.parent.as_ref() {
@@ -305,19 +297,16 @@ impl Context {
         }
     }
 
-    pub fn get_obj_port<
+    pub fn get_obj_port<'a, V: View + ?Sized + 'static>(
-        'a,
-        V: View + ?Sized + 'static
-    >(
         &self,
         name: &str,
-        type_ladder: impl Iterator<Item = &'a str>
+        type_ladder: impl Iterator<Item = &'a str>,
     ) -> Option<OuterViewPort<V>>
-    where V::Msg: Clone {
+    where
+        V::Msg: Clone,
+    {
         self.get_obj(&name.into())?
-            .downcast_ladder(
+            .downcast_ladder(type_ladder.map(|tn| self.type_dict.type_term_from_str(tn).unwrap()))?
-                type_ladder.map(|tn| self.type_dict.type_term_from_str(tn).unwrap())
-            )?
             .get_port()
     }
 
@@ -325,43 +314,40 @@ impl Context {
         &mut self,
         name: &str,
         type_ladder: impl Iterator<Item = &'a str>,
-        port: AnyOuterViewPort
+        port: AnyOuterViewPort,
     ) {
-        self.get_obj(&name.to_string()).unwrap()
+        self.get_obj(&name.to_string())
-            .repr.write().unwrap()
+            .unwrap()
+            .repr
+            .write()
+            .unwrap()
             .insert_leaf(
                 type_ladder.map(|tn| self.type_dict.type_term_from_str(tn).unwrap()),
-                port
+                port,
             );
     }
 
-    pub fn epi_cast(
+    pub fn epi_cast(&mut self, name: &str, typename: &str) {
-        &mut self,
-        name: &str,
-        typename: &str
-    ) {
         let dst_type = self.type_dict.type_term_from_str(typename).unwrap();
         let old_obj = self.objects.get(&name.to_string()).unwrap().clone();
-        let new_obj =
+        let new_obj = if let Some(ctor) = self.morphism_constructors.get(&MorphismType {
-            if let Some(ctor) = self.morphism_constructors.get(
-                &MorphismType {
             mode: MorphismMode::Epi,
             src_type: old_obj.type_tag.clone(),
-                    dst_type: dst_type.clone()
+            dst_type: dst_type.clone(),
-                }
+        }) {
-            ) {
             ctor(old_obj.clone())
         } else {
             Object {
                 type_tag: dst_type,
-                    repr: Arc::new(RwLock::new(ReprTree::new()))
+                repr: Arc::new(RwLock::new(ReprTree::new())),
             }
         };
 
-        new_obj.repr.write().unwrap().insert_branch(
+        new_obj
-            old_obj.type_tag,
+            .repr
-            old_obj.repr
+            .write()
-        );
+            .unwrap()
+            .insert_branch(old_obj.type_tag, old_obj.repr);
 
         self.objects.insert(name.to_string(), new_obj);
     }
@@ -369,9 +355,11 @@ impl Context {
     pub fn mono_view<'a, V: View + ?Sized + 'static>(
         &mut self,
         name: &str,
-        type_ladder: impl Iterator<Item = &'a str>
+        type_ladder: impl Iterator<Item = &'a str>,
     ) -> Option<OuterViewPort<V>>
-    where V::Msg: Clone {
+    where
+        V::Msg: Clone,
+    {
         if let Some(p) = self.get_obj_port(name, type_ladder) {
             Some(p)
         } else {
@@ -391,4 +379,3 @@ impl Context {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

nested/src/core/mod.rs

@@ -1,47 +1,17 @@
-
-pub mod view;
-pub mod observer;
 pub mod channel;
+pub mod context;
+pub mod observer;
 pub mod port;
 pub mod type_term;
-pub mod context;
+pub mod view;
 
 pub use {
-    view::{View},
+    channel::{queue_channel, set_channel, singleton_channel, ChannelReceiver, ChannelSender},
-    observer::{
+    context::{Context, MorphismMode, MorphismType, Object, ReprTree},
-        Observer,
+    observer::{NotifyFnObserver, Observer, ObserverBroadcast, ObserverExt, ResetFnObserver},
-        ObserverExt,
-        ObserverBroadcast,
-        NotifyFnObserver,
-        ResetFnObserver
-    },
-    channel::{
-        ChannelReceiver,
-        ChannelSender,
-        set_channel,
-        queue_channel,
-        singleton_channel
-    },
     port::{
-        ViewPort,
+        AnyInnerViewPort, AnyOuterViewPort, AnyViewPort, InnerViewPort, OuterViewPort, ViewPort,
-        InnerViewPort,
-        OuterViewPort,
-        AnyViewPort,
-        AnyOuterViewPort,
-        AnyInnerViewPort,
     },
-    type_term::{
+    type_term::{TypeDict, TypeID, TypeTerm},
-        TypeID,
+    view::View,
-        TypeTerm,
-        TypeDict,
-    },
-    context::{
-        ReprTree,
-        Object,
-        Context,
-        MorphismMode,
-        MorphismType
-    }
 };
-
-

nested/src/core/observer.rs

@@ -1,14 +1,10 @@
 use {
-    crate::{
+    crate::core::{
-        core::{
+        channel::{channel, ChannelReceiver, ChannelSender},
         View,
-            channel::{channel, ChannelSender, ChannelReceiver}
-        }
     },
-    std::{
+    std::sync::RwLock,
-        sync::{Arc, Weak}
+    std::sync::{Arc, Weak},
-    },
-    std::sync::RwLock
 };
 
 /*\
@@ -53,19 +49,24 @@ impl<V: View + ?Sized, T: Observer<V>> ObserverExt<V> for T {
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                     \*/
 pub struct ObserverBroadcast<V: View + ?Sized>
-where V::Msg : Send + Sync {
+where
+    V::Msg: Send + Sync,
+{
     rx: ChannelReceiver<Vec<V::Msg>>,
     tx: ChannelSender<Vec<V::Msg>>,
-    observers: Vec<Weak<RwLock<dyn Observer<V>>>>
+    observers: Vec<Weak<RwLock<dyn Observer<V>>>>,
 }
 
 impl<V: View + ?Sized> ObserverBroadcast<V>
-where V::Msg : Clone + Send + Sync {
+where
+    V::Msg: Clone + Send + Sync,
+{
     pub fn new() -> Self {
         let (tx, rx) = channel::<Vec<V::Msg>>();
         ObserverBroadcast {
-            rx, tx,
+            rx,
-            observers: Vec::new()
+            tx,
+            observers: Vec::new(),
         }
     }
 
@@ -94,7 +95,9 @@ where V::Msg : Clone + Send + Sync {
 }
 
 impl<V: View + ?Sized> Observer<V> for ObserverBroadcast<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn reset(&mut self, view: Option<Arc<V>>) {
         for o in self.iter() {
             o.write().unwrap().reset(view.clone());
@@ -109,26 +112,32 @@ where V::Msg: Clone {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct NotifyFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(&V::Msg) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(&V::Msg) + Send + Sync,
+{
     f: F,
-    _phantom: std::marker::PhantomData<V>
+    _phantom: std::marker::PhantomData<V>,
 }
 
 impl<V, F> NotifyFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(&V::Msg) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(&V::Msg) + Send + Sync,
+{
     pub fn new(f: F) -> Self {
         NotifyFnObserver {
             f,
-            _phantom: std::marker::PhantomData
+            _phantom: std::marker::PhantomData,
         }
     }
 }
 
 impl<V, F> Observer<V> for NotifyFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(&V::Msg) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(&V::Msg) + Send + Sync,
+{
     fn notify(&mut self, msg: &V::Msg) {
         (self.f)(msg);
     }
@@ -137,30 +146,34 @@ where V: View + ?Sized,
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct ResetFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(Option<Arc<V>>) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(Option<Arc<V>>) + Send + Sync,
+{
     f: F,
-    _phantom: std::marker::PhantomData<V>
+    _phantom: std::marker::PhantomData<V>,
 }
 
 impl<V, F> ResetFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(Option<Arc<V>>) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(Option<Arc<V>>) + Send + Sync,
+{
     pub fn new(f: F) -> Self {
         ResetFnObserver {
             f,
-            _phantom: std::marker::PhantomData
+            _phantom: std::marker::PhantomData,
         }
     }
 }
 
 impl<V, F> Observer<V> for ResetFnObserver<V, F>
-where V: View + ?Sized,
+where
-      F: Fn(Option<Arc<V>>) + Send + Sync {
+    V: View + ?Sized,
+    F: Fn(Option<Arc<V>>) + Send + Sync,
+{
     fn notify(&mut self, _msg: &V::Msg) {}
     fn reset(&mut self, view: Option<Arc<V>>) {
         (self.f)(view);
     }
 }
-
-

nested/src/core/port.rs

@@ -1,17 +1,10 @@
 use {
-    std::sync::Arc,
+    crate::core::{NotifyFnObserver, Observer, ObserverBroadcast, ResetFnObserver, View},
     std::any::Any,
+    std::sync::Arc,
     std::sync::RwLock,
-    crate::core::{
-        View,
-        Observer,
-        ObserverBroadcast,
-        NotifyFnObserver,
-        ResetFnObserver
-    }
 };
 
-
 pub trait UpdateTask: Send + Sync {
     fn update(&self);
 }
@@ -24,16 +17,18 @@ pub trait UpdateTask : Send + Sync {
 pub struct ViewPort<V: View + ?Sized> {
     view: Arc<RwLock<Option<Arc<V>>>>,
     cast: Arc<RwLock<ObserverBroadcast<V>>>,
-    pub update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>
+    pub update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>,
 }
 
 impl<V: View + ?Sized> ViewPort<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     pub fn new() -> Self {
         ViewPort {
             view: Arc::new(RwLock::new(None)),
             cast: Arc::new(RwLock::new(ObserverBroadcast::new())),
-            update_hooks: Arc::new(RwLock::new(Vec::new()))
+            update_hooks: Arc::new(RwLock::new(Vec::new())),
         }
     }
 
@@ -51,8 +46,14 @@ where V::Msg: Clone {
 
     pub fn add_observer(&self, observer: Arc<RwLock<dyn Observer<V>>>) {
         self.update();
-        self.cast.write().unwrap().add_observer(Arc::downgrade(&observer));
+        self.cast
-        observer.write().unwrap().reset(self.view.read().unwrap().clone());
+            .write()
+            .unwrap()
+            .add_observer(Arc::downgrade(&observer));
+        observer
+            .write()
+            .unwrap()
+            .reset(self.view.read().unwrap().clone());
     }
 
     pub fn add_update_hook(&self, hook_cast: Arc<dyn UpdateTask>) {
@@ -60,47 +61,42 @@ where V::Msg: Clone {
     }
 
     pub fn inner(&self) -> InnerViewPort<V> {
-        InnerViewPort(
+        InnerViewPort(ViewPort {
-            ViewPort{
             view: self.view.clone(),
             cast: self.cast.clone(),
-                update_hooks: self.update_hooks.clone()
+            update_hooks: self.update_hooks.clone(),
-            }
+        })
-        )
     }
 
     pub fn outer(&self) -> OuterViewPort<V> {
-        OuterViewPort(
+        OuterViewPort(ViewPort {
-            ViewPort{
             view: self.view.clone(),
             cast: self.cast.clone(),
-                update_hooks: self.update_hooks.clone()
+            update_hooks: self.update_hooks.clone(),
-            }
+        })
-        )
     }
 
     pub fn into_inner(self) -> InnerViewPort<V> {
-        InnerViewPort(
+        InnerViewPort(ViewPort {
-            ViewPort{
             view: self.view,
             cast: self.cast,
-                update_hooks: self.update_hooks
+            update_hooks: self.update_hooks,
-            }
+        })
-        )
     }
 
     pub fn into_outer(self) -> OuterViewPort<V> {
-        OuterViewPort(
+        OuterViewPort(ViewPort {
-            ViewPort{
             view: self.view,
             cast: self.cast,
-                update_hooks: self.update_hooks
+            update_hooks: self.update_hooks,
-            }
+        })
-        )
     }
 }
 
-impl<V: View + ?Sized> UpdateTask for ViewPort<V> where V::Msg: Clone + Send + Sync{
+impl<V: View + ?Sized> UpdateTask for ViewPort<V>
+where
+    V::Msg: Clone + Send + Sync,
+{
     fn update(&self) {
         let v = {
             let t = self.update_hooks.read().unwrap();
@@ -115,26 +111,34 @@ impl<V: View + ?Sized> UpdateTask for ViewPort<V> where V::Msg: Clone + Send + S
     }
 }
 
-
 impl<V: View + ?Sized> Clone for ViewPort<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn clone(&self) -> Self {
         ViewPort {
             view: self.view.clone(),
             cast: self.cast.clone(),
-            update_hooks: self.update_hooks.clone()
+            update_hooks: self.update_hooks.clone(),
         }
     }
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub struct InnerViewPort<V: View + ?Sized>(pub ViewPort<V>) where V::Msg: Clone;
+pub struct InnerViewPort<V: View + ?Sized>(pub ViewPort<V>)
-pub struct OuterViewPort<V: View + ?Sized>(pub ViewPort<V>) where V::Msg: Clone;
+where
+    V::Msg: Clone;
+pub struct OuterViewPort<V: View + ?Sized>(pub ViewPort<V>)
+where
+    V::Msg: Clone;
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl<V: View + ?Sized> InnerViewPort<V> where V::Msg: Clone {
+impl<V: View + ?Sized> InnerViewPort<V>
+where
+    V::Msg: Clone,
+{
     pub fn get_broadcast(&self) -> Arc<RwLock<ObserverBroadcast<V>>> {
         self.0.cast.clone()
     }
@@ -154,7 +158,9 @@ impl<V: View + ?Sized> InnerViewPort<V> where V::Msg: Clone {
 }
 
 impl<V: View + ?Sized> Clone for InnerViewPort<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn clone(&self) -> Self {
         InnerViewPort(self.0.clone())
     }
@@ -163,7 +169,9 @@ where V::Msg: Clone {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<V: View + ?Sized + 'static> OuterViewPort<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     pub fn get_view(&self) -> Option<Arc<V>> {
         self.0.view.read().unwrap().clone()
     }
@@ -172,18 +180,27 @@ where V::Msg: Clone {
         self.0.view.clone()
     }
 
-    pub fn add_observer(&self, observer: Arc<RwLock<dyn Observer<V>>>) -> Arc<RwLock<Option<Arc<V>>>> {
+    pub fn add_observer(
+        &self,
+        observer: Arc<RwLock<dyn Observer<V>>>,
+    ) -> Arc<RwLock<Option<Arc<V>>>> {
         self.0.add_observer(observer);
         self.get_view_arc()
     }
 
-    pub fn add_reset_fn<F: Fn(Option<Arc<V>>) + Send + Sync + 'static>(&self, reset: F) -> Arc<RwLock<ResetFnObserver<V, F>>> {
+    pub fn add_reset_fn<F: Fn(Option<Arc<V>>) + Send + Sync + 'static>(
+        &self,
+        reset: F,
+    ) -> Arc<RwLock<ResetFnObserver<V, F>>> {
         let obs = Arc::new(RwLock::new(ResetFnObserver::new(reset)));
         self.add_observer(obs.clone());
         obs
     }
 
-    pub fn add_notify_fn<F: Fn(&V::Msg) + Send + Sync + 'static>(&self, notify: F) -> Arc<RwLock<NotifyFnObserver<V, F>>> {
+    pub fn add_notify_fn<F: Fn(&V::Msg) + Send + Sync + 'static>(
+        &self,
+        notify: F,
+    ) -> Arc<RwLock<NotifyFnObserver<V, F>>> {
         let obs = Arc::new(RwLock::new(NotifyFnObserver::new(notify)));
         self.add_observer(obs.clone());
         obs
@@ -191,7 +208,9 @@ where V::Msg: Clone {
 }
 
 impl<V: View + ?Sized> Clone for OuterViewPort<V>
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn clone(&self) -> Self {
         OuterViewPort(self.0.clone())
     }
@@ -223,7 +242,7 @@ where V::Msg: Clone {
 pub struct AnyViewPort {
     view: Arc<dyn Any + Send + Sync + 'static>,
     cast: Arc<dyn Any + Send + Sync + 'static>,
-    update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>
+    update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>,
 }
 
 impl AnyViewPort {
@@ -231,10 +250,14 @@ impl AnyViewPort {
         match (
             self.view.clone().downcast::<RwLock<Option<Arc<V>>>>(),
             self.cast.clone().downcast::<RwLock<ObserverBroadcast<V>>>(),
-            self.update_hooks.clone()
+            self.update_hooks.clone(),
         ) {
-            (Ok(view), Ok(cast), update_hooks) => Ok(ViewPort{view, cast, update_hooks}),
+            (Ok(view), Ok(cast), update_hooks) => Ok(ViewPort {
-            _ => Err(self)
+                view,
+                cast,
+                update_hooks,
+            }),
+            _ => Err(self),
         }
     }
 }
@@ -244,7 +267,7 @@ impl<V: View + ?Sized + 'static> From<ViewPort<V>> for AnyViewPort {
         AnyViewPort {
             view: port.view as Arc<dyn Any + Send + Sync + 'static>,
             cast: port.cast as Arc<dyn Any + Send + Sync + 'static>,
-            update_hooks: port.update_hooks
+            update_hooks: port.update_hooks,
         }
     }
 }
@@ -258,38 +281,47 @@ pub struct AnyOuterViewPort(AnyViewPort);
 pub struct AnyInnerViewPort(AnyViewPort);
 
 impl AnyOuterViewPort {
-    pub fn downcast<V: View + ?Sized + 'static>(self) -> Result<OuterViewPort<V>, AnyViewPort> where V::Msg: Clone {
+    pub fn downcast<V: View + ?Sized + 'static>(self) -> Result<OuterViewPort<V>, AnyViewPort>
+    where
+        V::Msg: Clone,
+    {
         Ok(OuterViewPort(self.0.downcast::<V>()?))
     }
 }
 
 impl<V: View + ?Sized + 'static> From<OuterViewPort<V>> for AnyOuterViewPort
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn from(port: OuterViewPort<V>) -> Self {
         AnyOuterViewPort(AnyViewPort {
             view: port.0.view as Arc<dyn Any + Send + Sync + 'static>,
             cast: port.0.cast as Arc<dyn Any + Send + Sync + 'static>,
-            update_hooks: port.0.update_hooks
+            update_hooks: port.0.update_hooks,
         })
     }
 }
 
 impl AnyInnerViewPort {
-    pub fn downcast<V: View + ?Sized + 'static>(self) -> Result<InnerViewPort<V>, AnyViewPort> where V::Msg: Clone {
+    pub fn downcast<V: View + ?Sized + 'static>(self) -> Result<InnerViewPort<V>, AnyViewPort>
+    where
+        V::Msg: Clone,
+    {
         Ok(InnerViewPort(self.0.downcast::<V>()?))
     }
 }
 
 impl<V: View + ?Sized + 'static> From<InnerViewPort<V>> for AnyInnerViewPort
-where V::Msg: Clone {
+where
+    V::Msg: Clone,
+{
     fn from(port: InnerViewPort<V>) -> Self {
         AnyInnerViewPort(AnyViewPort {
             view: port.0.view as Arc<dyn Any + Send + Sync + 'static>,
             cast: port.0.cast as Arc<dyn Any + Send + Sync + 'static>,
-            update_hooks: port.0.update_hooks
+            update_hooks: port.0.update_hooks,
         })
     }
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

nested/src/core/type_term.rs

@@ -1,11 +1,4 @@
-use {
+use {crate::bimap::Bimap, std::collections::HashMap};
-    std::{
-        collections::HashMap
-    },
-    crate::{
-        bimap::Bimap,
-    }
-};
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
@@ -15,11 +8,8 @@ pub type TypeID = u64;
 
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub enum TypeTerm {
-    Type {
+    Type { id: TypeID, args: Vec<TypeTerm> },
-        id: TypeID,
+    Num(i64),
-        args: Vec<TypeTerm>
-    },
-    Num(i64)
 }
 
 impl TypeTerm {
@@ -46,7 +36,7 @@ impl TypeTerm {
             match token {
                 "(" => {
                     term_stack.push(None);
-                },
+                }
                 ")" => {
                     let t = term_stack.pop().unwrap();
                     if term_stack.len() > 0 {
@@ -59,19 +49,24 @@ impl TypeTerm {
                     } else {
                         return t;
                     }
-                },
+                }
                 atom => {
                     let f = term_stack.last_mut().unwrap();
 
                     match f {
-                        Some(f) =>
+                        Some(f) => {
                             if atom.chars().nth(0).unwrap().is_numeric() {
                                 f.num_arg(i64::from_str_radix(atom, 10).unwrap());
                             } else {
-                                f.arg(TypeTerm::new(*names.get(atom).expect(&format!("invalid atom {}", atom))));
+                                f.arg(TypeTerm::new(
+                                    *names.get(atom).expect(&format!("invalid atom {}", atom)),
+                                ));
+                            }
                         }
                         None => {
-                            *f = Some(TypeTerm::new(*names.get(atom).expect(&format!("invalid atom {}", atom))));
+                            *f = Some(TypeTerm::new(
+                                *names.get(atom).expect(&format!("invalid atom {}", atom)),
+                            ));
                         }
                     }
                 }
@@ -84,64 +79,60 @@ impl TypeTerm {
     // only adds parenthesis where args.len > 0
     pub fn to_str1(&self, names: &HashMap<u64, String>) -> String {
         match self {
-            TypeTerm::Type{ id, args } =>
+            TypeTerm::Type { id, args } => {
                 if args.len() > 0 {
                     format!(
                         "( {} {})",
                         names[id],
                         if args.len() > 0 {
-                            args.iter().fold(
+                            args.iter().fold(String::new(), |str, term| {
-                                String::new(),
+                                format!("{}{} ", str, term.to_str1(names))
-                                |str, term| format!("{}{} ", str, term.to_str1(names) )
+                            })
-                            )
                         } else {
                             String::new()
                         }
                     )
                 } else {
                     names[id].clone()
-                },
+                }
+            }
 
-            TypeTerm::Num(n) =>
+            TypeTerm::Num(n) => format!("{}", n),
-                format!("{}", n)
         }
     }
 
     // always adds an enclosing pair of parenthesis
     pub fn to_str(&self, names: &HashMap<u64, String>) -> String {
         match self {
-            TypeTerm::Type{ id, args } =>
+            TypeTerm::Type { id, args } => format!(
-                format!(
                 "( {} {})",
                 names[id],
                 if args.len() > 0 {
-                        args.iter().fold(
+                    args.iter().fold(String::new(), |str, term| {
-                            String::new(),
+                        format!("{}{} ", str, term.to_str1(names))
-                            |str, term| format!("{}{} ", str, term.to_str1(names) )
+                    })
-                        )
                 } else {
                     String::new()
-                    }),
+                }
+            ),
 
-            TypeTerm::Num(n) =>
+            TypeTerm::Num(n) => format!("{}", n),
-                format!("{}", n)
         }
     }
-
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct TypeDict {
-    typenames: Bimap::<String, u64>,
+    typenames: Bimap<String, u64>,
-    type_id_counter: u64
+    type_id_counter: u64,
 }
 
 impl TypeDict {
     pub fn new() -> Self {
         TypeDict {
             typenames: Bimap::new(),
-            type_id_counter: 0
+            type_id_counter: 0,
         }
     }
 
@@ -160,4 +151,3 @@ impl TypeDict {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

nested/src/core/view.rs

@@ -1,4 +1,3 @@
-
 /*\
 <<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
                    View
@@ -25,4 +24,3 @@ impl<V: View + ?Sized> View for Arc<V> {
 impl<V: View> View for Option<V> {
     type Msg = V::Msg;
 }
-

nested/src/grid/flatten.rs

@@ -1,25 +1,19 @@
 use {
-    std::{
-        sync::Arc,
-        cmp::max,
-        collections::HashMap
-    },
-    std::sync::RwLock,
-    cgmath::{Point2, Vector2},
     crate::{
-        core::{
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
-            View, Observer, ObserverBroadcast,
-            ViewPort, InnerViewPort, OuterViewPort,
-            port::UpdateTask
-        },
         grid::{GridView, GridWindowIterator},
         index::{IndexArea, IndexView},
-        projection::ProjectionHelper
+        projection::ProjectionHelper,
-    }
+    },
+    cgmath::{Point2, Vector2},
+    std::sync::RwLock,
+    std::{cmp::max, collections::HashMap, sync::Arc},
 };
 
 impl<Item> OuterViewPort<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>
-where Item: 'static{
+where
+    Item: 'static,
+{
     pub fn flatten(&self) -> OuterViewPort<dyn GridView<Item = Item>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -29,31 +23,35 @@ where Item: 'static{
 }
 
 pub struct Chunk<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     offset: Vector2<i16>,
     limit: Point2<i16>,
-    view: Arc<dyn GridView<Item = Item>>
+    view: Arc<dyn GridView<Item = Item>>,
 }
 
 pub struct Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     limit: Point2<i16>,
     top: Arc<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>,
     chunks: HashMap<Point2<i16>, Chunk<Item>>,
     cast: Arc<RwLock<ObserverBroadcast<dyn GridView<Item = Item>>>>,
-    proj_helper: ProjectionHelper<Point2<i16>, Self>
+    proj_helper: ProjectionHelper<Point2<i16>, Self>,
 }
 
 impl<Item> View for Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     type Msg = IndexArea<Point2<i16>>;
 }
 
 impl<Item> IndexView<Point2<i16>> for Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     type Item = Item;
 
@@ -64,24 +62,22 @@ where Item: 'static
     }
 
     fn area(&self) -> IndexArea<Point2<i16>> {
-        IndexArea::Range(
+        IndexArea::Range(Point2::new(0, 0)..=self.limit)
-            Point2::new(0, 0) ..= self.limit
-        )
     }
 }
 
 /* TODO: remove unused projection args (bot-views) if they get replaced by a new viewport  */
 impl<Item> Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     pub fn new(
         top_port: OuterViewPort<dyn GridView<Item = OuterViewPort<dyn GridView<Item = Item>>>>,
-        out_port: InnerViewPort<dyn GridView<Item = Item>>
+        out_port: InnerViewPort<dyn GridView<Item = Item>>,
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
 
-        let flat = Arc::new(RwLock::new(
+        let flat = Arc::new(RwLock::new(Flatten {
-            Flatten {
             limit: Point2::new(0, 0),
             top: proj_helper.new_index_arg(
                 Point2::new(-1, -1),
@@ -90,11 +86,11 @@ where Item: 'static
                     for chunk_idx in chunk_area.iter() {
                         s.update_chunk(chunk_idx);
                     }
-                    }
+                },
             ),
             chunks: HashMap::new(),
             cast: out_port.get_broadcast(),
-                proj_helper
+            proj_helper,
         }));
 
         flat.write().unwrap().proj_helper.set_proj(&flat);
@@ -117,26 +113,23 @@ where Item: 'static
                     }
 
                     if let Some(chunk) = s.chunks.get(&chunk_idx) {
-                        s.cast.notify(
+                        s.cast.notify(&area.map(|pt| pt + chunk.offset));
-                            &area.map(|pt| pt + chunk.offset)
-                        );
-                    }
                     }
+                },
             );
 
             if let Some(chunk) = self.chunks.get_mut(&chunk_idx) {
                 chunk.view = view;
-                self.cast.notify(
+                self.cast
-                    &chunk.view.area().map(|pt| pt + chunk.offset)
+                    .notify(&chunk.view.area().map(|pt| pt + chunk.offset));
-                );
             } else {
                 self.chunks.insert(
                     chunk_idx,
                     Chunk {
                         offset: Vector2::new(-1, -1),
                         limit: Point2::new(-1, -1),
-                        view
+                        view,
-                    }
+                    },
                 );
             }
 
@@ -144,7 +137,7 @@ where Item: 'static
         } else {
             self.proj_helper.remove_arg(&chunk_idx);
 
-            if let Some(chunk) = self.chunks.remove(&chunk_idx) {
+            if let Some(_chunk) = self.chunks.remove(&chunk_idx) {
                 self.update_all_offsets();
             }
         }
@@ -162,28 +155,26 @@ where Item: 'static
                 let chunk_range = chunk.view.area().range();
                 let lim = *chunk_range.end();
 
-                col_widths[chunk_idx.x as usize] =
+                col_widths[chunk_idx.x as usize] = max(
-                    max(
                     col_widths[chunk_idx.x as usize],
-                        if lim.x < 0 { 0 } else { lim.x+1 }
+                    if lim.x < 0 { 0 } else { lim.x + 1 },
                 );
-                row_heights[chunk_idx.y as usize] =
+                row_heights[chunk_idx.y as usize] = max(
-                    max(
                     row_heights[chunk_idx.y as usize],
-                        if lim.y < 0 { 0 } else { lim.y+1 }
+                    if lim.y < 0 { 0 } else { lim.y + 1 },
                 );
             }
         }
 
         for chunk_idx in GridWindowIterator::from(top_range.clone()) {
             if let Some(chunk) = self.chunks.get_mut(&chunk_idx) {
-                let old_offset = chunk.offset;
+                let _old_offset = chunk.offset;
-                let old_limit = chunk.limit;
+                let _old_limit = chunk.limit;
 
                 chunk.limit = *chunk.view.area().range().end();
                 chunk.offset = Vector2::new(
                     (0..chunk_idx.x as usize).map(|x| col_widths[x]).sum(),
-                    (0 .. chunk_idx.y as usize).map(|y| row_heights[y]).sum()
+                    (0..chunk_idx.y as usize).map(|y| row_heights[y]).sum(),
                 );
                 /*
                                 if old_offset != chunk.offset {
@@ -206,15 +197,23 @@ where Item: 'static
 
         let old_limit = self.limit;
         self.limit = Point2::new(
-            (0 ..= top_range.end().x as usize).map(|x| col_widths[x]).sum::<i16>() - 1,
+            (0..=top_range.end().x as usize)
-            (0 ..= top_range.end().y as usize).map(|y| row_heights[y]).sum::<i16>() - 1,
+                .map(|x| col_widths[x])
+                .sum::<i16>()
+                - 1,
+            (0..=top_range.end().y as usize)
+                .map(|y| row_heights[y])
+                .sum::<i16>()
+                - 1,
         );
 
-        self.cast.notify(
+        self.cast.notify(&IndexArea::Range(
-            &IndexArea::Range(
+            Point2::new(0, 0)
-                Point2::new(0, 0) ..= Point2::new(max(self.limit.x, old_limit.x), max(self.limit.y, old_limit.y))
+                ..=Point2::new(
-            )
+                    max(self.limit.x, old_limit.x),
-        );
+                    max(self.limit.y, old_limit.y),
+                ),
+        ));
     }
 
     /// given an index in the flattened sequence,
@@ -233,4 +232,3 @@ where Item: 'static
         None
     }
 }
-

nested/src/grid/mod.rs

@@ -1,11 +1,10 @@
-
 use {
+    crate::index::{IndexArea, IndexView},
+    cgmath::Point2,
     std::{
+        cmp::{max, min},
         ops::RangeInclusive,
-        cmp::{min, max}
     },
-    cgmath::{Point2},
-    crate::index::{IndexArea, IndexView}
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -14,8 +13,8 @@ pub trait GridView = IndexView<Point2<i16>>;
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub mod offset;
 pub mod flatten;
+pub mod offset;
 pub mod window_iterator;
 
 pub use window_iterator::GridWindowIterator;
@@ -23,7 +22,6 @@ pub use window_iterator::GridWindowIterator;
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl IndexArea<Point2<i16>> {
-
     // todo: this is not perfect (e.g. diagonals are inefficient)
     pub fn iter(&self) -> GridWindowIterator {
         GridWindowIterator::from(self.range())
@@ -33,50 +31,44 @@ impl IndexArea<Point2<i16>> {
         match self {
             IndexArea::Empty => Point2::new(i16::MAX, i16::MAX)..=Point2::new(i16::MIN, i16::MIN),
             IndexArea::Full => panic!("range from full grid area"),
-            IndexArea::Set(v) =>
+            IndexArea::Set(v) => {
                 Point2::new(
                     v.iter().map(|p| p.x).min().unwrap_or(0),
-                    v.iter().map(|p| p.y).min().unwrap_or(0)
+                    v.iter().map(|p| p.y).min().unwrap_or(0),
-                ) ..=
+                )
-                Point2::new(
+                    ..=Point2::new(
                         v.iter().map(|p| p.x).max().unwrap_or(0),
-                    v.iter().map(|p| p.y).max().unwrap_or(0)
+                        v.iter().map(|p| p.y).max().unwrap_or(0),
-                ),
+                    )
-            IndexArea::Range(r) => r.clone()
+            }
+            IndexArea::Range(r) => r.clone(),
         }
     }
 
     pub fn union(self, other: IndexArea<Point2<i16>>) -> IndexArea<Point2<i16>> {
         match (self, other) {
-            (IndexArea::Empty, a) |
+            (IndexArea::Empty, a) | (a, IndexArea::Empty) => a,
-            (a, IndexArea::Empty) => a,
 
-            (IndexArea::Full, _) |
+            (IndexArea::Full, _) | (_, IndexArea::Full) => IndexArea::Full,
-            (_, IndexArea::Full) => IndexArea::Full,
 
-            (IndexArea::Set(mut va), IndexArea::Set(mut vb)) => {
+            (IndexArea::Set(mut va), IndexArea::Set(vb)) => {
                 va.extend(vb.into_iter());
                 IndexArea::Set(va)
-            },
+            }
 
-            (IndexArea::Range(r), IndexArea::Set(mut v)) |
+            (IndexArea::Range(r), IndexArea::Set(mut v))
-            (IndexArea::Set(mut v), IndexArea::Range(r)) => {
+            | (IndexArea::Set(mut v), IndexArea::Range(r)) => {
                 v.extend(GridWindowIterator::from(r));
                 IndexArea::Set(v)
-            },
+            }
 
             (IndexArea::Range(ra), IndexArea::Range(rb)) => IndexArea::Range(
                 Point2::new(
                     min(ra.start().x, rb.start().x),
-                    min(ra.start().y, rb.start().y)
+                    min(ra.start().y, rb.start().y),
-                )
-                    ..=
-                    Point2::new(
-                        max(ra.end().x, rb.end().x),
-                        max(ra.end().y, rb.end().y)
-                    )
                 )
+                    ..=Point2::new(max(ra.end().x, rb.end().x), max(ra.end().y, rb.end().y)),
+            ),
         }
     }
 }
-

nested/src/grid/offset.rs

@@ -1,20 +1,15 @@
 use {
+    crate::{core::OuterViewPort, grid::GridView},
     cgmath::Vector2,
-    crate::{
-        core::OuterViewPort,
-        grid::GridView
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<Item> OuterViewPort<dyn GridView<Item = Item>>
-where Item: 'static {
+where
+    Item: 'static,
+{
     pub fn offset(&self, offset: Vector2<i16>) -> OuterViewPort<dyn GridView<Item = Item>> {
-        self.map_key(
+        self.map_key(move |pt| pt + offset, move |pt| Some(pt - offset))
-            move |pt| pt + offset,
-            move |pt| Some(pt - offset)
-        )
     }
 }
-

nested/src/grid/window_iterator.rs

@@ -1,14 +1,13 @@
-
 use {
+    cgmath::Point2,
     std::ops::{Range, RangeInclusive},
-    cgmath::{Point2}
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct GridWindowIterator {
     next: Point2<i16>,
-    range: Range<Point2<i16>>
+    range: Range<Point2<i16>>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -17,7 +16,7 @@ impl From<Range<Point2<i16>>> for GridWindowIterator {
     fn from(range: Range<Point2<i16>>) -> Self {
         GridWindowIterator {
             next: range.start,
-            range
+            range,
         }
     }
 }
@@ -26,7 +25,7 @@ impl From<RangeInclusive<Point2<i16>>> for GridWindowIterator {
     fn from(range: RangeInclusive<Point2<i16>>) -> Self {
         GridWindowIterator {
             next: *range.start(),
-            range: *range.start() .. Point2::new(range.end().x+1, range.end().y+1)
+            range: *range.start()..Point2::new(range.end().x + 1, range.end().y + 1),
         }
     }
 }
@@ -57,4 +56,3 @@ impl Iterator for GridWindowIterator {
         }
     }
 }
-

nested/src/index/buffer.rs

@@ -1,36 +1,29 @@
-
 use {
-    std::{
+    crate::{
-        sync::Arc,
+        core::{InnerViewPort, Observer, ObserverBroadcast, View},
-        collections::HashMap,
+        index::{IndexArea, IndexView},
-        hash::Hash
     },
     std::sync::RwLock,
-    crate::{
+    std::{collections::HashMap, hash::Hash, sync::Arc},
-        core::{
-            Observer,
-            ObserverBroadcast,
-            View,
-            InnerViewPort
-        },
-        index::{IndexArea, IndexView}
-    }
 };
 
 pub struct IndexBufferView<Key, Item>(Arc<RwLock<HashMap<Key, Item>>>)
-where Key: Clone + Hash + Eq + Send + Sync + 'static,
+where
+    Key: Clone + Hash + Eq + Send + Sync + 'static,
     Item: Clone + Send + Sync + 'static;
 
 impl<Key, Item> View for IndexBufferView<Key, Item>
-where Key: Clone + Hash + Eq + Send + Sync + 'static,
+where
-      Item: Clone + Send + Sync + 'static
+    Key: Clone + Hash + Eq + Send + Sync + 'static,
+    Item: Clone + Send + Sync + 'static,
 {
     type Msg = IndexArea<Key>;
 }
 
 impl<Key, Item> IndexView<Key> for IndexBufferView<Key, Item>
-where Key: Clone + Hash + Eq + Send + Sync + 'static,
+where
-      Item: Clone + Send + Sync + 'static
+    Key: Clone + Hash + Eq + Send + Sync + 'static,
+    Item: Clone + Send + Sync + 'static,
 {
     type Item = Item;
 
@@ -44,16 +37,18 @@ where Key: Clone + Hash + Eq + Send + Sync + 'static,
 }
 
 pub struct IndexBuffer<Key, Item>
-where Key: Clone + Hash + Eq + Send + Sync + 'static,
+where
-      Item: Clone + Send + Sync + 'static
+    Key: Clone + Hash + Eq + Send + Sync + 'static,
+    Item: Clone + Send + Sync + 'static,
 {
     data: Arc<RwLock<HashMap<Key, Item>>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<Key, Item = Item>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<Key, Item = Item>>>>,
 }
 
 impl<Key, Item> IndexBuffer<Key, Item>
-where Key: Clone + Hash + Eq + Send + Sync + 'static,
+where
-      Item: Clone + Send + Sync + 'static
+    Key: Clone + Hash + Eq + Send + Sync + 'static,
+    Item: Clone + Send + Sync + 'static,
 {
     pub fn new(port: InnerViewPort<dyn IndexView<Key, Item = Item>>) -> Self {
         let data = Arc::new(RwLock::new(HashMap::<Key, Item>::new()));
@@ -61,7 +56,7 @@ where Key: Clone + Hash + Eq + Send + Sync + 'static,
 
         IndexBuffer {
             data,
-            cast: port.get_broadcast()
+            cast: port.get_broadcast(),
         }
     }
 
@@ -71,7 +66,9 @@ where Key: Clone + Hash + Eq + Send + Sync + 'static,
     }
 
     pub fn insert_iter<T>(&mut self, iter: T)
-    where T: IntoIterator<Item = (Key, Item)> {
+    where
+        T: IntoIterator<Item = (Key, Item)>,
+    {
         for (key, item) in iter {
             self.insert(key, item);
         }
@@ -82,4 +79,3 @@ where Key: Clone + Hash + Eq + Send + Sync + 'static,
         self.cast.notify(&IndexArea::Set(vec![key]));
     }
 }
-

nested/src/index/map_item.rs

@@ -1,33 +1,22 @@
 pub use {
-    std::{
-        sync::Arc,
-        boxed::Box
-    },
-    std::sync::RwLock,
     crate::{
         core::{
-            View,
+            InnerViewPort, Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort,
-            Observer,
-            ObserverExt,
-            ObserverBroadcast,
-            ViewPort,
-            InnerViewPort,
-            OuterViewPort
         },
-        index::{IndexArea, IndexView}
+        index::{IndexArea, IndexView},
-    }
+    },
+    std::sync::RwLock,
+    std::{boxed::Box, sync::Arc},
 };
 
 impl<Key, Item> OuterViewPort<dyn IndexView<Key, Item = Item>>
-where Key: Clone + Send + Sync + 'static,
+where
-      Item: Send + Sync + 'static
+    Key: Clone + Send + Sync + 'static,
+    Item: Send + Sync + 'static,
 {
-    pub fn map_item<
+    pub fn map_item<DstItem: 'static, F: Fn(&Key, &Item) -> DstItem + Send + Sync + 'static>(
-        DstItem: 'static,
-        F: Fn(&Key, &Item) -> DstItem + Send + Sync + 'static
-    >(
         &self,
-        f: F
+        f: F,
     ) -> OuterViewPort<dyn IndexView<Key, Item = DstItem>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -39,32 +28,29 @@ where Key: Clone + Send + Sync + 'static,
 }
 
 pub struct MapIndexItem<Key, DstItem, SrcView, F>
-where Key: Clone + Send + Sync,
+where
+    Key: Clone + Send + Sync,
     SrcView: IndexView<Key> + ?Sized,
-      F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync
+    F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync,
 {
     src_view: Option<Arc<SrcView>>,
     f: F,
-    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<Key, Item = DstItem>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<Key, Item = DstItem>>>>,
 }
 
 impl<Key, DstItem, SrcView, F> MapIndexItem<Key, DstItem, SrcView, F>
-where Key: Clone + Send + Sync + 'static,
+where
+    Key: Clone + Send + Sync + 'static,
     DstItem: 'static,
     SrcView: IndexView<Key> + ?Sized + 'static,
-      F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync + 'static
+    F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync + 'static,
 {
-    fn new(
+    fn new(port: InnerViewPort<dyn IndexView<Key, Item = DstItem>>, f: F) -> Arc<RwLock<Self>> {
-        port: InnerViewPort<dyn IndexView<Key, Item = DstItem>>,
+        let map = Arc::new(RwLock::new(MapIndexItem {
-        f: F
-    ) -> Arc<RwLock<Self>> {
-        let map = Arc::new(RwLock::new(
-            MapIndexItem {
             src_view: None,
             f,
-                cast: port.get_broadcast()
+            cast: port.get_broadcast(),
-            }
+        }));
-        ));
 
         port.set_view(Some(map.clone()));
         map
@@ -72,22 +58,27 @@ where Key: Clone + Send + Sync + 'static,
 }
 
 impl<Key, DstItem, SrcView, F> View for MapIndexItem<Key, DstItem, SrcView, F>
-where Key: Clone + Send + Sync,
+where
+    Key: Clone + Send + Sync,
     SrcView: IndexView<Key> + ?Sized,
-      F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync
+    F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync,
 {
     type Msg = IndexArea<Key>;
 }
 
 impl<Key, DstItem, SrcView, F> IndexView<Key> for MapIndexItem<Key, DstItem, SrcView, F>
-where Key: Clone + Send + Sync,
+where
+    Key: Clone + Send + Sync,
     SrcView: IndexView<Key> + ?Sized,
-      F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync
+    F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync,
 {
     type Item = DstItem;
 
     fn get(&self, key: &Key) -> Option<Self::Item> {
-        self.src_view.get(key).as_ref().map(|item| (self.f)(key, item))
+        self.src_view
+            .get(key)
+            .as_ref()
+            .map(|item| (self.f)(key, item))
     }
 
     fn area(&self) -> IndexArea<Key> {
@@ -96,9 +87,10 @@ where Key: Clone + Send + Sync,
 }
 
 impl<Key, DstItem, SrcView, F> Observer<SrcView> for MapIndexItem<Key, DstItem, SrcView, F>
-where Key: Clone + Send + Sync,
+where
+    Key: Clone + Send + Sync,
     SrcView: IndexView<Key> + ?Sized,
-      F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync
+    F: Fn(&Key, &SrcView::Item) -> DstItem + Send + Sync,
 {
     fn reset(&mut self, view: Option<Arc<SrcView>>) {
         let old_area = self.area();
@@ -113,4 +105,3 @@ where Key: Clone + Send + Sync,
         self.cast.notify(area);
     }
 }
-

nested/src/index/map_key.rs

@@ -1,27 +1,19 @@
 pub use {
-    std::{
-        sync::Arc,
-        boxed::Box
-    },
-    std::sync::RwLock,
     crate::{
         core::{
-            View,
+            InnerViewPort, Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort,
-            Observer,
-            ObserverExt,
-            ObserverBroadcast,
-            ViewPort,
-            InnerViewPort,
-            OuterViewPort
         },
+        grid::GridView,
         index::{IndexArea, IndexView},
-        grid::{GridView}
+    },
-    }
+    std::sync::RwLock,
+    std::{boxed::Box, sync::Arc},
 };
 
 impl<SrcKey, Item> OuterViewPort<dyn IndexView<SrcKey, Item = Item>>
-where SrcKey: Clone + Send + Sync + 'static,
+where
-      Item: 'static
+    SrcKey: Clone + Send + Sync + 'static,
+    Item: 'static,
 {
     pub fn map_key<
         DstKey: Clone + Send + Sync + 'static,
@@ -30,7 +22,7 @@ where SrcKey: Clone + Send + Sync + 'static,
     >(
         &self,
         f1: F1,
-        f2: F2
+        f2: F2,
     ) -> OuterViewPort<dyn IndexView<DstKey, Item = Item>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -42,25 +34,27 @@ where SrcKey: Clone + Send + Sync + 'static,
 }
 
 impl<Item> OuterViewPort<dyn IndexView<usize, Item = Item>>
-where Item: 'static
+where
+    Item: 'static,
 {
     pub fn to_grid_horizontal(&self) -> OuterViewPort<dyn GridView<Item = Item>> {
         self.map_key(
             |idx| cgmath::Point2::new(*idx as i16, 0),
-            |pt| if pt.y == 0 { Some(pt.x as usize) } else { None }
+            |pt| if pt.y == 0 { Some(pt.x as usize) } else { None },
         )
     }
 
     pub fn to_grid_vertical(&self) -> OuterViewPort<dyn GridView<Item = Item>> {
         self.map_key(
             |idx| cgmath::Point2::new(0, *idx as i16),
-            |pt| if pt.x == 0 { Some(pt.y as usize) } else { None }
+            |pt| if pt.x == 0 { Some(pt.y as usize) } else { None },
         )
     }
 }
 
 pub struct MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
-where DstKey: Clone + Send + Sync,
+where
+    DstKey: Clone + Send + Sync,
     SrcKey: Clone + Send + Sync,
     SrcView: IndexView<SrcKey> + ?Sized,
     F1: Fn(&SrcKey) -> DstKey + Send + Sync,
@@ -69,11 +63,12 @@ where DstKey: Clone + Send + Sync,
     src_view: Option<Arc<SrcView>>,
     f1: F1,
     f2: F2,
-    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<DstKey, Item = SrcView::Item>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<DstKey, Item = SrcView::Item>>>>,
 }
 
 impl<DstKey, SrcKey, SrcView, F1, F2> MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
-where DstKey: Clone + Send + Sync + 'static,
+where
+    DstKey: Clone + Send + Sync + 'static,
     SrcKey: Clone + Send + Sync + 'static,
     SrcView: IndexView<SrcKey> + ?Sized + 'static,
     SrcView::Item: 'static,
@@ -83,16 +78,14 @@ where DstKey: Clone + Send + Sync + 'static,
     fn new(
         port: InnerViewPort<dyn IndexView<DstKey, Item = SrcView::Item>>,
         f1: F1,
-        f2: F2
+        f2: F2,
     ) -> Arc<RwLock<Self>> {
-        let map = Arc::new(RwLock::new(
+        let map = Arc::new(RwLock::new(MapIndexKey {
-            MapIndexKey {
             src_view: None,
             f1,
             f2,
-                cast: port.get_broadcast()
+            cast: port.get_broadcast(),
-            }
+        }));
-        ));
 
         port.set_view(Some(map.clone()));
         map
@@ -100,7 +93,8 @@ where DstKey: Clone + Send + Sync + 'static,
 }
 
 impl<DstKey, SrcKey, SrcView, F1, F2> View for MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
-where DstKey: Clone + Send + Sync,
+where
+    DstKey: Clone + Send + Sync,
     SrcKey: Clone + Send + Sync,
     SrcView: IndexView<SrcKey> + ?Sized,
     F1: Fn(&SrcKey) -> DstKey + Send + Sync,
@@ -109,8 +103,10 @@ where DstKey: Clone + Send + Sync,
     type Msg = IndexArea<DstKey>;
 }
 
-impl<DstKey, SrcKey, SrcView, F1, F2> IndexView<DstKey> for MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
+impl<DstKey, SrcKey, SrcView, F1, F2> IndexView<DstKey>
-where DstKey: Clone + Send + Sync,
+    for MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
+where
+    DstKey: Clone + Send + Sync,
     SrcKey: Clone + Send + Sync,
     SrcView: IndexView<SrcKey> + ?Sized,
     F1: Fn(&SrcKey) -> DstKey + Send + Sync,
@@ -127,8 +123,10 @@ where DstKey: Clone + Send + Sync,
     }
 }
 
-impl<DstKey, SrcKey, SrcView, F1, F2> Observer<SrcView> for MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
+impl<DstKey, SrcKey, SrcView, F1, F2> Observer<SrcView>
-where DstKey: Clone + Send + Sync,
+    for MapIndexKey<DstKey, SrcKey, SrcView, F1, F2>
+where
+    DstKey: Clone + Send + Sync,
     SrcKey: Clone + Send + Sync,
     SrcView: IndexView<SrcKey> + ?Sized,
     F1: Fn(&SrcKey) -> DstKey + Send + Sync,
@@ -145,4 +143,3 @@ where DstKey: Clone + Send + Sync,
         self.cast.notify(&msg.map(&self.f1));
     }
 }
-

nested/src/index/mod.rs

@@ -1,15 +1,14 @@
-
+pub mod buffer;
 pub mod map_item;
 pub mod map_key;
-pub mod buffer;
 
 use {
-    std::{
+    crate::core::View,
-        sync::Arc,
-        ops::{Deref, RangeInclusive},
-    },
     std::sync::RwLock,
-    crate::core::View
+    std::{
+        ops::{Deref, RangeInclusive},
+        sync::Arc,
+    },
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -29,13 +28,15 @@ impl<Key> IndexArea<Key> {
             IndexArea::Empty => IndexArea::Empty,
             IndexArea::Full => IndexArea::Full,
             IndexArea::Set(v) => IndexArea::Set(v.iter().map(&f).collect()),
-            IndexArea::Range(r) => IndexArea::Range(f(&r.start()) ..= f(&r.end()))
+            IndexArea::Range(r) => IndexArea::Range(f(&r.start())..=f(&r.end())),
         }
     }
 }
 
 pub trait IndexView<Key>: View<Msg = IndexArea<Key>>
-where Key: Send + Sync {
+where
+    Key: Send + Sync,
+{
     type Item;
 
     fn get(&self, key: &Key) -> Option<Self::Item>;
@@ -48,8 +49,9 @@ where Key: Send + Sync {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<Key, V> IndexView<Key> for RwLock<V>
-where Key: Send + Sync,
+where
-      V: IndexView<Key> + ?Sized
+    Key: Send + Sync,
+    V: IndexView<Key> + ?Sized,
 {
     type Item = V::Item;
 
@@ -63,8 +65,9 @@ where Key: Send + Sync,
 }
 
 impl<Key, V> IndexView<Key> for Arc<V>
-where Key: Send + Sync,
+where
-      V: IndexView<Key> + ?Sized
+    Key: Send + Sync,
+    V: IndexView<Key> + ?Sized,
 {
     type Item = V::Item;
 
@@ -78,8 +81,9 @@ where Key: Send + Sync,
 }
 
 impl<Key, V> IndexView<Key> for Option<V>
-where Key: Send + Sync,
+where
-      V: IndexView<Key>
+    Key: Send + Sync,
+    V: IndexView<Key>,
 {
     type Item = V::Item;
 

nested/src/integer/add.rs

@@ -1,35 +1,27 @@
 use {
-    std::sync::{Arc, RwLock},
     crate::{
         core::{InnerViewPort, OuterViewPort},
+        projection::ProjectionHelper,
         sequence::SequenceView,
         vec::VecBuffer,
-        projection::ProjectionHelper
+    },
-    }
+    std::sync::{Arc, RwLock},
 };
 
 fn posint_add(
     radix: usize,
     a: impl SequenceView<Item = usize>,
-    b: impl SequenceView<Item = usize>
+    b: impl SequenceView<Item = usize>,
 ) -> Vec<usize> {
     let mut carry = 0;
     let mut result = Vec::new();
 
     for digit_idx in 0..std::cmp::max(a.len().unwrap_or(0), b.len().unwrap_or(0)) {
-        let sum =
+        let sum = a.get(&digit_idx).unwrap_or(0) + b.get(&digit_idx).unwrap_or(0) + carry;
-            a.get(&digit_idx).unwrap_or(0) +
-            b.get(&digit_idx).unwrap_or(0) +
-            carry;
 
         result.push(sum % radix);
 
-        carry =
+        carry = if sum > radix { sum - radix } else { 0 };
-            if sum > radix {
-                sum - radix
-            } else {
-                0
-            };
     }
 
     if carry > 0 {
@@ -44,7 +36,7 @@ pub struct Add {
     a: Arc<dyn SequenceView<Item = usize>>, // PosInt, Little Endian
     b: Arc<dyn SequenceView<Item = usize>>, // PosInt, Little Endian
     c: VecBuffer<usize>,
-    _proj_helper: ProjectionHelper<usize, Self>
+    _proj_helper: ProjectionHelper<usize, Self>,
 }
 
 impl Add {
@@ -52,18 +44,16 @@ impl Add {
         radix: usize,
         a: OuterViewPort<dyn SequenceView<Item = usize>>,
         b: OuterViewPort<dyn SequenceView<Item = usize>>,
-        c: InnerViewPort<RwLock<Vec<usize>>>//<dyn SequenceView<Item = usize>>
+        c: InnerViewPort<RwLock<Vec<usize>>>, //<dyn SequenceView<Item = usize>>
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(c.0.update_hooks.clone());
-        let add = Arc::new(RwLock::new(
+        let add = Arc::new(RwLock::new(Add {
-            Add {
             radix,
             a: proj_helper.new_sequence_arg(0, a, |s: &mut Self, _digit_idx| s.update()),
             b: proj_helper.new_sequence_arg(1, b, |s: &mut Self, _digit_idx| s.update()),
             c: VecBuffer::new(c),
-                _proj_helper: proj_helper
+            _proj_helper: proj_helper,
-            }
+        }));
-        ));
         add
     }
 

nested/src/integer/editor.rs

@@ -1,17 +1,18 @@
 use {
+    crate::{
+        core::{OuterViewPort, ViewPort},
+        list::{sexpr::ListDecoration, ListEditor},
+        sequence::{SequenceView, SequenceViewExt},
+        singleton::{SingletonBuffer, SingletonView},
+        terminal::{
+            TerminalAtom, TerminalEditor, TerminalEditorResult, TerminalEvent, TerminalStyle,
+            TerminalView,
+        },
+        tree_nav::{TerminalTreeEditor, TreeCursor, TreeNav, TreeNavResult},
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    termion::event::{Key, Event},
+    termion::event::{Event, Key},
-    cgmath::Point2,
-    crate::{
-        core::{ViewPort, OuterViewPort, Observer},
-        singleton::{SingletonView, SingletonBuffer},
-        sequence::{SequenceView, SequenceViewExt},
-        vec::VecBuffer,
-        terminal::{TerminalAtom, TerminalStyle, TerminalView, TerminalEvent, TerminalEditor, TerminalEditorResult},
-        tree_nav::{TreeNav, TreeNavResult, TerminalTreeEditor, TreeCursor},
-        list::{ListEditor, ListEditorStyle, sexpr::ListDecoration}
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -24,19 +25,17 @@ pub struct DigitEditor {
 
 impl DigitEditor {
     pub fn new(radix: u32) -> Self {
-        let mut data_port = ViewPort::new();
+        let data_port = ViewPort::new();
         DigitEditor {
             radix,
             data: SingletonBuffer::new(None, data_port.inner()),
-            data_port
+            data_port,
         }
     }
 
     pub fn get_data_port(&self) -> OuterViewPort<dyn SingletonView<Item = Option<u32>>> {
         let radix = self.radix;
-        self.data_port.outer().map(
+        self.data_port.outer().map(move |c| c?.to_digit(radix))
-            move |c| c?.to_digit(radix)
-        )
     }
 }
 
@@ -44,42 +43,44 @@ impl TreeNav for DigitEditor {}
 impl TerminalEditor for DigitEditor {
     fn get_term_view(&self) -> OuterViewPort<dyn TerminalView> {
         let radix = self.radix;
-        self.data_port.outer().map(
+        self.data_port
-            move |c| TerminalAtom::new(
+            .outer()
+            .map(move |c| {
+                TerminalAtom::new(
                     c.unwrap_or('?'),
                     if c.unwrap_or('?').to_digit(radix).is_some() {
                         TerminalStyle::fg_color((100, 140, 100))
                     } else {
                         //TerminalStyle::bg_color((90, 10, 10))
                         TerminalStyle::fg_color((200, 40, 40))
-                }
+                    },
                 )
-        ).to_grid()
+            })
+            .to_grid()
     }
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
         match event {
-            TerminalEvent::Input(Event::Key(Key::Char(' '))) |
+            TerminalEvent::Input(Event::Key(Key::Char(' ')))
-            TerminalEvent::Input(Event::Key(Key::Char('\n'))) =>
+            | TerminalEvent::Input(Event::Key(Key::Char('\n'))) => TerminalEditorResult::Exit,
-                TerminalEditorResult::Exit,
             TerminalEvent::Input(Event::Key(Key::Char(c))) => {
                 self.data.set(Some(*c));
                 TerminalEditorResult::Exit
             }
-            TerminalEvent::Input(Event::Key(Key::Backspace)) |
+            TerminalEvent::Input(Event::Key(Key::Backspace))
-            TerminalEvent::Input(Event::Key(Key::Delete)) => {
+            | TerminalEvent::Input(Event::Key(Key::Delete)) => {
                 self.data.set(None);
                 TerminalEditorResult::Exit
             }
-            _ => TerminalEditorResult::Continue
+            _ => TerminalEditorResult::Continue,
         }
     }
 }
 
 pub struct PosIntEditor {
     radix: u32,
-    digits_editor: ListEditor< DigitEditor,
+    digits_editor:
-                               Box<dyn Fn() -> Arc<RwLock<DigitEditor>> + Send + Sync + 'static> >
+        ListEditor<DigitEditor, Box<dyn Fn() -> Arc<RwLock<DigitEditor>> + Send + Sync + 'static>>,
 }
 
 impl PosIntEditor {
@@ -87,26 +88,33 @@ impl PosIntEditor {
         PosIntEditor {
             radix,
             digits_editor: ListEditor::new(
-                Box::new(
+                Box::new(move || Arc::new(RwLock::new(DigitEditor::new(radix)))),
-                    move || {
+                crate::list::ListEditorStyle::Hex,
-                        Arc::new(RwLock::new(DigitEditor::new(radix)))
-                    }
             ),
-                crate::list::ListEditorStyle::Hex
-            )
         }
     }
 
     pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = u32>> {
         let radix = self.radix;
-        self.digits_editor.get_data_port()
+        self.digits_editor
-            .filter_map(move |digit_editor| digit_editor.read().unwrap().data.get()?.to_digit(radix))
+            .get_data_port()
+            .filter_map(move |digit_editor| {
+                digit_editor.read().unwrap().data.get()?.to_digit(radix)
+            })
     }
 
     pub fn get_value(&self) -> u32 {
         let mut value = 0;
         let mut weight = 1;
-        for digit_value in self.get_data_port().get_view().unwrap().iter().collect::<Vec<_>>().into_iter().rev() {
+        for digit_value in self
+            .get_data_port()
+            .get_view()
+            .unwrap()
+            .iter()
+            .collect::<Vec<_>>()
+            .into_iter()
+            .rev()
+        {
             value += digit_value * weight;
             weight *= self.radix;
         }
@@ -116,14 +124,30 @@ impl PosIntEditor {
 }
 
 impl TreeNav for PosIntEditor {
-    fn get_cursor(&self) -> TreeCursor { self.digits_editor.get_cursor() }
+    fn get_cursor(&self) -> TreeCursor {
-    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult  { self.digits_editor.goto(cur) }
+        self.digits_editor.get_cursor()
-    fn goto_home(&mut self) -> TreeNavResult  { self.digits_editor.goto_home() }
+    }
-    fn goto_end(&mut self) -> TreeNavResult  { self.digits_editor.goto_end() }
+    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult {
-    fn pxev(&mut self) -> TreeNavResult  { self.digits_editor.pxev() }
+        self.digits_editor.goto(cur)
-    fn nexd(&mut self) -> TreeNavResult  { self.digits_editor.nexd() }
+    }
-    fn up(&mut self) -> TreeNavResult { self.digits_editor.up() }
+    fn goto_home(&mut self) -> TreeNavResult {
-    fn dn(&mut self) -> TreeNavResult { self.digits_editor.dn() }
+        self.digits_editor.goto_home()
+    }
+    fn goto_end(&mut self) -> TreeNavResult {
+        self.digits_editor.goto_end()
+    }
+    fn pxev(&mut self) -> TreeNavResult {
+        self.digits_editor.pxev()
+    }
+    fn nexd(&mut self) -> TreeNavResult {
+        self.digits_editor.nexd()
+    }
+    fn up(&mut self) -> TreeNavResult {
+        self.digits_editor.up()
+    }
+    fn dn(&mut self) -> TreeNavResult {
+        self.digits_editor.dn()
+    }
 }
 
 impl TerminalEditor for PosIntEditor {
@@ -136,11 +160,11 @@ impl TerminalEditor for PosIntEditor {
                     8 => "0o",
                     10 => "0d",
                     16 => "0x",
-                    _ => ""
+                    _ => "",
                 },
                 "",
                 "",
-                0
+                0,
             )
             .to_grid_horizontal()
             .flatten()
@@ -148,14 +172,13 @@ impl TerminalEditor for PosIntEditor {
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
         match event {
-            TerminalEvent::Input(Event::Key(Key::Char(' '))) |
+            TerminalEvent::Input(Event::Key(Key::Char(' ')))
-            TerminalEvent::Input(Event::Key(Key::Char('\n'))) => {
+            | TerminalEvent::Input(Event::Key(Key::Char('\n'))) => {
                 self.digits_editor.up();
                 TerminalEditorResult::Exit
             }
 
-            event => self.digits_editor.handle_terminal_event(event)
+            event => self.digits_editor.handle_terminal_event(event),
         }
     }
 }
-

nested/src/integer/mod.rs

@@ -1,11 +1,9 @@
-
-pub mod radix;
 pub mod add;
 pub mod editor;
+pub mod radix;
 
 pub use {
-    radix::RadixProjection,
     add::Add,
-    editor::{DigitEditor, PosIntEditor}
+    editor::{DigitEditor, PosIntEditor},
+    radix::RadixProjection,
 };
-

nested/src/integer/radix.rs

@@ -1,21 +1,17 @@
 use {
-    std::sync::{Arc, RwLock},
     crate::{
-        core::{
+        core::{InnerViewPort, Observer, OuterViewPort},
-            Observer,
-            InnerViewPort,
-            OuterViewPort
-        },
         sequence::SequenceView,
-        vec::VecBuffer
+        vec::VecBuffer,
-    }
+    },
+    std::sync::{Arc, RwLock},
 };
 
 pub struct RadixProjection {
     src_radix: usize,
     dst_radix: usize,
     src_digits: Option<Arc<dyn SequenceView<Item = usize>>>,
-    dst_digits: RwLock<VecBuffer<usize>>
+    dst_digits: RwLock<VecBuffer<usize>>,
 }
 
 impl RadixProjection {
@@ -23,17 +19,15 @@ impl RadixProjection {
         src_radix: usize,
         dst_radix: usize,
         src_digits: OuterViewPort<dyn SequenceView<Item = usize>>,
-        dst_digits: InnerViewPort<RwLock<Vec<usize>>>
+        dst_digits: InnerViewPort<RwLock<Vec<usize>>>,
     ) -> Arc<RwLock<Self>> {
         dst_digits.0.add_update_hook(Arc::new(src_digits.0.clone()));
-        let proj = Arc::new(RwLock::new(
+        let proj = Arc::new(RwLock::new(RadixProjection {
-            RadixProjection {
             src_radix,
             dst_radix,
             src_digits: None,
-                dst_digits: RwLock::new(VecBuffer::new(dst_digits))
+            dst_digits: RwLock::new(VecBuffer::new(dst_digits)),
-            }
+        }));
-        ));
         src_digits.add_observer(proj.clone());
         proj
     }

nested/src/lib.rs

@@ -3,14 +3,14 @@
 pub mod core;
 pub mod projection;
 
-pub mod singleton;
-pub mod index;
 pub mod grid;
-pub mod sequence;
+pub mod index;
-pub mod vec;
-pub mod terminal;
 pub mod integer;
 pub mod list;
+pub mod sequence;
+pub mod singleton;
+pub mod terminal;
+pub mod vec;
 
 pub mod tree_nav;
 
@@ -21,4 +21,3 @@ pub mod bimap;
 pub fn magic_header() {
     eprintln!("<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>");
 }
-

nested/src/list/cursor.rs

@@ -1,22 +1,21 @@
-
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub enum ListCursorMode {
     Insert,
     Select,
-    Modify
+    Modify,
 }
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub struct ListCursor {
     pub mode: ListCursorMode,
-    pub idx: Option<usize>
+    pub idx: Option<usize>,
 }
 
 impl Default for ListCursor {
     fn default() -> Self {
         ListCursor {
             mode: ListCursorMode::Select,
-            idx: None
+            idx: None,
         }
     }
 }
@@ -32,4 +31,3 @@ pub trait ListNav {
     fn get_cursor(&self) -> Option<ListCursor>;
 }
 */
-

nested/src/list/editor.rs

@@ -1,25 +1,21 @@
 use {
+    crate::{
+        core::{OuterViewPort, ViewPort},
+        list::{
+            editor_view::{ListEditorView, ListEditorViewSegment},
+            ListCursor, ListCursorMode, ListDecoration, SExprView,
+        },
+        sequence::SequenceView,
+        singleton::{SingletonBuffer, SingletonView},
+        terminal::{
+            make_label, TerminalEditor, TerminalEditorResult, TerminalEvent, TerminalStyle,
+            TerminalView,
+        },
+        tree_nav::{TerminalTreeEditor, TreeCursor, TreeNav, TreeNavResult},
+        vec::VecBuffer,
+    },
     std::sync::{Arc, RwLock},
     termion::event::{Event, Key},
-    crate::{
-        core::{
-            ViewPort,
-            OuterViewPort,
-        },
-        singleton::{SingletonView, SingletonBuffer},
-        sequence::{SequenceView},
-        vec::{VecBuffer},
-        terminal::{
-            TerminalView,
-            TerminalStyle,
-            TerminalEvent,
-            TerminalEditor,
-            TerminalEditorResult,
-            make_label
-        },
-        list::{SExprView, ListDecoration, ListCursor, ListCursorMode, editor_view::{ListEditorView, ListEditorViewSegment}},
-        tree_nav::{TreeCursor, TreeNav, TreeNavResult, TerminalTreeEditor}
-    }
 };
 
 #[derive(Clone, Copy)]
@@ -30,15 +26,16 @@ pub enum ListEditorStyle {
     String,
     Clist,
     Hex,
-    Plain
+    Plain,
 }
 
 pub struct ListEditor<ItemEditor, FnMakeItemEditor>
-where ItemEditor: TerminalEditor + ?Sized + Send + Sync + 'static,
+where
-      FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>
+    ItemEditor: TerminalEditor + ?Sized + Send + Sync + 'static,
+    FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>,
 {
     cursor: SingletonBuffer<ListCursor>,
-    pub data: VecBuffer<Arc<RwLock<ItemEditor>>>,
+    data: VecBuffer<Arc<RwLock<ItemEditor>>>,
 
     cursor_port: ViewPort<dyn SingletonView<Item = ListCursor>>,
     data_port: ViewPort<RwLock<Vec<Arc<RwLock<ItemEditor>>>>>,
@@ -46,23 +43,25 @@ where ItemEditor: TerminalEditor + ?Sized + Send + Sync + 'static,
     make_item_editor: FnMakeItemEditor,
 
     style: ListEditorStyle,
-    level: usize,
+    _level: usize,
     cur_dist: Arc<RwLock<usize>>,
 }
 
 impl<ItemEditor, FnMakeItemEditor> TreeNav for ListEditor<ItemEditor, FnMakeItemEditor>
-where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+where
-      FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>
+    ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+    FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>,
 {
     fn get_cursor(&self) -> TreeCursor {
         let cur = self.cursor.get();
         match cur.mode {
-            ListCursorMode::Insert |
+            ListCursorMode::Insert | ListCursorMode::Select => TreeCursor {
-            ListCursorMode::Select => {
-                TreeCursor {
                 leaf_mode: cur.mode,
-                    tree_addr: if let Some(i) = cur.idx { vec![ i ] } else { vec![] }
+                tree_addr: if let Some(i) = cur.idx {
-                }
+                    vec![i]
+                } else {
+                    vec![]
+                },
             },
             ListCursorMode::Modify => {
                 if let Some(i) = cur.idx {
@@ -74,7 +73,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                 }
                 TreeCursor {
                     leaf_mode: cur.mode,
-                    tree_addr: vec![]
+                    tree_addr: vec![],
                 }
             }
         }
@@ -93,29 +92,28 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         if new_cur.tree_addr.len() == 1 {
             self.cursor.set(ListCursor {
                 mode: new_cur.leaf_mode,
-                idx: Some(new_cur.tree_addr[0])
+                idx: Some(new_cur.tree_addr[0]),
             });
             TreeNavResult::Continue
         } else if new_cur.tree_addr.len() > 1 && new_cur.tree_addr[0] < self.data.len() {
             self.cursor.set(ListCursor {
                 mode: ListCursorMode::Modify,
-                idx: Some(new_cur.tree_addr[0])
+                idx: Some(new_cur.tree_addr[0]),
             });
 
             let ne = self.data.get_mut(new_cur.tree_addr[0]);
             let mut nxt_edit = ne.write().unwrap();
 
-            nxt_edit.goto(
+            nxt_edit.goto(TreeCursor {
-                TreeCursor {
                 leaf_mode: new_cur.leaf_mode,
-                    tree_addr: new_cur.tree_addr[1..].iter().cloned().collect()
+                tree_addr: new_cur.tree_addr[1..].iter().cloned().collect(),
             });
 
             TreeNavResult::Continue
         } else {
             self.cursor.set(ListCursor {
                 mode: new_cur.leaf_mode,
-                idx: None
+                idx: None,
             });
             TreeNavResult::Continue
         }
@@ -126,12 +124,10 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         let i = cur.idx.unwrap_or(0);
 
         if self.data.len() == 0 && cur.idx.is_none() {
-            self.cursor.set(
+            self.cursor.set(ListCursor {
-                ListCursor {
                 mode: ListCursorMode::Insert,
-                    idx: Some(0)
+                idx: Some(0),
-                }
+            });
-            );
             return TreeNavResult::Continue;
         }
 
@@ -149,12 +145,10 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                 }
                 ListCursorMode::Select => {
                     if self.data.len() == 0 && cur.idx.is_none() {
-                        self.cursor.set(
+                        self.cursor.set(ListCursor {
-                            ListCursor {
                             mode: ListCursorMode::Insert,
-                                idx: Some(0)
+                            idx: Some(0),
-                            }
+                        });
-                        );
                         return TreeNavResult::Continue;
                     }
 
@@ -173,9 +167,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                     let cur_mode = cur_edit.get_cursor().leaf_mode;
                     let depth = cur_edit.get_cursor().tree_addr.len();
                     match cur_edit.goto_end() {
-                        TreeNavResult::Continue => {
+                        TreeNavResult::Continue => TreeNavResult::Continue,
-                            TreeNavResult::Continue
-                        }
                         TreeNavResult::Exit => {
                             drop(cur_edit);
 
@@ -185,7 +177,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                                 self.set_mode(ListCursorMode::Select);
                                 self.nexd();
 
-                                for x in 1 .. depth {
+                                for _x in 1..depth {
                                     self.dn();
                                     self.goto_home();
                                 }
@@ -211,25 +203,24 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
     fn goto_home(&mut self) -> TreeNavResult {
         let cur = self.cursor.get();
         if self.data.len() == 0 && cur.idx.is_none() {
-            self.cursor.set(
+            self.cursor.set(ListCursor {
-                ListCursor {
                 mode: ListCursorMode::Insert,
-                    idx: Some(0)
+                idx: Some(0),
-                }
+            });
-            );
             return TreeNavResult::Continue;
         }
 
         match cur.mode {
-            ListCursorMode::Insert |
+            ListCursorMode::Insert | ListCursorMode::Select => {
-            ListCursorMode::Select => {
                 if cur.idx != Some(0) {
-                    self.cursor.set(
+                    self.cursor.set(ListCursor {
-                        ListCursor {
+                        mode: if self.data.len() == 0 {
-                            mode: if self.data.len() == 0 { ListCursorMode::Insert } else { cur.mode },
+                            ListCursorMode::Insert
-                            idx: Some(0)
+                        } else {
-                        }
+                            cur.mode
-                    );
+                        },
+                        idx: Some(0),
+                    });
                     TreeNavResult::Continue
                 } else {
                     self.cursor.set(ListCursor::default());
@@ -253,7 +244,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                                 self.set_mode(ListCursorMode::Select);
                                 self.pxev();
 
-                                for x in 1 .. depth {
+                                for _x in 1..depth {
                                     self.dn();
                                     self.goto_end();
                                 }
@@ -267,7 +258,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 
                         TreeNavResult::Exit
                     }
-                    TreeNavResult::Continue => TreeNavResult::Continue
+                    TreeNavResult::Continue => TreeNavResult::Continue,
                 }
             }
         }
@@ -294,7 +285,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 
         self.cursor.set(ListCursor {
             mode: cur.mode,
-            idx: None
+            idx: None,
         });
         TreeNavResult::Exit
     }
@@ -302,25 +293,20 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
     fn dn(&mut self) -> TreeNavResult {
         let cur = self.cursor.get();
         match cur.mode {
-            ListCursorMode::Insert |
+            ListCursorMode::Insert | ListCursorMode::Select => {
-            ListCursorMode::Select => {
                 if let Some(i) = cur.idx {
                     if i < self.data.len() {
                         self.set_mode(ListCursorMode::Modify);
-                        self.data.get_mut(i).write().unwrap().goto(
+                        self.data.get_mut(i).write().unwrap().goto(TreeCursor {
-                            TreeCursor {
                             leaf_mode: cur.mode,
-                                tree_addr: vec![]
+                            tree_addr: vec![],
-                            }
+                        });
-                        );
                         *self.cur_dist.write().unwrap() += 1;
                     }
                 }
                 TreeNavResult::Continue
             }
-            ListCursorMode::Modify => {
+            ListCursorMode::Modify => self.get_item().unwrap().write().unwrap().dn(),
-                self.get_item().unwrap().write().unwrap().dn()
-            }
         }
     }
 
@@ -328,8 +314,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         let mut cur = self.cursor.get();
         if let Some(i) = cur.idx {
             match cur.mode {
-                ListCursorMode::Insert |
+                ListCursorMode::Insert | ListCursorMode::Select => {
-                ListCursorMode::Select => {
                     if i > 0 {
                         cur.idx = Some(i - 1);
                         self.cursor.set(cur);
@@ -355,7 +340,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                                 self.set_mode(ListCursorMode::Select);
                                 self.pxev();
 
-                                for x in 1 .. depth {
+                                for _x in 1..depth {
                                     self.dn();
                                     self.goto_end();
                                 }
@@ -367,8 +352,8 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                             } else {
                                 TreeNavResult::Exit
                             }
-                        },
+                        }
-                        TreeNavResult::Continue => TreeNavResult::Continue
+                        TreeNavResult::Continue => TreeNavResult::Continue,
                     }
                 }
             }
@@ -415,11 +400,10 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                             self.up();
 
                             if i + 1 < self.data.len() {
-
                                 self.set_mode(ListCursorMode::Select);
                                 self.nexd();
 
-                                for x in 1 .. depth {
+                                for _x in 1..depth {
                                     self.dn();
                                     self.goto_home();
                                 }
@@ -432,7 +416,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                                 TreeNavResult::Exit
                             }
                         }
-                        TreeNavResult::Continue => TreeNavResult::Continue
+                        TreeNavResult::Continue => TreeNavResult::Continue,
                     }
                 }
             }
@@ -443,8 +427,9 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 }
 
 impl<ItemEditor, FnMakeItemEditor> TerminalEditor for ListEditor<ItemEditor, FnMakeItemEditor>
-where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+where
-      FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>
+    ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+    FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>,
 {
     fn get_term_view(&self) -> OuterViewPort<dyn TerminalView> {
         match self.style {
@@ -454,7 +439,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
             ListEditorStyle::String => self.string_view(),
             ListEditorStyle::Clist => self.clist_view(),
             ListEditorStyle::Hex => self.hex_view(),
-            ListEditorStyle::Plain => self.plain_view()
+            ListEditorStyle::Plain => self.plain_view(),
         }
     }
 
@@ -462,8 +447,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         let mut cur = self.cursor.get();
         if let Some(idx) = cur.idx {
             match cur.mode {
-                ListCursorMode::Insert => {
+                ListCursorMode::Insert => match event {
-                    match event {
                     TerminalEvent::Input(Event::Key(Key::Backspace)) => {
                         if idx > 0 && idx <= self.data.len() {
                             cur.idx = Some(idx - 1);
@@ -482,8 +466,8 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                             TerminalEditorResult::Exit
                         }
                     }
-                        TerminalEvent::Input(Event::Key(Key::Char('\t'))) |
+                    TerminalEvent::Input(Event::Key(Key::Char('\t')))
-                        TerminalEvent::Input(Event::Key(Key::Insert)) => {
+                    | TerminalEvent::Input(Event::Key(Key::Insert)) => {
                         self.set_mode(ListCursorMode::Select);
                         TerminalEditorResult::Continue
                     }
@@ -497,19 +481,17 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                             TerminalEditorResult::Exit => {
                                 self.cursor.set(ListCursor {
                                     mode: ListCursorMode::Insert,
-                                        idx: Some(idx+1)
+                                    idx: Some(idx + 1),
                                 });
                             }
                             _ => {}
                         }
                         TerminalEditorResult::Continue
                     }
-                    }
+                },
-                }
+                ListCursorMode::Select => match event {
-                ListCursorMode::Select => {
+                    TerminalEvent::Input(Event::Key(Key::Char('\t')))
-                    match event {
+                    | TerminalEvent::Input(Event::Key(Key::Insert)) => {
-                        TerminalEvent::Input(Event::Key(Key::Char('\t'))) |
-                        TerminalEvent::Input(Event::Key(Key::Insert)) => {
                         self.set_mode(ListCursorMode::Insert);
                         TerminalEditorResult::Continue
                     }
@@ -521,18 +503,15 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                         } else if idx == self.data.len() {
                             self.cursor.set(ListCursor {
                                 mode: ListCursorMode::Select,
-                                    idx: Some(idx-1)
+                                idx: Some(idx - 1),
                             });
                         }
                         TerminalEditorResult::Continue
                     }
-                        _ => {
+                    _ => TerminalEditorResult::Continue,
-                            TerminalEditorResult::Continue
+                },
-                        }
-                    }
-                }
                 ListCursorMode::Modify => {
-                    let mut ce = self.data.get_mut(idx);
+                    let ce = self.data.get_mut(idx);
                     let mut cur_edit = ce.write().unwrap();
 
                     match cur_edit.handle_terminal_event(event) {
@@ -546,7 +525,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
                                     // todo: join instead of remove
                                     self.cursor.set(ListCursor {
                                         mode: ListCursorMode::Insert,
-                                        idx: Some(idx)
+                                        idx: Some(idx),
                                     });
 
                                     self.data.remove(idx);
@@ -556,11 +535,11 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 
                                     self.cursor.set(ListCursor {
                                         mode: ListCursorMode::Insert,
-                                        idx: Some(idx+1)
+                                        idx: Some(idx + 1),
                                     });
                                 }
                             }
-                        },
+                        }
                         TerminalEditorResult::Continue => {}
                     }
 
@@ -574,50 +553,55 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 }
 
 impl<ItemEditor, FnMakeItemEditor> ListEditor<ItemEditor, FnMakeItemEditor>
-where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+where
-      FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>
+    ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+    FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>,
 {
-    pub fn get_seg_seq_view(&self) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
+    pub fn get_seg_seq_view(
+        &self,
+    ) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
         let segment_view_port = ViewPort::<dyn SequenceView<Item = ListEditorViewSegment>>::new();
         ListEditorView::new(
             self.cursor_port.outer(),
-            self.data_port.outer().to_sequence().map(|ed| ed.read().unwrap().get_term_view()),
+            self.data_port
-            segment_view_port.inner()
+                .outer()
+                .to_sequence()
+                .map(|ed| ed.read().unwrap().get_term_view()),
+            segment_view_port.inner(),
         );
 
-        segment_view_port.into_outer()
+        segment_view_port.into_outer().map(move |segment| {
-            .map(
-                move |segment| {
             let cursor_col = (90, 60, 200);
             match segment {
-                    ListEditorViewSegment::InsertCursor =>
+                ListEditorViewSegment::InsertCursor => {
-                        make_label("|")
+                    make_label("|").map_item(move |_pt, atom| {
-                        .map_item(
-                            move |_pt, atom|
                         atom.add_style_back(TerminalStyle::fg_color(cursor_col))
                             .add_style_back(TerminalStyle::bold(true))
-                        ),
+                    })
-                    ListEditorViewSegment::Select(sub_view) =>
-                        sub_view.map_item(
-                            move |_pt, atom| {
-                                let old_col = atom.style.bg_color.unwrap_or(cursor_col);
-                                atom.add_style_front(TerminalStyle::bg_color(((old_col.0 as f32 * 0.4) as u8, (old_col.1 as f32 * 0.4) as u8, (old_col.2 as f32 * 0.4) as u8)))
                 }
-                        ),
+                ListEditorViewSegment::Select(sub_view) => sub_view.map_item(move |_pt, atom| {
+                    let old_col = atom.style.bg_color.unwrap_or(cursor_col);
+                    atom.add_style_front(TerminalStyle::bg_color((
+                        (old_col.0 as f32 * 0.4) as u8,
+                        (old_col.1 as f32 * 0.4) as u8,
+                        (old_col.2 as f32 * 0.4) as u8,
+                    )))
+                }),
                 ListEditorViewSegment::Modify(sub_view) => {
                     sub_view.clone().map_item(
                         move |_pt, atom| {
                             let old_col = atom.style.bg_color.unwrap_or(cursor_col);
-                                atom.add_style_front(TerminalStyle::bg_color(((old_col.0 as f32 * 0.4) as u8, (old_col.1 as f32 * 0.4) as u8, (old_col.2 as f32 * 0.4) as u8)))
+                            atom.add_style_front(TerminalStyle::bg_color((
-                            }
+                                (old_col.0 as f32 * 0.4) as u8,
-                                //.add_style_back(TerminalStyle::bold(true))
+                                (old_col.1 as f32 * 0.4) as u8,
+                                (old_col.2 as f32 * 0.4) as u8,
+                            )))
+                        }, //.add_style_back(TerminalStyle::bold(true))
                     )
-                    },
-                    ListEditorViewSegment::View(sub_view) =>
-                        sub_view.clone()
                 }
+                ListEditorViewSegment::View(sub_view) => sub_view.clone(),
             }
-            )
+        })
     }
 
     pub fn horizontal_sexpr_view(&self) -> OuterViewPort<dyn TerminalView> {
@@ -639,7 +623,6 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         self.get_seg_seq_view()
             .decorate("\"", "\"", "", 1)
             .to_grid_horizontal()
-
             .flatten()
     }
 
@@ -658,16 +641,14 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
     }
 
     pub fn plain_view(&self) -> OuterViewPort<dyn TerminalView> {
-        self.get_seg_seq_view()
+        self.get_seg_seq_view().to_grid_horizontal().flatten()
-            .to_grid_horizontal()
-            .flatten()
     }
 
     pub fn new(make_item_editor: FnMakeItemEditor, style: ListEditorStyle) -> Self {
         let cursor_port = ViewPort::new();
         let data_port = ViewPort::new();
-        let mut cursor = SingletonBuffer::new(ListCursor::default(), cursor_port.inner());
+        let cursor = SingletonBuffer::new(ListCursor::default(), cursor_port.inner());
-        let mut data = VecBuffer::<Arc<RwLock<ItemEditor>>>::new(data_port.inner());
+        let data = VecBuffer::<Arc<RwLock<ItemEditor>>>::new(data_port.inner());
 
         let mut le = ListEditor {
             data,
@@ -677,8 +658,8 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 
             style,
             make_item_editor,
-            level: 0,
+            _level: 0,
-            cur_dist: Arc::new(RwLock::new(0))
+            cur_dist: Arc::new(RwLock::new(0)),
         };
         le.set_style(style);
         le
@@ -708,6 +689,10 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         }
     }
 
+    pub fn clear(&mut self) {
+        self.data.clear();
+    }
+    
     fn set_idx(&mut self, idx: isize) {
         let cur = self.cursor.get();
         let mode = cur.mode;
@@ -715,12 +700,12 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         if idx < 0 {
             self.cursor.set(ListCursor {
                 mode,
-                idx: Some((self.data.len() as isize + idx) as usize)
+                idx: Some((self.data.len() as isize + idx) as usize),
             });
         } else {
             self.cursor.set(ListCursor {
                 mode,
-                idx: Some(idx as usize)
+                idx: Some(idx as usize),
             });
         }
     }
@@ -728,9 +713,7 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
     fn set_mode(&mut self, mode: ListCursorMode) {
         let mut cur = self.cursor.get();
 
-        if cur.mode == ListCursorMode::Insert &&
+        if cur.mode == ListCursorMode::Insert && mode != ListCursorMode::Insert {
-            mode != ListCursorMode::Insert
-        {
             if let Some(idx) = cur.idx {
                 if idx == self.data.len() && idx > 0 {
                     cur.idx = Some(idx - 1);
@@ -745,8 +728,9 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
 }
 
 impl<ItemEditor, FnMakeItemEditor> ListEditor<ItemEditor, FnMakeItemEditor>
-where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+where
-      FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>
+    ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
+    FnMakeItemEditor: Fn() -> Arc<RwLock<ItemEditor>>,
 {
     fn set_leaf_mode(&mut self, mode: ListCursorMode) {
         let mut c = self.get_cursor();
@@ -754,4 +738,3 @@ where ItemEditor: TerminalTreeEditor + ?Sized + Send + Sync + 'static,
         self.goto(c);
     }
 }
-

nested/src/list/editor_view.rs

@@ -1,30 +1,21 @@
 use {
+    crate::{
+        core::{InnerViewPort, Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View},
+        list::{ListCursor, ListCursorMode},
+        projection::ProjectionHelper,
+        sequence::SequenceView,
+        singleton::SingletonView,
+        terminal::TerminalView,
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    crate::{
-        core::{
-            View,
-            InnerViewPort,
-            OuterViewPort,
-            Observer,
-            ObserverExt,
-            ObserverBroadcast
-        },
-        projection::ProjectionHelper,
-
-        singleton::SingletonView,
-        sequence::SequenceView,
-        terminal::TerminalView,
-
-        list::{ListCursor, ListCursorMode}
-    }
 };
 
 pub enum ListEditorViewSegment {
     InsertCursor,
     View(OuterViewPort<dyn TerminalView>),
     Select(OuterViewPort<dyn TerminalView>),
-    Modify(OuterViewPort<dyn TerminalView>)
+    Modify(OuterViewPort<dyn TerminalView>),
 }
 
 pub struct ListEditorView {
@@ -33,7 +24,7 @@ pub struct ListEditorView {
     cur_cursor: ListCursor,
 
     cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = ListEditorViewSegment>>>>,
-    proj_helper: ProjectionHelper<usize, Self>
+    proj_helper: ProjectionHelper<usize, Self>,
 }
 
 impl View for ListEditorView {
@@ -45,14 +36,15 @@ impl SequenceView for ListEditorView {
 
     fn len(&self) -> Option<usize> {
         match self.cursor.get().mode {
-            ListCursorMode::Insert => Some(self.data.len()? + if self.cur_cursor.idx.is_some() { 1 } else { 0 }),
+            ListCursorMode::Insert => {
-            _ => self.data.len()
+                Some(self.data.len()? + if self.cur_cursor.idx.is_some() { 1 } else { 0 })
+            }
+            _ => self.data.len(),
         }
     }
 
     fn get(&self, idx: &usize) -> Option<Self::Item> {
-        Some(
+        Some(if let Some(cur) = self.cur_cursor.idx {
-            if let Some(cur) = self.cur_cursor.idx {
             match self.cur_cursor.mode {
                 ListCursorMode::Select => {
                     if *idx == cur {
@@ -80,8 +72,7 @@ impl SequenceView for ListEditorView {
             }
         } else {
             ListEditorViewSegment::View(self.data.get(&idx)?)
-            }
+        })
-        )
     }
 }
 
@@ -89,28 +80,19 @@ impl ListEditorView {
     pub fn new(
         cursor_port: OuterViewPort<dyn SingletonView<Item = ListCursor>>,
         data_port: OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>>,
-        out_port: InnerViewPort<dyn SequenceView<Item = ListEditorViewSegment>>
+        out_port: InnerViewPort<dyn SequenceView<Item = ListEditorViewSegment>>,
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
-        let proj = Arc::new(RwLock::new(
+        let proj = Arc::new(RwLock::new(ListEditorView {
-                ListEditorView {
             cur_cursor: ListCursor::default(),
-                    cursor: proj_helper.new_singleton_arg(
+            cursor: proj_helper.new_singleton_arg(0, cursor_port, |s: &mut Self, _msg| {
-                        0,
+                let _old_cursor = s.cur_cursor;
-                        cursor_port,
-                        |s: &mut Self, _msg| {
-                            let old_cursor = s.cur_cursor;
                 let new_cursor = s.cursor.get();
                 s.cur_cursor = new_cursor;
 
-                            s.cast.notify_each(
+                s.cast.notify_each(0..=s.data.len().unwrap_or(0) + 1);
-                                0 ..= s.data.len().unwrap_or(0)+1
-                            );
             }),
-                    data: proj_helper.new_sequence_arg(
+            data: proj_helper.new_sequence_arg(1, data_port, |s: &mut Self, idx| {
-                        1,
-                        data_port,
-                        |s: &mut Self, idx| {
                 if let Some(cur_idx) = s.cur_cursor.idx {
                     match s.cur_cursor.mode {
                         ListCursorMode::Insert => {
@@ -119,7 +101,7 @@ impl ListEditorView {
                             } else {
                                 s.cast.notify(&(*idx + 1));
                             }
-                                    },
+                        }
                         _ => {
                             s.cast.notify(idx);
                         }
@@ -129,9 +111,8 @@ impl ListEditorView {
                 }
             }),
             cast: out_port.get_broadcast(),
-                    proj_helper
+            proj_helper,
-                }
+        }));
-            ));
 
         proj.write().unwrap().proj_helper.set_proj(&proj);
         out_port.set_view(Some(proj.clone()));
@@ -139,4 +120,3 @@ impl ListEditorView {
         proj
     }
 }
-

nested/src/list/mod.rs

@@ -1,10 +1,8 @@
-
-pub mod sexpr;
 pub mod cursor;
 pub mod editor;
 pub mod editor_view;
+pub mod sexpr;
 
-pub use sexpr::{SExprView, ListDecoration};
+pub use cursor::{ListCursor, ListCursorMode};
-pub use cursor::{ListCursorMode, ListCursor};
 pub use editor::{ListEditor, ListEditorStyle};
-
+pub use sexpr::{ListDecoration, SExprView};

nested/src/list/sexpr.rs

@@ -1,9 +1,9 @@
 use {
     crate::{
         core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
+        index::IndexArea,
         projection::ProjectionHelper,
         sequence::SequenceView,
-        index::{IndexArea},
         terminal::{make_label, TerminalStyle, TerminalView},
     },
     cgmath::Point2,
@@ -150,7 +150,8 @@ impl IndexView<Point2<i16>> for VerticalSexprDecorator {
 
     fn area(&self) -> IndexArea<Point2<i16>> {
         IndexArea::Range(
-            Point2::new(0, 0) ..= Point2::new(2, std::cmp::max(self.items.len().unwrap() as i16 - 1, 0))
+            Point2::new(0, 0)
+                ..=Point2::new(2, std::cmp::max(self.items.len().unwrap() as i16 - 1, 0)),
         )
     }
 
@@ -216,11 +217,9 @@ impl VerticalSexprDecorator {
             opening_port: make_label(opening),
             closing_port: make_label(closing),
             items: proj_helper.new_sequence_arg((), items_port, |s: &mut Self, item_idx| {
-                s.cast.notify(
+                s.cast.notify(&IndexArea::Range(
-                    &IndexArea::Range(
+                    Point2::new(0, *item_idx as i16)..=Point2::new(2, *item_idx as i16),
-                        Point2::new(0, *item_idx as i16) ..= Point2::new(2, *item_idx as i16)
+                ));
-                    )
-                );
             }),
             list_style: TerminalStyle::fg_color(match level {
                 0 => (200, 120, 10),

nested/src/projection.rs

@@ -1,51 +1,46 @@
 use {
-    std::{
-        cmp::{max},
-        any::Any,
-        sync::{Arc, Weak},
-        hash::Hash,
-        collections::HashMap
-    },
-    std::sync::RwLock,
     crate::{
         core::{
-            View,
+            channel::{queue_channel, set_channel, ChannelData, ChannelReceiver, ChannelSender},
-            Observer, ObserverExt,
             port::UpdateTask,
-            OuterViewPort,
+            Observer, ObserverExt, OuterViewPort, View,
-            channel::{
+        },
-                ChannelSender, ChannelReceiver,
+        index::{IndexArea, IndexView},
-                ChannelData,
+        sequence::SequenceView,
-                set_channel,
+        singleton::SingletonView,
-                queue_channel
+    },
-            }
+    std::sync::RwLock,
+    std::{
+        any::Any,
+        cmp::max,
+        collections::HashMap,
+        hash::Hash,
+        sync::{Arc, Weak},
     },
-        singleton::{SingletonView},
-        sequence::{SequenceView},
-        index::{IndexArea, IndexView}
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct ProjectionHelper<ArgKey, P>
-where ArgKey: Clone + Hash + Eq,
+where
-      P: Send + Sync + 'static
+    ArgKey: Clone + Hash + Eq,
+    P: Send + Sync + 'static,
 {
     keepalive: HashMap<ArgKey, (usize, Arc<dyn Any + Send + Sync>)>,
     proj: Arc<RwLock<Weak<RwLock<P>>>>,
-    update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>
+    update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>,
 }
 
 impl<ArgKey, P> ProjectionHelper<ArgKey, P>
-where ArgKey: Clone + Hash + Eq,
+where
-      P: Send + Sync + 'static
+    ArgKey: Clone + Hash + Eq,
+    P: Send + Sync + 'static,
 {
     pub fn new(update_hooks: Arc<RwLock<Vec<Arc<dyn UpdateTask>>>>) -> Self {
         ProjectionHelper {
             keepalive: HashMap::new(),
             proj: Arc::new(RwLock::new(Weak::new())),
-            update_hooks
+            update_hooks,
         }
     }
 
@@ -60,7 +55,7 @@ where ArgKey: Clone + Hash + Eq,
         &mut self,
         arg_key: ArgKey,
         port: OuterViewPort<dyn SingletonView<Item = Item>>,
-        notify: impl Fn(&mut P, &()) + Send + Sync + 'static
+        notify: impl Fn(&mut P, &()) + Send + Sync + 'static,
     ) -> Arc<RwLock<Option<Arc<dyn SingletonView<Item = Item>>>>> {
         port.add_observer(self.new_arg(arg_key, Arc::new(port.0.clone()), notify, set_channel()));
         port.get_view_arc()
@@ -70,7 +65,7 @@ where ArgKey: Clone + Hash + Eq,
         &mut self,
         arg_key: ArgKey,
         port: OuterViewPort<dyn SequenceView<Item = Item>>,
-        notify: impl Fn(&mut P, &usize) + Send + Sync + 'static
+        notify: impl Fn(&mut P, &usize) + Send + Sync + 'static,
     ) -> Arc<RwLock<Option<Arc<dyn SequenceView<Item = Item>>>>> {
         port.add_observer(self.new_arg(arg_key, Arc::new(port.0.clone()), notify, set_channel()));
         port.get_view_arc()
@@ -80,34 +75,31 @@ where ArgKey: Clone + Hash + Eq,
         &mut self,
         arg_key: ArgKey,
         port: OuterViewPort<dyn IndexView<Key, Item = Item>>,
-        notify: impl Fn(&mut P, &IndexArea<Key>) + Send + Sync + 'static
+        notify: impl Fn(&mut P, &IndexArea<Key>) + Send + Sync + 'static,
     ) -> Arc<RwLock<Option<Arc<dyn IndexView<Key, Item = Item>>>>> {
         port.add_observer(self.new_arg(arg_key, Arc::new(port.0.clone()), notify, queue_channel()));
         port.get_view_arc()
     }
 
-    pub fn new_arg<
+    pub fn new_arg<V: View + ?Sized + 'static, D: ChannelData<Item = V::Msg> + 'static>(
-        V: View + ?Sized + 'static,
-        D: ChannelData<Item = V::Msg> + 'static
-    >(
         &mut self,
         arg_key: ArgKey,
         src_update: Arc<dyn UpdateTask>,
         notify: impl Fn(&mut P, &V::Msg) + Send + Sync + 'static,
-        (tx, rx): (ChannelSender<D>, ChannelReceiver<D>)
+        (tx, rx): (ChannelSender<D>, ChannelReceiver<D>),
-    )
+    ) -> Arc<RwLock<ProjectionArg<P, V, D>>>
-        -> Arc<RwLock<ProjectionArg<P, V, D>>>
+    where
-    where V::Msg: Send + Sync,
+        V::Msg: Send + Sync,
-          D::IntoIter: Send + Sync + 'static
+        D::IntoIter: Send + Sync + 'static,
     {
         self.remove_arg(&arg_key);
 
-        let arg = Arc::new(RwLock::new(
+        let arg = Arc::new(RwLock::new(ProjectionArg {
-            ProjectionArg {
             src: None,
             notify: Box::new(notify),
             proj: self.proj.clone(),
-                rx, tx
+            rx,
+            tx,
         }));
 
         let mut hooks = self.update_hooks.write().unwrap();
@@ -121,7 +113,7 @@ where ArgKey: Clone + Hash + Eq,
 
     pub fn remove_arg(&mut self, arg_key: &ArgKey) {
         let mut hooks = self.update_hooks.write().unwrap();
-        if let Some((idx, arg)) = self.keepalive.remove(arg_key) {
+        if let Some((idx, _arg)) = self.keepalive.remove(arg_key) {
             hooks.remove(idx);
             hooks.remove(idx);
             for (_, (j, _)) in self.keepalive.iter_mut() {
@@ -136,33 +128,32 @@ where ArgKey: Clone + Hash + Eq,
 /// Special Observer which can access the state of the projection on notify
 /// also handles the reset()
 pub struct ProjectionArg<P, V, D>
-where P: Send + Sync + 'static,
+where
+    P: Send + Sync + 'static,
     V: View + ?Sized,
     D: ChannelData<Item = V::Msg>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     src: Option<Arc<V>>,
     notify: Box<dyn Fn(&mut P, &V::Msg) + Send + Sync + 'static>,
     proj: Arc<RwLock<Weak<RwLock<P>>>>,
     rx: ChannelReceiver<D>,
-    tx: ChannelSender<D>
+    tx: ChannelSender<D>,
 }
 
 impl<P, V, D> UpdateTask for ProjectionArg<P, V, D>
-where P: Send + Sync + 'static,
+where
+    P: Send + Sync + 'static,
     V: View + ?Sized,
     D: ChannelData<Item = V::Msg>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     fn update(&self) {
         if let Some(p) = self.proj.read().unwrap().upgrade() {
             if let Some(data) = self.rx.try_recv() {
                 for msg in data {
                     //eprintln!("proj update {:?}", msg);
-                    (self.notify)(
+                    (self.notify)(&mut *p.write().unwrap(), &msg);
-                        &mut *p.write().unwrap(),
-                        &msg
-                    );
                 }
             }
         } else {
@@ -172,10 +163,11 @@ where P: Send + Sync + 'static,
 }
 
 impl<P, V, D> UpdateTask for RwLock<ProjectionArg<P, V, D>>
-where P: Send + Sync + 'static,
+where
+    P: Send + Sync + 'static,
     V: View + ?Sized,
     D: ChannelData<Item = V::Msg>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     fn update(&self) {
         self.read().unwrap().update();
@@ -184,10 +176,12 @@ where P: Send + Sync + 'static,
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl<P, Item, D> Observer<dyn SingletonView<Item = Item>> for ProjectionArg<P, dyn SingletonView<Item = Item>, D>
+impl<P, Item, D> Observer<dyn SingletonView<Item = Item>>
-where P: Send + Sync + 'static,
+    for ProjectionArg<P, dyn SingletonView<Item = Item>, D>
+where
+    P: Send + Sync + 'static,
     D: ChannelData<Item = ()>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     fn reset(&mut self, new_src: Option<Arc<dyn SingletonView<Item = Item>>>) {
         self.src = new_src;
@@ -201,10 +195,12 @@ where P: Send + Sync + 'static,
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl<P, Item, D> Observer<dyn SequenceView<Item = Item>> for ProjectionArg<P, dyn SequenceView<Item = Item>, D>
+impl<P, Item, D> Observer<dyn SequenceView<Item = Item>>
-where P: Send + Sync + 'static,
+    for ProjectionArg<P, dyn SequenceView<Item = Item>, D>
+where
+    P: Send + Sync + 'static,
     D: ChannelData<Item = usize>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     fn reset(&mut self, new_src: Option<Arc<dyn SequenceView<Item = Item>>>) {
         let old_len = self.src.len().unwrap_or(0);
@@ -221,11 +217,13 @@ where P: Send + Sync + 'static,
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl<P, Key, Item, D> Observer<dyn IndexView<Key, Item = Item>> for ProjectionArg<P, dyn IndexView<Key, Item = Item>, D>
+impl<P, Key, Item, D> Observer<dyn IndexView<Key, Item = Item>>
-where P: Send + Sync + 'static,
+    for ProjectionArg<P, dyn IndexView<Key, Item = Item>, D>
+where
+    P: Send + Sync + 'static,
     Key: Clone + Send + Sync,
     D: ChannelData<Item = IndexArea<Key>>,
-      D::IntoIter: Send + Sync
+    D::IntoIter: Send + Sync,
 {
     fn reset(&mut self, new_src: Option<Arc<dyn IndexView<Key, Item = Item>>>) {
         let old_area = self.src.area();
@@ -239,4 +237,3 @@ where P: Send + Sync + 'static,
         self.tx.send(msg.clone());
     }
 }
-

nested/src/sequence/filter.rs

@@ -1,33 +1,28 @@
 use {
+    crate::{
+        core::{Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort},
+        sequence::SequenceView,
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    crate::{
-        sequence::{SequenceView},
-        core::{
-            Observer, ObserverExt, ObserverBroadcast,
-            View, ViewPort, OuterViewPort
-        }
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl<V: SequenceView + ?Sized + 'static> OuterViewPort<V>
+impl<V: SequenceView + ?Sized + 'static> OuterViewPort<V> {
-{
+    pub fn filter<P: Fn(&V::Item) -> bool + Send + Sync + 'static>(
-    pub fn filter<
+        &self,
-        P: Fn(&V::Item) -> bool + Send + Sync + 'static
+        pred: P,
-    >(&self, pred: P) -> OuterViewPort<dyn SequenceView<Item = V::Item>> {
+    ) -> OuterViewPort<dyn SequenceView<Item = V::Item>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
 
-        let filter = Arc::new(RwLock::new(
+        let filter = Arc::new(RwLock::new(Filter {
-            Filter {
             src_view: None,
             pred,
             old_preds: RwLock::new(Vec::new()),
-                cast: port.inner().get_broadcast()
+            cast: port.inner().get_broadcast(),
-            }
+        }));
-        ));
 
         self.add_observer(filter.clone());
         port.inner().set_view(Some(filter));
@@ -38,18 +33,20 @@ impl<V: SequenceView + ?Sized + 'static> OuterViewPort<V>
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 struct Filter<SrcView, P>
-where SrcView: SequenceView + ?Sized + 'static,
+where
-      P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static
+    SrcView: SequenceView + ?Sized + 'static,
+    P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static,
 {
     src_view: Option<Arc<SrcView>>,
     pred: P,
     old_preds: RwLock<Vec<bool>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = SrcView::Item>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = SrcView::Item>>>>,
 }
 
 impl<SrcView, P> Filter<SrcView, P>
-where SrcView: SequenceView + ?Sized + 'static,
+where
-      P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static
+    SrcView: SequenceView + ?Sized + 'static,
+    P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static,
 {
     fn get_offset(&self, idx: usize) -> usize {
         if let Some(v) = self.src_view.clone() {
@@ -76,15 +73,17 @@ where SrcView: SequenceView + ?Sized + 'static,
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<SrcView, P> View for Filter<SrcView, P>
-where SrcView: SequenceView + ?Sized + 'static,
+where
-      P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static
+    SrcView: SequenceView + ?Sized + 'static,
+    P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static,
 {
     type Msg = usize;
 }
 
 impl<SrcView, P> SequenceView for Filter<SrcView, P>
-where SrcView: SequenceView + ?Sized + 'static,
+where
-      P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static
+    SrcView: SequenceView + ?Sized + 'static,
+    P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static,
 {
     type Item = SrcView::Item;
 
@@ -104,8 +103,9 @@ where SrcView: SequenceView + ?Sized + 'static,
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<SrcView, P> Observer<SrcView> for Filter<SrcView, P>
-where SrcView: SequenceView + ?Sized + 'static,
+where
-      P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static
+    SrcView: SequenceView + ?Sized + 'static,
+    P: Fn(&SrcView::Item) -> bool + Send + Sync + 'static,
 {
     fn reset(&mut self, new_src: Option<Arc<SrcView>>) {
         let old_len = self.len();
@@ -113,14 +113,17 @@ where SrcView: SequenceView + ?Sized + 'static,
         self.old_preds = RwLock::new(Vec::new());
         let new_len = self.len();
 
-        if let Some(len) = old_len { self.cast.notify_each(0 .. len); }
+        if let Some(len) = old_len {
-        if let Some(len) = new_len { self.cast.notify_each(0 .. len); }
+            self.cast.notify_each(0..len);
+        }
+        if let Some(len) = new_len {
+            self.cast.notify_each(0..len);
+        }
     }
 
     fn notify(&mut self, idx: &usize) {
         let l = self.len().unwrap_or(0) + 1;
-        let np = 
+        let np = if let Some(x) = self.src_view.get(idx) {
-            if let Some(x) = self.src_view.get(idx) {
             (self.pred)(&x)
         } else {
             false
@@ -134,16 +137,18 @@ where SrcView: SequenceView + ?Sized + 'static,
 
         drop(opds);
 
-        let i =
+        let i = (0..*idx)
-            (0 .. *idx)
+            .map(|j| {
-            .map(
-                |j|
                 if let Some(x) = self.src_view.get(&j) {
-                    if (self.pred)(&x) { 1 } else { 0 }
+                    if (self.pred)(&x) {
+                        1
                     } else {
                         0
                     }
-            )
+                } else {
+                    0
+                }
+            })
             .sum();
 
         if np != op {
@@ -153,4 +158,3 @@ where SrcView: SequenceView + ?Sized + 'static,
         }
     }
 }
-

nested/src/sequence/flatten.rs

@@ -1,22 +1,20 @@
 use {
-    std::{
-        sync::Arc,
-        collections::BTreeMap
-    },
-    std::sync::RwLock,
     crate::{
         core::{
-            View, Observer, ObserverBroadcast, ObserverExt,
+            port::UpdateTask, InnerViewPort, Observer, ObserverBroadcast, ObserverExt,
-            ViewPort, InnerViewPort, OuterViewPort,
+            OuterViewPort, View, ViewPort,
-            port::UpdateTask
         },
+        projection::ProjectionHelper,
         sequence::SequenceView,
-        projection::ProjectionHelper
+    },
-    }
+    std::sync::RwLock,
+    std::{collections::BTreeMap, sync::Arc},
 };
 
 impl<Item> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn SequenceView<Item = Item>>>>
-where Item: 'static{
+where
+    Item: 'static,
+{
     pub fn flatten(&self) -> OuterViewPort<dyn SequenceView<Item = Item>> {
         let port = ViewPort::new();
         Flatten::new(self.clone(), port.inner());
@@ -25,31 +23,35 @@ where Item: 'static{
 }
 
 pub struct Chunk<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     offset: usize,
     len: usize,
-    view: Arc<dyn SequenceView<Item = Item>>
+    view: Arc<dyn SequenceView<Item = Item>>,
 }
 
 pub struct Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     length: usize,
     top: Arc<dyn SequenceView<Item = OuterViewPort<dyn SequenceView<Item = Item>>>>,
     chunks: BTreeMap<usize, Chunk<Item>>,
     cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = Item>>>>,
-    proj_helper: ProjectionHelper<usize, Self>
+    proj_helper: ProjectionHelper<usize, Self>,
 }
 
 impl<Item> View for Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     type Msg = usize;
 }
 
 impl<Item> SequenceView for Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     type Item = Item;
 
@@ -65,27 +67,25 @@ where Item: 'static
 
 /* TODO: remove unused projection args (bot-views) if they get replaced by a new viewport  */
 impl<Item> Flatten<Item>
-where Item: 'static
+where
+    Item: 'static,
 {
     pub fn new(
-        top_port: OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn SequenceView<Item = Item>>>>,
+        top_port: OuterViewPort<
-        out_port: InnerViewPort<dyn SequenceView<Item = Item>>
+            dyn SequenceView<Item = OuterViewPort<dyn SequenceView<Item = Item>>>,
+        >,
+        out_port: InnerViewPort<dyn SequenceView<Item = Item>>,
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
 
-        let flat = Arc::new(RwLock::new(
+        let flat = Arc::new(RwLock::new(Flatten {
-            Flatten {
             length: 0,
-                top: proj_helper.new_sequence_arg(
+            top: proj_helper.new_sequence_arg(usize::MAX, top_port, |s: &mut Self, chunk_idx| {
-                    usize::MAX,
-                    top_port,
-                    |s: &mut Self, chunk_idx| {
                 s.update_chunk(*chunk_idx);
-                    }
+            }),
-                ),
             chunks: BTreeMap::new(),
             cast: out_port.get_broadcast(),
-                proj_helper
+            proj_helper,
         }));
 
         flat.write().unwrap().proj_helper.set_proj(&flat);
@@ -118,9 +118,9 @@ where Item: 'static
                                 s.cast.notify(&(idx + chunk_offset));
                                 s.cast.notify_each(dirty_idx);
                             }
-                        }
+                        },
-                    )
+                    ),
-                }
+                },
             );
 
             chunk_port.0.update();
@@ -152,7 +152,7 @@ where Item: 'static
             if old_offset != cur_offset {
                 dirty_idx.extend(
                     std::cmp::min(old_offset, cur_offset)
-                        .. std::cmp::max(old_offset, cur_offset) + chunk.len
+                        ..std::cmp::max(old_offset, cur_offset) + chunk.len,
                 );
             }
 
@@ -179,4 +179,3 @@ where Item: 'static
         None
     }
 }
-

nested/src/sequence/map.rs

@@ -1,24 +1,18 @@
 use {
+    crate::{
+        core::{Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort},
+        sequence::SequenceView,
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    crate::{
-        sequence::{SequenceView},
-        core::{
-            Observer, ObserverExt, ObserverBroadcast,
-            View, ViewPort, OuterViewPort
-        }
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<Item: 'static> OuterViewPort<dyn SequenceView<Item = Item>> {
-    pub fn map<
+    pub fn map<DstItem: 'static, F: Fn(&Item) -> DstItem + Send + Sync + 'static>(
-        DstItem: 'static,
-        F: Fn(&Item) -> DstItem + Send + Sync + 'static
-    >(
         &self,
-        f: F
+        f: F,
     ) -> OuterViewPort<dyn SequenceView<Item = DstItem>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -26,7 +20,7 @@ impl<Item: 'static> OuterViewPort<dyn SequenceView<Item = Item>> {
         let map = Arc::new(RwLock::new(MapSequenceItem {
             src_view: None,
             f,
-            cast: port.inner().get_broadcast()
+            cast: port.inner().get_broadcast(),
         }));
 
         self.add_observer(map.clone());
@@ -36,10 +30,10 @@ impl<Item: 'static> OuterViewPort<dyn SequenceView<Item = Item>> {
 
     pub fn filter_map<
         DstItem: Clone + 'static,
-        F: Fn(&Item) -> Option<DstItem> + Send + Sync + 'static
+        F: Fn(&Item) -> Option<DstItem> + Send + Sync + 'static,
     >(
         &self,
-        f: F
+        f: F,
     ) -> OuterViewPort<dyn SequenceView<Item = DstItem>> {
         self.map(f)
             .filter(|x| x.is_some())
@@ -50,26 +44,29 @@ impl<Item: 'static> OuterViewPort<dyn SequenceView<Item = Item>> {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct MapSequenceItem<DstItem, SrcView, F>
-where SrcView: SequenceView + ?Sized,
+where
-      F: Fn(&SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SequenceView + ?Sized,
+    F: Fn(&SrcView::Item) -> DstItem + Send + Sync,
 {
     src_view: Option<Arc<SrcView>>,
     f: F,
-    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = DstItem>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = DstItem>>>>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<DstItem, SrcView, F> View for MapSequenceItem<DstItem, SrcView, F>
-where SrcView: SequenceView + ?Sized,
+where
-      F: Fn(&SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SequenceView + ?Sized,
+    F: Fn(&SrcView::Item) -> DstItem + Send + Sync,
 {
     type Msg = usize;
 }
 
 impl<DstItem, SrcView, F> SequenceView for MapSequenceItem<DstItem, SrcView, F>
-where SrcView: SequenceView + ?Sized,
+where
-      F: Fn(&SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SequenceView + ?Sized,
+    F: Fn(&SrcView::Item) -> DstItem + Send + Sync,
 {
     type Item = DstItem;
 
@@ -85,20 +82,24 @@ where SrcView: SequenceView + ?Sized,
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<DstItem, SrcView, F> Observer<SrcView> for MapSequenceItem<DstItem, SrcView, F>
-where SrcView: SequenceView + ?Sized,
+where
-      F: Fn(&SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SequenceView + ?Sized,
+    F: Fn(&SrcView::Item) -> DstItem + Send + Sync,
 {
     fn reset(&mut self, view: Option<Arc<SrcView>>) {
         let old_len = self.len();
         self.src_view = view;
         let new_len = self.len();
 
-        if let Some(len) = old_len { self.cast.notify_each(0 .. len ); }
+        if let Some(len) = old_len {
-        if let Some(len) = new_len { self.cast.notify_each(0 .. len ); }
+            self.cast.notify_each(0..len);
+        }
+        if let Some(len) = new_len {
+            self.cast.notify_each(0..len);
+        }
     }
 
     fn notify(&mut self, msg: &usize) {
         self.cast.notify(msg);
     }
 }
-

nested/src/sequence/mod.rs

@@ -1,10 +1,9 @@
-
-pub mod seq2idx;
-pub mod map;
 pub mod filter;
 pub mod flatten;
+pub mod map;
+pub mod seq2idx;
 
-pub use seq2idx::{Sequence2Index};
+pub use seq2idx::Sequence2Index;
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
@@ -21,10 +20,7 @@ pub trait SequenceView : View<Msg = usize> {
 
 pub trait SequenceViewExt: SequenceView {
     fn iter<'a>(&'a self) -> SequenceViewIter<'a, Self> {
-        SequenceViewIter {
+        SequenceViewIter { view: self, cur: 0 }
-            view: self,
-            cur: 0
-        }
     }
 }
 
@@ -33,14 +29,16 @@ impl<V: SequenceView + ?Sized> SequenceViewExt for V {}
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct SequenceViewIter<'a, V>
-where V: SequenceView + ?Sized
+where
+    V: SequenceView + ?Sized,
 {
     view: &'a V,
-    cur: usize
+    cur: usize,
 }
 
 impl<'a, V> Iterator for SequenceViewIter<'a, V>
-where V: SequenceView + ?Sized
+where
+    V: SequenceView + ?Sized,
 {
     type Item = V::Item;
 
@@ -53,11 +51,8 @@ where V: SequenceView + ?Sized
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-use std::{
-    sync::Arc,
-    ops::{Deref}
-};
 use std::sync::RwLock;
+use std::{ops::Deref, sync::Arc};
 
 impl<V: SequenceView + ?Sized> SequenceView for RwLock<V> {
     type Item = V::Item;
@@ -98,4 +93,3 @@ impl<V: SequenceView> SequenceView for Option<V> {
         }
     }
 }
-

nested/src/sequence/seq2idx.rs

@@ -1,37 +1,34 @@
 use {
-    std::{
-        sync::Arc
-    },
-    std::sync::RwLock,
     crate::{
-        core::{
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
-            View, Observer, ObserverBroadcast,
+        grid::GridView,
-            ViewPort, InnerViewPort, OuterViewPort
-        },
-        sequence::SequenceView,
         index::{IndexArea, IndexView},
-        grid::GridView
+        sequence::SequenceView,
-    }
+    },
+    std::sync::Arc,
+    std::sync::RwLock,
 };
 
 /// Transforms a SequenceView into IndexView<usize>
 pub struct Sequence2Index<SrcView>
-where SrcView: SequenceView + ?Sized + 'static {
+where
+    SrcView: SequenceView + ?Sized + 'static,
+{
     src_view: Option<Arc<SrcView>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<usize, Item = SrcView::Item>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<usize, Item = SrcView::Item>>>>,
 }
 
 impl<SrcView> Sequence2Index<SrcView>
-where SrcView: SequenceView + ?Sized + 'static {
+where
+    SrcView: SequenceView + ?Sized + 'static,
+{
     pub fn new(
-        port: InnerViewPort<dyn IndexView<usize, Item = SrcView::Item>>
+        port: InnerViewPort<dyn IndexView<usize, Item = SrcView::Item>>,
     ) -> Arc<RwLock<Self>> {
-        let s2i = Arc::new(RwLock::new(
+        let s2i = Arc::new(RwLock::new(Sequence2Index {
-            Sequence2Index {
             src_view: None,
-                cast: port.get_broadcast()
+            cast: port.get_broadcast(),
-            }
+        }));
-        ));
         port.set_view(Some(s2i.clone()));
         s2i
     }
@@ -55,12 +52,16 @@ impl<Item: 'static> OuterViewPort<dyn SequenceView<Item = Item>> {
 }
 
 impl<SrcView> View for Sequence2Index<SrcView>
-where SrcView: SequenceView + ?Sized + 'static {
+where
+    SrcView: SequenceView + ?Sized + 'static,
+{
     type Msg = IndexArea<usize>;
 }
 
 impl<SrcView> IndexView<usize> for Sequence2Index<SrcView>
-where SrcView: SequenceView + ?Sized + 'static {
+where
+    SrcView: SequenceView + ?Sized + 'static,
+{
     type Item = SrcView::Item;
 
     fn get(&self, key: &usize) -> Option<Self::Item> {
@@ -81,7 +82,9 @@ where SrcView: SequenceView + ?Sized + 'static {
 }
 
 impl<SrcView> Observer<SrcView> for Sequence2Index<SrcView>
-where SrcView: SequenceView + ?Sized + 'static {
+where
+    SrcView: SequenceView + ?Sized + 'static,
+{
     fn reset(&mut self, view: Option<Arc<SrcView>>) {
         let old_area = self.area();
         self.src_view = view;
@@ -94,4 +97,3 @@ where SrcView: SequenceView + ?Sized + 'static {
         self.cast.notify(&IndexArea::Set(vec![*idx]));
     }
 }
-

nested/src/singleton/buffer.rs

@@ -1,18 +1,13 @@
 use {
-    std::{
+    crate::{
-        sync::{Arc},
+        core::{InnerViewPort, Observer, ObserverBroadcast, View},
-        ops::{Deref, DerefMut}
+        singleton::SingletonView,
     },
     std::sync::RwLock,
-    crate::{
+    std::{
-        core::{
+        ops::{Deref, DerefMut},
-            Observer,
+        sync::Arc,
-            ObserverBroadcast,
-            View,
-            InnerViewPort
     },
-        singleton::{SingletonView}
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -20,12 +15,16 @@ use {
 pub struct SingletonBufferView<T: Clone + Send + Sync + 'static>(Arc<RwLock<T>>);
 
 impl<T> View for SingletonBufferView<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Msg = ();
 }
 
 impl<T> SingletonView for SingletonBufferView<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Item = T;
 
     fn get(&self) -> Self::Item {
@@ -37,23 +36,24 @@ where T: Clone + Send + Sync + 'static {
 
 #[derive(Clone)]
 pub struct SingletonBuffer<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     value: Arc<RwLock<T>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn SingletonView<Item = T>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn SingletonView<Item = T>>>>,
 }
 
 impl<T> SingletonBuffer<T>
-where T: Clone + Send + Sync + 'static {
+where
-    pub fn new(
+    T: Clone + Send + Sync + 'static,
-        value: T,
+{
-        port: InnerViewPort<dyn SingletonView<Item = T>>
+    pub fn new(value: T, port: InnerViewPort<dyn SingletonView<Item = T>>) -> Self {
-    ) -> Self {
         let value = Arc::new(RwLock::new(value));
         port.set_view(Some(Arc::new(SingletonBufferView(value.clone()))));
 
         SingletonBuffer {
             value,
-            cast: port.get_broadcast()
+            cast: port.get_broadcast(),
         }
     }
 
@@ -64,7 +64,7 @@ where T: Clone + Send + Sync + 'static {
     pub fn get_mut(&self) -> MutableSingletonAccess<T> {
         MutableSingletonAccess {
             buf: self.clone(),
-            val: self.get()
+            val: self.get(),
         }
     }
 
@@ -79,13 +79,17 @@ where T: Clone + Send + Sync + 'static {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct MutableSingletonAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     buf: SingletonBuffer<T>,
     val: T,
 }
 
 impl<T> Deref for MutableSingletonAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -94,17 +98,19 @@ where T: Clone + Send + Sync + 'static {
 }
 
 impl<T> DerefMut for MutableSingletonAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.val
     }
 }
 
 impl<T> Drop for MutableSingletonAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     fn drop(&mut self) {
         self.buf.set(self.val.clone());
     }
 }
-
-

nested/src/singleton/map.rs

@@ -1,24 +1,18 @@
 use {
+    crate::{
+        core::{Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
+        singleton::SingletonView,
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    crate::{
-        singleton::{SingletonView},
-        core::{
-            Observer, ObserverBroadcast,
-            View, ViewPort, OuterViewPort
-        }
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
-    pub fn map<
+    pub fn map<DstItem: 'static, F: Fn(Item) -> DstItem + Send + Sync + 'static>(
-        DstItem: 'static,
-        F: Fn(Item) -> DstItem + Send + Sync + 'static
-    >(
         &self,
-        f: F
+        f: F,
     ) -> OuterViewPort<dyn SingletonView<Item = DstItem>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -26,7 +20,7 @@ impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
         let map = Arc::new(RwLock::new(MapSingleton {
             src_view: None,
             f,
-            cast: port.inner().get_broadcast()
+            cast: port.inner().get_broadcast(),
         }));
 
         self.add_observer(map.clone());
@@ -38,26 +32,29 @@ impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct MapSingleton<DstItem, SrcView, F>
-where SrcView: SingletonView + ?Sized,
+where
-      F: Fn(SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SingletonView + ?Sized,
+    F: Fn(SrcView::Item) -> DstItem + Send + Sync,
 {
     src_view: Option<Arc<SrcView>>,
     f: F,
-    cast: Arc<RwLock<ObserverBroadcast<dyn SingletonView<Item = DstItem>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn SingletonView<Item = DstItem>>>>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<DstItem, SrcView, F> View for MapSingleton<DstItem, SrcView, F>
-where SrcView: SingletonView + ?Sized,
+where
-      F: Fn(SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SingletonView + ?Sized,
+    F: Fn(SrcView::Item) -> DstItem + Send + Sync,
 {
     type Msg = ();
 }
 
 impl<DstItem, SrcView, F> SingletonView for MapSingleton<DstItem, SrcView, F>
-where SrcView: SingletonView + ?Sized,
+where
-      F: Fn(SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SingletonView + ?Sized,
+    F: Fn(SrcView::Item) -> DstItem + Send + Sync,
 {
     type Item = DstItem;
 
@@ -69,8 +66,9 @@ where SrcView: SingletonView + ?Sized,
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<DstItem, SrcView, F> Observer<SrcView> for MapSingleton<DstItem, SrcView, F>
-where SrcView: SingletonView + ?Sized,
+where
-      F: Fn(SrcView::Item) -> DstItem + Send + Sync
+    SrcView: SingletonView + ?Sized,
+    F: Fn(SrcView::Item) -> DstItem + Send + Sync,
 {
     fn reset(&mut self, view: Option<Arc<SrcView>>) {
         self.src_view = view;
@@ -81,4 +79,3 @@ where SrcView: SingletonView + ?Sized,
         self.cast.notify(msg);
     }
 }
-

nested/src/singleton/mod.rs

@@ -1,16 +1,12 @@
-
 pub mod buffer;
 pub mod map;
 pub mod to_index;
 //pub mod unwrap;
 
 use {
-    std::{
+    crate::core::View,
-        sync::Arc,
-        ops::Deref
-    },
     std::sync::RwLock,
-    crate::core::{View}
+    std::{ops::Deref, sync::Arc},
 };
 
 pub use buffer::SingletonBuffer;
@@ -41,7 +37,9 @@ impl<V: SingletonView + ?Sized> SingletonView for Arc<V> {
 }
 
 impl<V: SingletonView> SingletonView for Option<V>
-where V::Item: Default{
+where
+    V::Item: Default,
+{
     type Item = V::Item;
 
     fn get(&self) -> Self::Item {
@@ -65,4 +63,3 @@ impl<T> OuterViewPort<dyn SingletonView<Item = T>> {
     }
 }
  */
-

nested/src/singleton/to_index.rs

@@ -1,15 +1,12 @@
 use {
+    crate::{
+        core::{Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
+        grid::GridView,
+        index::{IndexArea, IndexView},
+        singleton::SingletonView,
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    crate::{
-        singleton::{SingletonView},
-        index::{IndexArea, IndexView},
-        grid::{GridView},
-        core::{
-            Observer, ObserverBroadcast,
-            View, ViewPort, OuterViewPort
-        }
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -21,7 +18,7 @@ impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
 
         let map = Arc::new(RwLock::new(Singleton2Index {
             src_view: None,
-            cast: port.inner().get_broadcast()
+            cast: port.inner().get_broadcast(),
         }));
 
         self.add_observer(map.clone());
@@ -30,10 +27,15 @@ impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
     }
 
     pub fn to_grid(&self) -> OuterViewPort<dyn GridView<Item = Item>> {
-        self.to_index()
+        self.to_index().map_key(
-            .map_key(
             |_msg: &()| cgmath::Point2::new(0, 0),
-                |pt| if pt.x == 0 && pt.y == 0 { Some(()) } else { None }
+            |pt| {
+                if pt.x == 0 && pt.y == 0 {
+                    Some(())
+                } else {
+                    None
+                }
+            },
         )
     }
 }
@@ -41,22 +43,25 @@ impl<Item: 'static> OuterViewPort<dyn SingletonView<Item = Item>> {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct Singleton2Index<SrcView>
-where SrcView: SingletonView + ?Sized
+where
+    SrcView: SingletonView + ?Sized,
 {
     src_view: Option<Arc<SrcView>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<(), Item = SrcView::Item>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn IndexView<(), Item = SrcView::Item>>>>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<SrcView> View for Singleton2Index<SrcView>
-where SrcView: SingletonView + ?Sized
+where
+    SrcView: SingletonView + ?Sized,
 {
     type Msg = IndexArea<()>;
 }
 
 impl<SrcView> IndexView<()> for Singleton2Index<SrcView>
-where SrcView: SingletonView + ?Sized
+where
+    SrcView: SingletonView + ?Sized,
 {
     type Item = SrcView::Item;
 
@@ -72,7 +77,8 @@ where SrcView: SingletonView + ?Sized
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<SrcView> Observer<SrcView> for Singleton2Index<SrcView>
-where SrcView: SingletonView + ?Sized
+where
+    SrcView: SingletonView + ?Sized,
 {
     fn reset(&mut self, view: Option<Arc<SrcView>>) {
         self.src_view = view;
@@ -83,4 +89,3 @@ where SrcView: SingletonView + ?Sized
         self.cast.notify(&IndexArea::Full);
     }
 }
-

nested/src/string_editor.rs

@@ -1,30 +1,32 @@
 use {
+    crate::{
+        core::{OuterViewPort, ViewPort},
+        list::{sexpr::ListDecoration, ListEditor},
+        sequence::SequenceView,
+        singleton::{SingletonBuffer, SingletonView},
+        terminal::{
+            TerminalEditor, TerminalEditorResult, TerminalEvent, TerminalStyle, TerminalView,
+        },
+        tree_nav::{TreeCursor, TreeNav, TreeNavResult},
+    },
     std::sync::Arc,
     std::sync::RwLock,
-    termion::event::{Key, Event},
+    termion::event::{Event, Key},
-    crate::{
-        core::{ViewPort, OuterViewPort},
-        singleton::{SingletonView, SingletonBuffer},
-        sequence::{SequenceView},
-        terminal::{TerminalView, TerminalStyle, TerminalEvent, TerminalEditor, TerminalEditorResult},
-        list::{ListEditor, sexpr::ListDecoration},
-        tree_nav::{TreeNav, TreeNavResult, TreeCursor}
-    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct CharEditor {
     data: SingletonBuffer<Option<char>>,
-    data_port: ViewPort<dyn SingletonView<Item = Option<char>>>
+    data_port: ViewPort<dyn SingletonView<Item = Option<char>>>,
 }
 
 impl CharEditor {
     pub fn new() -> Self {
-        let mut data_port = ViewPort::new();
+        let data_port = ViewPort::new();
         CharEditor {
             data: SingletonBuffer::new(None, data_port.inner()),
-            data_port
+            data_port,
         }
     }
 
@@ -36,8 +38,7 @@ impl CharEditor {
 impl TreeNav for CharEditor {}
 impl TerminalEditor for CharEditor {
     fn get_term_view(&self) -> OuterViewPort<dyn TerminalView> {
-        crate::terminal::make_label(
+        crate::terminal::make_label(&if let Some(c) = self.data.get() {
-            &if let Some(c) = self.data.get() {
             c.to_string()
         } else {
             "".to_string()
@@ -46,18 +47,17 @@ impl TerminalEditor for CharEditor {
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
         match event {
-            TerminalEvent::Input(Event::Key(Key::Char('\n'))) =>
+            TerminalEvent::Input(Event::Key(Key::Char('\n'))) => TerminalEditorResult::Continue,
-                TerminalEditorResult::Continue,
             TerminalEvent::Input(Event::Key(Key::Char(c))) => {
                 self.data.set(Some(*c));
                 TerminalEditorResult::Exit
             }
-            TerminalEvent::Input(Event::Key(Key::Backspace)) |
+            TerminalEvent::Input(Event::Key(Key::Backspace))
-            TerminalEvent::Input(Event::Key(Key::Delete)) => {
+            | TerminalEvent::Input(Event::Key(Key::Delete)) => {
                 self.data.set(None);
                 TerminalEditorResult::Exit
             }
-            _ => TerminalEditorResult::Continue
+            _ => TerminalEditorResult::Continue,
         }
     }
 }
@@ -65,41 +65,52 @@ impl TerminalEditor for CharEditor {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct StringEditor {
-    chars_editor: ListEditor< CharEditor,
+    chars_editor:
-                              Box<dyn Fn() -> Arc<RwLock<CharEditor>> + Send + Sync + 'static> >
+        ListEditor<CharEditor, Box<dyn Fn() -> Arc<RwLock<CharEditor>> + Send + Sync + 'static>>,
 }
 
 impl StringEditor {
     pub fn new() -> Self {
         StringEditor {
             chars_editor: ListEditor::new(
-                Box::new(
+                Box::new(move || Arc::new(RwLock::new(CharEditor::new()))),
-                    move || {
+                crate::list::ListEditorStyle::String,
-                        Arc::new(RwLock::new(CharEditor::new()))
-                    }
             ),
-                crate::list::ListEditorStyle::String
-            )
         }
     }
 
     pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = char>> {
-        self.chars_editor.get_data_port()
+        self.chars_editor
-            .map(
+            .get_data_port()
-                |char_editor| char_editor.read().unwrap().data.get().unwrap()
+            .map(|char_editor| char_editor.read().unwrap().data.get().unwrap())
-            )
     }
 }
 
 impl TreeNav for StringEditor {
-    fn get_cursor(&self) -> TreeCursor { self.chars_editor.get_cursor() }
+    fn get_cursor(&self) -> TreeCursor {
-    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult  { self.chars_editor.goto(cur) }
+        self.chars_editor.get_cursor()
-    fn goto_home(&mut self) -> TreeNavResult  { self.chars_editor.goto_home() }
+    }
-    fn goto_end(&mut self) -> TreeNavResult  { self.chars_editor.goto_end() }
+    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult {
-    fn pxev(&mut self) -> TreeNavResult  { self.chars_editor.pxev() }
+        self.chars_editor.goto(cur)
-    fn nexd(&mut self) -> TreeNavResult  { self.chars_editor.nexd() }
+    }
-    fn up(&mut self) -> TreeNavResult { self.chars_editor.up() }
+    fn goto_home(&mut self) -> TreeNavResult {
-    fn dn(&mut self) -> TreeNavResult { TreeNavResult::Exit }
+        self.chars_editor.goto_home()
+    }
+    fn goto_end(&mut self) -> TreeNavResult {
+        self.chars_editor.goto_end()
+    }
+    fn pxev(&mut self) -> TreeNavResult {
+        self.chars_editor.pxev()
+    }
+    fn nexd(&mut self) -> TreeNavResult {
+        self.chars_editor.nexd()
+    }
+    fn up(&mut self) -> TreeNavResult {
+        self.chars_editor.up()
+    }
+    fn dn(&mut self) -> TreeNavResult {
+        TreeNavResult::Exit
+    }
 }
 
 impl TerminalEditor for StringEditor {
@@ -109,10 +120,7 @@ impl TerminalEditor for StringEditor {
             .decorate("\"", "\"", "", 1)
             .to_grid_horizontal()
             .flatten()
-            .map_item(
+            .map_item(|_idx, atom| atom.add_style_back(TerminalStyle::fg_color((120, 200, 10))))
-                |_idx, atom|
-                atom.add_style_back(TerminalStyle::fg_color((120, 200, 10)))
-            )
     }
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
@@ -121,8 +129,7 @@ impl TerminalEditor for StringEditor {
                 self.chars_editor.up();
                 TerminalEditorResult::Exit
             }
-            event => self.chars_editor.handle_terminal_event(event)
+            event => self.chars_editor.handle_terminal_event(event),
         }
     }
 }
-

nested/src/terminal/ansi_parser.rs

@@ -1,37 +1,25 @@
 use {
-    std::{
-        sync::{Arc, RwLock},
-        pin::Pin,
-        fs::File,
-        os::unix::io::FromRawFd
-    },
-    std::io::Read,
     //async_std::{io::{Read, ReadExt}},
     crate::{
-        core::{View, InnerViewPort, OuterViewPort, ViewPort, Observer, ObserverBroadcast},
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View, ViewPort},
+        index::{buffer::IndexBuffer, IndexArea, IndexView},
         projection::ProjectionHelper,
-        terminal::{
+        singleton::{SingletonBuffer, SingletonView},
-            TerminalAtom,
+        terminal::{TerminalAtom, TerminalStyle, TerminalView},
-            TerminalStyle,
-            TerminalView
     },
-        singleton::{
+    cgmath::{Point2, Vector2},
-            SingletonBuffer,
+    std::io::Read,
-            SingletonView
+    std::sync::{Arc, RwLock},
-        },
+    vte::{Params, Parser, Perform},
-        index::{
-            buffer::IndexBuffer,
-            IndexView,
-            IndexArea
-        }
-    },
-    cgmath::{Vector2, Point2},
-    vte::{Params, Parser, Perform}
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub fn read_ansi_from<R: Read + Unpin>(ansi_reader: &mut R, max_size: Vector2<i16>, port: InnerViewPort<dyn TerminalView>) {
+pub fn read_ansi_from<R: Read + Unpin>(
+    ansi_reader: &mut R,
+    max_size: Vector2<i16>,
+    port: InnerViewPort<dyn TerminalView>,
+) {
     let mut statemachine = Parser::new();
 
     let buf_port = ViewPort::new();
@@ -56,17 +44,16 @@ pub fn read_ansi_from<R: Read + Unpin>(ansi_reader: &mut R, max_size: Vector2<i1
             blue: (0, 111, 184),
             magenta: (118, 38, 113),
             cyan: (44, 181, 233),
-            white: (204, 204, 204)
+            white: (204, 204, 204),
         },
 
-        pty_proj: PtyView::new(
+        _pty_proj: PtyView::new(
             buf_port.outer(),
             cursor_port.outer().map(|x| Some(x)),
             offset_port.outer().map(|x| Some(x)),
             size_port.outer().map(|x| Some(x)),
-
+            port,
-            port
+        ),
-        )
     };
 
     let mut buf = [0; 2048];
@@ -78,11 +65,11 @@ pub fn read_ansi_from<R: Read + Unpin>(ansi_reader: &mut R, max_size: Vector2<i1
                 for byte in &buf[..n] {
                     statemachine.advance(&mut performer, *byte);
                 }
-            },
+            }
-            Err(err) => {
+            Err(_err) => {
                 //println!("err: {}", err);
                 break;
-            },
+            }
         }
     }
 }
@@ -93,14 +80,22 @@ enum TTYColor {
     Rgb(u8, u8, u8),
 
     // 3-Bit/4-Bit colors
-    Black,  LightBlack,
+    Black,
-    Red,    LightRed,
+    LightBlack,
-    Green,  LightGreen,
+    Red,
-    Yellow, LightYellow,
+    LightRed,
-    Blue,   LightBlue,
+    Green,
-    Magenta,LightMagenta,
+    LightGreen,
-    Cyan,   LightCyan,
+    Yellow,
-    White,  LightWhite,
+    LightYellow,
+    Blue,
+    LightBlue,
+    Magenta,
+    LightMagenta,
+    Cyan,
+    LightCyan,
+    White,
+    LightWhite,
 }
 
 struct ColorPalett {
@@ -146,7 +141,7 @@ struct PtyView {
     max_pt: Point2<i16>,
 
     cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
-    proj_helper: ProjectionHelper<usize, Self>
+    proj_helper: ProjectionHelper<usize, Self>,
 }
 
 impl View for PtyView {
@@ -166,7 +161,10 @@ impl IndexView<Point2<i16>> for PtyView {
                 a.style.bg_color = Some(bg_col);
                 Some(a)
             } else {
-                Some(TerminalAtom::new(' ', TerminalStyle::bg_color((255, 255, 255))))
+                Some(TerminalAtom::new(
+                    ' ',
+                    TerminalStyle::bg_color((255, 255, 255)),
+                ))
             }
         } else {
             atom
@@ -174,10 +172,13 @@ impl IndexView<Point2<i16>> for PtyView {
     }
 
     fn area(&self) -> IndexArea<Point2<i16>> {
-        IndexArea::Range(Point2::new(0, 0) ..= Point2::new(
+        IndexArea::Range(
+            Point2::new(0, 0)
+                ..=Point2::new(
                     std::cmp::max(self.old_curpos.x, self.max_pt.x),
-            std::cmp::max(self.old_curpos.y, self.max_pt.y)
+                    std::cmp::max(self.old_curpos.y, self.max_pt.y),
-        ))
+                ),
+        )
     }
 }
 
@@ -188,29 +189,22 @@ impl PtyView {
         offset_port: OuterViewPort<dyn SingletonView<Item = Option<Vector2<i16>>>>,
         size_port: OuterViewPort<dyn SingletonView<Item = Option<Vector2<i16>>>>,
 
-        out_port: InnerViewPort<dyn TerminalView>
+        out_port: InnerViewPort<dyn TerminalView>,
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
-        let proj = Arc::new(RwLock::new(
+        let proj = Arc::new(RwLock::new(PtyView {
-                PtyView {
             old_curpos: Point2::new(0, 0),
             old_size: Vector2::new(0, 0),
             old_offset: Vector2::new(0, 0),
             max_pt: Point2::new(0, 0),
 
-                    curpos: proj_helper.new_singleton_arg(
+            curpos: proj_helper.new_singleton_arg(0, curpos_port, |s: &mut Self, _msg| {
-                        0,
-                        curpos_port,
-                        |s: &mut Self, _msg| {
                 s.cast.notify(&IndexArea::Set(vec![s.old_curpos]));
                 s.old_curpos = s.curpos.get().unwrap_or(Point2::new(0, 0));
                 s.cast.notify(&IndexArea::Set(vec![s.old_curpos]));
             }),
 
-                    offset: proj_helper.new_singleton_arg(
+            offset: proj_helper.new_singleton_arg(1, offset_port, |s: &mut Self, _msg| {
-                        1,
-                        offset_port,
-                        |s: &mut Self, _msg| {
                 // todo
                 let new_offset = s.offset.get().unwrap_or(Vector2::new(0, 0));
                 if s.old_offset != new_offset {
@@ -219,10 +213,7 @@ impl PtyView {
                 }
             }),
 
-                    size: proj_helper.new_singleton_arg(
+            size: proj_helper.new_singleton_arg(2, size_port, |s: &mut Self, _msg| {
-                        2,
-                        size_port,
-                        |s: &mut Self, _msg| {
                 let new_size = s.size.get().unwrap_or(Vector2::new(0, 0));
                 if s.old_size != new_size {
                     s.old_size = new_size;
@@ -230,16 +221,9 @@ impl PtyView {
                 }
             }),
 
-                    buf: proj_helper.new_index_arg(
+            buf: proj_helper.new_index_arg(3, buf_port, |s: &mut Self, area| {
-                        3,
-                        buf_port,
-                        |s: &mut Self, area| {
                 let size = s.old_size;
-                            let area = area.map(
+                let area = area.map(|pt| *pt - s.old_offset);
-                                |pt| {
-                                    *pt - s.old_offset
-                                }
-                            );
 
                 if s.max_pt.x < size.x || s.max_pt.y < size.y {
                     match &area {
@@ -264,9 +248,8 @@ impl PtyView {
             }),
 
             cast: out_port.get_broadcast(),
-                    proj_helper
+            proj_helper,
-                }
+        }));
-            ));
 
         proj.write().unwrap().proj_helper.set_proj(&proj);
         out_port.set_view(Some(proj.clone()));
@@ -288,12 +271,12 @@ struct PerfAtom {
 
     colors: ColorPalett,
 
-    pty_proj: Arc<RwLock<PtyView>>
+    _pty_proj: Arc<RwLock<PtyView>>,
 }
 
 impl PerfAtom {
     fn write_atom(&mut self, pos: Point2<i16>, atom: Option<TerminalAtom>) {
-        if let Some(mut a) = atom {
+        if let Some(a) = atom {
             self.buf.insert(pos + self.offset.get(), a);
         } else {
             self.buf.remove(pos);
@@ -310,11 +293,15 @@ impl PerfAtom {
     }
 
     fn set_fg_color(&mut self, col: &TTYColor) {
-        self.cursty = self.cursty.add(TerminalStyle::fg_color(self.colors.get_rgb(col)));
+        self.cursty = self
+            .cursty
+            .add(TerminalStyle::fg_color(self.colors.get_rgb(col)));
     }
 
     fn set_bg_color(&mut self, col: &TTYColor) {
-        self.cursty = self.cursty.add(TerminalStyle::bg_color(self.colors.get_rgb(col)));
+        self.cursty = self
+            .cursty
+            .add(TerminalStyle::bg_color(self.colors.get_rgb(col)));
     }
 
     fn linefeed(&mut self) {
@@ -372,7 +359,7 @@ impl PerfAtom {
 
     fn cursor_pxev(&mut self, n: usize) {
         let mut c = self.cursor.get_mut();
-        let s = self.size.get();
+        let _s = self.size.get();
 
         if c.y - (n as i16) >= 0 {
             c.y -= n as i16;
@@ -392,7 +379,7 @@ impl PerfAtom {
         }
     }
 
-    fn insert_blank_lines(&mut self, n: usize) {
+    fn insert_blank_lines(&mut self, _n: usize) {
         //eprintln!("insert blank lines");
     }
 
@@ -437,7 +424,7 @@ impl Perform for PerfAtom {
         }
     }
 
-    fn hook(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
+    fn hook(&mut self, _params: &Params, _intermediates: &[u8], _ignore: bool, _c: char) {
         /*
         eprintln!(
             "[hook] params={:?}, intermediates={:?}, ignore={:?}, char={:?}",
@@ -446,7 +433,7 @@ impl Perform for PerfAtom {
          */
     }
 
-    fn put(&mut self, byte: u8) {
+    fn put(&mut self, _byte: u8) {
         /*
         eprintln!("[put] {:02x}", byte);
          */
@@ -456,7 +443,7 @@ impl Perform for PerfAtom {
         //eprintln!("[unhook]");
     }
 
-    fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
+    fn osc_dispatch(&mut self, params: &[&[u8]], _bell_terminated: bool) {
         //eprintln!("[osc_dispatch] params={:?} bell_terminated={}", params, bell_terminated);
 
         match params[0] {
@@ -465,17 +452,18 @@ impl Perform for PerfAtom {
             // Reset background color
             b"111" => self.set_bg_color(&TTYColor::Black),
             // Reset text cursor color
-            b"112" => {},
+            b"112" => {}
 
             _ => {}
         }
     }
 
-    fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
+    fn csi_dispatch(&mut self, params: &Params, _intermediates: &[u8], _ignore: bool, c: char) {
         let mut piter = params.into_iter();
         match c {
             // Set SGR
-            'm' =>  while let Some(n) = piter.next() {
+            'm' => {
+                while let Some(n) = piter.next() {
                     match n[0] {
                         0 => {
                             self.cursty = TerminalStyle::default();
@@ -528,15 +516,15 @@ impl Perform for PerfAtom {
                                     let g = piter.next().unwrap()[0] as u8;
                                     let b = piter.next().unwrap()[0] as u8;
                                     self.set_fg_color(&TTYColor::Rgb(r, g, b));
-                            },
+                                }
                                 5 => {
                                     let v = piter.next().unwrap();
                                     let rgb = ansi_colours::rgb_from_ansi256(v[0] as u8);
                                     self.set_fg_color(&TTYColor::Rgb(rgb.0, rgb.1, rgb.2));
-                            },
+                                }
                                 _ => {}
                             }
-                    },
+                        }
                         48 => {
                             let x = piter.next().unwrap();
                             match x[0] {
@@ -545,27 +533,32 @@ impl Perform for PerfAtom {
                                     let g = piter.next().unwrap()[0] as u8;
                                     let b = piter.next().unwrap()[0] as u8;
                                     self.set_bg_color(&TTYColor::Rgb(r, g, b));
-                            },
+                                }
                                 5 => {
                                     let v = piter.next().unwrap();
                                     let rgb = ansi_colours::rgb_from_ansi256(v[0] as u8);
                                     self.set_bg_color(&TTYColor::Rgb(rgb.0, rgb.1, rgb.2));
-                            },
+                                }
                                 _ => {}
                             }
-                    },
+                        }
 
                         _ => {}
                     }
                 }
+            }
             '@' => {
                 let n = piter.next().unwrap_or(&[1])[0] as usize;
                 for _ in 0..n {
                     self.print(' ');
                 }
             }
-            'A' => { self.cursor_up(piter.next().unwrap_or(&[1])[0] as usize); }
+            'A' => {
-            'B' => { self.cursor_dn(piter.next().unwrap_or(&[1])[0] as usize); }
+                self.cursor_up(piter.next().unwrap_or(&[1])[0] as usize);
+            }
+            'B' => {
+                self.cursor_dn(piter.next().unwrap_or(&[1])[0] as usize);
+            }
             'C' | 'a' => {
                 self.cursor_nexd(piter.next().unwrap_or(&[1])[0] as usize);
             }
@@ -587,7 +580,6 @@ impl Perform for PerfAtom {
                 let mut c = self.cursor.get_mut();
                 c.x = 0;
                 c.y -= piter.next().unwrap_or(&[1])[0] as i16;
-                
             }
             'G' | '`' => {
                 self.cursor.get_mut().x = piter.next().unwrap_or(&[1])[0] as i16 - 1;
@@ -600,7 +592,6 @@ impl Perform for PerfAtom {
             'J' => {
                 let x = piter.next().unwrap_or(&[0 as u16; 1]);
                 match x[0] {
-
                     // clear from cursor until end of screen
                     0 => {
                         let mut pos = self.cursor.get();
@@ -613,7 +604,7 @@ impl Perform for PerfAtom {
                                 pos.y += 1;
                             }
                         }
-                    },
+                    }
 
                     // clear from cursor to begin
                     1 => {
@@ -649,30 +640,38 @@ impl Perform for PerfAtom {
             'K' => {
                 let x = piter.next().unwrap_or(&[0]);
                 match x[0] {
-
                     // clear from cursor until end of line
                     0 => {
                         let c = self.cursor.get();
                         for x in c.x..self.size.get().x {
-                            self.write_atom(Point2::new(x, c.y), Some(TerminalAtom::new(' ', self.get_style())));
+                            self.write_atom(
+                                Point2::new(x, c.y),
+                                Some(TerminalAtom::new(' ', self.get_style())),
+                            );
+                        }
                     }
-                    },
 
                     // clear from start of line until cursor
                     1 => {
                         let c = self.cursor.get();
                         for x in 0..c.x {
-                            self.write_atom(Point2::new(x, c.y), Some(TerminalAtom::new(' ', self.get_style())));
+                            self.write_atom(
+                                Point2::new(x, c.y),
+                                Some(TerminalAtom::new(' ', self.get_style())),
+                            );
+                        }
                     }
-                    },
 
                     // clear entire line
                     2 => {
                         let c = self.cursor.get();
                         for x in 0..self.size.get().x {
-                            self.write_atom(Point2::new(x, c.y), Some(TerminalAtom::new(' ', self.get_style())));
+                            self.write_atom(
+                                Point2::new(x, c.y),
+                                Some(TerminalAtom::new(' ', self.get_style())),
+                            );
+                        }
                     }
-                    },
 
                     // invalid
                     _ => {}
@@ -704,14 +703,25 @@ impl Perform for PerfAtom {
                 //eprintln!("delete chars");
                 let c = self.cursor.get();
                 for x in 0..piter.next().unwrap_or(&[1])[0] {
-                    self.write_atom(Point2::new(c.x + x as i16, c.y), Some(TerminalAtom::new(' ', self.get_style())));
+                    self.write_atom(
+                        Point2::new(c.x + x as i16, c.y),
+                        Some(TerminalAtom::new(' ', self.get_style())),
+                    );
                 }
             }
 
-            'S' => { self.scroll_up(piter.next().unwrap_or(&[1])[0] as usize); }
+            'S' => {
-            'T' => { self.scroll_dn(piter.next().unwrap_or(&[1])[0] as usize); }
+                self.scroll_up(piter.next().unwrap_or(&[1])[0] as usize);
-            's' => { self.save_cursor_position(); }
+            }
-            'u' => { self.restore_cursor_position(); }            
+            'T' => {
+                self.scroll_dn(piter.next().unwrap_or(&[1])[0] as usize);
+            }
+            's' => {
+                self.save_cursor_position();
+            }
+            'u' => {
+                self.restore_cursor_position();
+            }
             _ => {
                 /*
                                 eprintln!(
@@ -723,14 +733,14 @@ impl Perform for PerfAtom {
         }
     }
 
-    fn esc_dispatch(&mut self, intermediates: &[u8], ignore: bool, byte: u8) {
+    fn esc_dispatch(&mut self, intermediates: &[u8], _ignore: bool, byte: u8) {
         match (byte, intermediates) {
             //(b'B', intermediates) => configure_charset!(StandardCharset::Ascii, intermediates),
             (b'D', []) => self.linefeed(),
             (b'E', []) => {
                 self.linefeed();
                 self.carriage_return();
-            },
+            }
             /*
                         (b'H', []) => self.handler.set_horizontal_tabstop(),
                         (b'M', []) => self.handler.reverse_index(),
@@ -760,5 +770,3 @@ impl Perform for PerfAtom {
         }
     }
 }
-
-

nested/src/terminal/atom.rs

@@ -1,12 +1,12 @@
 use {
     super::TerminalStyle,
-    serde::{Serialize, Deserialize}
+    serde::{Deserialize, Serialize},
 };
 
 #[derive(Clone, Copy, Serialize, Deserialize, Debug)]
 pub struct TerminalAtom {
     pub c: Option<char>,
-    pub style: TerminalStyle
+    pub style: TerminalStyle,
 }
 
 impl TerminalAtom {
@@ -15,7 +15,10 @@ impl TerminalAtom {
     }
 
     pub fn new_bg(bg_color: (u8, u8, u8)) -> Self {
-        TerminalAtom { c: None, style: TerminalStyle::bg_color(bg_color) }
+        TerminalAtom {
+            c: None,
+            style: TerminalStyle::bg_color(bg_color),
+        }
     }
 
     pub fn add_style_front(mut self, style: TerminalStyle) -> Self {
@@ -33,7 +36,7 @@ impl From<char> for TerminalAtom {
     fn from(c: char) -> Self {
         TerminalAtom {
             c: Some(c),
-            style: TerminalStyle::default()
+            style: TerminalStyle::default(),
         }
     }
 }
@@ -42,7 +45,7 @@ impl From<Option<char>> for TerminalAtom {
     fn from(c: Option<char>) -> Self {
         TerminalAtom {
             c,
-            style: TerminalStyle::default()
+            style: TerminalStyle::default(),
         }
     }
 }
@@ -51,8 +54,7 @@ impl From<&char> for TerminalAtom {
     fn from(c: &char) -> Self {
         TerminalAtom {
             c: Some(*c),
-            style: TerminalStyle::default()
+            style: TerminalStyle::default(),
         }
     }
 }
-

nested/src/terminal/compositor.rs

@@ -1,15 +1,13 @@
 use {
-    std::{
-        sync::{Arc}
-    },
-    std::sync::RwLock,
-    cgmath::Point2,
     crate::{
-        core::{InnerViewPort, OuterViewPort, View, Observer, ObserverBroadcast},
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View},
         index::{IndexArea, IndexView},
+        projection::ProjectionHelper,
         terminal::{TerminalAtom, TerminalView},
-        projection::ProjectionHelper
+    },
-    }
+    cgmath::Point2,
+    std::sync::Arc,
+    std::sync::RwLock,
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -17,22 +15,18 @@ use {
 pub struct TerminalCompositor {
     layers: Vec<Arc<dyn TerminalView>>,
     cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
-    proj_helper: ProjectionHelper<usize, Self>
+    proj_helper: ProjectionHelper<usize, Self>,
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl TerminalCompositor {
-    pub fn new(
+    pub fn new(port: InnerViewPort<dyn TerminalView>) -> Arc<RwLock<Self>> {
-        port: InnerViewPort<dyn TerminalView>
+        let comp = Arc::new(RwLock::new(TerminalCompositor {
-    ) -> Arc<RwLock<Self>> {
-        let comp = Arc::new(RwLock::new(
-            TerminalCompositor {
             layers: Vec::new(),
             cast: port.get_broadcast(),
-                proj_helper: ProjectionHelper::new(port.0.update_hooks.clone())
+            proj_helper: ProjectionHelper::new(port.0.update_hooks.clone()),
-            }
+        }));
-        ));
 
         comp.write().unwrap().proj_helper.set_proj(&comp);
         port.set_view(Some(comp.clone()));
@@ -43,13 +37,10 @@ impl TerminalCompositor {
     pub fn push(&mut self, v: OuterViewPort<dyn TerminalView>) {
         let idx = self.layers.len();
         self.layers.push(
-            self.proj_helper.new_index_arg(
+            self.proj_helper
-                idx,
+                .new_index_arg(idx, v, |s: &mut Self, area| {
-                v,
-                |s: &mut Self, area| {
                     s.cast.notify(area);
-                }
+                }),
-            )
         );
     }
 }
@@ -87,4 +78,3 @@ impl IndexView<Point2<i16>> for TerminalCompositor {
         area
     }
 }
-

nested/src/terminal/mod.rs

@@ -1,21 +1,17 @@
-pub mod style;
-pub mod atom;
-pub mod terminal;
-pub mod compositor;
 pub mod ansi_parser;
+pub mod atom;
+pub mod compositor;
+pub mod style;
+pub mod terminal;
 
 pub use {
-    style::{TerminalStyle},
+    atom::TerminalAtom,
-    atom::{TerminalAtom},
-    terminal::{Terminal, TerminalEvent},
     compositor::TerminalCompositor,
+    style::TerminalStyle,
+    terminal::{Terminal, TerminalEvent},
 };
 
-use {
+use crate::grid::GridView;
-    crate::{
-        grid::GridView
-    }
-};
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
@@ -25,7 +21,7 @@ pub trait TerminalView = GridView<Item = TerminalAtom>;
 
 pub enum TerminalEditorResult {
     Continue,
-    Exit
+    Exit,
 }
 
 pub trait TerminalEditor {
@@ -37,25 +33,25 @@ pub trait TerminalEditor {
 
 use {
     crate::{
+        core::{OuterViewPort, ViewPort},
         vec::VecBuffer,
-        core::{ViewPort, OuterViewPort}
     },
-    cgmath::Point2
+    cgmath::Point2,
 };
 
 pub fn make_label(s: &str) -> OuterViewPort<dyn TerminalView> {
     let label_port = ViewPort::new();
-    let mut label = VecBuffer::with_data(s.chars().collect(), label_port.inner());
+    let _label = VecBuffer::with_data(s.chars().collect(), label_port.inner());
 
-    let v = label_port.outer()
+    let v = label_port
+        .outer()
         .to_sequence()
         .map(|c| TerminalAtom::from(c))
         .to_index()
         .map_key(
             |idx| Point2::new(*idx as i16, 0),
-            |pt| if pt.y == 0 { Some(pt.x as usize) } else { None }
+            |pt| if pt.y == 0 { Some(pt.x as usize) } else { None },
         );
 
     v
 }
-

nested/src/terminal/style.rs

@@ -1,4 +1,4 @@
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 #[derive(Default, Copy, Clone, PartialEq, Serialize, Deserialize, Debug)]
 pub struct TerminalStyle {
@@ -6,7 +6,7 @@ pub struct TerminalStyle {
     pub bg_color: Option<(u8, u8, u8)>,
     pub bold: Option<bool>,
     pub italic: Option<bool>,
-    pub underline: Option<bool>
+    pub underline: Option<bool>,
 }
 
 impl TerminalStyle {
@@ -85,4 +85,3 @@ impl std::fmt::Display for TerminalStyle {
         Ok(())
     }
 }
-

nested/src/terminal/terminal.rs

@@ -1,44 +1,32 @@
 use {
-    std::{
+    super::{TerminalStyle, TerminalView},
-        sync::Arc,
-        io::{Write, stdout, stdin},
-        collections::HashSet
-    },
-    std::sync::RwLock,
-    async_std::{
-        stream::StreamExt,
-        task
-    },
-    signal_hook,
-    signal_hook_async_std::Signals,
-    cgmath::{Vector2, Point2},
-    termion::{
-        raw::IntoRawMode,
-        input::{TermRead, MouseTerminal}
-    },
     crate::{
         core::{
-            OuterViewPort,
+            channel::{queue_channel, set_channel, ChannelReceiver, ChannelSender},
-            Observer,
+            Observer, OuterViewPort,
-            channel::{
-                ChannelReceiver,
-                ChannelSender,
-                queue_channel,
-                set_channel
-            }
         },
-        index::{IndexArea},
+        grid::GridWindowIterator,
-        grid::{GridWindowIterator}
+        index::IndexArea,
     },
-    super::{
+    async_std::{stream::StreamExt, task},
-        TerminalStyle,
+    cgmath::{Point2, Vector2},
-        TerminalView
+    signal_hook,
+    signal_hook_async_std::Signals,
+    std::sync::RwLock,
+    std::{
+        collections::HashSet,
+        io::{stdin, stdout, Write},
+        sync::Arc,
+    },
+    termion::{
+        input::{MouseTerminal, TermRead},
+        raw::IntoRawMode,
     },
 };
 
 pub enum TerminalEvent {
     Resize(Vector2<i16>),
-    Input(termion::event::Event)
+    Input(termion::event::Event),
 }
 
 pub struct Terminal {
@@ -46,24 +34,22 @@ pub struct Terminal {
     _observer: Arc<RwLock<TermOutObserver>>,
 
     events: ChannelReceiver<Vec<TerminalEvent>>,
-    _signal_handle: signal_hook_async_std::Handle
+    _signal_handle: signal_hook_async_std::Handle,
 }
 
 impl Terminal {
-    pub fn new(
+    pub fn new(port: OuterViewPort<dyn TerminalView>) -> Self {
-        port: OuterViewPort<dyn TerminalView>
-    ) -> Self {
         let (dirty_pos_tx, dirty_pos_rx) = set_channel();
 
         let writer = Arc::new(TermOutWriter {
             out: RwLock::new(MouseTerminal::from(stdout().into_raw_mode().unwrap())),
             dirty_pos_rx,
-            view: port.get_view_arc()
+            view: port.get_view_arc(),
         });
 
         let observer = Arc::new(RwLock::new(TermOutObserver {
             dirty_pos_tx,
-            writer: writer.clone()
+            writer: writer.clone(),
         }));
 
         port.add_observer(observer.clone());
@@ -92,7 +78,7 @@ impl Terminal {
                     signal_hook::consts::signal::SIGWINCH => {
                         let (w, h) = termion::terminal_size().unwrap();
                         event_tx.send(TerminalEvent::Resize(Vector2::new(w as i16, h as i16)));
-                    },
+                    }
                     _ => unreachable!(),
                 }
             }
@@ -102,7 +88,7 @@ impl Terminal {
             writer,
             _observer: observer,
             events: event_rx,
-            _signal_handle: handle
+            _signal_handle: handle,
         }
     }
 
@@ -117,16 +103,18 @@ impl Terminal {
 
 struct TermOutObserver {
     dirty_pos_tx: ChannelSender<HashSet<Point2<i16>>>,
-    writer: Arc<TermOutWriter>
+    writer: Arc<TermOutWriter>,
 }
 
 impl TermOutObserver {
     fn send_area(&mut self, area: IndexArea<Point2<i16>>) {
         match area {
-            IndexArea::Empty => {},
+            IndexArea::Empty => {}
             IndexArea::Full => {
                 let (w, h) = termion::terminal_size().unwrap();
-                for pos in GridWindowIterator::from(Point2::new(0, 0) .. Point2::new(w as i16, h as i16)) {
+                for pos in
+                    GridWindowIterator::from(Point2::new(0, 0)..Point2::new(w as i16, h as i16))
+                {
                     self.dirty_pos_tx.send(pos);
                 }
             }
@@ -160,7 +148,7 @@ impl Observer<dyn TerminalView> for TermOutObserver {
 pub struct TermOutWriter {
     out: RwLock<MouseTerminal<termion::raw::RawTerminal<std::io::Stdout>>>,
     dirty_pos_rx: ChannelReceiver<HashSet<Point2<i16>>>,
-    view: Arc<RwLock<Option<Arc<dyn TerminalView>>>>
+    view: Arc<RwLock<Option<Arc<dyn TerminalView>>>>,
 }
 
 impl TermOutWriter {
@@ -173,22 +161,27 @@ impl TermOutWriter {
 impl TermOutWriter {
     pub async fn show(&self) -> std::io::Result<()> {
         // init
-        write!(self.out.write().unwrap(), "{}{}{}",
+        write!(
+            self.out.write().unwrap(),
+            "{}{}{}",
             termion::cursor::Hide,
             termion::cursor::Goto(1, 1),
-               termion::style::Reset)?;
+            termion::style::Reset
+        )?;
 
         let mut cur_pos = Point2::<i16>::new(0, 0);
         let mut cur_style = TerminalStyle::default();
 
         // draw atoms until view port is destroyed
         while let Some(dirty_pos) = self.dirty_pos_rx.recv().await {
-            let (w, h) = termion::terminal_size().unwrap();
+            let (w, _h) = termion::terminal_size().unwrap();
 
             if let Some(view) = self.view.read().unwrap().as_ref() {
                 let mut out = self.out.write().unwrap();
 
-                let d = dirty_pos.into_iter().filter(|p| p.x >= 0 && p.y >= 0 && p.x < w as i16 && p.y < w as i16);//.collect::<Vec<_>>();
+                let d = dirty_pos
+                    .into_iter()
+                    .filter(|p| p.x >= 0 && p.y >= 0 && p.x < w as i16 && p.y < w as i16); //.collect::<Vec<_>>();
                                                                                            /*
                                                                                                            d.sort_by(|a,b| {
                                                                                                                if a.y < b.y {
@@ -202,7 +195,11 @@ impl TermOutWriter {
                                                                                            */
                 for pos in d {
                     if pos != cur_pos {
-                        write!(out, "{}", termion::cursor::Goto(pos.x as u16 + 1, pos.y as u16 + 1))?;
+                        write!(
+                            out,
+                            "{}",
+                            termion::cursor::Goto(pos.x as u16 + 1, pos.y as u16 + 1)
+                        )?;
                     }
 
                     if let Some(atom) = view.get(&pos) {
@@ -232,4 +229,3 @@ impl TermOutWriter {
         std::io::Result::Ok(())
     }
 }
-

nested/src/tree_nav.rs

@@ -1,10 +1,9 @@
-
 use crate::list::ListCursorMode;
 
 #[derive(Clone, Copy, Eq, PartialEq)]
 pub enum TreeNavResult {
     Continue,
-    Exit
+    Exit,
 }
 /*
 impl From<TreeNavResult> for TerminalEditorResult {
@@ -19,14 +18,14 @@ impl From<TreeNavResult> for TerminalEditorResult {
 #[derive(Clone, Eq, PartialEq)]
 pub struct TreeCursor {
     pub leaf_mode: ListCursorMode,
-    pub tree_addr: Vec<usize>
+    pub tree_addr: Vec<usize>,
 }
 
 impl Default for TreeCursor {
     fn default() -> Self {
         TreeCursor {
             leaf_mode: ListCursorMode::Select,
-            tree_addr: vec![]
+            tree_addr: vec![],
         }
     }
 }
@@ -56,7 +55,7 @@ pub trait TreeNav {
         TreeNavResult::Exit
     }
 
-    fn goto(&mut self, new_cursor: TreeCursor)  -> TreeNavResult {
+    fn goto(&mut self, _new_cursor: TreeCursor) -> TreeNavResult {
         TreeNavResult::Exit
     }
 
@@ -65,7 +64,6 @@ pub trait TreeNav {
     }
 }
 
-use crate::terminal::{TerminalView, TerminalEditor};
+use crate::terminal::{TerminalEditor};
 
 pub trait TerminalTreeEditor = TerminalEditor + TreeNav;
-

nested/src/vec/buffer.rs

@@ -1,19 +1,21 @@
 use {
-    std::{
+    crate::{
-        sync::Arc,
+        core::{InnerViewPort, Observer, ObserverBroadcast, View},
-        ops::{Deref, DerefMut},
+        vec::VecDiff,
     },
     std::sync::RwLock,
-    crate::{
+    std::{
-        core::{View, Observer, ObserverBroadcast, InnerViewPort},
+        ops::{Deref, DerefMut},
-        vec::VecDiff
+        sync::Arc,
-    }
+    },
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<T> View for Vec<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Msg = VecDiff<T>;
 }
 
@@ -21,19 +23,18 @@ where T: Clone + Send + Sync + 'static {
 
 #[derive(Clone)]
 pub struct VecBuffer<T>
-where T: Clone + Send + Sync + 'static
+where
+    T: Clone + Send + Sync + 'static,
 {
     data: Arc<RwLock<Vec<T>>>,
-    cast: Arc<RwLock<ObserverBroadcast<RwLock<Vec<T>>>>>
+    cast: Arc<RwLock<ObserverBroadcast<RwLock<Vec<T>>>>>,
 }
 
 impl<T> VecBuffer<T>
-where T: Clone + Send + Sync + 'static
+where
+    T: Clone + Send + Sync + 'static,
 {
-    pub fn with_data(
+    pub fn with_data(data: Vec<T>, port: InnerViewPort<RwLock<Vec<T>>>) -> Self {
-        data: Vec<T>,
-        port: InnerViewPort<RwLock<Vec<T>>>
-    ) -> Self {
         let mut b = VecBuffer::new(port);
         for x in data.into_iter() {
             b.push(x);
@@ -45,17 +46,30 @@ where T: Clone + Send + Sync + 'static
     pub fn new(port: InnerViewPort<RwLock<Vec<T>>>) -> Self {
         let data = Arc::new(RwLock::new(Vec::new()));
         port.set_view(Some(data.clone()));
-        VecBuffer { data, cast: port.get_broadcast() }
+        VecBuffer {
+            data,
+            cast: port.get_broadcast(),
+        }
     }
 
     pub fn apply_diff(&mut self, diff: VecDiff<T>) {
         let mut data = self.data.write().unwrap();
         match &diff {
-            VecDiff::Clear => { data.clear(); },
+            VecDiff::Clear => {
-            VecDiff::Push(val) => { data.push(val.clone()); },
+                data.clear();
-            VecDiff::Remove(idx) => { data.remove(*idx); },
+            }
-            VecDiff::Insert{ idx, val } => { data.insert(*idx, val.clone()); },
+            VecDiff::Push(val) => {
-            VecDiff::Update{ idx, val } => { data[*idx] = val.clone(); }
+                data.push(val.clone());
+            }
+            VecDiff::Remove(idx) => {
+                data.remove(*idx);
+            }
+            VecDiff::Insert { idx, val } => {
+                data.insert(*idx, val.clone());
+            }
+            VecDiff::Update { idx, val } => {
+                data[*idx] = val.clone();
+            }
         }
         drop(data);
 
@@ -94,7 +108,7 @@ where T: Clone + Send + Sync + 'static
         MutableVecAccess {
             buf: self.clone(),
             idx,
-            val: self.get(idx)
+            val: self.get(idx),
         }
     }
 }
@@ -102,14 +116,18 @@ where T: Clone + Send + Sync + 'static
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct MutableVecAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     buf: VecBuffer<T>,
     idx: usize,
     val: T,
 }
 
 impl<T> Deref for MutableVecAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Target = T;
 
     fn deref(&self) -> &T {
@@ -118,17 +136,19 @@ where T: Clone + Send + Sync + 'static {
 }
 
 impl<T> DerefMut for MutableVecAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.val
     }
 }
 
 impl<T> Drop for MutableVecAccess<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     fn drop(&mut self) {
         self.buf.update(self.idx, self.val.clone());
     }
 }
-
-

nested/src/vec/mod.rs

@@ -1,18 +1,13 @@
-
 pub mod buffer;
-pub mod vec2seq;
-pub mod vec2json;
 pub mod vec2bin;
+pub mod vec2json;
+pub mod vec2seq;
 
-pub use {
+pub use buffer::VecBuffer;
-    buffer::VecBuffer
-};
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-use {
+use serde::{Deserialize, Serialize};
-    serde::{Serialize, Deserialize}
-};
 
 #[derive(Clone, Serialize, Deserialize)]
 pub enum VecDiff<T> {
@@ -20,6 +15,5 @@ pub enum VecDiff<T> {
     Push(T),
     Remove(usize),
     Insert { idx: usize, val: T },
-    Update{ idx: usize, val: T }
+    Update { idx: usize, val: T },
 }
-

nested/src/vec/vec2bin.rs

@@ -1,56 +1,70 @@
 use {
-    std::{
-        sync::Arc,
-        io::Write
-    },
-    std::sync::RwLock,
-    serde::Serialize,
     crate::{
         core::{Observer, OuterViewPort},
-        vec::VecDiff
+        vec::VecDiff,
-    }
+    },
+    serde::Serialize,
+    std::sync::RwLock,
+    std::{io::Write, sync::Arc},
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 /// Serialization Observer for `Vec`
 pub struct VecBinWriter<T, W>
-where T: Clone + Send + Sync + 'static,
+where
-      W: Write + Send + Sync {
+    T: Clone + Send + Sync + 'static,
+    W: Write + Send + Sync,
+{
     data: Option<Arc<RwLock<Vec<T>>>>,
-    out: RwLock<W>
+    out: RwLock<W>,
 }
 
-
 impl<T> OuterViewPort<RwLock<Vec<T>>>
-where T: Clone + Serialize + Send + Sync + 'static {
+where
-    pub fn serialize_bin<W: Write + Send + Sync + 'static>(&self, out: W) -> Arc<RwLock<VecBinWriter<T, W>>> {
+    T: Clone + Serialize + Send + Sync + 'static,
-        let writer = Arc::new(RwLock::new(
+{
-            VecBinWriter {
+    pub fn serialize_bin<W: Write + Send + Sync + 'static>(
+        &self,
+        out: W,
+    ) -> Arc<RwLock<VecBinWriter<T, W>>> {
+        let writer = Arc::new(RwLock::new(VecBinWriter {
             data: None,
             out: RwLock::new(out),
-            }
+        }));
-        ));
         self.add_observer(writer.clone());
         writer
     }
 }
 
 impl<T, W> Observer<RwLock<Vec<T>>> for VecBinWriter<T, W>
-where T: Clone + Serialize + Send + Sync + 'static,
+where
-      W: Write + Send + Sync
+    T: Clone + Serialize + Send + Sync + 'static,
+    W: Write + Send + Sync,
 {
     fn reset(&mut self, view: Option<Arc<RwLock<Vec<T>>>>) {
         self.data = view;
         let mut out = self.out.write().unwrap();
 
-        out.write(&bincode::serialized_size(&VecDiff::<T>::Clear).unwrap().to_le_bytes()).expect("");
+        out.write(
-        out.write(&bincode::serialize(&VecDiff::<T>::Clear).unwrap()).expect("");
+            &bincode::serialized_size(&VecDiff::<T>::Clear)
+                .unwrap()
+                .to_le_bytes(),
+        )
+        .expect("");
+        out.write(&bincode::serialize(&VecDiff::<T>::Clear).unwrap())
+            .expect("");
 
         if let Some(data) = self.data.as_ref() {
             for x in data.read().unwrap().iter() {
-                out.write(&bincode::serialized_size(&VecDiff::Push(x)).unwrap().to_le_bytes()).expect("");
+                out.write(
-                out.write(&bincode::serialize(&VecDiff::Push(x)).unwrap()).expect("");
+                    &bincode::serialized_size(&VecDiff::Push(x))
+                        .unwrap()
+                        .to_le_bytes(),
+                )
+                .expect("");
+                out.write(&bincode::serialize(&VecDiff::Push(x)).unwrap())
+                    .expect("");
             }
         }
 
@@ -59,9 +73,9 @@ where T: Clone + Serialize + Send + Sync + 'static,
 
     fn notify(&mut self, diff: &VecDiff<T>) {
         let mut out = self.out.write().unwrap();
-        out.write(&bincode::serialized_size(diff).unwrap().to_le_bytes()).expect("");
+        out.write(&bincode::serialized_size(diff).unwrap().to_le_bytes())
+            .expect("");
         out.write(&bincode::serialize(diff).unwrap()).expect("");
         out.flush().expect("");
     }
 }
-

nested/src/vec/vec2json.rs

@@ -1,56 +1,71 @@
 use {
-    std::{
-        sync::Arc,
-        io::Write
-    },
-    std::sync::RwLock,
-    async_std::{
-        io::{Read, ReadExt},
-        stream::{StreamExt}
-    },
-    serde::{Serialize, de::DeserializeOwned},
     crate::{
         core::{Observer, OuterViewPort},
-        vec::{VecDiff, VecBuffer}
+        vec::{VecBuffer, VecDiff},
-    }
+    },
+    async_std::{
+        io::{Read, ReadExt},
+        stream::StreamExt,
+    },
+    serde::{de::DeserializeOwned, Serialize},
+    std::sync::RwLock,
+    std::{io::Write, sync::Arc},
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct VecJsonWriter<T, W>
-where T: Clone + Send + Sync + 'static,
+where
-      W: Write + Send + Sync {
+    T: Clone + Send + Sync + 'static,
+    W: Write + Send + Sync,
+{
     data: Option<Arc<RwLock<Vec<T>>>>,
-    out: RwLock<W>
+    out: RwLock<W>,
 }
 
 impl<T> OuterViewPort<RwLock<Vec<T>>>
-where T: Clone + Serialize + Send + Sync + 'static {
+where
-    pub fn serialize_json<W: Write + Send + Sync + 'static>(&self, out: W) -> Arc<RwLock<VecJsonWriter<T, W>>> {
+    T: Clone + Serialize + Send + Sync + 'static,
-        let writer = Arc::new(RwLock::new(
+{
-            VecJsonWriter {
+    pub fn serialize_json<W: Write + Send + Sync + 'static>(
+        &self,
+        out: W,
+    ) -> Arc<RwLock<VecJsonWriter<T, W>>> {
+        let writer = Arc::new(RwLock::new(VecJsonWriter {
             data: None,
             out: RwLock::new(out),
-            }
+        }));
-        ));
         self.add_observer(writer.clone());
         writer
     }
 }
 
 impl<T, W> Observer<RwLock<Vec<T>>> for VecJsonWriter<T, W>
-where T: Clone + Serialize + Send + Sync + 'static,
+where
-      W: Write + Send + Sync
+    T: Clone + Serialize + Send + Sync + 'static,
+    W: Write + Send + Sync,
 {
     fn reset(&mut self, view: Option<Arc<RwLock<Vec<T>>>>) {
         self.data = view;
 
-        self.out.write().unwrap().write(&serde_json::to_string(&VecDiff::<T>::Clear).unwrap().as_bytes()).expect("");
+        self.out
+            .write()
+            .unwrap()
+            .write(
+                &serde_json::to_string(&VecDiff::<T>::Clear)
+                    .unwrap()
+                    .as_bytes(),
+            )
+            .expect("");
         self.out.write().unwrap().write(b"\n").expect("");
 
         if let Some(data) = self.data.as_ref() {
             for x in data.read().unwrap().iter() {
-                self.out.write().unwrap().write(&serde_json::to_string(&VecDiff::Push(x)).unwrap().as_bytes()).expect("");
+                self.out
+                    .write()
+                    .unwrap()
+                    .write(&serde_json::to_string(&VecDiff::Push(x)).unwrap().as_bytes())
+                    .expect("");
                 self.out.write().unwrap().write(b"\n").expect("");
             }
         }
@@ -59,14 +74,19 @@ where T: Clone + Serialize + Send + Sync + 'static,
     }
 
     fn notify(&mut self, diff: &VecDiff<T>) {
-        self.out.write().unwrap().write(serde_json::to_string(diff).unwrap().as_bytes()).expect("");
+        self.out
+            .write()
+            .unwrap()
+            .write(serde_json::to_string(diff).unwrap().as_bytes())
+            .expect("");
         self.out.write().unwrap().write(b"\n").expect("");
         self.out.write().unwrap().flush().expect("");
     }
 }
 
 impl<T> VecBuffer<T>
-where T: DeserializeOwned + Clone + Send + Sync + 'static
+where
+    T: DeserializeOwned + Clone + Send + Sync + 'static,
 {
     pub async fn from_json<R: Read + async_std::io::Read + Unpin>(&mut self, read: R) {
         let mut bytes = read.bytes();
@@ -75,11 +95,12 @@ where T: DeserializeOwned + Clone + Send + Sync + 'static
             match b {
                 b'\n' => {
                     if s.len() > 0 {
-                        let diff = serde_json::from_str::<VecDiff<T>>(&s).expect("error parsing json");
+                        let diff =
+                            serde_json::from_str::<VecDiff<T>>(&s).expect("error parsing json");
                         self.apply_diff(diff);
                         s.clear();
                     }
-                },
+                }
                 c => {
                     s.push(c as char);
                 }
@@ -87,5 +108,3 @@ where T: DeserializeOwned + Clone + Send + Sync + 'static
         }
     }
 }
-
-

nested/src/vec/vec2seq.rs

@@ -1,50 +1,50 @@
 use {
-    std::{
-        sync::Arc,
-    },
-    std::sync::RwLock,
     crate::{
-        core::{View, Observer, ObserverExt, ObserverBroadcast, ViewPort, InnerViewPort, OuterViewPort},
+        core::{
+            InnerViewPort, Observer, ObserverBroadcast, ObserverExt, OuterViewPort, View, ViewPort,
+        },
         sequence::SequenceView,
-        vec::VecDiff
+        vec::VecDiff,
-    }
+    },
+    std::sync::Arc,
+    std::sync::RwLock,
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 /// Adapter View implementing `Sequence` for `Vec`
 pub struct VecSequence<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     cur_len: usize,
     data: Option<Arc<RwLock<Vec<T>>>>,
-    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = T>>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn SequenceView<Item = T>>>>,
 }
 
-
 impl<T> VecSequence<T>
-where T: Clone + Send + Sync + 'static {
+where
-    pub fn new(
+    T: Clone + Send + Sync + 'static,
-        port: InnerViewPort<dyn SequenceView<Item = T>>
+{
-    ) -> Arc<RwLock<Self>> {
+    pub fn new(port: InnerViewPort<dyn SequenceView<Item = T>>) -> Arc<RwLock<Self>> {
-        let seq = Arc::new(RwLock::new(
+        let seq = Arc::new(RwLock::new(VecSequence {
-            VecSequence {
             cur_len: 0,
             data: None,
-                cast: port.get_broadcast()
+            cast: port.get_broadcast(),
-            }
+        }));
-        ));
         port.set_view(Some(seq.clone()));
         seq
     }
 }
 
 impl<T> Observer<RwLock<Vec<T>>> for VecSequence<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     fn reset(&mut self, view: Option<Arc<RwLock<Vec<T>>>>) {
         let old_len = self.cur_len;
         self.data = view;
-        let new_len =
+        let new_len = if let Some(data) = self.data.as_ref() {
-            if let Some(data) = self.data.as_ref() {
             data.read().unwrap().len()
         } else {
             0
@@ -59,19 +59,19 @@ where T: Clone + Send + Sync + 'static {
             VecDiff::Clear => {
                 self.cast.notify_each(0..self.cur_len);
                 self.cur_len = 0
-            },
+            }
             VecDiff::Push(_) => {
                 self.cast.notify(&self.cur_len);
                 self.cur_len += 1;
-            },
+            }
             VecDiff::Remove(idx) => {
                 self.cast.notify_each(*idx..self.cur_len);
                 self.cur_len -= 1;
-            },
+            }
             VecDiff::Insert { idx, val: _ } => {
                 self.cur_len += 1;
                 self.cast.notify_each(*idx..self.cur_len);
-            },
+            }
             VecDiff::Update { idx, val: _ } => {
                 self.cast.notify(&idx);
             }
@@ -80,18 +80,20 @@ where T: Clone + Send + Sync + 'static {
 }
 
 impl<T> View for VecSequence<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Msg = usize;
 }
 
 impl<T> SequenceView for VecSequence<T>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     type Item = T;
 
     fn get(&self, idx: &usize) -> Option<T> {
-        self.data.as_ref()?
+        self.data.as_ref()?.read().unwrap().get(*idx).cloned()
-            .read().unwrap()
-            .get(*idx).cloned()
     }
 
     fn len(&self) -> Option<usize> {
@@ -102,7 +104,9 @@ where T: Clone + Send + Sync + 'static {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl<T> OuterViewPort<RwLock<Vec<T>>>
-where T: Clone + Send + Sync + 'static {
+where
+    T: Clone + Send + Sync + 'static,
+{
     pub fn to_sequence(&self) -> OuterViewPort<dyn SequenceView<Item = T>> {
         let port = ViewPort::new();
         port.add_update_hook(Arc::new(self.0.clone()));
@@ -112,5 +116,3 @@ where T: Clone + Send + Sync + 'static {
         port.into_outer()
     }
 }
-
-

shell/src/ascii_box.rs

@@ -1,52 +1,38 @@
-
 use {
-    std::sync::{Arc, RwLock},
     cgmath::{Point2, Vector2},
     nested::{
-        core::{
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View},
-            View,
-            ViewPort,
-            InnerViewPort,
-            OuterViewPort,
-            Observer,
-            ObserverExt,
-            ObserverBroadcast,
-            context::{ReprTree, Object, MorphismType, MorphismMode, Context},
-            port::{UpdateTask}},
         index::{IndexArea, IndexView},
-        grid::{GridWindowIterator},
+        terminal::{TerminalAtom, TerminalView},
-        terminal::{
+    },
-            Terminal,
+    std::sync::{Arc, RwLock},
-            TerminalStyle,
-            TerminalAtom,
-            TerminalCompositor,
-            TerminalEvent,
-            make_label,
-            TerminalView,
-            TerminalEditor},
-    }
 };
 
 pub struct AsciiBox {
     content: Option<Arc<dyn TerminalView>>,
     extent: Vector2<i16>,
 
-    cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>
+    cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
 }
 
 impl AsciiBox {
     pub fn new(
         extent: Vector2<i16>,
         content_port: OuterViewPort<dyn TerminalView>,
-        output_port: InnerViewPort<dyn TerminalView>
+        output_port: InnerViewPort<dyn TerminalView>,
     ) -> Arc<RwLock<Self>> {
         let ascii_box = Arc::new(RwLock::new(AsciiBox {
             content: None,
             extent,
-            cast: output_port.get_broadcast()
+            cast: output_port.get_broadcast(),
         }));
 
-        output_port.0.update_hooks.write().unwrap().push(Arc::new(content_port.0.clone()));
+        output_port
+            .0
+            .update_hooks
+            .write()
+            .unwrap()
+            .push(Arc::new(content_port.0.clone()));
         output_port.set_view(Some(ascii_box.clone()));
         content_port.add_observer(ascii_box.clone());
 
@@ -57,12 +43,13 @@ impl AsciiBox {
         if self.extent != new_extent {
             let old_extent = self.extent;
             self.extent = new_extent;
-            self.cast.notify(
+            self.cast.notify(&IndexArea::Range(
-                &IndexArea::Range(
+                Point2::new(0, 0)
-                    Point2::new(0, 0) ..=
+                    ..=Point2::new(
-                        Point2::new(
                         1 + std::cmp::max(old_extent.x, new_extent.x),
-                            1+std::cmp::max(old_extent.y, new_extent.y))));
+                        1 + std::cmp::max(old_extent.y, new_extent.y),
+                    ),
+            ));
         }
     }
 
@@ -118,13 +105,12 @@ impl IndexView<Point2<i16>> for AsciiBox {
             } else {
                 None
             }
-        } else if
+        } else if pt.x > 0 && pt.y > 0 && pt.x < self.extent.x + 1 && pt.y < self.extent.y + 1 {
-            pt.x > 0 &&
+            Some(
-            pt.y > 0 &&
+                self.content
-            pt.x < self.extent.x+1 &&
+                    .get(&(pt - Vector2::new(1, 1)))
-            pt.y < self.extent.y+1
+                    .unwrap_or(TerminalAtom::from(' ')),
-        {
+            )
-            Some(self.content.get(&(pt - Vector2::new(1, 1))).unwrap_or(TerminalAtom::from(' ')))
         } else {
             None
         }
@@ -134,4 +120,3 @@ impl IndexView<Point2<i16>> for AsciiBox {
         IndexArea::Range(Point2::new(0, 0)..=Point2::new(1, 1) + self.extent)
     }
 }
-

shell/src/main.rs

@@ -1,52 +1,28 @@
-
 extern crate portable_pty;
 
+mod ascii_box;
 mod monstera;
 mod process;
 mod pty;
-mod ascii_box;
 
 mod plot;
 
 use {
-    std::sync::{Arc, RwLock},
+    crate::process::ProcessLauncher,
     cgmath::{Point2, Vector2},
-    termion::event::{Event, Key},
     nested::{
-        core::{
+        core::{port::UpdateTask, Observer, OuterViewPort, ViewPort},
-            View,
+        index::IndexArea,
-            ViewPort,
+        list::{ListCursorMode, ListEditor, ListEditorStyle},
-            InnerViewPort,
-            OuterViewPort,
-            Observer,
-            ObserverExt,
-            ObserverBroadcast,
-            context::{ReprTree, Object, MorphismType, MorphismMode, Context},
-            port::{UpdateTask}},
-        index::{IndexView, IndexArea},
-        grid::{GridWindowIterator},
-        sequence::{SequenceView, SequenceViewExt},
-        vec::{VecBuffer},
-        integer::{RadixProjection, DigitEditor, PosIntEditor},
         terminal::{
-            Terminal,
+            make_label, Terminal, TerminalAtom, TerminalCompositor, TerminalEditor,
-            TerminalStyle,
+            TerminalEditorResult, TerminalEvent, TerminalStyle, TerminalView,
-            TerminalAtom,
-            TerminalCompositor,
-            TerminalEvent,
-            make_label,
-            TerminalView,
-            TerminalEditor,
-            TerminalEditorResult
         },
-        string_editor::{StringEditor},
+        tree_nav::{TerminalTreeEditor, TreeCursor, TreeNavResult},
-        tree_nav::{TreeNav, TreeNavResult, TreeCursor, TerminalTreeEditor},
+        vec::VecBuffer,
-        list::{SExprView, ListCursorMode, ListEditor, ListEditorStyle},
-        projection::ProjectionHelper
     },
-    crate::{
+    std::sync::{Arc, RwLock},
-        process::ProcessLauncher
+    termion::event::{Event, Key},
-    }
 };
 
 #[async_std::main]
@@ -57,53 +33,45 @@ async fn main() {
     let mut term = Terminal::new(term_port.outer());
     let term_writer = term.get_writer();
 
-    async_std::task::spawn(
+    async_std::task::spawn(async move {
-        async move {
+        let table_port =
-            let table_port = ViewPort::<dyn nested::grid::GridView<Item = OuterViewPort<dyn TerminalView>>>::new();
+            ViewPort::<dyn nested::grid::GridView<Item = OuterViewPort<dyn TerminalView>>>::new();
         let mut table_buf = nested::index::buffer::IndexBuffer::new(table_port.inner());
 
         let magic =
-                make_label("<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>")
+            make_label("<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>").map_item(|pos, atom| {
-                .map_item(
+                atom.add_style_back(TerminalStyle::fg_color((
-                    |pos, atom|
+                    5,
-                    atom.add_style_back(
-                        TerminalStyle::fg_color(
-                            (5,
                     ((80 + (pos.x * 30) % 100) as u8),
-                             (55+(pos.x*15)%180) as u8)
+                    (55 + (pos.x * 15) % 180) as u8,
-                        )
+                )))
-                    )
+            });
-                );
 
         let cur_size_port = ViewPort::new();
-            let mut cur_size = nested::singleton::SingletonBuffer::new(Vector2::new(10, 10), cur_size_port.inner());
+        let mut cur_size =
+            nested::singleton::SingletonBuffer::new(Vector2::new(10, 10), cur_size_port.inner());
 
         let status_chars_port = ViewPort::new();
         let mut status_chars = VecBuffer::new(status_chars_port.inner());
 
         let mut process_list_editor = ListEditor::new(
-                Box::new(|| {
+            Box::new(|| Arc::new(RwLock::new(ProcessLauncher::new()))),
-                    Arc::new(RwLock::new(
+            ListEditorStyle::VerticalSexpr,
-                        ProcessLauncher::new()
-                    ))
-                }),
-                ListEditorStyle::VerticalSexpr
         );
 
-            
         let plist_vec_port = ViewPort::new();
         let mut plist = VecBuffer::new(plist_vec_port.inner());
 
         async_std::task::spawn(async move {
-                let (w, h) = termion::terminal_size().unwrap();
+            let (w, _h) = termion::terminal_size().unwrap();
             let mut x: usize = 0;
             loop {
-                    let val =
+                let val = (5.0
-                        (
+                    + (x as f32 / 3.0).sin() * 5.0
-                            5.0 + (x as f32 / 3.0).sin() * 5.0 +
+                    + 2.0
-                            2.0 + ((7+x) as f32 / 5.0).sin() * 2.0 +
+                    + ((7 + x) as f32 / 5.0).sin() * 2.0
-                            2.0 + ((9+x) as f32 / 10.0).cos() * 3.0
+                    + 2.0
-                        ) as usize;
+                    + ((9 + x) as f32 / 10.0).cos() * 3.0) as usize;
 
                 if x < w as usize {
                     plist.push(val);
@@ -121,11 +89,14 @@ async fn main() {
         });
 
         let plot_port = ViewPort::new();
-            let plot = crate::plot::Plot::new(plist_vec_port.outer().to_sequence(), plot_port.inner());
+        let _plot = crate::plot::Plot::new(plist_vec_port.outer().to_sequence(), plot_port.inner());
 
         table_buf.insert_iter(vec![
             (Point2::new(0, 0), magic.clone()),
-                (Point2::new(0, 1), status_chars_port.outer().to_sequence().to_grid_horizontal()),
+            (
+                Point2::new(0, 1),
+                status_chars_port.outer().to_sequence().to_grid_horizontal(),
+            ),
             (Point2::new(0, 2), magic.clone()),
             (Point2::new(0, 3), process_list_editor.get_term_view()),
         ]);
@@ -133,65 +104,87 @@ async fn main() {
         let (w, h) = termion::terminal_size().unwrap();
 
         compositor.write().unwrap().push(
-                plot_port.outer()
+            plot_port
+                .outer()
                 .map_item(|pt, a| {
-                        a.add_style_back(TerminalStyle::fg_color((255 - pt.y as u8 * 8, 100, pt.y as u8 *15)))
+                    a.add_style_back(TerminalStyle::fg_color((
+                        255 - pt.y as u8 * 8,
+                        100,
+                        pt.y as u8 * 15,
+                    )))
                 })
-                    .offset(Vector2::new(0,h as i16-20))
+                .offset(Vector2::new(0, h as i16 - 20)),
         );
 
-            compositor.write().unwrap().push(
+        compositor
-                monstera::make_monstera()
+            .write()
-                    .offset(Vector2::new(w as i16-38, 0)));
+            .unwrap()
+            .push(monstera::make_monstera().offset(Vector2::new(w as i16 - 38, 0)));
 
-            compositor.write().unwrap().push(
+        compositor
-                table_port.outer()
+            .write()
-                    .flatten()
+            .unwrap()
-                    .offset(Vector2::new(3, 0))
+            .push(table_port.outer().flatten().offset(Vector2::new(3, 0)));
-            );
 
         process_list_editor.goto(TreeCursor {
             leaf_mode: ListCursorMode::Insert,
-                tree_addr: vec![ 0 ]
+            tree_addr: vec![0],
         });
 
         let tp = term_port.clone();
-            async_std::task::spawn(
+        async_std::task::spawn(async move {
-                async move {
             loop {
                 tp.update();
                 async_std::task::sleep(std::time::Duration::from_millis(10)).await;
             }
-                }
+        });
-            );
 
         loop {
             status_chars.clear();
             let cur = process_list_editor.get_cursor();
 
             if cur.tree_addr.len() > 0 {
-                    status_chars.push(TerminalAtom::new('@', TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true))));
+                status_chars.push(TerminalAtom::new(
+                    '@',
+                    TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true)),
+                ));
                 for x in cur.tree_addr {
                     for c in format!("{}", x).chars() {
-                            status_chars.push(TerminalAtom::new(c, TerminalStyle::fg_color((0, 100, 20))));
+                        status_chars
+                            .push(TerminalAtom::new(c, TerminalStyle::fg_color((0, 100, 20))));
                     }
-                        status_chars.push(TerminalAtom::new('.', TerminalStyle::fg_color((120, 80, 80))));
+                    status_chars.push(TerminalAtom::new(
+                        '.',
+                        TerminalStyle::fg_color((120, 80, 80)),
+                    ));
                 }
 
-                    status_chars.push(TerminalAtom::new(':', TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true))));
+                status_chars.push(TerminalAtom::new(
-                    for c in
+                    ':',
-                        match cur.leaf_mode {
+                    TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true)),
+                ));
+                for c in match cur.leaf_mode {
                     ListCursorMode::Insert => "INSERT",
                     ListCursorMode::Select => "SELECT",
-                            ListCursorMode::Modify => "MODIFY"
+                    ListCursorMode::Modify => "MODIFY",
-                        }.chars()
-                    {
-                        status_chars.push(TerminalAtom::new(c, TerminalStyle::fg_color((200, 200, 20))));
                 }
-                    status_chars.push(TerminalAtom::new(':', TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true))));
+                .chars()
+                {
+                    status_chars.push(TerminalAtom::new(
+                        c,
+                        TerminalStyle::fg_color((200, 200, 20)),
+                    ));
+                }
+                status_chars.push(TerminalAtom::new(
+                    ':',
+                    TerminalStyle::fg_color((120, 80, 80)).add(TerminalStyle::bold(true)),
+                ));
             } else {
                 for c in "Press <DN> to enter".chars() {
-                        status_chars.push(TerminalAtom::new(c, TerminalStyle::fg_color((200, 200, 20))));
+                    status_chars.push(TerminalAtom::new(
+                        c,
+                        TerminalStyle::fg_color((200, 200, 20)),
+                    ));
                 }
             }
 
@@ -220,10 +213,10 @@ async fn main() {
                 TerminalEvent::Input(Event::Key(Key::Ctrl('l'))) => {
                     process_list_editor.goto(TreeCursor {
                         leaf_mode: ListCursorMode::Insert,
-                            tree_addr: vec![ 0 ]
+                        tree_addr: vec![0],
                     });
-                        process_list_editor.data.clear();
+                    process_list_editor.clear();
-                    },
+                }
                 TerminalEvent::Input(Event::Key(Key::Left)) => {
                     process_list_editor.pxev();
                 }
@@ -250,18 +243,32 @@ async fn main() {
                 ev => {
                     if process_list_editor.get_cursor().leaf_mode == ListCursorMode::Select {
                         match ev {
-                                TerminalEvent::Input(Event::Key(Key::Char('l'))) => { process_list_editor.up(); },
+                            TerminalEvent::Input(Event::Key(Key::Char('l'))) => {
-                                TerminalEvent::Input(Event::Key(Key::Char('a'))) => { process_list_editor.dn(); },
+                                process_list_editor.up();
-                                TerminalEvent::Input(Event::Key(Key::Char('i'))) => { process_list_editor.pxev(); },
+                            }
-                                TerminalEvent::Input(Event::Key(Key::Char('e'))) => { process_list_editor.nexd(); },
+                            TerminalEvent::Input(Event::Key(Key::Char('a'))) => {
-                                TerminalEvent::Input(Event::Key(Key::Char('u'))) => { process_list_editor.goto_home(); },
+                                process_list_editor.dn();
-                                TerminalEvent::Input(Event::Key(Key::Char('o'))) => { process_list_editor.goto_end(); },
+                            }
+                            TerminalEvent::Input(Event::Key(Key::Char('i'))) => {
+                                process_list_editor.pxev();
+                            }
+                            TerminalEvent::Input(Event::Key(Key::Char('e'))) => {
+                                process_list_editor.nexd();
+                            }
+                            TerminalEvent::Input(Event::Key(Key::Char('u'))) => {
+                                process_list_editor.goto_home();
+                            }
+                            TerminalEvent::Input(Event::Key(Key::Char('o'))) => {
+                                process_list_editor.goto_end();
+                            }
                             _ => {
                                 process_list_editor.handle_terminal_event(&ev);
                             }
                         }
                     } else {
-                            if let TerminalEditorResult::Exit = process_list_editor.handle_terminal_event(&ev) {
+                        if let TerminalEditorResult::Exit =
+                            process_list_editor.handle_terminal_event(&ev)
+                        {
                             process_list_editor.nexd();
                         }
                     }
@@ -271,9 +278,7 @@ async fn main() {
 
         drop(term);
         drop(term_port);
-        }
+    });
-    );
 
     term_writer.show().await.expect("output error!");
 }
-

shell/src/monstera.rs

@@ -1,18 +1,15 @@
-
 use {
     cgmath::Point2,
     nested::{
-        core::{ViewPort, OuterViewPort},
+        core::{OuterViewPort, ViewPort},
+        terminal::{make_label, TerminalStyle, TerminalView},
         vec::VecBuffer,
-        terminal::{
-            TerminalStyle, TerminalView, make_label
     },
-    }
 };
 
 pub fn make_monstera() -> OuterViewPort<dyn TerminalView> {
     let monstera_lines_port = ViewPort::new();
-    let monstera_lines = VecBuffer::with_data(
+    let _monstera_lines = VecBuffer::with_data(
         vec![
             make_label("                   |"),
             make_label("                   |"),
@@ -36,21 +33,19 @@ pub fn make_monstera() -> OuterViewPort<dyn TerminalView> {
             make_label("        *. (       |       ) .*"),
             make_label("             \\_ .  |   . _/"),
             make_label("                 \\ | /"),
-            make_label("                   .")
+            make_label("                   ."),
         ],
-        monstera_lines_port.inner()
+        monstera_lines_port.inner(),
     );
 
-    monstera_lines_port.outer()
+    monstera_lines_port
+        .outer()
         .to_sequence()
         .to_index()
         .map_key(
             |idx| Point2::new(0 as i16, *idx as i16),
-            |pt| if pt.x == 0 { Some(pt.y as usize) } else { None }
+            |pt| if pt.x == 0 { Some(pt.y as usize) } else { None },
         )
         .flatten()
-        .map_item(
+        .map_item(|_p, at| at.add_style_back(TerminalStyle::fg_color((0, 100, 10))))
-            |p, at| at.add_style_back(TerminalStyle::fg_color((0,100,10)))
-        )
 }
-

shell/src/plot.rs

@@ -1,49 +1,20 @@
 use {
-    std::sync::{Arc, RwLock},
+    cgmath::Point2,
-    cgmath::{Point2, Vector2},
-    termion::event::{Event, Key},
     nested::{
-        core::{
+        core::{InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View},
-            View,
+        sequence::{SequenceView},
-            ViewPort,
+        index::{IndexArea, IndexView},
-            InnerViewPort,
+        projection::ProjectionHelper,
-            OuterViewPort,
+        terminal::{TerminalAtom, TerminalView},
-            Observer,
-            ObserverExt,
-            ObserverBroadcast,
-            context::{ReprTree, Object, MorphismType, MorphismMode, Context},
-            port::{UpdateTask}},
-        index::{IndexView, IndexArea},
-        grid::{GridWindowIterator},
-        sequence::{SequenceView, SequenceViewExt},
-        vec::{VecBuffer},
-        integer::{RadixProjection, DigitEditor, PosIntEditor},
-        terminal::{
-            Terminal,
-            TerminalStyle,
-            TerminalAtom,
-            TerminalCompositor,
-            TerminalEvent,
-            make_label,
-            TerminalView,
-            TerminalEditor,
-            TerminalEditorResult
     },
-        string_editor::{StringEditor},
+    std::sync::{Arc, RwLock},
-        tree_nav::{TreeNav, TreeNavResult, TreeCursor, TerminalTreeEditor},
-        list::{SExprView, ListCursorMode, ListEditor, ListEditorStyle},
-        projection::ProjectionHelper
-    },
-    crate::{
-        process::ProcessLauncher
-    }
 };
 
 pub struct Plot {
     limit: usize,
     data: Arc<dyn SequenceView<Item = usize>>,
     cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
-    proj_helper: ProjectionHelper<(), Self>
+    proj_helper: ProjectionHelper<(), Self>,
 }
 
 impl View for Plot {
@@ -58,25 +29,21 @@ impl IndexView<Point2<i16>> for Plot {
             if let Some(cur_val) = self.data.get(&(pt.x as usize)) {
                 if cur_val <= self.limit {
                     if pt.y == (self.limit - cur_val) as i16 {
-                        return Some(TerminalAtom::from(
+                        return Some(TerminalAtom::from(if cur_val < 4 {
-                            if cur_val < 4 { 'o' }
+                            'o'
-                            else if cur_val < 8 { 'O' }
+                        } else if cur_val < 8 {
-                            else { '*' }
+                            'O'
-                        ));
+                        } else {
+                            '*'
+                        }));
                     }
                 }
                 if pt.x > 0 {
                     if let Some(prev_val) = self.data.get(&((pt.x - 1) as usize)) {
-                        if
+                        if (pt.y > (self.limit - prev_val) as i16
-                            (
+                            && pt.y < (self.limit - cur_val) as i16)
-                                pt.y > (self.limit - prev_val) as i16 &&
+                            || (pt.y < (self.limit - prev_val) as i16
-                                pt.y < (self.limit - cur_val) as i16
+                                && pt.y > (self.limit - cur_val) as i16)
-                            )
-                            ||
-                            (
-                                pt.y < (self.limit - prev_val) as i16 &&
-                                pt.y > (self.limit - cur_val) as i16
-                            )
                         {
                             return Some(TerminalAtom::from('.'));
                         }
@@ -89,11 +56,7 @@ impl IndexView<Point2<i16>> for Plot {
 
     fn area(&self) -> IndexArea<Point2<i16>> {
         IndexArea::Range(
-            Point2::new(0,0)
+            Point2::new(0, 0)..=Point2::new(self.data.len().unwrap_or(0) as i16, self.limit as i16),
-                ..= Point2::new(
-                    self.data.len().unwrap_or(0) as i16,
-                    self.limit as i16
-                )
         )
     }
 }
@@ -101,15 +64,11 @@ impl IndexView<Point2<i16>> for Plot {
 impl Plot {
     pub fn new(
         data_port: OuterViewPort<dyn SequenceView<Item = usize>>,
-        out_port: InnerViewPort<dyn TerminalView>
+        out_port: InnerViewPort<dyn TerminalView>,
     ) -> Arc<RwLock<Self>> {
         let mut proj_helper = ProjectionHelper::new(out_port.0.update_hooks.clone());
-        let proj = Arc::new(RwLock::new(
+        let proj = Arc::new(RwLock::new(Plot {
-            Plot {
+            data: proj_helper.new_sequence_arg((), data_port, |s: &mut Self, idx| {
-                data: proj_helper.new_sequence_arg(
-                    (),
-                    data_port,
-                    |s: &mut Self, idx| {
                 let val = s.data.get(idx).unwrap_or(0);
 
                 if val > s.limit {
@@ -117,18 +76,15 @@ impl Plot {
                     s.cast.notify(&s.area());
                 } else {
                     s.cast.notify(&IndexArea::Range(
-                                Point2::new(*idx as i16, 0)
+                        Point2::new(*idx as i16, 0)..=Point2::new(*idx as i16, s.limit as i16),
-                                    ..= Point2::new(*idx as i16, s.limit as i16)
                     ));
                 }
-                    }
+            }),
-                ),
 
             limit: 0,
             cast: out_port.get_broadcast(),
-                proj_helper
+            proj_helper,
-            }
+        }));
-        ));
 
         proj.write().unwrap().proj_helper.set_proj(&proj);
         out_port.set_view(Some(proj.clone()));
@@ -136,4 +92,3 @@ impl Plot {
         proj
     }
 }
-

shell/src/process.rs

@@ -1,39 +1,41 @@
 use {
-    std::{
+    crate::pty::{PTYStatus, PTY},
-        sync::Arc,
-        process::Command,
-        os::unix::io::{FromRawFd, AsRawFd},
-    },
-    std::sync::RwLock,
-    termion::event::{Key, Event},
-    cgmath::Point2,
     nested::{
-        core::{ViewPort, OuterViewPort, InnerViewPort, Observer},
+        core::{OuterViewPort, ViewPort},
-        singleton::{SingletonView, SingletonBuffer},
+        list::{sexpr::ListDecoration, ListCursorMode, ListEditor, ListEditorStyle},
         sequence::{SequenceView, SequenceViewExt},
-        index::buffer::IndexBuffer,
+        singleton::SingletonView,
-        vec::VecBuffer,
-        terminal::{TerminalAtom, TerminalStyle, TerminalView, TerminalEvent, TerminalEditor, TerminalEditorResult, make_label},
-        tree_nav::{TreeNav, TreeNavResult, TerminalTreeEditor, TreeCursor},
-        list::{ListCursorMode, ListEditor, ListEditorStyle, sexpr::ListDecoration},
         string_editor::CharEditor,
+        terminal::{
+            TerminalAtom, TerminalEditor, TerminalEditorResult, TerminalEvent, TerminalStyle,
+            TerminalView,
         },
-    crate::pty::{PTY, PTYStatus}
+        tree_nav::{TerminalTreeEditor, TreeCursor, TreeNav, TreeNavResult},
+    },
+    std::sync::Arc,
+    std::sync::RwLock,
+    termion::event::{Event, Key},
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 pub struct ProcessArg {
-    editor: ListEditor< CharEditor,
+    editor:
-                        Box<dyn Fn() -> Arc<RwLock<CharEditor>> + Send + Sync + 'static> >
+        ListEditor<CharEditor, Box<dyn Fn() -> Arc<RwLock<CharEditor>> + Send + Sync + 'static>>,
 }
 
 impl ProcessArg {
     pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = char>> {
-        self.editor.get_data_port()
+        self.editor.get_data_port().map(|char_editor| {
-            .map(
+            char_editor
-                |char_editor| char_editor.read().unwrap().get_data_port().get_view().unwrap().get().unwrap()
+                .read()
-            )
+                .unwrap()
+                .get_data_port()
+                .get_view()
+                .unwrap()
+                .get()
+                .unwrap()
+        })
     }
 }
 
@@ -47,41 +49,56 @@ impl TerminalEditor for ProcessArg {
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
         match event {
-            TerminalEvent::Input(Event::Key(Key::Char(' '))) |
+            TerminalEvent::Input(Event::Key(Key::Char(' ')))
-            TerminalEvent::Input(Event::Key(Key::Char('\n'))) => {
+            | TerminalEvent::Input(Event::Key(Key::Char('\n'))) => {
                 self.editor.up();
                 TerminalEditorResult::Exit
             }
 
-            event => self.editor.handle_terminal_event(event)
+            event => self.editor.handle_terminal_event(event),
         }
     }
 }
 
 impl TreeNav for ProcessArg {
-    fn get_cursor(&self) -> TreeCursor { self.editor.get_cursor() }
+    fn get_cursor(&self) -> TreeCursor {
-    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult  { self.editor.goto(cur) }
+        self.editor.get_cursor()
-    fn goto_home(&mut self) -> TreeNavResult  { self.editor.goto_home() }
+    }
-    fn goto_end(&mut self) -> TreeNavResult  { self.editor.goto_end() }
+    fn goto(&mut self, cur: TreeCursor) -> TreeNavResult {
-    fn pxev(&mut self) -> TreeNavResult  { self.editor.pxev() }
+        self.editor.goto(cur)
-    fn nexd(&mut self) -> TreeNavResult  { self.editor.nexd() }
+    }
-    fn up(&mut self) -> TreeNavResult { self.editor.up() }
+    fn goto_home(&mut self) -> TreeNavResult {
-    fn dn(&mut self) -> TreeNavResult { self.editor.dn() }
+        self.editor.goto_home()
+    }
+    fn goto_end(&mut self) -> TreeNavResult {
+        self.editor.goto_end()
+    }
+    fn pxev(&mut self) -> TreeNavResult {
+        self.editor.pxev()
+    }
+    fn nexd(&mut self) -> TreeNavResult {
+        self.editor.nexd()
+    }
+    fn up(&mut self) -> TreeNavResult {
+        self.editor.up()
+    }
+    fn dn(&mut self) -> TreeNavResult {
+        self.editor.dn()
+    }
 }
 
 pub struct ProcessLauncher {
-    cmd_editor: ListEditor<
+    cmd_editor:
-            ProcessArg, Box<dyn Fn() -> Arc<RwLock<ProcessArg>> + Send + Sync + 'static>
+        ListEditor<ProcessArg, Box<dyn Fn() -> Arc<RwLock<ProcessArg>> + Send + Sync + 'static>>,
-        >,
     pty: Option<crate::pty::PTY>,
-    ptybox: Arc<RwLock<crate::ascii_box::AsciiBox>>,
+    _ptybox: Arc<RwLock<crate::ascii_box::AsciiBox>>,
     suspended: bool,
 
     pty_port: ViewPort<dyn TerminalView>,
     status_port: ViewPort<dyn SingletonView<Item = PTYStatus>>,
 
     comp_port: ViewPort<dyn TerminalView>,
-    compositor: Arc<RwLock<nested::terminal::TerminalCompositor>>
+    _compositor: Arc<RwLock<nested::terminal::TerminalCompositor>>,
 }
 
 impl ProcessLauncher {
@@ -93,50 +110,45 @@ impl ProcessLauncher {
         let compositor = nested::terminal::TerminalCompositor::new(comp_port.inner());
 
         let cmd_editor = ListEditor::new(
-                Box::new(
+            Box::new(|| {
-                    || {
                 Arc::new(RwLock::new(ProcessArg {
                     editor: ListEditor::new(
-                            Box::new(
+                        Box::new(|| Arc::new(RwLock::new(CharEditor::new()))),
-                                || {
+                        ListEditorStyle::Plain,
-                                    Arc::new(RwLock::new(CharEditor::new()))
-                                }
                     ),
-                            ListEditorStyle::Plain)
                 }))
-                    }
+            }) as Box<dyn Fn() -> Arc<RwLock<ProcessArg>> + Send + Sync>,
-                ) as Box::<dyn Fn() -> Arc<RwLock<ProcessArg>> + Send + Sync>,
+            ListEditorStyle::Plain,
-                ListEditorStyle::Plain
         );
 
-        
-        
         compositor.write().unwrap().push(
-            box_port.outer()
+            box_port
-                .map_item(|_idx, x| x.add_style_back(TerminalStyle::fg_color((90, 120, 100))))
+                .outer()
+                .map_item(|_idx, x| x.add_style_back(TerminalStyle::fg_color((90, 120, 100)))),
         );
         compositor.write().unwrap().push(
             cmd_editor
                 .get_seg_seq_view()
                 .decorate("$(", ")", " ", 0)
                 .to_grid_horizontal()
-                .flatten()
+                .flatten(),
         );
 
         ProcessLauncher {
             cmd_editor,
             pty: None,
-            ptybox: crate::ascii_box::AsciiBox::new(
+            _ptybox: crate::ascii_box::AsciiBox::new(
                 cgmath::Vector2::new(0, 0),
-                    pty_port.outer()
+                pty_port.outer().map_item(|_, a: &TerminalAtom| {
-                        .map_item(|_,a:&TerminalAtom| a.add_style_back(TerminalStyle::fg_color((230, 230, 230)))),
+                    a.add_style_back(TerminalStyle::fg_color((230, 230, 230)))
-                    box_port.inner()
+                }),
+                box_port.inner(),
             ),
             suspended: false,
             pty_port,
             status_port,
             comp_port,
-            compositor
+            _compositor: compositor,
         }
     }
 
@@ -145,7 +157,14 @@ impl ProcessLauncher {
 
         let v = self.cmd_editor.get_data_port().get_view().unwrap();
         for i in 0..v.len().unwrap_or(0) {
-            let arg_view = v.get(&i).unwrap().read().unwrap().get_data_port().get_view().unwrap();
+            let arg_view = v
+                .get(&i)
+                .unwrap()
+                .read()
+                .unwrap()
+                .get_data_port()
+                .get_view()
+                .unwrap();
             strings.push(arg_view.iter().collect::<String>());
         }
 
@@ -157,10 +176,15 @@ impl ProcessLauncher {
 
             self.cmd_editor.goto(TreeCursor {
                 leaf_mode: ListCursorMode::Insert,
-                tree_addr: vec![]
+                tree_addr: vec![],
             });
 
-            self.pty = PTY::new(cmd, cgmath::Vector2::new(120, 40), self.pty_port.inner(), self.status_port.inner());
+            self.pty = PTY::new(
+                cmd,
+                cgmath::Vector2::new(120, 40),
+                self.pty_port.inner(),
+                self.status_port.inner(),
+            );
         }
     }
 
@@ -175,9 +199,8 @@ impl TerminalEditor for ProcessLauncher {
     }
 
     fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
-
         // todo: move to observer of status view
-        if let PTYStatus::Done{ status } = self.status_port.outer().get_view().get() {
+        if let PTYStatus::Done { status: _ } = self.status_port.outer().get_view().get() {
             self.pty = None;
             self.suspended = false;
         }
@@ -185,7 +208,7 @@ impl TerminalEditor for ProcessLauncher {
         match event {
             TerminalEvent::Input(Event::Key(Key::Ctrl('c'))) => {
                 // todo: sigterm instead of kill?
-                if let Some(mut pty) = self.pty.as_mut() {
+                if let Some(pty) = self.pty.as_mut() {
                     pty.kill();
                 }
 
@@ -193,15 +216,15 @@ impl TerminalEditor for ProcessLauncher {
                 self.suspended = false;
                 self.cmd_editor.goto(TreeCursor {
                     leaf_mode: ListCursorMode::Insert,
-                    tree_addr: vec![]
+                    tree_addr: vec![],
                 });
                 TerminalEditorResult::Exit
-            },
+            }
             TerminalEvent::Input(Event::Key(Key::Ctrl('z'))) => {
                 self.suspended = true;
                 self.cmd_editor.goto(TreeCursor {
                     leaf_mode: ListCursorMode::Insert,
-                    tree_addr: vec![]
+                    tree_addr: vec![],
                 });
                 TerminalEditorResult::Exit
             }
@@ -216,7 +239,7 @@ impl TerminalEditor for ProcessLauncher {
                             self.launch_pty();
                             TerminalEditorResult::Continue
                         }
-                        event => self.cmd_editor.handle_terminal_event(event)                    
+                        event => self.cmd_editor.handle_terminal_event(event),
                     }
                 }
             }
@@ -231,7 +254,7 @@ impl TreeNav for ProcessLauncher {
 
     fn goto(&mut self, cur: TreeCursor) -> TreeNavResult {
         self.suspended = false;
-        if let PTYStatus::Done{status} = self.status_port.outer().get_view().get() {
+        if let PTYStatus::Done { status: _ } = self.status_port.outer().get_view().get() {
             self.pty = None;
         }
 
@@ -240,7 +263,7 @@ impl TreeNav for ProcessLauncher {
         } else {
             self.cmd_editor.goto(TreeCursor {
                 leaf_mode: ListCursorMode::Select,
-                tree_addr: vec![]
+                tree_addr: vec![],
             });
             TreeNavResult::Continue
         }
@@ -270,4 +293,3 @@ impl TreeNav for ProcessLauncher {
         self.cmd_editor.dn()
     }
 }
-

shell/src/pty.rs

@@ -1,13 +1,12 @@
-
 use {
-    std::sync::{Arc, Mutex},
-    termion::event::{Key, Event},
     cgmath::Vector2,
     nested::{
-        core::{InnerViewPort},
+        core::InnerViewPort,
-        singleton::{SingletonView, SingletonBuffer},
+        singleton::{SingletonBuffer, SingletonView},
-        terminal::{TerminalView, TerminalEvent, TerminalEditorResult}
+        terminal::{TerminalEditorResult, TerminalEvent, TerminalView},
-    }
+    },
+    std::sync::{Arc, Mutex},
+    termion::event::{Event, Key},
 };
 
 pub use portable_pty::CommandBuilder;
@@ -17,14 +16,12 @@ pub use portable_pty::CommandBuilder;
 #[derive(Clone)]
 pub enum PTYStatus {
     Running { pid: u32 },
-    Done{ status: portable_pty::ExitStatus }
+    Done { status: portable_pty::ExitStatus },
 }
 
 impl Default for PTYStatus {
     fn default() -> Self {
-        PTYStatus::Running {
+        PTYStatus::Running { pid: 0 }
-            pid: 0
-        }
     }
 }
 
@@ -32,7 +29,7 @@ impl Default for PTYStatus {
 
 pub struct PTY {
     master: Mutex<Box<dyn portable_pty::MasterPty + Send>>,
-    child: Arc<Mutex<Box<dyn portable_pty::Child + Send + Sync>>>
+    child: Arc<Mutex<Box<dyn portable_pty::Child + Send + Sync>>>,
 }
 
 impl PTY {
@@ -40,11 +37,11 @@ impl PTY {
         cmd: portable_pty::CommandBuilder,
         max_size: Vector2<i16>,
         term_port: InnerViewPort<dyn TerminalView>,
-        status_port: InnerViewPort<dyn SingletonView<Item = PTYStatus>>
+        status_port: InnerViewPort<dyn SingletonView<Item = PTYStatus>>,
     ) -> Option<Self> {
-
         // Create a new pty
-        let mut pair = portable_pty::native_pty_system().openpty(portable_pty::PtySize {
+        let pair = portable_pty::native_pty_system()
+            .openpty(portable_pty::PtySize {
                 rows: max_size.y as u16,
                 cols: max_size.x as u16,
 
@@ -55,23 +52,27 @@ impl PTY {
                 // brief example though!
                 pixel_width: 0,
                 pixel_height: 0,
-        }).unwrap();
+            })
+            .unwrap();
 
-        if let Ok(mut child) = pair.slave.spawn_command(cmd) {
+        if let Ok(child) = pair.slave.spawn_command(cmd) {
             let mut reader = pair.master.try_clone_reader().unwrap();
-            let mut status_buf = SingletonBuffer::new(PTYStatus::Running{ pid: child.process_id().expect("") }, status_port);
+            let mut status_buf = SingletonBuffer::new(
+                PTYStatus::Running {
+                    pid: child.process_id().expect(""),
+                },
+                status_port,
+            );
 
             let child = Arc::new(Mutex::new(child));
 
-            async_std::task::spawn_blocking(
+            async_std::task::spawn_blocking(move || {
-                move || {
                 nested::terminal::ansi_parser::read_ansi_from(&mut reader, max_size, term_port);
             });
 
             async_std::task::spawn_blocking({
                 let child = child.clone();
-                move || {
+                move || loop {
-                    loop {
                     if let Ok(Some(status)) = child.lock().unwrap().try_wait() {
                         status_buf.set(PTYStatus::Done { status });
                         break;
@@ -79,12 +80,11 @@ impl PTY {
 
                     std::thread::sleep(std::time::Duration::from_millis(10));
                 }
-                }
             });
 
             Some(PTY {
                 master: Mutex::new(pair.master),
-                child
+                child,
             })
         } else {
             None
@@ -92,7 +92,7 @@ impl PTY {
     }
 
     pub fn kill(&mut self) {
-        self.child.lock().unwrap().kill();
+        self.child.lock().unwrap().kill().unwrap();
     }
 
     pub fn handle_terminal_event(&mut self, event: &TerminalEvent) -> TerminalEditorResult {
@@ -100,11 +100,11 @@ impl PTY {
             TerminalEvent::Input(Event::Key(Key::Char('\n'))) => {
                 self.master.lock().unwrap().write(&[13]).unwrap();
                 TerminalEditorResult::Continue
-            },
+            }
             TerminalEvent::Input(Event::Key(Key::Char(c))) => {
-                write!(self.master.lock().unwrap(), "{}", c);
+                write!(self.master.lock().unwrap(), "{}", c).unwrap();
                 TerminalEditorResult::Continue
-            },
+            }
             TerminalEvent::Input(Event::Key(Key::Esc)) => {
                 self.master.lock().unwrap().write(&[0x1b]).unwrap();
                 TerminalEditorResult::Continue
@@ -114,37 +114,54 @@ impl PTY {
                 TerminalEditorResult::Continue
             }
             TerminalEvent::Input(Event::Key(Key::F(n))) => {
-                self.master.lock().unwrap().write(&[
+                self.master
+                    .lock()
+                    .unwrap()
+                    .write(&[
                         0x1b,
                         0x0a,
                         match n {
                             11 => 133,
                             12 => 134,
-                        n => 58 + n
+                            n => 58 + n,
-                    }
+                        },
-                ]).unwrap();
+                    ])
+                    .unwrap();
                 TerminalEditorResult::Continue
             }
             TerminalEvent::Input(Event::Key(Key::Up)) => {
-                self.master.lock().unwrap().write(&[b'\x1B', b'[', b'A']).unwrap();
+                self.master
+                    .lock()
+                    .unwrap()
+                    .write(&[b'\x1B', b'[', b'A'])
+                    .unwrap();
                 TerminalEditorResult::Continue
             }
             TerminalEvent::Input(Event::Key(Key::Down)) => {
-                self.master.lock().unwrap().write(&[b'\x1B', b'[', b'B']).unwrap();
+                self.master
+                    .lock()
+                    .unwrap()
+                    .write(&[b'\x1B', b'[', b'B'])
+                    .unwrap();
                 TerminalEditorResult::Continue
             }
             TerminalEvent::Input(Event::Key(Key::Right)) => {
-                self.master.lock().unwrap().write(&[b'\x1B', b'[', b'C']).unwrap();
+                self.master
+                    .lock()
+                    .unwrap()
+                    .write(&[b'\x1B', b'[', b'C'])
+                    .unwrap();
                 TerminalEditorResult::Continue
             }
             TerminalEvent::Input(Event::Key(Key::Left)) => {
-                self.master.lock().unwrap().write(&[b'\x1B', b'[', b'D']).unwrap();
+                self.master
+                    .lock()
+                    .unwrap()
+                    .write(&[b'\x1B', b'[', b'D'])
+                    .unwrap();
                 TerminalEditorResult::Continue
             }
-            _ => {
+            _ => TerminalEditorResult::Exit,
-                TerminalEditorResult::Exit
         }
     }
 }
-}
-

terminal/ansi_parser/src/main.rs

@@ -1,19 +1,14 @@
 #![feature(iter_advance_by)]
 
 use {
+    cgmath::Point2,
+    nested::terminal::{TerminalAtom, TerminalStyle},
     std::{
         fs::File,
+        io::{stdin, Read, Write},
         os::unix::io::FromRawFd,
-        io::{Read, Write, stdin}
     },
-    nested::{
+    vte::{Params, Parser, Perform},
-        terminal::{
-            TerminalAtom,
-            TerminalStyle
-        },
-    },
-    cgmath::Point2,
-    vte::{Params, Parser, Perform}
 };
 
 struct ColorPalett {
@@ -24,7 +19,7 @@ struct ColorPalett {
     blue: (u8, u8, u8),
     magenta: (u8, u8, u8),
     cyan: (u8, u8, u8),
-    white: (u8, u8, u8)
+    white: (u8, u8, u8),
 }
 
 struct PerfAtom {
@@ -39,17 +34,16 @@ struct PerfAtom {
 
 impl PerfAtom {
     fn write_atom(&mut self, pos: Point2<i16>, atom: Option<TerminalAtom>) {
-        self.out.write(&bincode::serialize(&(pos, atom)).unwrap()).expect("");
+        self.out
+            .write(&bincode::serialize(&(pos, atom)).unwrap())
+            .expect("");
     }
 }
 
 impl Perform for PerfAtom {
     fn print(&mut self, c: char) {
         //eprintln!("[print] {:?}", c);
-        self.write_atom(
+        self.write_atom(self.cursor, Some(TerminalAtom::new(c, self.style)));
-            self.cursor,
-            Some(TerminalAtom::new(c, self.style))
-        );
 
         self.cursor.x += 1;
         if self.cursor.x > self.term_width {
@@ -64,7 +58,7 @@ impl Perform for PerfAtom {
             b'\n' => {
                 self.cursor.x = 0;
                 self.cursor.y += 1;
-            },
+            }
             _ => {}
         }
     }
@@ -85,7 +79,10 @@ impl Perform for PerfAtom {
     }
 
     fn osc_dispatch(&mut self, params: &[&[u8]], bell_terminated: bool) {
-        eprintln!("[osc_dispatch] params={:?} bell_terminated={}", params, bell_terminated);
+        eprintln!(
+            "[osc_dispatch] params={:?} bell_terminated={}",
+            params, bell_terminated
+        );
     }
 
     fn csi_dispatch(&mut self, params: &Params, intermediates: &[u8], ignore: bool, c: char) {
@@ -98,29 +95,60 @@ impl Perform for PerfAtom {
 
         match c {
             // Set SGR
-            'm' =>  while let Some(n) = piter.next() {
+            'm' => {
+                while let Some(n) = piter.next() {
                     match n[0] {
                         0 => self.style = TerminalStyle::default(),
                         1 => self.style = self.style.add(TerminalStyle::bold(true)),
                         3 => self.style = self.style.add(TerminalStyle::italic(true)),
                         4 => self.style = self.style.add(TerminalStyle::underline(true)),
 
-                        30 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.black)),
+                        30 => {
-                        40 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.black)),
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.black))
+                        }
+                        40 => {
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.black))
+                        }
                         31 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.red)),
                         41 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.red)),
-                        32 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.green)),
+                        32 => {
-                        42 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.green)),
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.green))
-                        33 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.yellow)),
+                        }
-                        43 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.yellow)),
+                        42 => {
-                        34 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.blue)),
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.green))
-                        44 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.blue)),
+                        }
-                        35 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.magenta)),
+                        33 => {
-                        45 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.magenta)),
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.yellow))
-                        36 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.cyan)),
+                        }
-                        46 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.cyan)),
+                        43 => {
-                        37 => self.style = self.style.add(TerminalStyle::fg_color(self.colors.white)),
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.yellow))
-                        47 => self.style = self.style.add(TerminalStyle::bg_color(self.colors.white)),
+                        }
+                        34 => {
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.blue))
+                        }
+                        44 => {
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.blue))
+                        }
+                        35 => {
+                            self.style =
+                                self.style.add(TerminalStyle::fg_color(self.colors.magenta))
+                        }
+                        45 => {
+                            self.style =
+                                self.style.add(TerminalStyle::bg_color(self.colors.magenta))
+                        }
+                        36 => {
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.cyan))
+                        }
+                        46 => {
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.cyan))
+                        }
+                        37 => {
+                            self.style = self.style.add(TerminalStyle::fg_color(self.colors.white))
+                        }
+                        47 => {
+                            self.style = self.style.add(TerminalStyle::bg_color(self.colors.white))
+                        }
 
                         38 => {
                             let x = piter.next().unwrap();
@@ -129,15 +157,21 @@ impl Perform for PerfAtom {
                                     let r = piter.next().unwrap();
                                     let g = piter.next().unwrap();
                                     let b = piter.next().unwrap();
-                                    self.style = self.style.add(TerminalStyle::fg_color((r[0] as u8, g[0] as u8, b[30] as u8)))
+                                    self.style = self.style.add(TerminalStyle::fg_color((
-                                },
+                                        r[0] as u8,
+                                        g[0] as u8,
+                                        b[30] as u8,
+                                    )))
+                                }
                                 5 => {
                                     let v = piter.next().unwrap();
-                                    self.style = self.style.add(TerminalStyle::fg_color(ansi_colours::rgb_from_ansi256(v[0] as u8)))
+                                    self.style = self.style.add(TerminalStyle::fg_color(
-                                },
+                                        ansi_colours::rgb_from_ansi256(v[0] as u8),
+                                    ))
+                                }
                                 _ => {}
                             }
-                        },
+                        }
 
                         48 => {
                             let x = piter.next().unwrap();
@@ -146,31 +180,50 @@ impl Perform for PerfAtom {
                                     let r = piter.next().unwrap();
                                     let g = piter.next().unwrap();
                                     let b = piter.next().unwrap();
-                                    self.style = self.style.add(TerminalStyle::bg_color((r[0] as u8, g[0] as u8, b[30] as u8)))
+                                    self.style = self.style.add(TerminalStyle::bg_color((
-                                },
+                                        r[0] as u8,
+                                        g[0] as u8,
+                                        b[30] as u8,
+                                    )))
+                                }
                                 5 => {
                                     let v = piter.next().unwrap();
-                                    self.style = self.style.add(TerminalStyle::bg_color(ansi_colours::rgb_from_ansi256(v[0] as u8)))
+                                    self.style = self.style.add(TerminalStyle::bg_color(
-                                },
+                                        ansi_colours::rgb_from_ansi256(v[0] as u8),
+                                    ))
+                                }
                                 _ => {}
                             }
-                        },
+                        }
 
                         _ => {}
                     }
-            },
+                }
+            }
 
             'H' => {
-                if let Some(y) = piter.next() { self.cursor.y = y[0] as i16 - 1 };
+                if let Some(y) = piter.next() {
-                if let Some(x) = piter.next() { self.cursor.x = x[0] as i16 - 1 };
+                    self.cursor.y = y[0] as i16 - 1
+                };
+                if let Some(x) = piter.next() {
+                    self.cursor.x = x[0] as i16 - 1
+                };
 
                 eprintln!("cursor at {:?}", self.cursor);
-            },
+            }
 
-            'A' => { self.cursor.y -= piter.next().unwrap()[0] as i16; }
+            'A' => {
-            'B' => { self.cursor.y += piter.next().unwrap()[0] as i16; }
+                self.cursor.y -= piter.next().unwrap()[0] as i16;
-            'C' => { self.cursor.x += piter.next().unwrap()[0] as i16; }
+            }
-            'D' => { self.cursor.x -= piter.next().unwrap()[0] as i16; }
+            'B' => {
+                self.cursor.y += piter.next().unwrap()[0] as i16;
+            }
+            'C' => {
+                self.cursor.x += piter.next().unwrap()[0] as i16;
+            }
+            'D' => {
+                self.cursor.x -= piter.next().unwrap()[0] as i16;
+            }
             'E' => {
                 self.cursor.x = 0;
                 self.cursor.y += piter.next().unwrap()[0] as i16;
@@ -179,12 +232,8 @@ impl Perform for PerfAtom {
             'J' => {
                 let x = piter.next().unwrap_or(&[0 as u16; 1]);
                 match x[0] {
-                    0 => {
+                    0 => {}
-                        
+                    1 => {}
-                    },
-                    1 => {
-                        
-                    }
                     2 => {
                         for y in 0..100 {
                             for x in 0..self.term_width {
@@ -201,27 +250,26 @@ impl Perform for PerfAtom {
             'K' => {
                 let x = piter.next().unwrap();
                 match x[0] {
-
                     // clear cursor until end
                     0 => {
                         for x in self.cursor.x..self.term_width {
                             self.write_atom(Point2::new(x, self.cursor.y), None);
                         }
-                    },
+                    }
 
                     // clear start until cursor
                     1 => {
                         for x in 0..self.cursor.x {
                             self.write_atom(Point2::new(x, self.cursor.y), None);
                         }
-                    },
+                    }
 
                     // clear entire line
                     2 => {
                         for x in 0..self.term_width {
                             self.write_atom(Point2::new(x, self.cursor.y), None);
                         }
-                    },
+                    }
 
                     // invalid
                     _ => {}
@@ -259,8 +307,8 @@ fn main() {
             blue: (0, 111, 184),
             magenta: (118, 38, 113),
             cyan: (44, 181, 233),
-            white: (204, 204, 204)
+            white: (204, 204, 204),
-        }
+        },
     };
 
     let mut buf = [0; 2048];
@@ -273,12 +321,11 @@ fn main() {
                     statemachine.advance(&mut performer, *byte);
                     performer.out.flush().unwrap();
                 }
-            },
+            }
             Err(err) => {
                 println!("err: {}", err);
                 break;
-            },
             }
         }
     }
-
+}

terminal/display_server/src/main.rs

@@ -1,21 +1,20 @@
 use {
-    std::{
+    cgmath::{Point2, Vector2},
-        io::{Read, Write, stdout}
+    nested::terminal::{TerminalAtom, TerminalStyle},
-    },
+    std::io::{stdout, Read, Write},
-    nested::terminal::{
-        TerminalAtom,
-        TerminalStyle
-    },
     termion::raw::IntoRawMode,
-    cgmath::{Point2, Vector2}
 };
 
 fn main() {
     let mut out = stdout().into_raw_mode().unwrap();
-    write!(out, "{}{}{}",
+    write!(
+        out,
+        "{}{}{}",
         termion::cursor::Hide,
         termion::cursor::Goto(1, 1),
-           termion::style::Reset).unwrap();
+        termion::style::Reset
+    )
+    .unwrap();
 
     let mut cur_pos = Point2::<i16>::new(0, 0);
     let mut cur_style = TerminalStyle::default();
@@ -26,7 +25,12 @@ fn main() {
         match bincode::deserialize_from::<_, (Point2<i16>, Option<TerminalAtom>)>(input.by_ref()) {
             Ok((pos, atom)) => {
                 if pos != cur_pos {
-                    write!(out, "{}", termion::cursor::Goto(pos.x as u16 + 1, pos.y as u16 + 1)).unwrap();
+                    write!(
+                        out,
+                        "{}",
+                        termion::cursor::Goto(pos.x as u16 + 1, pos.y as u16 + 1)
+                    )
+                    .unwrap();
                 }
 
                 if let Some(atom) = atom {
@@ -47,9 +51,7 @@ fn main() {
             }
             Err(err) => {
                 match *err {
-                    bincode::ErrorKind::Io(_io_error) => {
+                    bincode::ErrorKind::Io(_io_error) => break,
-                        break
-                    }
                     err => {
                         eprintln!("deserialization error\n{:?}", err);
                     }
@@ -63,4 +65,3 @@ fn main() {
     write!(out, "{}", termion::cursor::Show).unwrap();
     out.flush().unwrap();
 }
-