more ReprTree refactoring

- <Vec Char>  ~>  <Vec ReprTree>  packing/unpacking
- remove Arc<RwLock<>> around EditTree
- gentle ListEditor update
- reactivate PosInt example

examples/tty-02-digit/src/main.rs

@@ -11,7 +11,7 @@ use {
     cgmath::Vector2,
     nested::{
         editors::ObjCommander,
-        repr_tree::{Context, ReprTree, ReprTreeExt},
+        repr_tree::{Context, ReprTree, ReprTreeExt, ReprTreeBuilder},
         edit_tree::{EditTree}
     },
     nested_tty::{
@@ -39,50 +39,23 @@ async fn main() {
 
     nested_tty::setup_edittree_hook(&ctx);
 
-    /* structure of Repr-Tree
-     *
-     *   === Repr-Tree ===
-     *
-     *        <Digit 10>
-     *         /   |     \
-     *        /    |        \
-     *       /     |          \
-     *     u64   EditTree     Char
-     *           - Editor         \
-     *           - Display        EditTree
-     *         /     |    \      - Editor
-     *        /      |     \     - Display
-     *      TTY  PixelBuf  SDF  /    |     \
-     *                         /     |      \
-     *                       TTY  PixelBuf  SDF
-     */
-    let mut rt_digit = ReprTree::new_arc( Context::parse(&ctx, "<Digit 16>") );
+    let digit_builder = ReprTreeBuilder::new( ctx.clone() )
+        .require(Context::parse(&ctx, "<Digit 16> ~ ℤ_2^64 ~ machine.UInt64"))
+        .require(Context::parse(&ctx, "<Digit 16> ~ EditTree"))
+    ;
 
     /* add initial representation
      *  <Digit 16> ~ Char
      */
-    rt_digit.insert_leaf(
+    let mut rt_digit = ReprTree::from_singleton_buffer(
         Context::parse(&ctx, "Char"),
-        nested::repr_tree::ReprLeaf::from_singleton_buffer( SingletonBuffer::new('5') )
+        SingletonBuffer::new('5')
     );
-
-    /* furthermore, setup projections to and from u8 value,
-     * this synchronizes the buffers 
-     */
-    ctx.read().unwrap().apply_morphism(
-        &rt_digit,
-        &laddertypes::MorphismType {
-            src_type: Context::parse(&ctx, "<Digit 16>~Char"),
-            dst_type: Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64")
-        }
-    );
-    ctx.read().unwrap().apply_morphism(
-        &rt_digit,
-        &laddertypes::MorphismType {
-            src_type: Context::parse(&ctx, "<Digit 16>~Char"),
-            dst_type: Context::parse(&ctx, "<Digit 16>~EditTree")
-        }
+    rt_digit.write().unwrap().set_halo(
+        Context::parse(&ctx, "<Digit 16>")
     );
+    rt_digit = digit_builder.build_from(rt_digit)
+        .expect("failed to build repr tree");
 
     /* setup terminal
      */
@@ -92,7 +65,7 @@ async fn main() {
         let ctx = ctx.clone();
         let digit_edittree = rt_digit.edittree( &ctx );
         move |ev| {
-            digit_edittree.get().write().unwrap().send_cmd_obj(ev.to_repr_tree(&ctx));
+            digit_edittree.get_mut().send_cmd_obj(ev.to_repr_tree(&ctx));
         }
     });
 
@@ -118,7 +91,7 @@ async fn main() {
             .offset(Vector2::new(1,1)));
 
         comp.push(rt_digit
-            .edittree( &ctx ).get().read().unwrap()
+            .edittree( &ctx ).get()
             .display_view()
             .offset(Vector2::new(3,2)));
 

examples/tty-03-string/src/main.rs

@@ -15,7 +15,7 @@ use {
     cgmath::Vector2,
     nested::{
         editors::ObjCommander,
-        repr_tree::{Context, ReprTree, ReprTreeExt},
+        repr_tree::{Context, ReprTree, ReprTreeExt, ReprTreeBuilder},
         edit_tree::{EditTree}
     },
     nested_tty::{
@@ -41,57 +41,37 @@ async fn main() {
     nested::editors::list::init_ctx( ctx.clone() );
     nested_tty::setup_edittree_hook(&ctx);
 
-    /* Create a Representation-Tree of type <List Char>
+    /* create a Representation-Tree of type <List Char>
      */
-    let mut rt_string = ReprTree::from_str(
-        Context::parse(&ctx, "<List Char>~<Vec Char>"),
-        "hello world"
+    let mut rt_data = ReprTree::from_str("Hello World!");
+    rt_data.write().unwrap().set_halo(
+        Context::parse(&ctx, "<List Char>")
     );
 
-    /* create EditTree
+    /* specify required representations
      */
-    ctx.read().unwrap().apply_morphism(
-        &rt_string,
-        &laddertypes::MorphismType {
-            src_type: Context::parse(&ctx, "<List~Vec Char>"),
-            dst_type: Context::parse(&ctx, "<List Char> ~ EditTree")
-        }
-    );
+    let rt_string_builder = ReprTreeBuilder::new( ctx.clone() )
+        .require(Context::parse(&ctx, "<List Char>~<Vec Char>"))
+        .require(Context::parse(&ctx, "<List Char>"))
+        .require(Context::parse(&ctx, "<List Char>~EditTree"))
+    ;
 
-    // .. avoid cycle of projections..
-    rt_string.write().unwrap().detach(&ctx);
+    // initially, populate from <Vec Char> representation
+    let mut rt_string = rt_string_builder.build_from(rt_data)
+        .expect("could not build rt_string");
+
+    // hand over control to EditTree representation
+    rt_string_builder.update( &rt_string, Context::parse(&ctx, "<List Char>~EditTree") )
+        .expect("could not update rt_string");
 
-    /* In order to get access to the values that are modified by the Editor,
-     * we apply a morphism that, given the List of Edit-Trees, extracts
-     * the value from each EditTree and shows them in a ListView.
-     */
-    ctx.read().unwrap().apply_morphism(
-        &rt_string,
-        &laddertypes::MorphismType {
-            src_type: Context::parse(&ctx, "<List Char>~EditTree"),
-            dst_type: Context::parse(&ctx, "<List Char>")
-        }
-    );
 
     /* Now, get the ListView that serves our char-values.
      * This view is a projection created by the morphism that was called above.
      */
     let mut chars_view = rt_string
-        .read().unwrap()
         .get_port::<dyn ListView<char>>()
         .unwrap();
 
-    /* Lets add another morphism which will store the values
-     * of the character-list in a `Vec<char>`
-     */
-    ctx.read().unwrap().apply_morphism(
-        &rt_string,
-        &laddertypes::MorphismType {
-            src_type: Context::parse(&ctx, "<List Char>"),
-            dst_type: Context::parse(&ctx, "<List Char>~<Vec Char>")
-        }
-    );
-
     /* Access the Vec<char> object (wrapped behind a VecBuffer<char>)
      * from the ReprTree.
      */
@@ -115,7 +95,8 @@ async fn main() {
          */
         let ctx = ctx.clone();
         move |ev| {
-            edittree_list.get().write().unwrap().send_cmd_obj(ev.to_repr_tree(&ctx));
+            let cmd = ev.to_repr_tree(&ctx);
+            edittree_list.get_mut().send_cmd_obj(cmd);
         }
     });
 
@@ -130,15 +111,17 @@ async fn main() {
     {
         let mut comp = compositor.write().unwrap();
 
-        let label_str = ctx.read().unwrap().type_term_to_str(&rt_string.read().unwrap().get_type());
+        let label_str = ctx.read().unwrap()
+            .type_term_to_str(&rt_string.read().unwrap().get_type());
+
         comp.push(
             nested_tty::make_label(&label_str)
-                .map_item(|_pt, atom| atom.add_style_front(TerminalStyle::fg_color((90,90,90))))
+                .map_item(|_pt, atom|
+                    atom.add_style_front(TerminalStyle::fg_color((90,90,90))))
                 .offset(Vector2::new(1,1)));
 
         comp.push(
             rt_string.edittree(&ctx).get()
-                .read().unwrap()
                 .display_view()
                 .offset(Vector2::new(3,2)));
 

examples/tty-04-posint/src/main.rs

@@ -16,17 +16,18 @@ use {
         editors::{
             ObjCommander
         },
-        repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf},
+        repr_tree::{Context, ReprTreeBuilder, ReprTree, ReprTreeExt, ReprLeaf},
         edit_tree::{EditTree, TreeNav, TreeCursor}
     },
     nested_tty::{
         DisplaySegment, TTYApplication,
         TerminalCompositor, TerminalStyle, TerminalView,
-        TerminalAtom, TerminalEvent
+        TerminalAtom, TerminalEvent,
+        edit_tree::cursor_widget::TreeNavExt
     },
     r3vi::{
         buffer::{singleton::*, vec::*},
-        view::{port::UpdateTask, singleton::*, list::*, sequence::*},
+        view::{port::UpdateTask, ViewPort, singleton::*, list::*, sequence::*},
         projection::*
     },
     std::sync::{Arc, RwLock},
@@ -46,89 +47,66 @@ async fn main() {
     /* Create a Representation-Tree of type `ℕ`
      * with a specific representation-path (big-endian hexadecimal string)
      */
-    let mut rt_int = nested::repr_tree::ReprTree::from_str(
-        /* TYPE */
+    let int_builder = ReprTreeBuilder::new( ctx.clone() )
+            .require(Context::parse(&ctx,
+                "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char> ~ EditTree"))
+            .require(Context::parse(&ctx,
+                "ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10>~Char> ~ EditTree"))
+            /*
+            .require(Context::parse(&ctx,
+                "ℕ ~ <PosInt 8 BigEndian> ~ EditTree"))
+            .require(Context::parse(&ctx,
+                "ℕ ~ <PosInt 2 BigEndian> ~ EditTree"))
+                */
+                ;
+
+    let mut rt_int = nested::repr_tree::ReprTree::from_str("f");
+    rt_int.write().unwrap().set_halo(
+        /* HALO TYPE */
         Context::parse(&ctx, "
               ℕ
             ~ <PosInt 16 BigEndian>
             ~ <Seq <Digit 16>>
             ~ <List <Digit 16>>
             ~ <List Char>
-            ~ <Vec Char>
-        "),
-
-        /* VALUE */
-        "cff"
+        ")
     );
+    rt_int = int_builder.build_from( rt_int )
+        .expect("cant build initial repr tree");
 
-    /* initially copy values from Vec to EditTree...
-     */
-    ctx.read().unwrap().build_repr_tree(
-        &rt_int,
-        Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char> ~ <Vec Char>"),
-        vec![
-            Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>> ~ EditTree"),
-            Context::parse(&ctx, "ℕ ~ <PosInt 16 LittleEndian> ~ <Seq~List <Digit 16>> ~ EditTree"),
-        ]);
-
-    fn set_master(
-        ctx: &Arc<RwLock<Context>>,
-        rt: &Arc<RwLock<ReprTree>>,
-        mut leaves: Vec< laddertypes::TypeTerm >,
-        master_idx: usize
-    ) {
-        eprintln!("set master to {}", master_idx);
-        if master_idx < leaves.len() {
-            let master = leaves.remove( master_idx );
-            rt.write().unwrap().detach( &ctx );
-            ctx.read().unwrap().build_repr_tree(
-                rt,
-                master,
-                leaves
-            );
-        }
-    }
-
-    let editor_types = vec![
-         Context::parse(&ctx,
-             "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>> ~ EditTree"),
-         Context::parse(&ctx,
-             "ℕ ~ <PosInt 16 LittleEndian> ~ <Seq~List <Digit 16>> ~ EditTree"),
-         Context::parse(&ctx,
-             "ℕ ~ <PosInt 16 BigEndian> ~ EditTree"),
-         Context::parse(&ctx,
-             "ℕ ~ <PosInt 8 BigEndian> ~ EditTree"),
-         Context::parse(&ctx,
-             "ℕ ~ <PosInt 2 BigEndian> ~ EditTree"),
-    ];
-
-    set_master(&ctx, &rt_int, editor_types.clone(), 0);
+    eprintln!("rt_int = \n{}\n", rt_int.read().unwrap().fmt(&ctx, 0));
 
     /* list of editors
      */
     let mut list_editor = nested::editors::list::ListEditor::new(ctx.clone(), Context::parse(&ctx, "<Seq Char>"));
 
     // add all desired editors to the list
-    for leaf in editor_types.iter() {
-        let et =  
-            rt_int
-                .descend(leaf.clone()).unwrap()
-                .edittree(&ctx).get();
-        et.write().unwrap().goto(TreeCursor::none());
-        list_editor.data.push(et);
+    for edit_leaf in int_builder.required_leaves.iter() {
+        let leaf_rt = rt_int.descend(edit_leaf.clone()).unwrap();
+        list_editor.data.push(leaf_rt);
     }
 
     let mut edittree = list_editor.into_node(SingletonBuffer::new(0).get_port());
+    nested_tty::editors::list::PTYListController::for_node(&mut edittree, None, None);
 
     /* cursors are a bit screwed initially so fix them up
      * TODO: how to fix this generally?
      */
+    for edit_leaf in int_builder.required_leaves.iter() {
+        let leaf_rt = rt_int.descend(edit_leaf.clone()).unwrap();
+        leaf_rt.edittree(&ctx).get_mut().goto(TreeCursor::none());
+    }
+
+    let first_idx : usize = 1;
+    int_builder.update( &rt_int, int_builder.required_leaves[first_idx].clone() );
+
     edittree.goto(TreeCursor{
         leaf_mode: nested::editors::list::ListCursorMode::Insert,
-        tree_addr: vec![0,0]
+        tree_addr: vec![first_idx as isize, 0]
     });
     let edittree = Arc::new(RwLock::new(edittree));
- 
+
+
     /* setup terminal
      */
     let app = TTYApplication::new({
@@ -136,23 +114,20 @@ async fn main() {
          */
         let ctx = ctx.clone();
         let rt_int = rt_int.clone();
-        let last_idx = RwLock::new(0);
-        let editor_types = editor_types.clone();
+        let last_idx = RwLock::new(first_idx);
+        let int_builder = int_builder.clone();
+        let edittree = edittree.clone();
         move |ev| {
             let cur = edittree.read().unwrap().get_cursor();
             if cur.tree_addr.len() > 0 {
                 let mut li = last_idx.write().unwrap();
                 let ci = cur.tree_addr[0];
 
-                if *li != ci {
-                    eprintln!("----------------------------------");
-                    set_master(
-                        &ctx,
-                        &rt_int,
-                        editor_types.clone(),
-                        ci as usize
-                    );
-                    *li = ci;
+                if *li != ci as usize {
+                    eprintln!("--------\nCHANGE MASTER EDITOR\n--------------------");
+                    int_builder.update( &rt_int, int_builder.required_leaves[ci as usize].clone() );
+                    eprintln!("-----\nDone\n----");
+                    *li = ci as usize;
                 }
             }
 
@@ -171,24 +146,35 @@ async fn main() {
     {
         let mut comp = compositor.write().unwrap();
 
+        let et = edittree.read().unwrap();
+        comp.push(et.get_cursor_widget());
+
         fn show_edit_tree( ctx: &Arc<RwLock<Context>>, comp: &mut TerminalCompositor, rt: &Arc<RwLock<ReprTree>>, y: i16 )
         {
             let rt_edittree = rt.descend(Context::parse(&ctx, "EditTree")).expect("descend");
             let halo_type = rt_edittree.read().unwrap().get_halo_type().clone();
             let edittree = rt_edittree.edittree( &ctx );
 
-            comp.push(  nested_tty::make_label( &ctx.read().unwrap().type_term_to_str(&halo_type) ) 
+
+            let box_port = ViewPort::new();
+            let ascii_box = nested_tty::widgets::ascii_box::AsciiBox::new(
+                Vector2::new(30, 1),
+                edittree.get().display_view(),
+                box_port.inner()
+            );
+
+            comp.push(
+                box_port.outer()
+                .offset(Vector2::new(1,y)));
+            comp.push(  nested_tty::make_label( &ctx.read().unwrap().type_term_to_str(&halo_type) )
                 .map_item(|_pt, atom| atom.add_style_front(TerminalStyle::fg_color((90,90,90))))
                 .offset(Vector2::new(1,y)));
-
-            comp.push(  edittree.get().read().unwrap().display_view()
-                .offset(Vector2::new(1,y+1)));
         }
 
-        let mut y = 1;
-        for t in editor_types.iter() {
+        let mut y = 2;
+        for t in int_builder.required_leaves.iter() {
             show_edit_tree(&ctx, &mut comp, &rt_int.descend(t.clone()).expect(""), y);
-            y += 3;
+            y += 4;
         }
     }
 
@@ -196,4 +182,3 @@ async fn main() {
      */
     app.show().await.expect("output error!");
 }
-

examples/tty-05-dictionary/src/main.rs

@@ -10,7 +10,7 @@ use {
         editors::{
             ObjCommander
         },
-        repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf},
+        repr_tree::{Context, ReprTreeBuilder, ReprTree, ReprTreeExt, ReprLeaf},
         edit_tree::{EditTree, TreeNav, TreeCursor}
     },
     laddertypes::{
@@ -160,65 +160,29 @@ async fn main() {
     ctx.write().unwrap().morphisms.add_morphism( symbol_morph_u64_to_str );
     ctx.write().unwrap().morphisms.add_morphism( symbol_morph_str_to_u64 );
 
-    let mut symbol_rt = nested::repr_tree::ReprTree::from_str(Context::parse(&ctx, "
-            Instruction ~ Mnemonic ~ <Seq~List~Vec Char>
-        "),
-        "Call"
-    );
+    let mut symbol_rt = nested::repr_tree::ReprTree::from_str("Call");
+    symbol_rt.write().unwrap().set_halo(Context::parse(&ctx, "
+        Instruction ~ Mnemonic ~ <Seq~List Char>
+    "));
 
-    // this is required to initialize the <Vec EditTree> representation,
-    // and to take the value from <Vec Char>
-    ctx.read().unwrap().build_repr_tree(
-        &symbol_rt,
-        Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List~Vec Char>"),
-        vec![
-            Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 10 BigEndian> ~ EditTree"),
-            Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List Char> ~ EditTree"),
-        ]);
+    let symbol_builder = ReprTreeBuilder::new( ctx.clone() )
+        //.require(Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 10 BigEndian> ~ EditTree"))
+        .require(Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List Char> ~ EditTree"))
+    ;
 
-    symbol_rt.write().unwrap().detach( &ctx );
+    symbol_rt = symbol_builder.build_from(symbol_rt).expect("failed to build symbol repr-tree");
 
-    fn set_master(
-        ctx: &Arc<RwLock<Context>>,
-        rt: &Arc<RwLock<ReprTree>>,
-        mut leaves: Vec< laddertypes::TypeTerm >,
-        master_idx: usize
-    ) {
-        eprintln!("set master to {}", master_idx);
-        if master_idx < leaves.len() {
-            let master = leaves.remove( master_idx );
-            rt.write().unwrap().detach( &ctx );
-            ctx.read().unwrap().build_repr_tree(
-                rt,
-                master,
-                leaves
-            );
-        }
-    }
-
-    let editor_types = vec![
-         Context::parse(&ctx,
-             "Instruction ~ Mnemonic ~ <Seq~List Char> ~ EditTree"),
-         Context::parse(&ctx,
-             "Instruction ~ Opcode ~ ℕ ~ <PosInt 10 BigEndian> ~ EditTree"),
-         Context::parse(&ctx,
-             "Instruction ~ Opcode ~ ℕ ~ <PosInt 16 BigEndian> ~ EditTree"),
-    ];
-
-    set_master(&ctx, &symbol_rt, editor_types.clone(), 0);
     let mut list_editor = nested::editors::list::ListEditor::new(ctx.clone(), Context::parse(&ctx, "<Seq Char>"));
 
     // add all desired editors to the list
-    for leaf in editor_types.iter() {
-        let et =
-            symbol_rt
-                .descend(leaf.clone()).unwrap()
-                .edittree(&ctx).get();
-        et.write().unwrap().goto(TreeCursor::none());
-        list_editor.data.push(et);
+    for edit_leaf in symbol_builder.required_leaves {
+        let leaf_rt = symbol_rt.descend(edit_leaf.clone()).unwrap();
+        list_editor.data.push(leaf_rt);
     }
 
     let mut edittree = list_editor.into_node(SingletonBuffer::new(0).get_port());
+    nested_tty::editors::list::PTYListController::for_node(&mut edittree, None, None);
+
     edittree.goto(TreeCursor{
         leaf_mode: nested::editors::list::ListCursorMode::Insert,
         tree_addr: vec![0, 0]
@@ -233,7 +197,6 @@ async fn main() {
         let ctx = ctx.clone();
         let symbol_rt = symbol_rt.clone();
         let last_idx = RwLock::new(0);
-        let editor_types = editor_types.clone();
         move |ev| {
             let cur = edittree.read().unwrap().get_cursor();
             if cur.tree_addr.len() > 0 {
@@ -241,13 +204,7 @@ async fn main() {
                 let ci = cur.tree_addr[0];
 
                 if *li != ci {
-                    eprintln!("----------------------------------");
-                    set_master(
-                        &ctx,
-                        &symbol_rt,
-                        editor_types.clone(),
-                        ci as usize
-                    );
+                    // symbol_builder.update()
                     *li = ci;
                 }
             }
@@ -289,8 +246,8 @@ async fn main() {
         }
 
         show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Mnemonic ~ <Seq~List Char>")).unwrap(), 1 );
-        show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 10 BigEndian>")).unwrap(), 3 );
-        show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 16 BigEndian>")).unwrap(), 5 );
+        //show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 10 BigEndian>")).unwrap(), 3 );
+        //show_edit_tree( &ctx, &mut comp, &symbol_rt.descend(Context::parse(&ctx, "Instruction ~ Opcode ~ ℕ ~ <PosInt 16 BigEndian>")).unwrap(), 5 );
     }
 
     /* write the changes in the view of `term_port` to the terminal

examples/tty-06-lines/src/main.rs

@@ -32,16 +32,20 @@ struct LineDiagnostic {
     msg: String
 }
 
+struct LineEditor {
+    num_buf: SingletonBuffer< u64 >,
+    diag_buf: VecBuffer< LineDiagnostic >,
+    chars_edit: Arc<RwLock<ListEditor>>,
+    out_port: ViewPort< dyn TerminalView >,
+    view: Arc<RwLock< LineView >>,
+    cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
+}
+
 struct LineView {
     line_num: Arc< dyn SingletonView<Item = u64> >,
     segments: Arc< dyn SequenceView<Item = ListSegment> >,
     diagnostics: Arc< dyn SequenceView<Item = LineDiagnostic> >,
-
-    diag_buf: VecBuffer< LineDiagnostic >,
-
-    cast: Arc<RwLock<ObserverBroadcast<dyn TerminalView>>>,
-    out_port: OuterViewPort<dyn TerminalView>,
-    proj_helper: ProjectionHelper<usize, Self>
+    proj_helper: ProjectionHelper<usize, LineEditor>
 }
 
 impl View for LineView {
@@ -121,10 +125,9 @@ impl IndexView<Point2<i16>> for LineView {
         while n > 0 { n_digits += 1; n /= 10; }
         let diag_len = self.diagnostics.iter().map(|d| d.msg.chars().count() as i16).max().unwrap_or(0);
         IndexArea::Range(
-            Point2::new( xoff -1-n_digits , 0) ..=
+            Point2::new( xoff - n_digits - 1 , 0) ..=
             Point2::new(
-                xoff+
-                i16::max(
+                xoff + i16::max(
                     self.segments.len().unwrap_or(i16::MAX as usize) as i16,
                     diag_len
                 ),
@@ -134,57 +137,72 @@ impl IndexView<Point2<i16>> for LineView {
     }
 }
 
-impl LineView {
+impl LineEditor {
     pub fn new(
+        ctx: &Arc<RwLock<Context>>,
         n: u64,
-        le: &ListEditor,
     ) -> Arc<RwLock<Self>> {
-        let line_num_buf = SingletonBuffer::new(n);
+        let num_buf = SingletonBuffer::new(n);
         let diag_buf = VecBuffer::new();
-        let seg_seq = ListSegmentSequence::new(le.get_cursor_port(), le.get_data_port())
+        let chars_edit = ListEditor::new(
+            ctx.clone(),
+            Context::parse(&ctx, "<List Char>")
+        );
+        let chars_seg_seq = ListSegmentSequence::new(chars_edit.get_cursor_port(), chars_edit.get_edittree_seq() )
             .read().unwrap().get_view();
 
         let out_port = ViewPort::new();
-        let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());
 
-        let lv = Arc::new(RwLock::new(LineView{
-            line_num: proj_helper.new_singleton_arg(0, line_num_buf.get_port(),
-                |s: &mut LineView, _msg|{
-                    s.cast.write().unwrap()
+        let mut proj_helper = ProjectionHelper::new(out_port.update_hooks.clone());
+        let line_view = Arc::new(RwLock::new(LineView {
+            line_num: proj_helper.new_singleton_arg(0, num_buf.get_port(),
+                |e: &mut LineEditor, _msg|{
+                    e.cast.write().unwrap()
                         .notify(&IndexArea::Range(
                             (Point2::new(-100, 0) ..= Point2::new(0, 0))
                         ));
                 }),
-            segments: proj_helper.new_sequence_arg(1, seg_seq,
-                |s: &mut LineView, idx| {
-                    s.cast.write().unwrap()
+            segments: proj_helper.new_sequence_arg(1, chars_seg_seq,
+                |e: &mut LineEditor, idx| {
+                    e.cast.write().unwrap()
                         .notify(&IndexArea::Range(
-                            (Point2::new(0, *idx as i16 - 1) ..= Point2::new(100, *idx as i16))
+                            (Point2::new(*idx as i16, 0) ..= Point2::new(*idx as i16, 0))
                         ));
                 }),
             diagnostics: proj_helper.new_sequence_arg(2, diag_buf.get_port().to_sequence(),
-                |s: &mut LineView, idx| {
-                    s.cast.write().unwrap()
+                |e: &mut LineEditor, idx| {
+                    e.cast.write().unwrap()
                         .notify(&IndexArea::Range(
                             (Point2::new(-100, 1+*idx as i16) ..= Point2::new(100, 1+*idx as i16))
                         ));
                 }),
 
-            diag_buf,
-
-            cast: out_port.inner().get_broadcast(),
             proj_helper,
-            out_port: out_port.outer()
         }));
 
-        lv.write().unwrap().proj_helper.set_proj(&lv);
-        out_port.inner().set_view(Some(lv.clone()));
+        let line_edit = Arc::new(RwLock::new(LineEditor {
+            num_buf,
+            diag_buf,
+            chars_edit: Arc::new(RwLock::new(chars_edit)),
+            cast: out_port.inner().get_broadcast(),
+            view: line_view.clone(),
+            out_port,
+        }));
 
-        lv
+        line_view.write().unwrap().proj_helper.set_proj(&line_edit);
+        line_edit
+    }
+
+    pub fn set_linum(&mut self, n: u64) {
+        self.num_buf.set(n);
+    }
+
+    pub fn add_diag(&mut self, diag: LineDiagnostic) {
+        self.diag_buf.push(diag);
     }
 
     pub fn get_port(&self) -> OuterViewPort<dyn TerminalView> {
-        self.out_port.clone()
+        self.out_port.outer()
     }
 }
 
@@ -205,13 +223,18 @@ impl LinesEditor {
             Context::parse(&ctx, "Line ~ EditTree"),
             |rt, σ| {
                 eprintln!("LINE EDITOR CONSTRUCT");
+/*
+                rt.insert_branch(
+                    Context::parse(&ctx, "EditTree"),
+
+                )*/
             }
         );
         ctx.write().unwrap().morphisms.add_morphism( line_to_edittree );
 
         let lines_segments = nested::editors::list::ListSegmentSequence::new(
             list_edit.get_cursor_port(),
-            list_edit.get_data_port()
+            list_edit.get_edittree_seq()
         ).read().unwrap().get_view();
         let lines_view = lines_segments
             .map({
@@ -238,12 +261,11 @@ impl LinesEditor {
 
         let mut list_edit = list_edit.into_node( depth_port );
         nested_tty::editors::list::PTYListController::for_node( &mut list_edit, Some('\n'), None );
-        list_edit.disp.view
-                .write().unwrap()
-                .insert_branch(ReprTree::from_view(
-                    Context::parse(&ctx, "TerminalView"),
-                    lines_view
-                ));
+        list_edit.disp.view.write().unwrap()
+            .insert_branch(ReprTree::from_view(
+                Context::parse(&ctx, "TerminalView"),
+                lines_view
+            ));
 
         LinesEditor {
            // lines,
@@ -258,35 +280,48 @@ impl LinesEditor {
             .read().unwrap()
             .data.len() as u64;
 
-        let line =
-            self.make_line(line_value)
-                .descend(Context::parse(&self.ctx, "EditTree")).unwrap()
-                .edittree(&self.ctx).get();
+        let depth = SingletonBuffer::new(0).get_port();
 
-        let le = line.read().unwrap().get_edit::<ListEditor>().unwrap();
-        le.write().unwrap().goto(TreeCursor::none());
+        let chars_rt = self.make_line(line_value);
+        let chars_edittree = chars_rt
+            .edittree(&self.ctx).get()
+            .read().unwrap().clone();
 
-        let lvport = LineView::new( n, &*le.read().unwrap() ).read().unwrap().get_port();
-        line.write().unwrap().disp.view
+        let line = LineEditor::new(&self.ctx, n);
+        line.write().unwrap().chars_edit = chars_edittree.get_edit::<ListEditor>().unwrap();
+        let line_port = line.read().unwrap().get_port();
+
+        let mut line_edittree = EditTree::new(self.ctx.clone(), depth)
+            .set_nav( line.read().unwrap().chars_edit.clone() )
+            .set_cmd( line.read().unwrap().chars_edit.clone() )
+            .set_editor( line.clone() );
+
+        line_edittree.disp.view
             .insert_leaf(
                 Context::parse(&self.ctx, "TerminalView"),
-                ReprLeaf::from_view( lvport )
+                ReprLeaf::from_view( line_port )
             );
 
+        let mut le_rt = ReprTree::from_singleton_buffer(
+            Context::parse(&self.ctx, "EditTree"),
+            SingletonBuffer::new( Arc::new(RwLock::new(line_edittree)) )
+        );
+        le_rt.write().unwrap().set_halo(Context::parse(&self.ctx, "Line"));
+        le_rt = ReprTree::rise(le_rt);
+
         self.edit.write().unwrap()
             .get_edit::< ListEditor >().unwrap()
             .write().unwrap()
             .data
-            .push(line);
+            .push( le_rt );
     }
 
     pub fn make_line(&self, line_value: &str) -> Arc<RwLock<ReprTree>> {
         let ctx = &self.ctx;
-        let mut rt_line = ReprTree::from_str(
-            Context::parse(&ctx, "<List Char>~<Vec Char>"),
-            line_value
-        );
+        let mut rt_line = ReprTree::from_str(line_value);
+        rt_line.write().unwrap().set_halo(Context::parse(&ctx, "<List Char>~<Vec Char>"));
 
+        // create Editor & transfer data to Editor
         ctx.read().unwrap().apply_morphism(
             &rt_line,
             &laddertypes::MorphismType {

examples/tty-07-color/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "tty-06-color"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+laddertypes = { path = "../../../lib-laddertypes" }
+r3vi = { path = "../../../lib-r3vi" }
+nested = { path = "../../lib-nested-core" }
+nested-tty = { path = "../../lib-nested-tty" }
+termion = "*"
+cgmath = "*"
+
+[dependencies.async-std]
+version = "1.9.0"
+features = ["unstable", "attributes"]
+

examples/tty-07-color/src/main.rs

@@ -0,0 +1,232 @@
+extern crate cgmath;
+extern crate nested;
+extern crate nested_tty;
+extern crate r3vi;
+extern crate termion;
+
+use {
+    cgmath::Vector2,
+    nested::{
+        editors::{
+            ObjCommander
+        },
+        repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf},
+        edit_tree::{EditTree, TreeNav, TreeCursor}
+    },
+    nested_tty::{
+        DisplaySegment, TTYApplication,
+        TerminalCompositor, TerminalStyle, TerminalView,
+        TerminalAtom, TerminalEvent
+    },
+    r3vi::{
+        buffer::{singleton::*, vec::*},
+        view::{port::UpdateTask, singleton::*, list::*, sequence::*},
+        projection::*
+    },
+    std::sync::{Arc, RwLock},
+};
+
+#[async_std::main]
+async fn main() {
+
+    /* setup context
+     */
+    let ctx = Arc::new(RwLock::new(Context::new()));
+    nested::editors::char::init_ctx( ctx.clone() );
+    nested::editors::digit::init_ctx( ctx.clone() );
+    nested::editors::integer::init_ctx( ctx.clone() );
+    nested::editors::list::init_ctx( ctx.clone() );
+    nested_tty::setup_edittree_hook(&ctx);
+
+    eprintln!(
+        "Char = {:?}\nu64 = {:?}\nEditTree = {:?}, <Vec EditTree> = {:?}",
+        Context::parse(&ctx, "Char"),
+        Context::parse(&ctx, "machine.UInt64"),
+        Context::parse(&ctx, "EditTree"),
+        Context::parse(&ctx, "<Vec EditTree>")
+    );
+
+    let mut red = nested::repr_tree::ReprTree::from_str(Context::parse(&ctx, "
+            ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ <Vec Char>
+        "),
+        "221"
+    );
+    ctx.read().unwrap().apply_morphism( &red,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10> ~ Char > ~ <Vec Char>"),
+            dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > ~ EditTree")
+        });
+    let red_edit = ctx.read().unwrap().setup_edittree(
+        red.descend(Context::parse(&ctx, "
+                ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char>
+            ")).unwrap(),
+        SingletonBuffer::new(0).get_port()
+    ).unwrap();
+
+    let mut green = nested::repr_tree::ReprTree::from_str(Context::parse(&ctx, "
+            ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ <Vec Char>
+        "),
+        "220"
+    );
+    ctx.read().unwrap().apply_morphism( &green,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10> ~ Char > ~ <Vec Char>"),
+            dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > ~ EditTree")
+        });
+     let green_edit = ctx.read().unwrap().setup_edittree(green.descend(Context::parse(&ctx, "
+                ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char>
+            ")).unwrap(),
+        SingletonBuffer::new(0).get_port()
+    ).unwrap();
+
+    
+    let mut blue = nested::repr_tree::ReprTree::from_str(Context::parse(&ctx, "
+            ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ <Vec Char>
+        "),
+        "5"
+    );
+    ctx.read().unwrap().apply_morphism( &blue,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10> ~ Char > ~ <Vec Char>"),
+            dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > ~ EditTree")
+        });
+    let blue_edit = ctx.read().unwrap().setup_edittree(
+        blue.descend(Context::parse(&ctx, "
+                ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char>
+            ")).unwrap(),
+        SingletonBuffer::new(0).get_port()
+    ).unwrap();
+
+
+    eprintln!("======\n   M A K E    L I S T    E D I T O R\n======\n");
+    
+    let mut color = nested::repr_tree::ReprTree::new_arc(
+        Context::parse(&ctx, "<List ℕ>")
+    );
+
+    color.insert_leaf(
+        Context::parse(&ctx, "
+                <List   ℕ
+                      ~ <PosInt 16 BigEndian>
+                      ~ <Seq <Digit 16>>
+                      ~ <List  <Digit 16>
+                              ~ Char >
+                >
+                ~ <List EditTree>
+                ~ <Vec EditTree>
+            "),
+
+        ReprLeaf::from_vec_buffer(VecBuffer::<
+            Arc<RwLock< EditTree >>
+        >::with_data(vec![
+            red_edit.get(),
+            green_edit.get(),
+            blue_edit.get()
+        ]))
+    );
+    ctx.read().unwrap().apply_morphism(
+        &color,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > ~ EditTree > ~ <Vec EditTree>"),
+            dst_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > > ~ EditTree")
+        });
+    let edit = ctx.read().unwrap().setup_edittree(
+        color.descend(Context::parse(&ctx, "
+                <List   ℕ
+                      ~ < PosInt 16 BigEndian >
+                      ~ < Seq~List   <Digit 16>
+                                   ~ Char >
+                >
+            ")).unwrap(),
+        SingletonBuffer::new(0).get_port()
+    ).unwrap();
+
+
+
+eprintln!(" edittree => list list char ");
+     ctx.read().unwrap().apply_morphism(
+        &color,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > > ~ EditTree"),
+            dst_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char > >")
+        });
+
+eprintln!("list char ==> list u64");
+    ctx.read().unwrap().apply_morphism(
+        &color,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ Char>>"),
+            dst_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64>>")
+        });
+return;
+
+    ctx.read().unwrap().apply_morphism(
+        &color,
+        &laddertypes::MorphismType {
+            src_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64 > >"),
+            dst_type: Context::parse(&ctx, "<List ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10> ~ Char > >")
+        });
+    /*
+    let edit2 = ctx.read().unwrap().setup_edittree(
+        color.descend(Context::parse(&ctx, "
+                <List   ℕ
+                      ~ < PosInt 10 BigEndian >
+                      ~ < Seq~List   <Digit 10>
+                                   ~ Char >
+                >
+            ")).unwrap(),
+        SingletonBuffer::new(0).get_port()
+    ).unwrap();
+*/
+
+    return;
+
+    /* setup terminal
+     */
+    let app = TTYApplication::new({
+        /* event handler
+         */
+        let ctx = ctx.clone();
+        let edit = edit.get().clone();
+
+        edit.write().unwrap().goto(TreeCursor::home());
+        
+        move |ev| {
+            edit.write().unwrap().send_cmd_obj( ev.to_repr_tree(&ctx) );
+        }
+    });
+
+    /* Setup the compositor to serve as root-view
+     * by routing it to the `app.port` Viewport,
+     * so it will be displayed on TTY-output.
+     */
+    let compositor = TerminalCompositor::new(app.port.inner());
+
+    /* Now add some views to our compositor
+     */
+    {
+        let mut comp = compositor.write().unwrap();
+
+        fn show_edit_tree( ctx: &Arc<RwLock<Context>>, comp: &mut TerminalCompositor, rt: &Arc<RwLock<ReprTree>>, y: i16 )
+        {
+            let rt_edittree = rt.descend(Context::parse(&ctx, "EditTree")).expect("descend");
+            let halo_type = rt_edittree.read().unwrap().get_halo_type().clone();
+            let edittree = rt_edittree.read().unwrap().get_view::<dyn r3vi::view::singleton::SingletonView<Item = Arc<RwLock<EditTree>>>>().unwrap().get().read().unwrap().clone();
+
+            comp.push(  nested_tty::make_label( &ctx.read().unwrap().type_term_to_str(&halo_type) ) 
+                .map_item(|_pt, atom| atom.add_style_front(TerminalStyle::fg_color((90,90,90))))
+                .offset(Vector2::new(1,y)));
+
+            comp.push(  edittree.display_view()
+                .offset(Vector2::new(1,y+1)));
+        }
+
+        show_edit_tree( &ctx, &mut comp, &color.descend(Context::parse(&ctx, "<List ℕ ~ <PosInt 16 BigEndian> ~ <Seq~List <Digit 16>~Char>>")).unwrap(), 1 );        
+        show_edit_tree( &ctx, &mut comp, &color.descend(Context::parse(&ctx, "<List ℕ ~ <PosInt 10 BigEndian> ~ <Seq~List <Digit 10>~Char>>")).unwrap(), 3 );
+    }
+
+    /* write the changes in the view of `term_port` to the terminal
+     */
+    app.show().await.expect("output error!");
+}
+

lib-nested-core/src/edit_tree/node.rs

@@ -7,7 +7,7 @@ use {
     },
     laddertypes::{TypeTerm},
     crate::{
-        repr_tree::{ReprTree, Context},
+        repr_tree::{ReprTree, ReprTreeArc, Context},
         edit_tree::{TreeNav, TreeCursor, TreeNavResult, TreeHeightOp, diagnostics::{Diagnostics, Message}},
         editors::{list::{ListCursorMode}, ObjCommander}
     }
@@ -32,9 +32,7 @@ pub struct EdittreeControl {
                     Option< Arc<dyn Any + Send + Sync> >
                 >,
 
-    pub spillbuf: Arc<RwLock<
-                    Vec< Arc<RwLock< EditTree >> >
-                  >>,
+    pub spillbuf: Arc<RwLock< Vec< ReprTreeArc > >>,
 
     /// commander & navigation
     pub cmd: SingletonBuffer<
@@ -46,7 +44,7 @@ pub struct EdittreeControl {
     // could be replaced by cmd when TreeNav -CmdObjects are used
     pub tree_nav: SingletonBuffer<
                       Option< Arc<RwLock<dyn TreeNav + Send + Sync>> >
-                  >,    
+                  >,
 }
 
 #[derive(Clone)]
@@ -153,7 +151,7 @@ impl TreeNav for EditTree {
             tn.read().unwrap().get_mode_view()
         } else {
             OuterViewPort::default()
-        }        
+        }
     }
 
     fn get_cursor_warp(&self) -> TreeCursor {
@@ -225,4 +223,3 @@ impl Diagnostics for EditTree {
         self.get_diag()
     }
 }
-

lib-nested-core/src/editors/char/ctx.rs

@@ -33,6 +33,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                     if let Some(buf) = b {
                         // buffer already exists
                     } else {
+                        eprintln!("create char buffer");
                         // create char buffer
                         rt.write().unwrap().insert_leaf(
                             vec![].into_iter(),
@@ -49,12 +50,10 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                 );
 
                 rt.insert_leaf(
-                        Context::parse(&ctx, "EditTree"),
-                        ReprLeaf::from_singleton_buffer(
-                            SingletonBuffer::new(
-                                Arc::new(RwLock::new(edittree))
-                            )
-                        )
+                    Context::parse(&ctx, "Char~EditTree"),
+                    ReprLeaf::from_singleton_buffer(
+                        SingletonBuffer::new(edittree)
+                    )
                 );
 
                 ctx.read().unwrap().setup_edittree(rt);
@@ -71,15 +70,25 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
             {
                 let mut b = rt
                    .descend(Context::parse(&ctx, "EditTree")).unwrap()
-                   .view_singleton::<Arc<RwLock<EditTree>>>();
+                   .singleton_buffer::<EditTree>();
+
+                if rt.write().unwrap().singleton_buffer::<char>().is_none() {
+                    eprintln!("insert singleton buffer");
+                    rt.insert_leaf(
+                        Context::parse(&ctx, "Char"),
+                        ReprLeaf::from_singleton_buffer(
+                            SingletonBuffer::new('\0')
+                        )
+                    );
+                }
 
                 rt.attach_leaf_to(
                     Context::parse(&ctx, "Char"),
-                    b.map(|x|
-                        x.read().unwrap()
-                            .get_edit::<CharEditor>().unwrap()
+                    b.get_port().map(
+                        |x| x.get_edit::<CharEditor>().unwrap()
                             .read().unwrap()
-                            .get())
+                            .get()
+                    )
                 );
             }
         });

lib-nested-core/src/editors/digit/ctx.rs

@@ -47,7 +47,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                         .insert_branch(
                             ReprTree::from_singleton_buffer(
                                 Context::parse(&ctx, "EditTree"),
-                                SingletonBuffer::new(Arc::new(RwLock::new(edittree)))
+                                SingletonBuffer::new(edittree)
                             )
                         );
 
@@ -85,7 +85,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                         .insert_branch(
                             ReprTree::from_singleton_buffer(
                                 Context::parse(&ctx, "EditTree"),
-                                SingletonBuffer::new(Arc::new(RwLock::new(edittree)))
+                                SingletonBuffer::new(edittree)
                             )
                         );
 
@@ -105,7 +105,6 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                 let port =
                         edittree
                             .get()
-                            .read().unwrap()
                             .get_edit::<DigitEditor>().unwrap()
                             .read().unwrap()
                             .get_char_port();
@@ -141,7 +140,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                         if let Some(src_rt) = rt.descend(Context::parse(&ctx, "Char")) {
                             /* insert projected view into ReprTree
                              */
-                            let u64_view = 
+                            let u64_view =
                                     src_rt.view_char()
                                         .map(move |c| c.to_digit(radix).unwrap_or(0) as u64);
 
@@ -177,7 +176,7 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
                 if radix <= 16 {
                     /* insert projected view into ReprTree
                      */
-                    let char_view = 
+                    let char_view =
                         rt.descend(Context::parse(&ctx, "ℤ_2^64~machine.UInt64"))
                             .unwrap()
                             .view_u64()
@@ -201,5 +200,3 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
     ctx.write().unwrap().morphisms.add_morphism( digit_morph_char_to_u64 );
     ctx.write().unwrap().morphisms.add_morphism( digit_morph_u64_to_char );
 }
-
-

lib-nested-core/src/editors/integer/ctx.rs

@@ -44,7 +44,7 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                         ~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
                     ").apply_substitution(&|k|σ.get(k).cloned()).clone(),
                     src_digits.reverse()
-                );            
+                );
             }
         }
     );
@@ -72,7 +72,7 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                         ~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
                     ").apply_substitution(&|k|σ.get(k).cloned()).clone(),
                     src_digits.reverse()
-                );            
+                );
             }
         }
     );
@@ -100,7 +100,7 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                         ~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
                     ").apply_substitution(&|k|σ.get(k).cloned()).clone(),
                     src_digits.reverse()
-                );            
+                );
             }
         }
     );
@@ -167,7 +167,7 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                     dst_digits_port
                 );
             }
-            
+
         }
     );
 
@@ -224,23 +224,21 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                     )
                     .unwrap()
                     .edittree( &ctx )
-                    .get().clone()
-                    .read().unwrap()
-                    .clone();
+                    .get();
 
                 // clear display
                 list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
-
+/*
                 src_rt.insert_leaf(
                     Context::parse(&ctx, "<PosInt Radix BigEndian> ~ EditTree")
                            .apply_substitution(&|x| σ.get(x).cloned()).clone(),
                     ReprLeaf::from_singleton_buffer(
                         SingletonBuffer::new(
-                            Arc::new(RwLock::new(list_edittree))
+                            list_edittree
                         )
                     )
                 );
-
+*/
                 ctx.read().unwrap().setup_edittree(
                     &src_rt.descend(
                         Context::parse(&ctx, "<PosInt Radix BigEndian>")
@@ -262,22 +260,19 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
                         .apply_substitution(&|x| σ.get(x).cloned()).clone())
                     .unwrap()
                     .edittree( &ctx )
-                    .get().clone()
-                    .read().unwrap()
-                    .clone();
+                    .get_mut();
 
                 // clear display
                 list_edittree.disp.view = ReprTree::new_arc(Context::parse(&ctx, "Display"));
-
+/*
                 src_rt.insert_leaf(
                     Context::parse(&ctx, "<PosInt Radix BigEndian> ~ <Seq~List <Digit Radix>>~EditTree")
                            .apply_substitution(&|x| σ.get(x).cloned()).clone(),
                     ReprLeaf::from_singleton_buffer(
-                        SingletonBuffer::new(
-                            Arc::new(RwLock::new(list_edittree))
-                        )
+                        SingletonBuffer::new(list_edittree)
                     )
                 );
+*/
 
                 ctx.read().unwrap().setup_edittree(
                     &src_rt.descend(
@@ -294,9 +289,8 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
 
     ctx.write().unwrap().morphisms.add_morphism( posint_seq_morph_big_to_little );
     ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_big_to_little );
-    ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_little_to_big );    
+    ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_little_to_big );
     ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_radix );
     ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_from_u64 );
     ctx.write().unwrap().morphisms.add_morphism( posint_list_morph_to_u64 );
 }
-

lib-nested-core/src/editors/list/cmd.rs

@@ -25,7 +25,7 @@ impl ListCmd {
     // note: cant use Into becaue of ctx (maybe global typedict?)
     pub fn into_repr_tree(self, ctx: &Arc<RwLock<Context>>) -> Arc<RwLock<ReprTree>> {
         ReprTree::from_singleton_buffer(
-            Context::parse(ctx, "ListCmd"),            
+            Context::parse(ctx, "ListCmd"),
             r3vi::buffer::singleton::SingletonBuffer::new(self)
         )
     }
@@ -35,28 +35,7 @@ impl ObjCommander for ListEditor {
     fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
         let cmd_repr = cmd_obj.read().unwrap();
 
-        if let Some(view) = cmd_repr.get_view::<dyn SingletonView<Item = EditTree>>() {
-            let node = view.get();
-            let cur = self.cursor.get();
-
-            if let Some(idx) = cur.idx {
-                match cur.mode {
-                    ListCursorMode::Select => {
-                        *self.data.get_mut(idx as usize) = Arc::new(RwLock::new(node));
-                        TreeNavResult::Exit
-                    }
-                    ListCursorMode::Insert => {
-                        self.insert(Arc::new(RwLock::new(node)));
-                        self.cursor.set(ListCursor{ idx: Some(idx+1),  mode: ListCursorMode::Insert });
-                        TreeNavResult::Continue
-                    }
-                }
-            } else {
-                TreeNavResult::Exit
-            }
-        }
-
-        else if let Some(cmd) = cmd_repr.get_view::<dyn SingletonView<Item = ListCmd>>() {
+        if let Some(cmd) = cmd_repr.get_view::<dyn SingletonView<Item = ListCmd>>() {
 
             let cur = self.cursor.get();
             drop(cmd_repr);
@@ -69,10 +48,11 @@ impl ObjCommander for ListEditor {
                 _ => {
                     if let Some(idx) = cur.idx {
                         match cur.mode {
-                            ListCursorMode::Select => {                        
-                                if let Some(mut item) = self.get_item().clone() {
+                            ListCursorMode::Select => {
+                                if let Some(mut item) = self.get_cur_edittree() {
+                                    //let mut item = item.write().unwrap();
                                     let item_cur = item.get_cursor();
-                                    
+
                                     match cmd.get() {
                                         ListCmd::DeletePxev => {
                                             if idx > 0
@@ -151,14 +131,30 @@ impl ObjCommander for ListEditor {
             }
 
         } else {
-            if let Some(cur_item) = self.get_item_mut() {
-                drop(cmd_repr);
-                cur_item.write().unwrap().send_cmd_obj(cmd_obj);
-                TreeNavResult::Continue
+            let cur = self.cursor.get();
+
+            if let Some(idx) = cur.idx {
+                match cur.mode {
+                    ListCursorMode::Select => {
+                        // what ??
+                        //*self.data.get_mut(idx as usize) = Arc::new(RwLock::new(node));
+
+
+
+                        TreeNavResult::Exit
+                    }
+                    ListCursorMode::Insert => {
+                        self.insert( cmd_obj.clone() );
+
+                        // todo: setup edittree
+
+                        self.cursor.set(ListCursor{ idx: Some(idx+1),  mode: ListCursorMode::Insert });
+                        TreeNavResult::Continue
+                    }
+                }
             } else {
                 TreeNavResult::Exit
             }
         }
     }
 }
-

lib-nested-core/src/editors/list/ctx.rs

@@ -1,60 +1,238 @@
 use {
-    r3vi::{
-        view::{
-            ViewPort, port::UpdateTask,
-            OuterViewPort, Observer,
-            singleton::*,
-            list::*
-        },
-        buffer::{singleton::*, vec::*}
-    },
-    laddertypes::{TypeTerm},
     crate::{
-        repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt, GenericReprTreeMorphism},
-        edit_tree::{EditTree},
-        editors::{
-            char::{CharEditor},
-            list::{ListEditor}
+        edit_tree::EditTree, editors::{
+            char::CharEditor,
+            list::ListEditor
+        }, repr_tree::{context::TYPEID_char, Context, GenericReprTreeMorphism, ReprLeaf, ReprTree, ReprTreeArc, ReprTreeExt}
+    }, laddertypes::TypeTerm, r3vi::{
+        buffer::{singleton::*, vec::*}, view::{
+            list::*, port::UpdateTask, singleton::*, Observer, OuterViewPort, ViewPort
         }
-    },
-    std::sync::{Arc, RwLock}
+    }, std::sync::{Arc, RwLock}
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
+pub fn init_ctx__seq_to_list( ctx: &Arc<RwLock<Context>> ) {
+
+    let seq_morph_to_list_char = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<Seq Char>"),
+            Context::parse(&ctx, "<Seq Char>~<List Char>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<List Char>"),
+                        src_rt.view_seq::<char>().to_list()
+                    );
+                }
+            }
+        );
+
+    let seq_morph_to_list_u64 = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<Seq machine.UInt64>"),
+            Context::parse(&ctx, "<Seq machine.UInt64>~<List machine.UInt64>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<List machine.UInt64>"),
+                        src_rt.view_seq::<u64>().to_list()
+                    );
+                }
+            }
+        );
+
+    ctx.write().unwrap().morphisms.add_morphism( seq_morph_to_list_char );
+    ctx.write().unwrap().morphisms.add_morphism( seq_morph_to_list_u64 );
+}
+
+pub fn init_ctx__vec_to_list( ctx: &Arc<RwLock<Context>> ) {
+    let list_morph_from_vec_char = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List Char>~<Vec Char>"),
+            Context::parse(&ctx, "<List Char>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    let src_port = src_rt.descend(
+                        Context::parse(&ctx, "<List Char>~<Vec Char>")
+                    )
+                        .expect("descend")
+                        .get_port::<RwLock<Vec<char>>>().unwrap();
+
+                    src_rt.attach_leaf_to( Context::parse(&ctx, "<List Char>"), src_port.to_list() );
+                }
+            }
+        );
+
+    let list_morph_from_vec_rt = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List ReprTree>~<Vec ReprTree>"),
+            Context::parse(&ctx, "<List ReprTree>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    let src_port = src_rt.descend(
+                        Context::parse(&ctx, "<List ReprTree>~<Vec ReprTree>")
+                    )
+                        .expect("descend")
+                        .get_port::<RwLock<Vec<ReprTreeArc>>>().unwrap();
+
+                    src_rt.attach_leaf_to( Context::parse(&ctx, "<List ReprTree>"), src_port.to_list() );
+                }
+            }
+        );
+
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_from_vec_char );
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_from_vec_rt );
+}
+
+pub fn init_ctx__list_to_vec( ctx: &Arc<RwLock<Context>> ) {
+    let list_morph_to_vec_char = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List Char>"),
+            Context::parse(&ctx, "<List Char>~<Vec Char>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<Vec Char>"),
+                        src_rt.view_list::<char>()
+                    );
+                }
+            }
+        );
+
+    let list_morph_to_vec_u64 = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List machine.UInt64>"),
+            Context::parse(&ctx, "<List machine.UInt64>~<Vec machine.UInt64>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<Vec machine.UInt64>"),
+                        src_rt.view_list::<u64>()
+                    );
+                }
+            }
+        );
+
+    let list_morph_to_vec_reprtree = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List ReprTree>"),
+            Context::parse(&ctx, "<List ReprTree>~<Vec ReprTree>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<Vec ReprTree>"),
+                        src_rt.view_list::< ReprTreeArc >()
+                    );
+                }
+            }
+        );
+
+    let list_morph_to_vec_edittree = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List EditTree>"),
+            Context::parse(&ctx, "<List EditTree>~<Vec EditTree>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    let list_port = src_rt.get_port::<dyn ListView< EditTree >>().unwrap();
+                    src_rt.attach_leaf_to( Context::parse(&ctx, "<Vec EditTree>"), list_port );
+                }
+            }
+        );
+
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_reprtree );
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_char );
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_u64 );
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_edittree );
+}
+
+pub fn init_ctx__unpack_reprtree( ctx: &Arc<RwLock<Context>> ) {
+    let list_morph_rt_to_char = GenericReprTreeMorphism::new(
+            Context::parse(&ctx, "<List Char> ~ <List ReprTree>"),
+            Context::parse(&ctx, "<List Char>"),
+            {
+                let ctx = ctx.clone();
+                move |src_rt, σ| {
+                    src_rt.attach_leaf_to(
+                        Context::parse(&ctx, "<List Char>"),
+                        src_rt.descend(Context::parse(&ctx, "<List ReprTree>")).expect("cant descend")
+                            .view_list::<ReprTreeArc>()
+                            .map(|rt| {
+                                rt.view_singleton::<char>().get_view().get()
+                            })
+                    );
+                }
+            }
+        );
+
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_rt_to_char );
+}
+
+pub fn init_ctx__pack_reprtree( ctx: &Arc<RwLock<Context>> ) {
+    let list_morph_rt_from_char = GenericReprTreeMorphism::new(
+                Context::parse(&ctx, "<List Char>"),
+                Context::parse(&ctx, "<List Char> ~ <List ReprTree>"),
+                {
+                    let ctx = ctx.clone();
+                    move |src_rt, σ| {
+                        src_rt.attach_leaf_to(
+                            Context::parse(&ctx, "<List Char>~<List ReprTree>"),
+                            src_rt.view_list::<char>()
+                                .map(|c| {
+                                    ReprTree::from_singleton_buffer(
+                                        TypeTerm::TypeID(TYPEID_char),
+                                        SingletonBuffer::<char>::new( *c )
+                                    )
+                                })
+                        );
+                    }
+                }
+            );
+    ctx.write().unwrap().morphisms.add_morphism( list_morph_rt_from_char );
+}
+
 pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
     ctx.write().unwrap().add_varname("Item");
 
     let list_morph_editsetup1 = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<List Item>~<List EditTree>~<Vec EditTree>"),
+        Context::parse(&ctx, "<List Item>~<List ReprTree>~<Vec ReprTree>"),
         Context::parse(&ctx, "<List Item>~EditTree"),
         {
             let ctx = ctx.clone();
             move |src_rt, σ| {
-                let item_id = laddertypes::TypeID::Var( ctx.read().unwrap().get_var_typeid("Item").unwrap() );
+                let item_id = laddertypes::TypeID::Var(ctx.read().unwrap().get_var_typeid("Item").unwrap());
                 if let Some( item_type ) = σ.get( &item_id ) {
-                    let mut item_vec_rt = src_rt
-                        .descend(
-                            Context::parse(&ctx, "<List Item~EditTree>~<Vec EditTree>")
-                                .apply_substitution(&|id| σ.get(id).cloned()).clone()
-                        )
+                    let mut item_rt_vec = src_rt
+                        .descend(Context::parse(&ctx, "<List ReprTree>~<Vec ReprTree>"))
                         .expect("cant descend src repr");
 
-                    let item_vec_buffer = item_vec_rt.vec_buffer::< Arc<RwLock<EditTree>> >();
+                    let item_vec_buffer = item_rt_vec.vec_buffer::< ReprTreeArc >();
 
-                    let mut list_editor = ListEditor::with_data(ctx.clone(), item_type.clone(), item_vec_buffer);
-                    let edittree_list = list_editor.into_node(
-                        SingletonBuffer::<usize>::new(0).get_port()
-                    );
-                    src_rt.insert_leaf(
-                        Context::parse(&ctx, "<List Item> ~ EditTree")
-                            .apply_substitution(&|id| σ.get(id).cloned()).clone(),
-
-                        ReprLeaf::from_singleton_buffer(
-                            SingletonBuffer::new(Arc::new(RwLock::new(edittree_list)))
-                        )
-                    );
+                    if let Some(mut buf) = src_rt.descend_create(Context::parse(&ctx, "EditTree")).as_mut()
+                        .expect("get_edittree rt")
+                        .write().unwrap()
+                        .singleton_buffer::<EditTree>()
+                    {
+                        let mut et = buf.get_mut();
+                        let mut list_editor = et.get_edit::<ListEditor>().unwrap();
+                        let mut list_editor = list_editor.write().unwrap();
 
+                        list_editor.data = item_vec_buffer;
+                        list_editor.update_item_reprtrees(&item_type);
+                    } else {
+                        let mut list_editor = ListEditor::with_data(ctx.clone(), item_type.clone(), item_vec_buffer);
+                        list_editor.update_item_reprtrees(&item_type);
+                        let mut edittree_list = list_editor.into_node(
+                            SingletonBuffer::<usize>::new(0).get_port()
+                        );
+                        src_rt.insert_branch(
+                            ReprTree::from_singleton_buffer(
+                                Context::parse(&ctx, "EditTree"),
+                                SingletonBuffer::new(edittree_list)
+                            )
+                        );
+                    }
                     ctx.read().unwrap().setup_edittree( &src_rt );
                 } else {
                     eprintln!("no item type");
@@ -65,116 +243,29 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
 
     let list_morph_editsetup3 = GenericReprTreeMorphism::new(
         Context::parse(&ctx, "<List Item> ~ EditTree"),
-        Context::parse(&ctx, "<List Item> ~ <List EditTree>"),
+        Context::parse(&ctx, "<List Item> ~ <List ReprTree> ~ <Vec ReprTree>"),
         {
             let ctx = ctx.clone();
             move |src_rt, σ| {
                 let edittree = src_rt.edittree( &ctx );
-                let list_edit = edittree.get().read().unwrap().get_edit::< ListEditor >().unwrap();
-                let edittree_items = list_edit.read().unwrap().data.get_port().to_list();
-
-                eprintln!("edittree_items.len() = {:?}", edittree_items.get_view().unwrap().len());
-
-                src_rt.attach_leaf_to(
-                    Context::parse(&ctx, "<List Item> ~ <List EditTree>")
-                        .apply_substitution(&|x| σ.get(x).cloned()).clone(),
-                    edittree_items
+                let list_edit = edittree.get().get_edit::< ListEditor >().unwrap();
+                list_edit.write().unwrap().update_item_reprtrees(Context::parse(&ctx, "Item~EditTree")
+                    .apply_substitution(&move |s| σ.get(s).cloned())
                 );
-            }
-        }
-    );
-
-    let seq_morph_to_list_char = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<Seq Char>"),
-        Context::parse(&ctx, "<Seq Char>~<List Char>"),
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
                 src_rt.attach_leaf_to(
-                    Context::parse(&ctx, "<List Char>"),
-                    src_rt.view_seq::<char>().to_list()
+                    Context::parse(&ctx, "<List EditTree> ~ <Vec ReprTree>"),
+                    list_edit.read().unwrap().data.get_port().to_list()
                 );
             }
         }
     );
 
-    let list_morph_to_vec_char = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<List Char>"),
-        Context::parse(&ctx, "<List Char>~<Vec Char>"),
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
-                src_rt.attach_leaf_to(
-                    Context::parse(&ctx, "<Vec Char>"),
-                    src_rt.view_list::<char>()
-                );
-            }
-        }
-    );
-
-    let seq_morph_to_list_u64 = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<Seq machine.UInt64>"),
-        Context::parse(&ctx, "<Seq machine.UInt64>~<List machine.UInt64>"),
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
-                src_rt.attach_leaf_to(
-                    Context::parse(&ctx, "<List machine.UInt64>"),
-                    src_rt.view_seq::<u64>().to_list()
-                );
-            }
-        }
-    );
-
-    let list_morph_to_vec_u64 = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<List machine.UInt64>"),
-        Context::parse(&ctx, "<List machine.UInt64>~<Vec machine.UInt64>"),
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
-                src_rt.attach_leaf_to(
-                    Context::parse(&ctx, "<Vec machine.UInt64>"),
-                    src_rt.view_list::<u64>()
-                );
-            }
-        }
-    );
-
-    let list_morph_from_vec_char = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<List Char>~<Vec Char>"),
-        Context::parse(&ctx, "<List Char>"),
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
-                let src_port = src_rt.descend(Context::parse(&ctx, "<List Char>~<Vec Char>")).expect("descend")
-                    .get_port::<RwLock<Vec<char>>>().unwrap();
-
-                src_rt.attach_leaf_to( Context::parse(&ctx, "<List Char>"), src_port.to_list() );
-            }
-        }
-    );
-
-
-    let list_morph_to_vec_edittree = GenericReprTreeMorphism::new(
-        Context::parse(&ctx, "<List EditTree>"),
-        Context::parse(&ctx, "<List EditTree> ~ <Vec EditTree>"),
-
-        {
-            let ctx = ctx.clone();
-            move |src_rt, σ| {
-                let list_port = src_rt.get_port::<dyn ListView< Arc<RwLock<EditTree>> >>().unwrap();
-                src_rt.attach_leaf_to( Context::parse(&ctx, "<Vec EditTree>"), list_port );
-            }
-        }
-    );
-
     ctx.write().unwrap().morphisms.add_morphism( list_morph_editsetup1 );
     ctx.write().unwrap().morphisms.add_morphism( list_morph_editsetup3 );
-    ctx.write().unwrap().morphisms.add_morphism( list_morph_from_vec_char );
-    ctx.write().unwrap().morphisms.add_morphism( seq_morph_to_list_char );
-    ctx.write().unwrap().morphisms.add_morphism( seq_morph_to_list_u64 );
-    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_char );
-    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_u64 );
-    ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_edittree );
-}
 
+    init_ctx__seq_to_list(&ctx);
+    init_ctx__vec_to_list(&ctx);
+    init_ctx__list_to_vec(&ctx);
+    init_ctx__pack_reprtree(&ctx);
+    init_ctx__unpack_reprtree(&ctx);
+}

lib-nested-core/src/editors/list/editor.rs

@@ -1,14 +1,14 @@
 use {
-    r3vi::{
-        view::{OuterViewPort, singleton::*, sequence::*},
-        buffer::{singleton::*, vec::*},
-        projection::*
-    },
-    laddertypes::{TypeTerm},
     crate::{
-        repr_tree::{Context, ReprTree},
-        edit_tree::{EditTree, TreeNav, TreeCursor, diagnostics::Diagnostics},
-        editors::{list::{ListCursor, ListCursorMode, ListCmd}, ObjCommander},
+        edit_tree::{diagnostics::Diagnostics, EditTree, TreeCursor, TreeNav},
+        editors::{list::{ListCmd, ListCursor, ListCursorMode}, ObjCommander},
+        repr_tree::{context::{TYPEID_edittree, TYPEID_reprtree}, node::ReprTreeArc, Context, ReprTree, ReprTreeBuilder, ReprTreeExt}
+    },
+    laddertypes::TypeTerm,
+    r3vi::{
+        buffer::{singleton::*, vec::*},
+        projection::*,
+        view::{list::*, port::UpdateTask, sequence::*, singleton::*, OuterViewPort}
     },
     std::sync::{Arc, RwLock}
 };
@@ -17,27 +17,24 @@ use {
 
 pub struct ListEditor {
     pub cursor: SingletonBuffer<ListCursor>,
-
-    // todo: (?) remove RwLock<..> around NestedNode ??
-    pub data: VecBuffer< Arc<RwLock<EditTree>> >,
-
-    pub spillbuf: Arc<RwLock<Vec<Arc<RwLock<EditTree>>>>>,
+    pub data: VecBuffer< ReprTreeArc >,
+    pub spillbuf: Arc<RwLock< Vec< ReprTreeArc > >>,
 
     pub(super) addr_port: OuterViewPort<dyn SequenceView<Item = isize>>,
     pub(super) mode_port: OuterViewPort<dyn SingletonView<Item = ListCursorMode>>,
 
     depth: OuterViewPort<dyn SingletonView<Item = usize>>,
 
+    pub item_type: TypeTerm,
+    pub master_repr: Arc<RwLock<TypeTerm>>,
+    pub item_builder: ReprTreeBuilder,
     pub ctx: Arc<RwLock<Context>>,
-
-    /// item type
-    pub typ: TypeTerm,
 }
 
 impl ListEditor {
     pub fn new(
        ctx: Arc<RwLock<Context>>,
-       typ: TypeTerm 
+       typ: TypeTerm
     ) -> Self {
         Self::with_data(
             ctx,
@@ -49,15 +46,16 @@ impl ListEditor {
     pub fn with_data(
         ctx: Arc<RwLock<Context>>,
         typ: TypeTerm,
-        data: VecBuffer<Arc<RwLock<EditTree>>>
+        data: VecBuffer< ReprTreeArc >
     ) -> Self {
         let cursor = SingletonBuffer::new(ListCursor::default());
 
-        ListEditor {
+        let mut le = ListEditor {
             mode_port: cursor
                 .get_port()
                 .map({
                     let data = data.clone();
+                    let ctx = ctx.clone();
                     move |c| {
                         let ip = SingletonBuffer::new(c.mode).get_port();
                         match c.mode {
@@ -65,7 +63,9 @@ impl ListEditor {
                             ListCursorMode::Select => {
                                 if let Some(idx) = c.idx {
                                     if idx >= 0 && idx < data.len() as isize {
-                                        data.get(idx as usize).read().unwrap().get_mode_view()
+                                        data.get(idx as usize)
+                                            .edittree(&ctx).get()
+                                            .get_mode_view()
                                     } else {
                                         ip
                                     }
@@ -86,11 +86,14 @@ impl ListEditor {
                     cursor.get_port()
                         .map({
                             let data = data.clone();
+                            let ctx = ctx.clone();
                             move |cur| {
                                 if cur.mode == ListCursorMode::Select {
                                     if let Some(idx) = cur.idx {
                                         if idx >= 0 && idx < data.len() as isize {
-                                            return data.get(idx as usize).read().unwrap().get_addr_view();
+                                            return data.get(idx as usize)
+                                                .edittree(&ctx).get()
+                                                .get_addr_view();
                                         }
                                     }
                                 }
@@ -98,7 +101,7 @@ impl ListEditor {
                             }
                         })
                         .to_sequence()
-                        .flatten()                
+                        .flatten()
                 ])
                 .get_port()
                 .to_sequence()
@@ -106,46 +109,65 @@ impl ListEditor {
             cursor,
             data,
             spillbuf: Arc::new(RwLock::new(Vec::new())),
+            item_builder: ReprTreeBuilder::new(ctx.clone())
+                .require( typ.clone() )
+                .require( TypeTerm::Ladder(vec![
+                    typ.clone(),
+                    TypeTerm::TypeID(TYPEID_edittree)
+                ]))
+                .clone(),
+            master_repr: Arc::new(RwLock::new(typ.clone())),
+            item_type: typ,
             ctx,
-            typ,
-            depth: SingletonBuffer::new(0).get_port()
-        }
+            depth: SingletonBuffer::new(0).get_port(),
+        };
+
+        le.update_item_reprtrees(&le.item_type.clone());
+        le
+    }
+
+    pub fn to_edittree(self, mut edittree: EditTree) -> EditTree {
+        let editor = Arc::new(RwLock::new(self));
+        let e = editor.read().unwrap();
+
+        edittree.ctrl.spillbuf = e.spillbuf.clone();
+        edittree
+            .set_editor(editor.clone())
+            .set_nav(editor.clone())
+            .set_cmd(editor.clone())
+            .set_diag(e.get_edittree_seq()
+                              .enumerate()
+                              .map(|(idx, item_editor)| {
+                                  let idx = *idx;
+                                  item_editor.get_msg_port()
+                                      .map(move |msg| {
+                                          let mut msg = msg.clone();
+                                          msg.addr.insert(0, idx);
+                                          msg
+                                      })
+                                  })
+                              .flatten())
     }
 
     pub fn into_node(mut self, depth: OuterViewPort<dyn SingletonView<Item = usize>>) -> EditTree {
         let ctx = self.ctx.clone();
-
         self.depth = depth.clone();
-        let editor = Arc::new(RwLock::new(self));
+        self.to_edittree(EditTree::new(ctx, depth))
+    }
 
-        let e = editor.read().unwrap();
-
-        let mut node = EditTree::new(ctx, depth)
-            .set_editor(editor.clone())
-            .set_nav(editor.clone())
-            .set_cmd(editor.clone())
-            .set_diag(e.get_data_port()
-                      .enumerate()
-                      .map(|(idx, item_editor)| {
-                          let idx = *idx;
-                          item_editor.get_msg_port()
-                              .map(move |msg| {
-                                  let mut msg = msg.clone();
-                                  msg.addr.insert(0, idx);
-                                  msg
-                              })
-                          })
-                      .flatten());
-
-        node.ctrl.spillbuf = e.spillbuf.clone();
-        node
+    pub fn update_item_reprtrees(&mut self, master_repr: &TypeTerm) {
+        self.data.get_port().0.update();
+        *self.master_repr.write().unwrap() = master_repr.clone();
+        for i in 0..self.data.len() {
+            self.item_builder.update( &self.data.get(i), master_repr.clone() );
+        }
     }
 
     pub fn get_item_type(&self) -> TypeTerm {
-        self.typ.clone()
+        self.item_type.clone()
     }
 
-    pub fn get_seq_type(&self) -> TypeTerm {
+    pub fn get_list_type(&self) -> TypeTerm {
         TypeTerm::App(vec![
             TypeTerm::TypeID(self.ctx.read().unwrap().get_typeid("List").unwrap()),
             self.get_item_type().into()
@@ -156,25 +178,43 @@ impl ListEditor {
         self.cursor.get_port()
     }
 
-    pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
-        self.data.get_port().to_list().map(
-            |x| x.read().unwrap().clone()
-        ).to_sequence()
+    pub fn get_reprtree_list(&self) -> OuterViewPort<dyn ListView<ReprTreeArc>> {
+        self.data.get_port().to_list()
     }
+
+    pub fn get_edittree_list(&self) -> OuterViewPort<dyn ListView< EditTree >> {
+        self.get_reprtree_list().map({
+            let ctx = self.ctx.clone();
+            let item_builder = self.item_builder.clone();
+            let master_repr = self.master_repr.clone();
+            let item_type = self.item_type.clone();
+            move |rt| {
+                if rt.descend(TypeTerm::TypeID(TYPEID_edittree)).is_none() {
+                    item_builder.update( &rt, item_type.clone() );
+                }
+                rt.edittree(&ctx).get()
+            }
+        })
+    }
+
+    pub fn get_edittree_seq(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
+        self.get_edittree_list().to_sequence()
+    }
+
 /*
     pub fn get_data(&self) -> Arc<RwLock<ReprTree>> {
         let data_view = self.get_data_port();
         ReprTree::new_leaf(
-            self.get_seq_type(),
+            self.get_list_type(),
             data_view.into()
         )
     }
 */
-    pub fn get_item(&self) -> Option<EditTree> {
+    pub fn get_item(&self) -> Option< ReprTreeArc > {
         if let Some(idx) = self.cursor.get().idx {
             let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
             if idx < self.data.len() {
-                Some(self.data.get(idx).read().unwrap().clone())
+                Some( self.data.get(idx).clone() )
             } else {
                 None
             }
@@ -183,7 +223,7 @@ impl ListEditor {
         }
     }
 
-    pub fn get_item_mut(&mut self) -> Option<MutableVecAccess<Arc<RwLock<EditTree>>>> {
+    pub fn get_item_mut(&mut self) -> Option<MutableVecAccess< ReprTreeArc >> {
         if let Some(idx) = self.cursor.get().idx {
             let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
             if idx < self.data.len() {
@@ -196,9 +236,26 @@ impl ListEditor {
         }
     }
 
+    pub fn get_edittree(&self, idx: usize) -> EditTree {
+        self.data.get(idx).edittree(&self.ctx).get()
+    }
+
+    pub fn get_cur_edittree(&self) -> Option< EditTree > {
+        if let Some(idx) = self.cursor.get().idx {
+            let idx = crate::utils::modulo(idx as isize, self.data.len() as isize) as usize;
+            if idx < self.data.len() {
+                Some(self.get_edittree(idx))
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
     /// is the element-type also a list-like editor (i.e. impls TreeNav)
     pub fn is_listlist(&self) -> bool {
-        self.ctx.read().unwrap().is_list_type(&self.typ)
+        self.ctx.read().unwrap().is_list_type(&self.item_type)
     }
 
     /// delete all items
@@ -207,7 +264,7 @@ impl ListEditor {
         for i in 0..self.data.len() {
             b.push( self.data.get(i) );
         }
-        
+
         self.data.clear();
         self.cursor.set(ListCursor::home());
     }
@@ -234,8 +291,11 @@ impl ListEditor {
     }
 
     /// insert a new element
-    pub fn insert(&mut self, item: Arc<RwLock<EditTree>>) {
-        item.read().unwrap().disp.depth.0.set_view(
+    pub fn insert(&mut self, item: ReprTreeArc) {
+        self.item_builder.update( &item, self.master_repr.read().unwrap().clone() );
+
+        let mut item_edit = item.edittree(&self.ctx).get_mut();
+        item_edit.disp.depth.0.set_view(
             self.depth.map(|d| d+1).get_view()
         );
 
@@ -247,13 +307,13 @@ impl ListEditor {
                     if self.is_listlist() {
                         cur.mode = ListCursorMode::Select;
                     } else {
-                        item.write().unwrap().goto(TreeCursor::none());
+                        item_edit.goto(TreeCursor::none());
                         cur.idx = Some(idx + 1);
                     }
                 }
 
                 ListCursorMode::Select => {
-                    self.data.insert(1 + idx as usize, item.clone());                    
+                    self.data.insert(1 + idx as usize, item.clone());
                     if self.is_listlist() {
                         cur.idx = Some(idx + 1);
                     }
@@ -304,51 +364,39 @@ impl ListEditor {
         let cur = self.get_cursor();
 
         if let Some(mut item) = self.get_item().clone() {
-            item.send_cmd_obj(ListCmd::Split.into_repr_tree(&self.ctx));
+            let mut ie = item.edittree(&self.ctx).get_mut();
+            ie.send_cmd_obj(ListCmd::Split.into_repr_tree(&self.ctx));
 
             if cur.tree_addr.len() < 3 {
-                item.goto(TreeCursor::none());
+                ie.goto(TreeCursor::none());
 
                 self.set_leaf_mode(ListCursorMode::Insert);
                 self.nexd();
 
-                let mut b = item.ctrl.spillbuf.write().unwrap();
+                let mut b = ie.ctrl.spillbuf.write().unwrap();
 
-                let rt = ReprTree::new_arc(self.typ.clone());
+                let rt = ReprTree::new_arc(self.item_type.clone());
                 let mut et = self.ctx.read().unwrap().setup_edittree(&rt);
 
                 if let Some(edittree) = et.as_mut(){
+                    let mut tail_node = edittree.get_mut();
+                    tail_node.goto(TreeCursor::home());
 
-                let mut tail_node = edittree.get();
-                let mut tail_node = tail_node.write().unwrap();
-                tail_node.goto(TreeCursor::home());
+                    for n in b.iter() {
+                        tail_node.send_cmd_obj(n.clone());
+                    }
 
-                for node in b.iter() {
-                    tail_node
-                        .send_cmd_obj(
-                            ReprTree::from_singleton_buffer(
-                                Context::parse(&self.ctx, "EditTree"),
-                                SingletonBuffer::<EditTree>::new(
-                                    node.read().unwrap().clone()
-                                )
-                            )
-                        );
-                }
+                    b.clear();
+                    drop(b);
+                    drop(item);
 
-                b.clear();
-                drop(b);
-                drop(item);
-
-                tail_node.goto(TreeCursor::home());
-                if cur.tree_addr.len() > 1 {
-                    tail_node.dn();
-                }
-                drop(tail_node);
-
-                self.insert(
-                    edittree.value.read().unwrap().clone()
-                );
+                    tail_node.goto(TreeCursor::home());
+                    if cur.tree_addr.len() > 1 {
+                        tail_node.dn();
+                    }
+                    drop(tail_node);
 
+                    self.insert(rt);
                 }
 
             } else {
@@ -361,10 +409,8 @@ impl ListEditor {
 
     pub fn listlist_join_pxev(&mut self, idx: isize) {
         {
-            let cur_editor = self.data.get(idx as usize);
-            let pxv_editor = self.data.get(idx as usize-1);
-            let mut cur_editor = cur_editor.write().unwrap();
-            let mut pxv_editor = pxv_editor.write().unwrap();
+            let mut cur_editor = self.data.get(idx as usize).edittree(&self.ctx).get_mut();
+            let mut pxv_editor = self.data.get(idx as usize-1).edittree(&self.ctx).get_mut();
 
             let oc0 = cur_editor.get_cursor();
 
@@ -373,7 +419,7 @@ impl ListEditor {
             cur_editor.send_cmd_obj(
                 ListCmd::Clear.into_repr_tree( &self.ctx )
             );
-            
+
             pxv_editor.goto(TreeCursor {
                 tree_addr: vec![-1],
                 leaf_mode: ListCursorMode::Insert
@@ -383,14 +429,7 @@ impl ListEditor {
 
             let data = cur_editor.ctrl.spillbuf.read().unwrap();
             for x in data.iter() {
-                pxv_editor.send_cmd_obj(
-                    ReprTree::from_singleton_buffer(
-                        Context::parse(&self.ctx, "EditTree"),
-                        SingletonBuffer::<EditTree>::new(
-                            x.read().unwrap().clone()
-                        )
-                    )
-                );
+                pxv_editor.send_cmd_obj(x.clone());
             }
 
 
@@ -398,13 +437,13 @@ impl ListEditor {
             if oc0.tree_addr.len() > 1 {
                 pxv_editor.goto(TreeCursor {
                     tree_addr: vec![ old_cur.tree_addr[0], 0 ],
-                    leaf_mode: ListCursorMode::Insert                
+                    leaf_mode: ListCursorMode::Insert
                 });
                 pxv_editor.send_cmd_obj(ListCmd::DeletePxev.into_repr_tree( &self.ctx ));
             } else if oc0.tree_addr.len() > 0 {
                 pxv_editor.goto(TreeCursor {
                     tree_addr: vec![ old_cur.tree_addr[0] ],
-                    leaf_mode: ListCursorMode::Insert                
+                    leaf_mode: ListCursorMode::Insert
                 });
             }
         }
@@ -420,10 +459,8 @@ impl ListEditor {
 
     pub fn listlist_join_nexd(&mut self, idx: usize) {
         {
-            let cur_editor = self.data.get(idx);
-            let nxd_editor = self.data.get(idx + 1);
-            let mut cur_editor = cur_editor.write().unwrap();
-            let mut nxd_editor = nxd_editor.write().unwrap();
+            let mut cur_editor = self.data.get(idx).edittree(&self.ctx).get_mut();
+            let mut nxd_editor = self.data.get(idx + 1).edittree(&self.ctx).get_mut();
 
             let oc0 = cur_editor.get_cursor();
 
@@ -438,25 +475,18 @@ impl ListEditor {
                 tree_addr: vec![-1],
                 leaf_mode: ListCursorMode::Insert
             });
- 
+
             let data = nxd_editor.ctrl.spillbuf.read().unwrap();
 
             for x in data.iter() {
-                cur_editor.send_cmd_obj(
-                    ReprTree::from_singleton_buffer(
-                        Context::parse(&self.ctx, "EditTree"),
-                        SingletonBuffer::<EditTree>::new(
-                            x.read().unwrap().clone()
-                        )
-                    )
-                );
+                cur_editor.send_cmd_obj(x.clone());
             }
 
             // fixme: is it oc0 or old_cur ??
             if oc0.tree_addr.len() > 1 {
                 cur_editor.goto(TreeCursor {
                     tree_addr: vec![ old_cur.tree_addr[0], -1 ],
-                    leaf_mode: ListCursorMode::Insert                
+                    leaf_mode: ListCursorMode::Insert
                 });
                 cur_editor.send_cmd_obj(ListCmd::DeleteNexd.into_repr_tree( &self.ctx ));
             } else if oc0.tree_addr.len() > 0 {
@@ -485,7 +515,7 @@ impl TreeType for ListEditor {
         let idx = crate::utils::modulo::modulo(addr.0[0] as isize, self.data.len() as isize) as usize;
 
         let mut addr = addr.clone();
-        
+
         if self.data.len() > 0 {
             addr.0.remove(0);
             self.data.get(idx).get_type(addr)
@@ -495,5 +525,3 @@ impl TreeType for ListEditor {
     }
 }
  */
-
-

lib-nested-core/src/editors/list/nav.rs

@@ -11,6 +11,7 @@ use {
             ListCursor, ListCursorMode,
             editor::ListEditor
         },
+        repr_tree::{ReprTreeExt},
         edit_tree::{TreeCursor, TreeNav, TreeNavResult, TreeHeightOp}
     },
     cgmath::Vector2
@@ -26,7 +27,7 @@ impl TreeNav for ListEditor {
     fn get_mode_view(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursorMode>> {
         self.mode_port.clone()
     }
-    
+
     fn get_height(&self, op: &TreeHeightOp) -> usize {
         match op {
             TreeHeightOp::P | TreeHeightOp::Q => {
@@ -35,7 +36,9 @@ impl TreeNav for ListEditor {
                         TreeHeightOp::P => 0,
                         TreeHeightOp::Q => self.data.len() - 1,
                         _ => 0
-                    }).read().unwrap().get_height(op)
+                    })
+                    .edittree(&self.ctx).get()
+                    .get_height(op)
                 } else {
                     1
                 }
@@ -43,7 +46,8 @@ impl TreeNav for ListEditor {
             TreeHeightOp::Max => {
                 1 + (0..self.data.len() as usize)
                     .map(|i| self.data
-                         .get(i).read().unwrap()
+                         .get(i)
+                         .edittree(&self.ctx).get()
                          .get_height(&TreeHeightOp::Max)
                     )
                     .max()
@@ -68,7 +72,8 @@ impl TreeNav for ListEditor {
             ListCursorMode::Select => {
                 if let Some(i) = cur.idx {
                     if i < self.data.len() as isize {
-                        let mut sub_cur = self.data.get(i as usize).read().unwrap().get_cursor_warp();
+                        let mut sub_cur = self.get_edittree(i as usize)
+                            .get_cursor_warp();
                         sub_cur.tree_addr.insert(0, i as isize - self.data.len() as isize);
                         return sub_cur;
                     } else {
@@ -100,11 +105,11 @@ impl TreeNav for ListEditor {
             ListCursorMode::Select => {
                 if let Some(i) = cur.idx {
                     if i < self.data.len() as isize {
-                        let mut sub_cur = self.data.get(i as usize).read().unwrap().get_cursor();
+                        let mut sub_cur = self.get_edittree(i as usize).get_cursor();
                         if sub_cur.tree_addr.len() > 0 {
                             sub_cur.tree_addr.insert(0, i as isize);
                             return sub_cur;
-                        } else {                            
+                        } else {
                             return TreeCursor {
                                 leaf_mode: ListCursorMode::Select,
                                 tree_addr: vec![ i ],
@@ -124,7 +129,7 @@ impl TreeNav for ListEditor {
         let old_cur = self.cursor.get();
         if let Some(i) = old_cur.idx {
             if i < self.data.len() as isize {
-                self.data.get_mut(i as usize).write().unwrap().goto(TreeCursor::none());
+                self.get_edittree(i as usize).goto(TreeCursor::none());
             }
         }
 
@@ -145,9 +150,7 @@ impl TreeNav for ListEditor {
                 });
 
                 if new_cur.leaf_mode == ListCursorMode::Select && self.data.len() > 0 {
-                    self.data
-                        .get_mut(idx as usize)
-                        .write().unwrap()
+                    self.get_edittree(idx as usize)
                         .goto(TreeCursor {
                             leaf_mode: ListCursorMode::Select,
                             tree_addr: vec![]
@@ -165,9 +168,7 @@ impl TreeNav for ListEditor {
                         idx: Some(idx),
                     });
 
-                    self.data
-                        .get_mut(idx as usize)
-                        .write().unwrap()
+                    self.get_edittree(idx as usize)
                         .goto(TreeCursor {
                             leaf_mode: new_cur.leaf_mode,
                             tree_addr: new_cur.tree_addr[1..].iter().cloned().collect(),
@@ -176,7 +177,7 @@ impl TreeNav for ListEditor {
                     self.cursor.set(ListCursor::home());
                 }
 
-                TreeNavResult::Continue                
+                TreeNavResult::Continue
             }
         }
     }
@@ -212,9 +213,7 @@ impl TreeNav for ListEditor {
                     // dn
 
                     if cur.tree_addr[0] < self.data.len() as isize {
-                        if self.data
-                            .get_mut(cur.tree_addr[0] as usize)
-                            .write().unwrap()
+                        if self.get_edittree(cur.tree_addr[0] as usize)
                             .goby(Vector2::new(direction.x, direction.y))
                             == TreeNavResult::Continue {
                                 self.cursor.set(ListCursor {
@@ -247,13 +246,12 @@ impl TreeNav for ListEditor {
 
                         match cur.leaf_mode {
                             ListCursorMode::Select => {
-                                let cur_item = self.data.get(cur.tree_addr[0] as usize);
-                                let cur_height = cur_item.read().unwrap().get_height(&TreeHeightOp::Max);
+                                let cur_item = self.get_edittree(cur.tree_addr[0] as usize);
+                                let cur_height = cur_item.get_height(&TreeHeightOp::Max);
 
-                                let new_item = self.data
-                                    .get_mut(idx as usize);
+                                let new_item = self.get_edittree(idx as usize);
 
-                                let height = new_item.read().unwrap().get_height(
+                                let height = new_item.get_height(
                                     if direction.x < 0 {
                                         &TreeHeightOp::Q
                                     } else {
@@ -277,28 +275,28 @@ impl TreeNav for ListEditor {
                                 if direction.x > 0
                                 {
                                     if (cur.tree_addr[0] as usize) < self.data.len() {
-                                        let cur_item = self.data.get(cur.tree_addr[0] as usize);
-                                        let cur_height = cur_item.read().unwrap().get_height(&TreeHeightOp::P);
+                                        let cur_item = self.get_edittree(cur.tree_addr[0] as usize);
+                                        let cur_height = cur_item.get_height(&TreeHeightOp::P);
 
                                         if gravity && cur_height > 1 {
                                             new_addr.push( cur.tree_addr[0] );
                                             new_addr.push(0);
                                         } else {
-                                            new_addr.push( idx );           
+                                            new_addr.push( idx );
                                         }
                                     }
                                 } else {
                                     if (idx as usize) < self.data.len() {
-                                        let pxv_item = self.data.get(idx as usize);
-                                        let pxv_height = pxv_item.read().unwrap().get_height(&TreeHeightOp::P);
+                                        let pxv_item = self.get_edittree(idx as usize);
+                                        let pxv_height = pxv_item.get_height(&TreeHeightOp::P);
 
                                         if gravity && pxv_height > 1 {
                                             new_addr.push( idx );
                                             new_addr.push( -1 );
                                         } else {
-                                            new_addr.push( idx );           
+                                            new_addr.push( idx );
                                         }
-                                    }                                    
+                                    }
                                 }
                             }
                         }
@@ -324,11 +322,8 @@ impl TreeNav for ListEditor {
                 // nested
 
                 if cur.tree_addr[0] < self.data.len() as isize {
-
-                    let cur_item = self.data
-                        .get_mut(cur.tree_addr[0] as usize);
-
-                    let result = cur_item.write().unwrap().goby(direction);
+                    let mut cur_item = self.get_edittree(cur.tree_addr[0] as usize);
+                    let result = cur_item.goby(direction);
 
                     match result
                     {
@@ -353,11 +348,10 @@ impl TreeNav for ListEditor {
                                     let mut new_addr = Vec::new();
 
                                     if direction.x < 0 {
-                                        let pxv_item = self.data
-                                            .get_mut(cur.tree_addr[0] as usize - 1);
+                                        let pxv_item = self.get_edittree(cur.tree_addr[0] as usize - 1);
 
-                                        let pxv_height = pxv_item.read().unwrap().get_height(&TreeHeightOp::Q) as isize;
-                                        let cur_height = cur_item.read().unwrap().get_height(&TreeHeightOp::P) as isize;
+                                        let pxv_height = pxv_item.get_height(&TreeHeightOp::Q) as isize;
+                                        let cur_height = cur_item.get_height(&TreeHeightOp::P) as isize;
                                         let dist_from_ground = cur_height - (depth as isize - 1);
                                         let n_steps_down =
                                             if gravity {
@@ -370,13 +364,12 @@ impl TreeNav for ListEditor {
                                         for _i in 0..n_steps_down {
                                             new_addr.push( -1 );
                                         }
-                                        
-                                    } else {
-                                        let nxd_item = self.data
-                                            .get_mut(cur.tree_addr[0] as usize + 1);
 
-                                        let cur_height = cur_item.read().unwrap().get_height(&TreeHeightOp::Q) as isize;
-                                        let nxd_height = nxd_item.read().unwrap().get_height(&TreeHeightOp::P) as isize;
+                                    } else {
+                                        let nxd_item = self.get_edittree(cur.tree_addr[0] as usize + 1);
+
+                                        let cur_height = cur_item.get_height(&TreeHeightOp::Q) as isize;
+                                        let nxd_height = nxd_item.get_height(&TreeHeightOp::P) as isize;
                                         let dist_from_ground = cur_height - (depth as isize - 1);
                                         let n_steps_down =
                                             if gravity {
@@ -422,4 +415,3 @@ impl TreeNav for ListEditor {
         }
     }
 }
-

lib-nested-core/src/editors/list/segment.rs

@@ -23,6 +23,8 @@ pub enum ListSegment {
     }
 }
 
+/* todo: switch to ListView instead of SequenceView
+ */
 pub struct ListSegmentSequence {
     data: Arc<dyn SequenceView<Item = EditTree>>,
     cursor: Arc<dyn SingletonView<Item = ListCursor>>,

lib-nested-core/src/repr_tree/builder.rs

@@ -0,0 +1,109 @@
+use {
+    r3vi::{
+        view::{
+            ViewPort, OuterViewPort,
+            AnyViewPort, AnyInnerViewPort, AnyOuterViewPort,
+            port::UpdateTask,
+            View, Observer,
+            singleton::*,
+            sequence::*,
+            list::*
+        },
+        buffer::{singleton::*, vec::*}
+    },
+    laddertypes::{TypeTerm, TypeID, sugar::*},
+    std::{
+        collections::HashMap,
+        sync::{Arc, RwLock},
+        any::Any
+    },
+    super::{Context, ReprLeaf, ReprTree, ReprTreeExt, context::{TYPEID_list, TYPEID_vec, TYPEID_char, TYPEID_u64, TYPEID_edittree}}
+};
+
+//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+
+#[derive(Clone)]
+pub struct ReprTreeBuilder {
+    ctx: Arc<RwLock<Context>>,
+    pub required_leaves: Vec<TypeTerm>,
+}
+
+#[derive(Debug)]
+pub enum ReprTreeError {
+    MissingMorphism
+}
+
+//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+
+impl ReprTreeBuilder {
+    pub fn new(ctx: Arc<RwLock<Context>>) -> Self {
+        ReprTreeBuilder {
+            ctx,
+            required_leaves: Vec::new()
+        }
+    }
+
+    /// Add a type to the set of required representations.
+    pub fn require(mut self, t: TypeTerm) -> Self {
+        self.required_leaves.push(t.normalize());
+        self
+    }
+
+    /// (re)build steiner tree with `required_leaves`,
+    /// and apply it to the projections in the ReprTree.
+    /// Updating and keeping existing nodes, while
+    /// adding new ones if required.
+    pub fn update(
+        &self,
+        rt: &Arc<RwLock<ReprTree>>,
+        master_leaf_type: impl Into<TypeTerm>
+    ) -> Result< Arc<RwLock<ReprTree>>, ReprTreeError > {
+        rt.write().unwrap().detach( &self.ctx );
+
+        let morphism_base = &self.ctx.read().unwrap().morphisms;
+
+        let mt = master_leaf_type.into();
+        //eprintln!("REBUILD repr tree from {}", self.ctx.read().unwrap().type_term_to_str(&mt));
+        let mut leaves = self.required_leaves.clone();
+        leaves.retain(|t| t != &mt);
+
+        let mut st_problem = laddertypes::steiner_tree::PathApproxSteinerTreeSolver::new(
+            mt,
+            leaves
+        );
+
+        if let Some( steiner_tree ) = st_problem.solve( &morphism_base ) {
+            for morphism_type in steiner_tree.into_edges() {
+                eprintln!("--> morph {} to {}",
+                    self.ctx.read().unwrap().type_term_to_str(&morphism_type.src_type),
+                    self.ctx.read().unwrap().type_term_to_str(&morphism_type.dst_type));
+
+                if let Some(( morphism, mut τ, σ )) =
+                    morphism_base.find_morphism_with_subtyping( &morphism_type )
+                {
+                    let mut rt = rt.descend_create( τ ).expect("descend src repr");
+                    (morphism.setup_projection)( &mut rt, &σ );
+                } else {
+                    eprintln!("failed to get morphism");
+                    //return Err(ReprTreeError::MissingMorphism);
+                }
+            }
+
+            Ok( rt.clone() )
+        } else {
+            eprintln!("could not find steiner tree to build the requested repr tree");
+            Err(ReprTreeError::MissingMorphism)
+        }
+    }
+
+    /// Build fresh ReprTree from a master representation.
+    pub fn build_from(
+        &self,
+        mut master_rt: Arc<RwLock<ReprTree>>
+    ) -> Result< Arc<RwLock<ReprTree>>, ReprTreeError > {
+        let master_leaf_type = master_rt.get_full_type();
+        self.update( &ReprTree::rise( master_rt ), master_leaf_type )
+    }
+}
+
+//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>

lib-nested-core/src/repr_tree/context.rs

@@ -1,7 +1,7 @@
 use {
     crate::{
         edit_tree::EditTree,
-        repr_tree::{GenericReprTreeMorphism, ReprTree, ReprTreeExt, ReprTreeArc},
+        repr_tree::{GenericReprTreeMorphism, ReprTree, ReprTreeArc, ReprTreeExt},
     },
     laddertypes::{
         parser::ParseLadderType, sugar::SugaredTypeTerm, unparser::UnparseLadderType,
@@ -12,18 +12,18 @@ use {
         view::{singleton::*, OuterViewPort},
     },
     std::{
-        collections::HashMap,
-        sync::{Arc, RwLock},
-    }
+        collections::HashMap, ops::DerefMut, sync::{Arc, RwLock}
+    },
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-pub static TYPEID_edittree : TypeID = TypeID::Fun(0);
-pub static TYPEID_char : TypeID = TypeID::Fun(1);
-pub static TYPEID_u64  : TypeID = TypeID::Fun(2);
-pub static TYPEID_list : TypeID = TypeID::Fun(3);
-pub static TYPEID_vec : TypeID = TypeID::Fun(4);
+pub static TYPEID_reprtree: TypeID = TypeID::Fun(0);
+pub static TYPEID_edittree: TypeID = TypeID::Fun(1);
+pub static TYPEID_char: TypeID = TypeID::Fun(2);
+pub static TYPEID_u64: TypeID = TypeID::Fun(3);
+pub static TYPEID_list: TypeID = TypeID::Fun(4);
+pub static TYPEID_vec: TypeID = TypeID::Fun(5);
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
@@ -32,18 +32,18 @@ pub struct Context {
     /// assigns a name to every type
     pub type_dict: Arc<RwLock<BimapTypeDict>>,
 
-    pub morphisms: laddertypes::morphism::MorphismBase< GenericReprTreeMorphism >,
+    pub morphisms: laddertypes::morphism::MorphismBase<GenericReprTreeMorphism>,
 
     /// named vertices of the graph
-    nodes: HashMap< String, Arc<RwLock<ReprTree>> >,
+    nodes: HashMap<String, ReprTreeArc>,
 
     /// todo: beautify
     /// types that can be edited as lists
     /// do we really need this?
-    pub list_types: Vec< TypeID >,
-    pub meta_chars: Vec< char >,
+    pub list_types: Vec<TypeID>,
+    pub meta_chars: Vec<char>,
 
-    edittree_hook: Arc< dyn Fn(&mut EditTree, TypeTerm) + Send +Sync +'static >,
+    edittree_hook: Arc<dyn Fn(&mut EditTree, TypeTerm) + Send + Sync + 'static>,
 
     /// recursion
     parent: Option<Arc<RwLock<Context>>>,
@@ -52,14 +52,13 @@ pub struct Context {
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
 impl Context {
-    pub fn with_parent(
-        parent: Option<Arc<RwLock<Context>>>
-    ) -> Self {
+    pub fn with_parent(parent: Option<Arc<RwLock<Context>>>) -> Self {
         Context {
             type_dict: match parent.as_ref() {
                 Some(p) => p.read().unwrap().type_dict.clone(),
                 None => {
                     let mut dict = BimapTypeDict::new();
+                    assert_eq!(TYPEID_reprtree, dict.add_typename("ReprTree".into()));
                     assert_eq!(TYPEID_edittree, dict.add_typename("EditTree".into()));
                     assert_eq!(TYPEID_char, dict.add_typename("Char".into()));
                     assert_eq!(TYPEID_u64, dict.add_typename("machine.UInt64".into()));
@@ -69,18 +68,18 @@ impl Context {
                     Arc::new(RwLock::new(dict))
                 }
             },
-            morphisms: MorphismBase::new( TYPEID_list ),
+            morphisms: MorphismBase::new(TYPEID_list),
             nodes: HashMap::new(),
             list_types: match parent.as_ref() {
                 Some(p) => p.read().unwrap().list_types.clone(),
-                None => Vec::new()
+                None => Vec::new(),
             },
             meta_chars: match parent.as_ref() {
                 Some(p) => p.read().unwrap().meta_chars.clone(),
-                None => Vec::new()
+                None => Vec::new(),
             },
             parent,
-            edittree_hook: Arc::new(|_et, _t| {})
+            edittree_hook: Arc::new(|_et, _t| {}),
         }
     }
 
@@ -88,7 +87,10 @@ impl Context {
         Context::with_parent(None)
     }
 
-    pub fn set_edittree_hook(&mut self, hook: Arc< dyn Fn(&mut EditTree, TypeTerm) + Send +Sync +'static >) {
+    pub fn set_edittree_hook(
+        &mut self,
+        hook: Arc<dyn Fn(&mut EditTree, TypeTerm) + Send + Sync + 'static>,
+    ) {
         self.edittree_hook = hook;
     }
 
@@ -100,22 +102,20 @@ impl Context {
         }
     }
 
-    pub fn apply_morphism( &self, rt: &Arc<RwLock<ReprTree>>, ty: &MorphismType ) {
-        if let Some(path)
-            = self.morphisms.find_morphism_path( ty.clone().normalize() )
-        {
+    pub fn apply_morphism(&self, rt: &Arc<RwLock<ReprTree>>, ty: &MorphismType) {
+        if let Some(path) = self.morphisms.find_morphism_path(ty.clone().normalize()) {
             let mut path = path.into_iter();
             if let Some(mut src_type) = path.next() {
                 for dst_type in path {
-                   if let Some(( m, mut τ, σ )) =
-                       self.morphisms.find_morphism_with_subtyping(
-                        &laddertypes::MorphismType {
-                            src_type: src_type.clone(),
-                            dst_type: dst_type.clone()
-                        }
-                    ) {
-                        let mut rt = rt.descend( τ ).expect("descend src repr");
-                        (m.setup_projection)( &mut rt, &σ );
+                    if let Some((m, mut τ, σ)) =
+                        self.morphisms
+                            .find_morphism_with_subtyping(&laddertypes::MorphismType {
+                                src_type: src_type.clone(),
+                                dst_type: dst_type.clone(),
+                            })
+                    {
+                        let mut rt = rt.descend(τ).expect("descend src repr");
+                        (m.setup_projection)(&mut rt, &σ);
                     }
 
                     src_type = dst_type;
@@ -123,43 +123,14 @@ impl Context {
             }
         } else {
             eprintln!("no path found");
-        }    
-    }
-
-    pub fn build_repr_tree(
-        &self,
-        rt: &Arc<RwLock<ReprTree>>,
-        root: TypeTerm,
-        leaves: Vec< TypeTerm >
-    ) {
-        let mut st_problem = laddertypes::steiner_tree::PathApproxSteinerTreeSolver::new(
-            root,
-            leaves
-        );
-
-        if let Some( steiner_tree ) = st_problem.solve( &self.morphisms ) {
-            for morphism_type in steiner_tree.into_edges() {
-                eprintln!("--> apply morph to {}", self.type_term_to_str(&morphism_type.dst_type));
-                if let Some(( morphism, mut τ, σ )) =
-                    self.morphisms.find_morphism_with_subtyping( &morphism_type )
-                {
-                    let mut rt = rt.descend( τ ).expect("descend src repr");
-                    (morphism.setup_projection)( &mut rt, &σ );
-                }
-            }
-        } else {
-            eprintln!("could not find steiner tree to build the requested repr tree");
         }
     }
 
-    pub fn make_repr(ctx: &Arc<RwLock<Self>>, t: &TypeTerm) -> ReprTreeArc {
-        let rt = Arc::new(RwLock::new(ReprTree::new( TypeTerm::unit() )));
-        ctx.read().unwrap().apply_morphism( &rt, &MorphismType{ src_type: TypeTerm::unit(), dst_type: t.clone() } );
-        rt
-    }
-
     pub fn parse(ctx: &Arc<RwLock<Self>>, s: &str) -> TypeTerm {
-        ctx.read().unwrap().type_term_from_str(s).expect("could not parse type term")
+        ctx.read()
+            .unwrap()
+            .type_term_from_str(s)
+            .expect("could not parse type term")
     }
 
     pub fn add_typename(&mut self, tn: &str) -> TypeID {
@@ -171,21 +142,21 @@ impl Context {
     }
 
     pub fn add_synonym(&mut self, new: &str, old: &str) {
-        self.type_dict.write().unwrap().add_synonym(new.to_string(), old.to_string());
+        self.type_dict
+            .write()
+            .unwrap()
+            .add_synonym(new.to_string(), old.to_string());
     }
 
     pub fn add_list_typename(&mut self, tn: &str) {
         let tid = self.add_typename(tn);
-        self.list_types.push( tid );
+        self.list_types.push(tid);
     }
 
     pub fn is_list_type(&self, t: &TypeTerm) -> bool {
         match t {
-            TypeTerm::TypeID(id) => {
-                self.list_types.contains(id)
-            }
-            TypeTerm::Ladder(args) |
-            TypeTerm::App(args) => {
+            TypeTerm::TypeID(id) => self.list_types.contains(id),
+            TypeTerm::Ladder(args) | TypeTerm::App(args) => {
                 if args.len() > 0 {
                     if self.is_list_type(&args[0]) {
                         true
@@ -196,7 +167,7 @@ impl Context {
                     false
                 }
             }
-            _ => false
+            _ => false,
         }
     }
 
@@ -207,7 +178,7 @@ impl Context {
     pub fn get_fun_typeid(&self, tn: &str) -> Option<u64> {
         match self.get_typeid(tn) {
             Some(TypeID::Fun(x)) => Some(x),
-            _ => None
+            _ => None,
         }
     }
 
@@ -218,11 +189,14 @@ impl Context {
     pub fn get_var_typeid(&self, tn: &str) -> Option<u64> {
         match self.get_typeid(tn) {
             Some(TypeID::Var(x)) => Some(x),
-            _ => None
+            _ => None,
         }
     }
 
-    pub fn type_term_from_str(&self, tn: &str) -> Result<TypeTerm, laddertypes::parser::ParseError> {
+    pub fn type_term_from_str(
+        &self,
+        tn: &str,
+    ) -> Result<TypeTerm, laddertypes::parser::ParseError> {
         self.type_dict.write().unwrap().parse(&tn)
     }
 
@@ -232,17 +206,22 @@ impl Context {
 
     /// adds an object without any representations
     pub fn add_obj(ctx: Arc<RwLock<Context>>, name: String, typename: &str) {
-        let type_tag = ctx.read().unwrap()
-            .type_dict.write().unwrap()
-            .parse(typename).unwrap();
-/*
-        if let Some(node) = Context::make_node(&ctx, type_tag, SingletonBuffer::new(0).get_port()) {
-            ctx.write().unwrap().nodes.insert(name, node);
-        }
-*/
+        let type_tag = ctx
+            .read()
+            .unwrap()
+            .type_dict
+            .write()
+            .unwrap()
+            .parse(typename)
+            .unwrap();
+        /*
+                if let Some(node) = Context::make_node(&ctx, type_tag, SingletonBuffer::new(0).get_port()) {
+                    ctx.write().unwrap().nodes.insert(name, node);
+                }
+        */
     }
 
-    pub fn get_obj(&self, name: &String) -> Option< ReprTreeArc > {
+    pub fn get_obj(&self, name: &String) -> Option<ReprTreeArc> {
         if let Some(obj) = self.nodes.get(name) {
             Some(obj.clone())
         } else if let Some(parent) = self.parent.as_ref() {
@@ -254,22 +233,24 @@ impl Context {
 
     pub fn setup_edittree(
         &self,
-        rt: &Arc<RwLock<ReprTree>>
-    ) -> Option<SingletonBuffer<Arc<RwLock<EditTree>>>> {
-        if let Some(new_edittree) =
-            rt.descend(self.type_term_from_str("EditTree").unwrap())
-        {
-            let typ = rt.read().unwrap().get_type().clone();
-            let buf = new_edittree.singleton_buffer::<Arc<RwLock<EditTree>>>();
-            (*self.edittree_hook)(
-                &mut *buf.get().write().unwrap(),
-                typ
-            );
+        rt: &Arc<RwLock<ReprTree>>,
+    ) -> Option<SingletonBuffer<EditTree>> {
+        let edittree_rt = rt
+            .descend(
+                self.type_term_from_str("EditTree")
+                    .expect("cant descend to editTree"),
+            )
+            .clone();
+        if let Some(new_edittree) = edittree_rt {
+            let typ = rt.get_type();
+            let mut buf = new_edittree.singleton_buffer::<EditTree>();
+            (*self.edittree_hook)(&mut *buf.get_mut(), typ);
             Some(buf)
         } else {
-            eprintln!("cant find edit tree repr {} ~Ψ~ {}",
-                self.type_term_to_str(rt.read().unwrap().get_halo_type()),
-                self.type_term_to_str(rt.read().unwrap().get_type())
+            eprintln!(
+                "cant find edit tree repr {} ~Ψ~ {}",
+                self.type_term_to_str(&rt.get_halo_type()),
+                self.type_term_to_str(&rt.get_type())
             );
             None
         }
@@ -277,4 +258,3 @@ impl Context {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

lib-nested-core/src/repr_tree/leaf.rs

@@ -50,13 +50,13 @@ impl ReprLeaf {
             in_keepalive: Some(in_keepalive),
             in_port: in_port.inner().into(),
             out_port: out_port.into(),
-            data: None, 
+            data: None,
         }
     }
 
     pub fn detach<V>(&mut self)
     where V: View + ?Sized + 'static,
-         V::Msg: Clone
+        V::Msg: Clone
     {
         self.keepalive = None;
         self.in_keepalive = None;
@@ -213,4 +213,3 @@ impl ReprLeaf {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

lib-nested-core/src/repr_tree/mod.rs

@@ -1,5 +1,6 @@
 pub mod node;
 pub mod leaf;
+pub mod builder;
 pub mod context;
 pub mod morphism;
 
@@ -10,6 +11,7 @@ pub use {
     context::{Context},
     leaf::ReprLeaf,
     node::{ReprTree, ReprTreeArc},
+    builder::{ReprTreeBuilder, ReprTreeError},
     morphism::{GenericReprTreeMorphism}
 };
 
@@ -34,15 +36,16 @@ use {
     },
 };
 
-//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-
 pub trait ReprTreeExt {
     fn get_type(&self) -> TypeTerm;
+    fn get_halo_type(&self) -> TypeTerm;
+    fn get_full_type(&self) -> TypeTerm;
 
     fn insert_leaf(&mut self, type_ladder: impl Into<TypeTerm>, leaf: ReprLeaf);
     fn insert_branch(&mut self, repr: Arc<RwLock<ReprTree>>);
     fn create_branch(&mut self, rung: impl Into<TypeTerm>);
     fn descend(&self, target_type: impl Into<TypeTerm>) -> Option< ReprTreeArc >;
+    fn descend_create(&self, target_type: impl Into<TypeTerm>) -> Option< ReprTreeArc >;
 
     fn attach_leaf_to<V: View + ?Sized + 'static>(&self, t: impl Into<TypeTerm>, v: OuterViewPort<V>) where V::Msg: Clone;
     fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>> where V::Msg: Clone;
@@ -59,8 +62,9 @@ pub trait ReprTreeExt {
     fn singleton_buffer<T: Clone + Send + Sync + 'static>(&self) -> SingletonBuffer<T>;
     fn vec_buffer<T: Clone + Send + Sync + 'static>(&self) -> VecBuffer<T>;
 
-    fn edittree(&self, ctx: &Arc<RwLock<Context>>) -> SingletonBuffer< Arc<RwLock<crate::edit_tree::EditTree>> > {
-        self.descend(Context::parse(&ctx, "EditTree")).unwrap()
+    fn edittree(&self, ctx: &Arc<RwLock<Context>>) -> SingletonBuffer< crate::edit_tree::EditTree > {
+        self.descend(Context::parse(&ctx, "EditTree"))
+            .expect("failed to get EditTree")
             .singleton_buffer()
     }
 }
@@ -70,6 +74,14 @@ impl ReprTreeExt for Arc<RwLock<ReprTree>> {
         self.read().unwrap().get_type().clone()
     }
 
+    fn get_halo_type(&self) -> TypeTerm {
+        self.read().unwrap().get_halo_type().clone()
+    }
+
+    fn get_full_type(&self) -> TypeTerm {
+        self.read().unwrap().get_full_type().clone()
+    }
+
     fn insert_leaf(&mut self, type_ladder: impl Into<TypeTerm>, leaf: ReprLeaf) {
         self.write().unwrap().insert_leaf(type_ladder.into().get_lnf_vec().into_iter(), leaf)
     }
@@ -78,8 +90,8 @@ impl ReprTreeExt for Arc<RwLock<ReprTree>> {
         self.write().unwrap().insert_branch(repr)
     }
 
-    fn create_branch(&mut self, rung: impl Into<TypeTerm>) {
-        let mut lnf = rung.into().get_lnf_vec().into_iter();
+    fn create_branch(&mut self, branch: impl Into<TypeTerm>) {
+        let mut lnf = branch.into().get_lnf_vec().into_iter();
         if let Some(rung) = lnf.next() {
             let mut parent = ReprTree::new_arc( rung );
             self.insert_branch( parent.clone() );
@@ -104,6 +116,10 @@ impl ReprTreeExt for Arc<RwLock<ReprTree>> {
         ReprTree::descend( self, target_type )
     }
 
+    fn descend_create(&self, target_type: impl Into<TypeTerm>)-> Option< ReprTreeArc > {
+        ReprTree::descend_create( self, target_type )
+    }
+
     fn view_char(&self) -> OuterViewPort<dyn SingletonView<Item = char>> {
         self.read().unwrap().view_char()
     }
@@ -133,13 +149,12 @@ impl ReprTreeExt for Arc<RwLock<ReprTree>> {
     }
 
     fn singleton_buffer<T: Clone + Send + Sync + 'static>(&self) -> SingletonBuffer<T> {
-        self.write().unwrap().singleton_buffer::<T>().expect("")
+        self.write().unwrap().singleton_buffer::<T>().expect("cant get singleton buffer")
     }
 
     fn vec_buffer<T: Clone + Send + Sync + 'static>(&self) -> VecBuffer<T> {
-        self.write().unwrap().vec_buffer::<T>().expect("")
+        self.write().unwrap().vec_buffer::<T>().expect("cant get vec buffer")
     }
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-

lib-nested-core/src/repr_tree/morphism.rs

@@ -80,29 +80,44 @@ impl GenericReprTreeMorphism {
                 lst_map_type.src_type.apply_substitution( &|x| subst.get(x).cloned() );
                 lst_map_type.dst_type.apply_substitution( &|x| subst.get(x).cloned() );
 
+                lst_map_type = lst_map_type.normalize();
+
                 eprintln!(
-                    "lst map type :  {:?}", lst_map_type
+                    "lst map type ::\n {:?}\n===>  {:?}\n\n", lst_map_type.src_type, lst_map_type.dst_type
                 );
 
-                let src_port = repr_tree
-                    .descend( lst_map_type.src_type.clone() )
-                    .expect("descend src seq")
-                    .view_list::<SrcItem>();
+                
+                let mut item_ladder = item_morph.morph_type.src_type.clone().get_lnf_vec();
+                let top_type = item_ladder.remove( item_ladder.len() - 1 );
 
-                let subst = subst.clone();
-                let item_morph = item_morph.clone();
+                if let Ok(item_sigma) = laddertypes::unify(
+                    &top_type,
+                    &TypeTerm::App(vec![
+                        TypeTerm::TypeID( list_typeid ),
+                        TypeTerm::TypeID( TypeID::Var( 200 ) )
+                    ])
+                ) {
+                    eprintln!("List OF List...");
+                } else {
+                    let src_port = repr_tree
+                        .descend( lst_map_type.src_type.clone() )
+                        .expect("descend src seq")
+                        .view_list::<SrcItem>();
 
-                let dst_view = src_port.map(
+                    let subst = subst.clone();
+                    let item_morph = item_morph.clone();
+
+                    let dst_view = src_port.map(
                         move |x| {
-                            let mut item_ladder = item_morph.morph_type.src_type.clone().get_lnf_vec();
                             let mut item_rt = ReprTree::from_singleton_buffer(
-                                item_ladder.remove( item_ladder.len() - 1 ),
-                                r3vi::buffer::singleton::SingletonBuffer::new(x.clone())
+                                    top_type.clone(),
+                                    r3vi::buffer::singleton::SingletonBuffer::new(x.clone())
                             );
+                            
 
                             // TODO: required?
-                            while item_ladder.len() > 0 {
-                                let mut n = ReprTree::new_arc( item_ladder.remove( item_ladder.len() - 1) );
+                            for t in item_ladder.iter().rev() {
+                                let mut n = ReprTree::new_arc( t.clone() );
                                 n.insert_branch( item_rt );
                                 item_rt = n;
                             }
@@ -112,13 +127,14 @@ impl GenericReprTreeMorphism {
                                 .view_singleton::< DstItem >()
                                 .get_view().unwrap()
                                 .get()
-                        }
-                );
+                        });
 
-                repr_tree.attach_leaf_to(
-                    lst_map_type.dst_type.clone(),
-                    dst_view as r3vi::view::OuterViewPort::< dyn r3vi::view::list::ListView<DstItem> >
-                );
+
+                    repr_tree.attach_leaf_to(
+                        lst_map_type.dst_type.clone(),
+                        dst_view as r3vi::view::OuterViewPort::< dyn r3vi::view::list::ListView<DstItem> >
+                    );
+                }
             })
         }
     }
@@ -192,16 +208,4 @@ impl GenericReprTreeMorphism {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-/*
-impl MorphismType {
-    pub fn to_str(&self, ctx: &Context) -> String {
-        format!("{:?} -> {:?}",
-                if let Some(t) = self.src_type.as_ref() {
-                    ctx.type_dict.read().unwrap().unparse(t)
-                } else {
-                    "None".into()
-                },
-                ctx.type_dict.read().unwrap().unparse(&self.dst_type))
-    }
-}
-*/
+

lib-nested-core/src/repr_tree/node.rs

@@ -1,5 +1,3 @@
-
-
 use {
     r3vi::{
         view::{
@@ -11,7 +9,7 @@ use {
             sequence::*,
             list::*
         },
-        buffer::{singleton::*, vec::*}
+        buffer::{singleton::*, vec::*},
     },
     laddertypes::{TypeTerm, TypeID},
     std::{
@@ -19,7 +17,12 @@ use {
         sync::{Arc, RwLock},
         any::Any
     },
-    super::{Context, ReprLeaf, ReprTreeExt, context::{TYPEID_list, TYPEID_vec, TYPEID_char, TYPEID_u64, TYPEID_edittree}}
+    super::{
+        Context,
+        ReprLeaf,
+        ReprTreeExt,
+        context::{TYPEID_reprtree, TYPEID_list, TYPEID_vec, TYPEID_char, TYPEID_u64, TYPEID_edittree}
+    }
 };
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
@@ -29,28 +32,13 @@ pub struct ReprTree {
     halo: TypeTerm,
     type_tag: TypeTerm,
     branches: HashMap<TypeTerm, ReprTreeArc>,
-    leaf: Option< ReprLeaf >
+    leaf: Option< ReprLeaf >,
 }
 
 pub type ReprTreeArc = Arc<RwLock<ReprTree>>;
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-impl std::fmt::Debug for ReprTree {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        writeln!(f, "| type: {:?}", self.type_tag)?;
-
-        for (_k,x) in self.branches.iter() {
-            writeln!(f, "|--> child: {:?}", x)?;
-        }
-        writeln!(f, "");
-
-        Ok(())
-    }
-}
-
-//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-
 impl ReprTree {
     pub fn new(typ: impl Into<TypeTerm>) -> Self {
         let mut lnf = typ.into().get_lnf_vec();
@@ -69,10 +57,33 @@ impl ReprTree {
         }
     }
 
+    pub fn fmt(&self, ctx: &Arc<RwLock<Context>>, depth: u32) -> String {
+        let mut s = String::new();
+        if( depth == 0 ) {
+            s.push_str(&format!("{}", ctx.read().unwrap().type_term_to_str(self.get_halo_type())))
+        }
+        s.push_str(&format!("+ {}\n", ctx.read().unwrap().type_term_to_str(&self.type_tag)));
+
+        for (_k,x) in self.branches.iter() {
+            for _ in 0..depth {
+                s.push_str("   ");
+            }
+            s.push_str(&format!("|--{}", x.read().unwrap().fmt(ctx, depth+1)));
+        }
+        s
+    }
+
     pub fn new_arc(type_tag: impl Into<TypeTerm>) -> ReprTreeArc {
         Arc::new(RwLock::new(Self::new(type_tag)))
     }
 
+    pub fn get_full_type(&self) -> TypeTerm {
+        TypeTerm::Ladder(vec![
+            self.halo.clone(),
+            self.type_tag.clone()
+        ]).normalize()
+    }
+
     pub fn get_type(&self) -> &TypeTerm {
         &self.type_tag
     }
@@ -128,7 +139,10 @@ impl ReprTree {
         )
     }
 
-    pub fn from_view<V>( type_tag: impl Into<TypeTerm>, view: OuterViewPort<V> ) -> ReprTreeArc
+    pub fn from_view<V>(
+        type_tag: impl Into<TypeTerm>,
+        view: OuterViewPort<V>
+    ) -> ReprTreeArc
     where V: View + ?Sized + 'static,
         V::Msg: Clone
     {
@@ -137,7 +151,10 @@ impl ReprTree {
         Arc::new(RwLock::new(rt))
     }
 
-    pub fn from_singleton_buffer<T>( type_tag: impl Into<TypeTerm>, buf: SingletonBuffer<T> ) -> ReprTreeArc
+    pub fn from_singleton_buffer<T>(
+        type_tag: impl Into<TypeTerm>,
+        buf: SingletonBuffer<T>
+    ) -> ReprTreeArc
     where T: Clone + Send + Sync + 'static
     {
         let mut rt = ReprTree::new(type_tag);
@@ -145,23 +162,20 @@ impl ReprTree {
         Arc::new(RwLock::new(rt))
     }
 
-    pub fn from_str(
-        type_tag: impl Into<TypeTerm>,
-        val: &str
-    ) -> ReprTreeArc {
-        let mut lnf = type_tag.into().get_lnf_vec();
-
-        let mut rt = ReprTree::from_vec_buffer(
-            lnf.pop().unwrap(),
+    pub fn from_str(val: &str) -> ReprTreeArc {
+        ReprTree::from_vec_buffer(
+            TypeTerm::App(vec![ TypeTerm::TypeID(TYPEID_vec), TypeTerm::TypeID(TYPEID_char) ]),
             VecBuffer::with_data( val.chars().collect() )
-        );
+        )
+    }
 
+    pub fn rise( mut rt: Arc<RwLock<ReprTree>> ) -> Arc<RwLock<ReprTree>> {
+        let mut lnf = rt.read().unwrap().get_halo_type().clone().get_lnf_vec();
         while let Some(t) = lnf.pop() {
             let mut new_rt = ReprTree::new_arc(t);
             new_rt.insert_branch(rt);
-            rt = new_rt;
+            rt = new_rt
         }
-
         rt
     }
 
@@ -198,7 +212,7 @@ impl ReprTree {
         V::Msg: Clone
     {
         while let Some(rung_type) = type_ladder.next() {
-            if &rung_type != self.get_type() { 
+            if &rung_type != self.get_type() {
                 if let Some(next_repr) = self.branches.get(&rung_type) {
                     next_repr.write().unwrap().attach_leaf_to(type_ladder, src_port);
                 } else {
@@ -215,17 +229,26 @@ impl ReprTree {
         } else {
             if self.type_tag == TypeTerm::App(vec![
                 TypeTerm::TypeID(TYPEID_vec),
-                TypeTerm::TypeID(TYPEID_edittree)
+                TypeTerm::TypeID(TYPEID_reprtree)
             ]) {
                 let mut leaf = ReprLeaf::from_vec_buffer(
-                    VecBuffer::<
-                        Arc<RwLock<crate::edit_tree::EditTree>>
-                    >::new()
+                    VecBuffer::<ReprTreeArc>::new()
                 );
 
                 leaf.attach_to(src_port);
                 self.leaf = Some(leaf);
-            }           
+            }
+            else  if self.type_tag == TypeTerm::App(vec![
+                TypeTerm::TypeID(TYPEID_vec),
+                TypeTerm::TypeID(TYPEID_edittree)
+            ]) {
+                let mut leaf = ReprLeaf::from_vec_buffer(
+                    VecBuffer::<crate::edit_tree::EditTree>::new()
+                );
+
+                leaf.attach_to(src_port);
+                self.leaf = Some(leaf);
+            }
             else if self.type_tag == TypeTerm::App(vec![
                 TypeTerm::TypeID(TYPEID_vec),
                 TypeTerm::TypeID(TYPEID_char)
@@ -247,7 +270,8 @@ impl ReprTree {
 
                 leaf.attach_to(src_port);
                 self.leaf = Some(leaf);
-            } else {
+            }
+            else {
                 self.leaf = Some(ReprLeaf::from_view(src_port));
             }
         }
@@ -258,9 +282,12 @@ impl ReprTree {
             if self.type_tag ==
                 TypeTerm::TypeID(TYPEID_edittree)
             {
-                leaf.detach::< dyn SingletonView<
-                    Item = Arc<RwLock< crate::edit_tree::EditTree >>
-                > >();
+                leaf.detach::< dyn SingletonView<Item = crate::edit_tree::EditTree> >();
+            }
+            else if self.type_tag ==
+                TypeTerm::TypeID(TYPEID_reprtree)
+            {
+                leaf.detach::< dyn SingletonView<Item = ReprTreeArc> >();
             }
             else if self.type_tag ==
                 TypeTerm::TypeID(TYPEID_char)
@@ -271,13 +298,17 @@ impl ReprTree {
             {
                 leaf.detach::< dyn SingletonView<Item = u64> >();
             }
+            else if self.type_tag == TypeTerm::App(vec![
+                TypeTerm::TypeID(TYPEID_vec),
+                TypeTerm::TypeID(TYPEID_reprtree),
+            ]) {
+                leaf.detach_vec::< ReprTreeArc >();
+            }
             else if self.type_tag == TypeTerm::App(vec![
                 TypeTerm::TypeID(TYPEID_vec),
                 TypeTerm::TypeID(TYPEID_edittree),
             ]) {
-                leaf.detach_vec::<
-                    Arc<RwLock< crate::edit_tree::EditTree >>
-                >();
+                leaf.detach_vec::<crate::edit_tree::EditTree>();
             }
             else if self.type_tag == TypeTerm::App(vec![
                 TypeTerm::TypeID(TYPEID_vec),
@@ -295,7 +326,13 @@ impl ReprTree {
                 TypeTerm::TypeID(TYPEID_list),
                 TypeTerm::TypeID(TYPEID_edittree),
             ]) {
-                leaf.detach::< dyn ListView<Arc<RwLock<crate::edit_tree::EditTree>>> >();
+                leaf.detach::< dyn ListView<crate::edit_tree::EditTree> >();
+            }
+            else if self.type_tag == TypeTerm::App(vec![
+                TypeTerm::TypeID(TYPEID_list),
+                TypeTerm::TypeID(TYPEID_reprtree),
+            ]) {
+                leaf.detach::< dyn ListView< ReprTreeArc > >();
             }
             else if self.type_tag == TypeTerm::App(vec![
                 TypeTerm::TypeID(TYPEID_list),
@@ -342,7 +379,7 @@ impl ReprTree {
 
     //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
 
-    pub fn descend_one(&self, dst_type: impl Into<TypeTerm>) -> Option< ReprTreeArc > {
+    pub fn descend_rung(&self, dst_type: impl Into<TypeTerm>) -> Option< ReprTreeArc > {
         let dst_type = dst_type.into();
         assert!( dst_type.is_flat() );
         self.branches.get(&dst_type).cloned()
@@ -352,7 +389,7 @@ impl ReprTree {
         if let Some(first) = repr_ladder.next() {
             let rt = rt.read().unwrap();
             repr_ladder.fold(
-                rt.descend_one(first),
+                rt.descend_rung(first),
                 |s, t| s?.descend(t))
         } else {
             Some(rt.clone())
@@ -371,25 +408,36 @@ impl ReprTree {
         }
     }
 
-    pub fn ascend(rt: &Arc<RwLock<Self>>, type_term: impl Into<TypeTerm>) -> Arc<RwLock<ReprTree>> {
+    pub fn descend_create(
+        rt: &Arc<RwLock<Self>>,
+        dst_type: impl Into<TypeTerm>
+    ) -> Option< ReprTreeArc > {
+        let dst_type = dst_type.into();
+        if let Some(branch) = ReprTree::descend(rt, dst_type.clone()) {
+            Some(branch)
+        } else {
+            let branch = ReprTree::new_arc(dst_type);
+            rt.write().unwrap().insert_branch(branch.clone());
+            Some(branch)
+        }
+    }
+
+    pub fn ascend(rt: &Arc<RwLock<Self>>, type_term: impl Into<TypeTerm>) -> ReprTreeArc {
         let mut n = Self::new(type_term);
         n.insert_branch(rt.clone());
         Arc::new(RwLock::new(n))
     }
 
-    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+
+
+    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>\\
+    //               Buffer Access               \\
+    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>\\
 
     pub fn singleton_buffer<T: Clone + Send + Sync + 'static>(&mut self) -> Option<SingletonBuffer<T>> {
         if let Some(leaf) = self.leaf.as_mut() {
             leaf.as_singleton_buffer::<T>()
         } else {
-            // create new singleton buffer
-            /*
-            // default value??
-            let buf = SingletonBuffer::<T>::default();
-            self.leaf = Some(ReprLeaf::from_singleton_buffer(buf.clone()));
-            Some(buf)
-            */
             None
         }
     }
@@ -402,7 +450,10 @@ impl ReprTree {
         }
     }
 
-    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
+
+    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>\\
+    //                 View Access               \\
+    //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>\\
 
     pub fn get_port<V: View + ?Sized + 'static>(&self) -> Option<OuterViewPort<V>>
     where
@@ -455,5 +506,3 @@ impl ReprTree {
 }
 
 //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
-
-

lib-nested-tty/src/editors/list.rs

@@ -43,7 +43,7 @@ impl DisplaySegment for ListSegment {
                         } else {
                             usize::MAX
                         };
-                    
+
                     atom
                         .add_style_back(bg_style_from_depth(select))
                         .add_style_back(TerminalStyle::bold(select==1))
@@ -70,7 +70,7 @@ impl PTYListStyle {
     pub fn get_seg_seq_view(&self, editor: &ListEditor) -> OuterViewPort<dyn SequenceView<Item = OuterViewPort<dyn TerminalView>>> {
         let seg_seq = ListSegmentSequence::new(
             editor.get_cursor_port(),
-            editor.get_data_port()
+            editor.get_edittree_seq()
         );
         let se = seg_seq.read().unwrap();
         se.get_view().map(move |segment| segment.display_view())
@@ -79,7 +79,7 @@ impl PTYListStyle {
     pub fn pty_view(&self, editor: &ListEditor) -> OuterViewPort<dyn TerminalView> {
         let seg_seq = ListSegmentSequence::new(
             editor.get_cursor_port(),
-            editor.get_data_port()
+            editor.get_edittree_seq()
         );
 
         let seg_seq0 = seg_seq.read().unwrap();
@@ -98,6 +98,8 @@ impl PTYListStyle {
         let editor = node.get_edit::<ListEditor>().unwrap();
         let editor = editor.read().unwrap();
         let pty_view = Self::new(style).pty_view(&editor);
+
+        eprintln!("reset TerminalView Leaf");
         node.disp.view
             .attach_leaf_to(
                 Context::parse(&node.ctx, "TerminalView"),
@@ -133,7 +135,7 @@ impl PTYListController {
             split_char,
             close_char,
             depth
-        } 
+        }
     }
 
     pub fn for_node(
@@ -162,17 +164,17 @@ impl PTYListController {
     }
 
     pub fn get_data_port(&self) -> OuterViewPort<dyn SequenceView<Item = EditTree>> {
-        self.editor.read().unwrap().get_data_port()
+        self.editor.read().unwrap().get_edittree_seq()
     }
 
     pub fn clear(&mut self) {
         self.editor.write().unwrap().clear();
     }
-
+/*
     pub fn get_item(&self) -> Option<EditTree> {
         self.editor.read().unwrap().get_item()
     }
-
+*/
     pub fn handle_term_event(&mut self, event: &TerminalEvent, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
         let mut e = self.editor.write().unwrap();
         match event {
@@ -218,58 +220,35 @@ impl PTYListController {
         let mut e = self.editor.write().unwrap();
         let cur = e.cursor.get();
         let ctx = e.ctx.clone();
-        let ctx = ctx.read().unwrap();
 
         match cur.mode {
             ListCursorMode::Insert => {
-                let rt = ReprTree::new_arc(e.typ.clone());
+                let mut rt = ReprTree::new_arc(e.item_type.clone());
+                rt = e.item_builder.build_from(rt).expect("cant creat EditTree for item");
 
-                let src_ladder = laddertypes::TypeTerm::Ladder(vec![
-                    rt.read().unwrap().get_type().clone()
-                ]);
-                let dst_ladder = laddertypes::TypeTerm::Ladder(vec![
-                    rt.read().unwrap().get_type().clone(),
-                    ctx.type_term_from_str("EditTree").expect("")
-                ]);
-                ctx.apply_morphism(
-                    &rt,
-                    &laddertypes::MorphismType {
-                        src_type: src_ladder,
-                        dst_type: dst_ladder
-                    }
-                );
-
-                let new_edittree = ctx.setup_edittree( &rt );
-
-                if let Some(new_edittree) = new_edittree {
-                    let mut ne = new_edittree.get();
-                    let mut ne = ne.write().unwrap();
-                    match ne.send_cmd_obj(cmd_obj.clone()) {
+                let mut ne = rt.edittree(&ctx).get_mut();
+                match ne.send_cmd_obj(cmd_obj.clone()) {
                         TreeNavResult::Continue => {
                             drop(ne);
-                            e.insert(new_edittree.value.read().unwrap().clone());
+                            e.insert(rt);
                             TreeNavResult::Continue
                         }
                         TreeNavResult::Exit => {
                             TreeNavResult::Exit
                         }
-                    }
-                } else {
-                    panic!("cant get edit tree");
-                    TreeNavResult::Continue
                 }
             },
             ListCursorMode::Select => {
-                if let Some(item) = e.get_item_mut() {
-                    let res = item.write().unwrap().send_cmd_obj(cmd_obj.clone());
-                    let child_close_char = item.read().unwrap().ctrl.close_char.get();
+                if let Some(mut item) = e.get_cur_edittree() {
+                    let res = item.send_cmd_obj(cmd_obj.clone());
+                    let child_close_char = item.ctrl.close_char.get();
 
                    match res {
                         TreeNavResult::Continue => TreeNavResult::Continue,
                         TreeNavResult::Exit => {
                             // child editor returned control, probably for meta-char handling..
 
-                            if cmd_obj.read().unwrap().get_type().clone() == ctx.type_term_from_str("Char").unwrap() {
+                            if cmd_obj.read().unwrap().get_type().clone() == Context::parse(&ctx, "Char") {
                                 let co = cmd_obj.read().unwrap();
                                 if let Some(cmd_view) = co.get_view::<dyn SingletonView<Item = char>>() {
                                     drop(co);

lib-nested-tty/src/lib.rs

@@ -13,7 +13,7 @@ pub mod tty_application;
 
 pub mod editors;
 pub mod edit_tree;
-//pub mod widgets;
+pub mod widgets;
 
 // <<<<>>>><<>><><<>><<< * >>><<>><><<>><<<<>>>> \\
 
@@ -47,13 +47,13 @@ impl DisplaySegment for nested::edit_tree::EditTree {
         if let Some( tv_repr ) = self.disp.view
             .descend( Context::parse(&self.ctx, "TerminalView") )
         {
-            if let Some(port) = 
+            if let Some(port) =
             tv_repr
                 .read().unwrap()
                 .get_port::<dyn TerminalView>() {
                     port
                 }
-                
+
                 else {
                 make_label("# could not get ViewPort #")
             }
@@ -127,9 +127,10 @@ pub fn setup_edittree_hook(ctx: &Arc<RwLock<Context>>) {
     let posint_hex_type = Context::parse(&ctx, "<PosInt 16 BigEndian>");
     let item_tyid = ctx.read().unwrap().get_var_typeid("Item").unwrap();
 
-    ctx.write().unwrap().meta_chars.push(',');
-    ctx.write().unwrap().meta_chars.push('\"');
-    ctx.write().unwrap().meta_chars.push('}');
+    ctx.write().unwrap().meta_chars.push('\n');
+    //ctx.write().unwrap().meta_chars.push(',');
+    //ctx.write().unwrap().meta_chars.push('\"');
+    //ctx.write().unwrap().meta_chars.push('}');
 
     // Define a hook which is executed when a new editTree of type `t` is created.
     // this will setup the display and navigation elements of the editor.
@@ -146,7 +147,7 @@ pub fn setup_edittree_hook(ctx: &Arc<RwLock<Context>>) {
                 else if let Ok(σ) = laddertypes::unify(&t, &posint_bin_type) {
                     crate::editors::list::PTYListStyle::for_node( &mut *et, ("0b", "", ""));
                     crate::editors::list::PTYListController::for_node( &mut *et, None, None );
-                }                
+                }
                 else if let Ok(σ) = laddertypes::unify(&t, &posint_oct_type) {
                     crate::editors::list::PTYListStyle::for_node( &mut *et, ("0o", "", ""));
                     crate::editors::list::PTYListController::for_node( &mut *et, None, None );
@@ -177,4 +178,3 @@ pub fn setup_edittree_hook(ctx: &Arc<RwLock<Context>>) {
     );
 
 }
-

lib-nested-tty/src/widgets/ascii_box.rs

@@ -1,15 +1,7 @@
 use {
-    cgmath::{Point2, Vector2},
-    r3vi::{
-        view::{
-            InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View,
-            index::*
-        },
-    },
-    crate::{
-        terminal::{TerminalAtom, TerminalView},
-    },
-    std::sync::{Arc, RwLock},
+    crate::{TerminalAtom, TerminalView}, cgmath::{Point2, Vector2}, r3vi::view::{
+            index::*, InnerViewPort, Observer, ObserverBroadcast, OuterViewPort, View
+        }, std::sync::{Arc, RwLock}
 };
 
 pub struct AsciiBox {