syntaxAlchemist/lib-nested
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Activity

in context.apply_morphism() now use find_morphism_path() to automatically find chained morphisms to create projections in ReprTree

Browse source
This commit is contained in:
Michael Sippel 2024-08-06 16:20:02 +02:00
parent ffeb4b8e73
commit 6e2b82585e
Signed by: senvas
GPG key ID: F96CF119C34B64A6
13 changed files with 395 additions and 861 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
examples/tty-02-digit/src/main.rs
View file

@ -69,16 +69,19 @@ async fn main() {
/* furthermore, setup projections to and from u8 value, /* furthermore, setup projections to and from u8 value,
* this synchronizes the buffers * this synchronizes the buffers
*/ */
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_digit.clone(), &rt_digit,
&Context::parse(&ctx, "<Digit 16>~Char"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64") src_type: Context::parse(&ctx, "<Digit 16>~Char"),
dst_type: Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64")
}
); );
ctx.read().unwrap().apply_morphism(
ctx.read().unwrap().morphisms.apply_morphism( &rt_digit,
rt_digit.clone(), &laddertypes::MorphismType {
&Context::parse(&ctx, "<Digit 16>~Char"), src_type: Context::parse(&ctx, "<Digit 16>~Char"),
&Context::parse(&ctx, "<Digit 16>~EditTree") dst_type: Context::parse(&ctx, "<Digit 16>~EditTree")
}
); );
/* setup TTY-Display for DigitEditor /* setup TTY-Display for DigitEditor

41
examples/tty-03-string/src/main.rs
View file

@ -45,21 +45,16 @@ async fn main() {
*/ */
let mut rt_string = ReprTree::new_arc( Context::parse(&ctx, "<List Char>") ); let mut rt_string = ReprTree::new_arc( Context::parse(&ctx, "<List Char>") );
let vec = VecBuffer::<Arc<RwLock<EditTree>>>::new();
rt_string.insert_leaf( rt_string.insert_leaf(
Context::parse(&ctx, "<List EditTree> ~ <Vec EditTree>"), Context::parse(&ctx, "<List~Vec EditTree>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( vec.clone() ) nested::repr_tree::ReprLeaf::from_vec_buffer( VecBuffer::<Arc<RwLock<EditTree>>>::new() )
); );
ctx.read().unwrap().apply_morphism(
let v2 = VecBuffer::<char>::new(); &rt_string,
rt_string.insert_leaf( &laddertypes::MorphismType {
Context::parse(&ctx, "<Vec Char>"), src_type: Context::parse(&ctx, "<List Char~EditTree>~<Vec EditTree>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( v2.clone() ) dst_type: Context::parse(&ctx, "<List Char> ~ EditTree")
); }
ctx.read().unwrap().morphisms.apply_morphism(
rt_string.clone(),
&Context::parse(&ctx, "<List Char~EditTree> ~ <Vec EditTree>"),
&Context::parse(&ctx, "<List Char> ~ EditTree")
); );
/* Setup the Editor-View for this ReprTree /* Setup the Editor-View for this ReprTree
@ -74,10 +69,12 @@ async fn main() {
* we apply a morphism that, given the List of Edit-Trees, extracts * we apply a morphism that, given the List of Edit-Trees, extracts
* the value from each EditTree and shows them in a ListView. * the value from each EditTree and shows them in a ListView.
*/ */
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_string.clone(), &rt_string,
&Context::parse(&ctx, "<List Char>~EditTree"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<List Char>") src_type: Context::parse(&ctx, "<List Char>~EditTree"),
dst_type: Context::parse(&ctx, "<List Char>")
}
); );
/* Now, get the ListView that serves our char-values. /* Now, get the ListView that serves our char-values.
@ -91,10 +88,12 @@ async fn main() {
/* Lets add another morphism which will store the values /* Lets add another morphism which will store the values
* of the character-list in a `Vec<char>` * of the character-list in a `Vec<char>`
*/ */
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_string.clone(), &rt_string,
&Context::parse(&ctx, "<List Char>"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<List Char>~<Vec Char>") 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>) /* Access the Vec<char> object (wrapped behind a VecBuffer<char>)

210
examples/tty-04-posint/src/main.rs
View file

@ -32,131 +32,25 @@ use {
std::sync::{Arc, RwLock}, std::sync::{Arc, RwLock},
}; };
fn rebuild_projections(
ctx: Arc<RwLock<Context>>,
repr_tree: Arc<RwLock<ReprTree>>,
morph_types: Vec< (laddertypes::TypeTerm, laddertypes::TypeTerm) >
) {
repr_tree.write().unwrap().detach(&ctx);
for (src_type, dst_type) in morph_types.iter() {
ctx.read().unwrap().morphisms.apply_morphism(
repr_tree.clone(),
&src_type,
&dst_type
);
}
}
fn setup_hex_master(ctx: &Arc<RwLock<Context>>, rt_int: &Arc<RwLock<ReprTree>>) { fn setup_hex_master(ctx: &Arc<RwLock<Context>>, rt_int: &Arc<RwLock<ReprTree>>) {
rebuild_projections( rt_int.write().unwrap().detach( ctx );
ctx.clone(), ctx.read().unwrap().apply_morphism(
rt_int.clone(), rt_int,
vec![ &laddertypes::MorphismType {
// extract values from hex-editor src_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree"),
( dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ EditTree")
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree", }
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>"
),
// convert to little-endian
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>",
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>"
),
// convert digit representation from char to u64
(
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>",
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64>"
),
// convert radix to decimal
(
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64>",
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ ℤ_2^64 ~ machine.UInt64>"
),
// convert decimal digit representation back to char
(
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ ℤ_2^64 ~ machine.UInt64>",
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>"
),
// convert to big-endian
(
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>",
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>"
),
// decimal editor
(
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>",
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char ~ EditTree>"
),
(
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char ~ EditTree>",
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char ~ EditTree> ~ <Vec EditTree>"
),
(
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char ~ EditTree> ~ <Vec EditTree>",
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ EditTree"
),
].into_iter()
.map(|(s,d)| (Context::parse(&ctx, s), Context::parse(&ctx, d)))
.collect()
); );
} }
fn setup_dec_master(ctx: &Arc<RwLock<Context>>, rt_int: &Arc<RwLock<ReprTree>>) { fn setup_dec_master(ctx: &Arc<RwLock<Context>>, rt_int: &Arc<RwLock<ReprTree>>) {
rebuild_projections( rt_int.write().unwrap().detach( ctx );
ctx.clone(), ctx.read().unwrap().apply_morphism(
rt_int.clone(), rt_int,
vec![ &laddertypes::MorphismType {
// extract values from decimal-editor src_type: Context::parse(&ctx, "ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ EditTree"),
( dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree")
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char> ~ EditTree", }
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>"
),
// convert to little-endian
(
"ℕ ~ <PosInt 10 BigEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>",
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>"
),
// convert digit representation to u64
(
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ Char>",
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ ℤ_2^64 ~ machine.UInt64>"
),
// convert radix to decimal
(
"ℕ ~ <PosInt 10 LittleEndian> ~ <Seq <Digit 10>> ~ <List <Digit 10> ~ ℤ_2^64 ~ machine.UInt64>",
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64>"
),
// convert back digit representation char
(
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ ℤ_2^64 ~ machine.UInt64>",
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>"
),
// convert back to big-endian
(
"ℕ ~ <PosInt 16 LittleEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>"
),
// hex editor
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char ~ EditTree>"
),
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char ~ EditTree>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char ~ EditTree> ~ <Vec EditTree>"
),
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char ~ EditTree> ~ <Vec EditTree>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree"
),
].into_iter()
.map(|(s,d)| (Context::parse(&ctx, s), Context::parse(&ctx, d)))
.collect()
); );
} }
@ -177,71 +71,20 @@ async fn main() {
/* Add a specific Representation-Path (big-endian hexadecimal) /* Add a specific Representation-Path (big-endian hexadecimal)
*/ */
let mut digits_hex = VecBuffer::with_data(vec![ 'c', 'f', 'f' ]);
rt_int.insert_leaf( rt_int.insert_leaf(
Context::parse(&ctx, "<PosInt 16 BigEndian>~<Seq <Digit 16>>~<List <Digit 16>>~<List Char>~<Vec Char>"), Context::parse(&ctx, "<PosInt 16 BigEndian>~<Seq <Digit 16>>~<List <Digit 16>>~<List Char>~<Vec Char>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( digits_hex.clone() ) nested::repr_tree::ReprLeaf::from_vec_buffer(
); VecBuffer::with_data(vec![ 'c', 'f', 'f' ]
)));
let mut digits_dec = VecBuffer::with_data(vec!['3', '2', '1']);
rt_int.insert_leaf(
Context::parse(&ctx, "<PosInt 10 BigEndian>~<Seq <Digit 10>>~<List <Digit 10>>~<List Char>~<Vec Char>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( digits_dec.clone() )
);
let mut digits_hex_editvec = VecBuffer::<Arc<RwLock<EditTree>>>::new();
rt_int.insert_leaf(
Context::parse(&ctx, "
<PosInt 16 BigEndian>
~ <Seq <Digit 16>>
~ <List <Digit 16>
~ Char
~ EditTree>
~ <Vec EditTree>
"),
nested::repr_tree::ReprLeaf::from_vec_buffer( digits_hex_editvec.clone() )
);
let mut digits_dec_editvec = VecBuffer::<Arc<RwLock<EditTree>>>::new();
rt_int.insert_leaf(
Context::parse(&ctx, "
<PosInt 10 BigEndian>
~ <Seq <Digit 10>>
~ <List <Digit 10>
~ Char
~ EditTree>
~ <Vec EditTree>
"),
nested::repr_tree::ReprLeaf::from_vec_buffer( digits_dec_editvec.clone() )
);
/* initially copy values from Vec to EditTree... /* initially copy values from Vec to EditTree...
*/ */
rebuild_projections( ctx.read().unwrap().apply_morphism(
ctx.clone(), &rt_int,
rt_int.clone(), &nested::repr_tree::morphism::MorphismType {
// master representation src_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ <Vec Char>"),
vec![ dst_type: Context::parse(&ctx, "ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree")
( });
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ <Vec Char>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>"
),
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char ~ EditTree>"
),
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ <List EditTree>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ <List EditTree> ~ <Vec EditTree>"
),
(
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ <List EditTree> ~ <Vec EditTree>",
"ℕ ~ <PosInt 16 BigEndian> ~ <Seq <Digit 16>> ~ <List <Digit 16> ~ Char> ~ EditTree"
),
].into_iter()
.map(|(s,d)| (Context::parse(&ctx, s), Context::parse(&ctx, d)))
.collect()
);
setup_hex_master(&ctx, &rt_int); setup_hex_master(&ctx, &rt_int);
@ -267,7 +110,6 @@ async fn main() {
SingletonBuffer::new(0).get_port() SingletonBuffer::new(0).get_port()
).unwrap().get(); ).unwrap().get();
let hex_digits_view = rt_int.descend(Context::parse(&ctx, " let hex_digits_view = rt_int.descend(Context::parse(&ctx, "
<PosInt 16 LittleEndian> <PosInt 16 LittleEndian>
~ <Seq <Digit 16> > ~ <Seq <Digit 16> >
@ -278,8 +120,7 @@ async fn main() {
.view_list::<u64>() .view_list::<u64>()
.map(|v| TerminalAtom::from(char::from_digit(*v as u32, 16))) .map(|v| TerminalAtom::from(char::from_digit(*v as u32, 16)))
.to_sequence() .to_sequence()
.to_grid_horizontal() .to_grid_horizontal();
;
let dec_digits_view = rt_int.descend(Context::parse(&ctx, " let dec_digits_view = rt_int.descend(Context::parse(&ctx, "
<PosInt 10 LittleEndian> <PosInt 10 LittleEndian>
@ -291,8 +132,7 @@ async fn main() {
.view_list::<u64>() .view_list::<u64>()
.map(|v| TerminalAtom::from(char::from_digit(*v as u32, 10))) .map(|v| TerminalAtom::from(char::from_digit(*v as u32, 10)))
.to_sequence() .to_sequence()
.to_grid_horizontal() .to_grid_horizontal();
;
/* list of both editors /* list of both editors
*/ */

24
lib-nested-core/src/editors/char/mod.rs
View file

@ -9,7 +9,7 @@ use {
}, },
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
crate::{ crate::{
repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt}, repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt, GenericReprTreeMorphism},
edit_tree::{EditTree, TreeNavResult}, edit_tree::{EditTree, TreeNavResult},
editors::ObjCommander, editors::ObjCommander,
}, },
@ -18,19 +18,14 @@ use {
}; };
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) { pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
let morphtype =
crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "Char"),
dst_type: Context::parse(&ctx, "Char~EditTree")
};
ctx.write().unwrap() let char_morph_to_edittree = GenericReprTreeMorphism::new(
.morphisms Context::parse(&ctx, "Char"),
.add_morphism( Context::parse(&ctx, "Char~EditTree"),
morphtype,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |rt, σ| { move |rt, σ| {
{ {
let mut b = rt.write().unwrap().singleton_buffer::<char>(); let mut b = rt.write().unwrap().singleton_buffer::<char>();
if let Some(buf) = b { if let Some(buf) = b {
@ -56,7 +51,11 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
rt.insert_leaf( rt.insert_leaf(
Context::parse(&ctx, "EditTree"), Context::parse(&ctx, "EditTree"),
ReprLeaf::from_singleton_buffer(SingletonBuffer::new(Arc::new(RwLock::new(edittree)))) ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(
Arc::new(RwLock::new(edittree))
)
)
); );
ctx.read().unwrap().setup_edittree( ctx.read().unwrap().setup_edittree(
@ -64,8 +63,11 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
SingletonBuffer::new(0).get_port() SingletonBuffer::new(0).get_port()
); );
} }
} }
); );
ctx.write().unwrap().morphisms.add_morphism( char_morph_to_edittree );
} }
pub struct CharEditor { pub struct CharEditor {

69
lib-nested-core/src/editors/digit/ctx.rs
View file

@ -9,27 +9,20 @@ use {
} }
}, },
crate::{ crate::{
repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf}, repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf, GenericReprTreeMorphism},
editors::digit::DigitEditor, editors::digit::DigitEditor,
}, },
std::sync::{Arc, RwLock} std::sync::{Arc, RwLock}
}; };
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) { pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
// todo: proper scoping of Radix variable // todo: proper scoping of Radix variable
ctx.write().unwrap().add_varname("Radix"); ctx.write().unwrap().add_varname("Radix");
let morphtype = let digit_morph_char_to_edittree = GenericReprTreeMorphism::new(
crate::repr_tree::MorphismType { Context::parse(&ctx, "<Digit Radix>~Char"),
src_type: Context::parse(&ctx, "<Digit Radix>~Char"), Context::parse(&ctx, "<Digit Radix>~EditTree"),
dst_type: Context::parse(&ctx, "<Digit Radix>~EditTree")
};
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
@ -39,31 +32,13 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
_ => 0 _ => 0
}; };
/* get char representation or create it if not available
*/
let char_rt =
if let Some(crt) = src_rt.descend(Context::parse(&ctx, "Char")) {
crt
} else {
/* TODO: replace this with some formal specification
* of "required representations"
*/
let crt = ReprTree::from_singleton_buffer(
Context::parse(&ctx, "Char"),
SingletonBuffer::new('\0')
);
src_rt.insert_branch(crt.clone());
crt
};
/* Create EditTree object /* Create EditTree object
*/ */
let mut edittree = DigitEditor::new( let mut edittree = DigitEditor::new(
ctx.clone(), ctx.clone(),
radix, radix,
src_rt.descend( src_rt
Context::parse(&ctx, "Char") .descend( Context::parse(&ctx, "Char") ).unwrap()
).unwrap()
.singleton_buffer::<char>() .singleton_buffer::<char>()
).into_node( ).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port() r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
@ -80,16 +55,10 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
} }
); );
let morphtype = let digit_morph_char_to_u64 = GenericReprTreeMorphism::new(
crate::repr_tree::MorphismType { Context::parse(&ctx, "<Digit Radix>~Char"),
src_type: Context::parse(&ctx, "<Digit Radix>~Char"), Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"),
dst_type: Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64")
};
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| { move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| {
@ -128,14 +97,10 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
); );
let morphtype = let digit_morph_u64_to_char = GenericReprTreeMorphism::new(
crate::repr_tree::MorphismType { Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"),
src_type: Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"), Context::parse(&ctx, "<Digit Radix>~Char"),
dst_type: Context::parse(&ctx, "<Digit Radix>~Char") {
};
ctx.write().unwrap().morphisms
.add_morphism(morphtype, {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| { move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| {
/* infer radix from type /* infer radix from type
@ -163,7 +128,13 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
eprintln!("radix too large ({})", radix); eprintln!("radix too large ({})", radix);
} }
} }
}); }
);
ctx.write().unwrap().morphisms.add_morphism( digit_morph_char_to_edittree );
ctx.write().unwrap().morphisms.add_morphism( digit_morph_char_to_u64 );
ctx.write().unwrap().morphisms.add_morphism( digit_morph_u64_to_char );
} }

359
lib-nested-core/src/editors/integer/ctx.rs
View file

@ -3,9 +3,9 @@ use {
r3vi::{ r3vi::{
view::{OuterViewPort, singleton::*, list::*} view::{OuterViewPort, singleton::*, list::*}
}, },
laddertypes::{TypeTerm}, laddertypes::{TypeTerm, MorphismType},
crate::{ crate::{
repr_tree::{ReprTree, ReprTreeExt, ReprLeaf, Context, MorphismType}, repr_tree::{ReprTree, ReprTreeExt, ReprLeaf, Context, GenericReprTreeMorphism},
editors::{ editors::{
list::*, list::*,
integer::* integer::*
@ -20,34 +20,18 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
ctx.write().unwrap().add_varname("DstRadix"); ctx.write().unwrap().add_varname("DstRadix");
/* let posint_seq_morph_big_to_little = GenericReprTreeMorphism::new(
* MACHINE INT, SEQ Context::parse(&ctx, "ℕ ~ <PosInt Radix BigEndian>
*/ ~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
let morphism_type = Context::parse(&ctx, "ℕ ~ <PosInt Radix LittleEndian>
MorphismType { ~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
src_type: Context::parse(&ctx, " {
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>
~ ℤ_2^64
~ machine.UInt64 >"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>
~ ℤ_2^64
~ machine.UInt64 >")
};
ctx.write().unwrap().morphisms.add_morphism(
morphism_type, {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
let src_digits = src_rt.descend( let src_digits = src_rt
Context::parse(&ctx, " .descend(Context::parse(&ctx, "
<PosInt Radix BigEndian> <PosInt Radix BigEndian>
~ <Seq <Digit Radix> ~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
~ ℤ_2^64
~ machine.UInt64 >
") ")
.apply_substitution(&|k|σ.get(k).cloned()) .apply_substitution(&|k|σ.get(k).cloned())
.clone() .clone()
@ -56,181 +40,63 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
src_rt.attach_leaf_to(Context::parse(&ctx, " src_rt.attach_leaf_to(Context::parse(&ctx, "
<PosInt Radix LittleEndian> <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>
~ ℤ_2^64
~ machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
/* MACHINE INT, LIST
*/
let morphism_type = MorphismType {
src_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List ℤ_2^64>
~ <List machine.UInt64>
"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List ℤ_2^64>
~ <List machine.UInt64>
")
};
ctx.write().unwrap().morphisms.add_morphism(
morphism_type,
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = src_rt.descend(Context::parse(&ctx, "
<PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
")
.apply_substitution(&|k|σ.get(k).cloned()).clone()
).expect("cant descend")
.get_port::< dyn ListView<u64> >().unwrap();
src_rt.attach_leaf_to(
Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64>
").apply_substitution(&|k| σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
let mt = MorphismType {
src_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
{
let ctx = ctx.clone();
move |src_rt, σ| {
let radix = σ.get( &laddertypes::TypeID::Var(ctx.read().unwrap().get_var_typeid("Radix").unwrap()) );
let src_digits = src_rt.descend(Context::parse(&ctx, "
<PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>~Char >
").apply_substitution(&|k|σ.get(k).cloned()).clone()
).expect("cant descend")
.get_port::< dyn ListView<char> >().unwrap();
let rev_port = src_digits.reverse();
src_rt.attach_leaf_to(
Context::parse(&ctx, "
< PosInt Radix LittleEndian >
~ < Seq <Digit Radix> >
~ < List <Digit Radix>~Char >
").apply_substitution(&|k| σ.get(k).cloned()).clone(),
rev_port
);
}
}
);
let morphism_type = MorphismType {
src_type: Context::parse(&ctx, "ℕ ~ <PosInt Radix LittleEndian> ~ <Seq <Digit Radix>~ℤ_2^64~machine.UInt64>"),
dst_type: Context::parse(&ctx, "ℕ ~ <PosInt Radix BigEndian> ~ <Seq <Digit Radix>~ℤ_2^64~machine.UInt64>")
};
ctx.write().unwrap().morphisms.add_morphism(
morphism_type,
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = ReprTree::descend(
&src_rt,
Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 > ~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
let posint_list_morph_big_to_little = GenericReprTreeMorphism::new(
Context::parse(&ctx, "ℕ ~ <PosInt Radix BigEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
Context::parse(&ctx, "ℕ ~ <PosInt Radix LittleEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = src_rt
.descend(Context::parse(&ctx, "
<PosInt Radix BigEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
") ")
.apply_substitution(&|k|σ.get(k).cloned()).clone() .apply_substitution(&|k|σ.get(k).cloned())
.clone()
).expect("cant descend") ).expect("cant descend")
.view_seq::< u64 >(); .view_list::< u64 >();
src_rt.attach_leaf_to(Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
let posint_list_morph_little_to_big = GenericReprTreeMorphism::new(
Context::parse(&ctx, "ℕ ~ <PosInt Radix LittleEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
Context::parse(&ctx, "ℕ ~ <PosInt Radix BigEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = src_rt
.descend(Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
")
.apply_substitution(&|k|σ.get(k).cloned())
.clone()
).expect("cant descend")
.view_list::< u64 >();
src_rt.attach_leaf_to(Context::parse(&ctx, " src_rt.attach_leaf_to(Context::parse(&ctx, "
<PosInt Radix BigEndian> <PosInt Radix BigEndian>
~ <Seq <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64> ~ <Seq~List <Digit Radix> ~ ℤ_2^64 ~ machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
let morphism_type =
MorphismType {
src_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List ℤ_2^64>
~ <List machine.UInt64>
"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List ℤ_2^64>
~ <List machine.UInt64>
")
};
ctx.write().unwrap().morphisms.add_morphism(
morphism_type, {
let ctx = ctx.clone();
move |src_rt, σ|
{
let src_digits = src_rt.descend(
Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>~ℤ_2^64~machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone()
)
.expect("cant descend")
.view_list::<u64>();
src_rt.attach_leaf_to(
Context::parse(&ctx, "
<PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>~ℤ_2^64~machine.UInt64 >
").apply_substitution(&|k|σ.get(k).cloned()).clone(), ").apply_substitution(&|k|σ.get(k).cloned()).clone(),
src_digits.reverse() src_digits.reverse()
); );
@ -239,93 +105,8 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
); );
let mt = MorphismType { let posint_list_morph_radix = GenericReprTreeMorphism::new(
src_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = src_rt.descend(Context::parse(&ctx, "
<PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>~Char >
").apply_substitution(&|k|σ.get(k).cloned()).clone()
).expect("cant descend")
.view_list::<char>();
src_rt.attach_leaf_to(
Context::parse(&ctx, " Context::parse(&ctx, "
< PosInt Radix BigEndian >
~ < Seq <Digit Radix> >
~ < List <Digit Radix>~Char >
").apply_substitution(&|k| σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
/*
let mt = MorphismType {
src_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
"),
dst_type: Context::parse(&ctx, "
ℕ
~ <PosInt Radix LittleEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>>
~ <List Char>
")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
{
let ctx = ctx.clone();
move |src_rt, σ| {
let src_digits = src_rt.descend(Context::parse(&ctx, "
<PosInt Radix BigEndian>
~ <Seq <Digit Radix>>
~ <List <Digit Radix>~Char >
").apply_substitution(&|k|σ.get(k).cloned()).clone()
).expect("cant descend")
.view_list::<char>();
src_rt.attach_leaf_to(
Context::parse(&ctx, "
< PosInt Radix LittleEndian >
~ < Seq <Digit Radix> >
~ < List <Digit Radix>~Char >
").apply_substitution(&|k| σ.get(k).cloned()).clone(),
src_digits.reverse()
);
}
}
);
*/
let morphism_type = MorphismType {
src_type: Context::parse(&ctx, "
ℕ ℕ
~ <PosInt SrcRadix LittleEndian> ~ <PosInt SrcRadix LittleEndian>
~ <Seq <Digit SrcRadix>> ~ <Seq <Digit SrcRadix>>
@ -333,18 +114,14 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
~ ℤ_2^64 ~ ℤ_2^64
~ machine.UInt64> ~ machine.UInt64>
"), "),
dst_type: Context::parse(&ctx, " Context::parse(&ctx, "
ℕ ℕ
~ <PosInt DstRadix LittleEndian> ~ <PosInt DstRadix LittleEndian>
~ <Seq <Digit DstRadix>> ~ <Seq <Digit DstRadix>>
~ <List <Digit DstRadix> ~ <List <Digit DstRadix>
~ ℤ_2^64 ~ ℤ_2^64
~ machine.UInt64> ~ machine.UInt64>
") "),
};
ctx.write().unwrap().morphisms.add_morphism(
morphism_type,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
@ -389,7 +166,13 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
dst_digits_port dst_digits_port
); );
} }
} }
); );
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_radix );
} }

74
lib-nested-core/src/editors/list/ctx.rs
View file

@ -10,11 +10,11 @@ use {
}, },
laddertypes::{TypeTerm}, laddertypes::{TypeTerm},
crate::{ crate::{
repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt}, repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt, GenericReprTreeMorphism},
edit_tree::{EditTree}, edit_tree::{EditTree},
editors::{ editors::{
char::{CharEditor}, char::{CharEditor},
list::{ListEditor}//, PTYListController, PTYListStyle} list::{ListEditor}
} }
}, },
std::sync::{Arc, RwLock} std::sync::{Arc, RwLock}
@ -25,12 +25,10 @@ use {
pub fn init_ctx(ctx: Arc<RwLock<Context>>) { pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
ctx.write().unwrap().add_varname("Item"); ctx.write().unwrap().add_varname("Item");
let mt = crate::repr_tree::MorphismType { let list_morph_editsetup1 = GenericReprTreeMorphism::new(
src_type: Context::parse(&ctx, "<List Item>~<List EditTree>~<Vec EditTree>"), Context::parse(&ctx, "<List Item>~<List EditTree>~<Vec EditTree>"),
dst_type: Context::parse(&ctx, "<List Item>~EditTree") Context::parse(&ctx, "<List Item>~EditTree"),
}; {
ctx.write().unwrap().morphisms.add_morphism(mt, {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { 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() );
@ -60,14 +58,13 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
eprintln!("no item type"); eprintln!("no item type");
} }
} }
}); }
);
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List Char>~EditTree"), let list_morph_editsetup2 = GenericReprTreeMorphism::new(
dst_type: Context::parse(&ctx, "<List Char>") Context::parse(&ctx, "<List Char>~EditTree"),
}; Context::parse(&ctx, "<List Char>"),
ctx.write().unwrap().morphisms.add_morphism(
mt,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
@ -93,54 +90,43 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
) )
); );
} }
} }
); );
let list_morph_to_vec_char = GenericReprTreeMorphism::new(
/* todo : unify the following two morphims with generic item parameter ? Context::parse(&ctx, "<List Char>"),
*/ Context::parse(&ctx, "<List Char>~<Vec Char>"),
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List Char>"),
dst_type: Context::parse(&ctx, "<List Char>~<Vec Char>")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
let list_view = src_rt.view_list::<char>(); src_rt.attach_leaf_to(
src_rt
.attach_leaf_to(
Context::parse(&ctx, "<Vec Char>"), Context::parse(&ctx, "<Vec Char>"),
list_view src_rt.view_list::<char>()
); );
} }
} }
); );
let mt = crate::repr_tree::MorphismType { let list_morph_from_vec_char = GenericReprTreeMorphism::new(
src_type: Context::parse(&ctx, "<List Char>~<Vec Char>"), Context::parse(&ctx, "<List Char>~<Vec Char>"),
dst_type: Context::parse(&ctx, "<List Char>") Context::parse(&ctx, "<List Char>"),
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
let src_port = src_rt.descend(Context::parse(&ctx, "<List Char>~<Vec Char>")).expect("descend") let src_port = src_rt.descend(Context::parse(&ctx, "<List Char>~<Vec Char>")).expect("descend")
.get_port::<RwLock<Vec<char>>>().unwrap(); .get_port::<RwLock<Vec<char>>>().unwrap();
src_rt.attach_leaf_to( Context::parse(&ctx, "<List Char>"), src_port.to_list() ); src_rt.attach_leaf_to( Context::parse(&ctx, "<List Char>"), src_port.to_list() );
} }
} }
); );
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List EditTree>"), let list_morph_to_vec_edittree = GenericReprTreeMorphism::new(
dst_type: Context::parse(&ctx, "<List EditTree>~<Vec EditTree>") Context::parse(&ctx, "<List EditTree>"),
}; Context::parse(&ctx, "<List EditTree> ~ <Vec EditTree>"),
ctx.write().unwrap().morphisms.add_morphism(
mt,
{ {
let ctx = ctx.clone(); let ctx = ctx.clone();
move |src_rt, σ| { move |src_rt, σ| {
@ -156,5 +142,11 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
} }
} }
); );
ctx.write().unwrap().morphisms.add_morphism( list_morph_editsetup1 );
ctx.write().unwrap().morphisms.add_morphism( list_morph_editsetup2 );
ctx.write().unwrap().morphisms.add_morphism( list_morph_from_vec_char );
ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_char );
ctx.write().unwrap().morphisms.add_morphism( list_morph_to_vec_edittree );
} }

41
lib-nested-core/src/repr_tree/context.rs
View file

@ -1,8 +1,8 @@
use { use {
r3vi::{view::{OuterViewPort, singleton::*}, buffer::{singleton::*}}, r3vi::{view::{OuterViewPort, singleton::*}, buffer::{singleton::*}},
laddertypes::{TypeDict, TypeTerm, TypeID}, laddertypes::{TypeDict, TypeTerm, TypeID, MorphismType, MorphismBase, Morphism},
crate::{ crate::{
repr_tree::{ReprTree, ReprTreeExt, MorphismType, GenericReprTreeMorphism, MorphismBase}, repr_tree::{ReprTree, ReprTreeExt, GenericReprTreeMorphism},
edit_tree::EditTree edit_tree::EditTree
}, },
std::{ std::{
@ -18,7 +18,7 @@ pub struct Context {
/// assigns a name to every type /// assigns a name to every type
pub type_dict: Arc<RwLock<TypeDict>>, pub type_dict: Arc<RwLock<TypeDict>>,
pub morphisms: MorphismBase, pub morphisms: laddertypes::morphism::MorphismBase< GenericReprTreeMorphism >,
/// named vertices of the graph /// named vertices of the graph
nodes: HashMap< String, Arc<RwLock<ReprTree>> >, nodes: HashMap< String, Arc<RwLock<ReprTree>> >,
@ -39,12 +39,15 @@ impl Context {
pub fn with_parent( pub fn with_parent(
parent: Option<Arc<RwLock<Context>>> parent: Option<Arc<RwLock<Context>>>
) -> Self { ) -> Self {
let mut dict = TypeDict::new();
let list_typeid = dict.add_typename("List".into());
Context { Context {
type_dict: match parent.as_ref() { type_dict: match parent.as_ref() {
Some(p) => p.read().unwrap().type_dict.clone(), Some(p) => p.read().unwrap().type_dict.clone(),
None => Arc::new(RwLock::new(TypeDict::new())) None => Arc::new(RwLock::new(dict))
}, },
morphisms: MorphismBase::new(), morphisms: MorphismBase::new( list_typeid ),
nodes: HashMap::new(), nodes: HashMap::new(),
list_types: match parent.as_ref() { list_types: match parent.as_ref() {
Some(p) => p.read().unwrap().list_types.clone(), Some(p) => p.read().unwrap().list_types.clone(),
@ -75,9 +78,35 @@ 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() )
{
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, &σ );
}
src_type = dst_type;
}
}
} else {
eprintln!("no path found");
}
}
pub fn make_repr(ctx: &Arc<RwLock<Self>>, t: &TypeTerm) -> Arc<RwLock<ReprTree>> { pub fn make_repr(ctx: &Arc<RwLock<Self>>, t: &TypeTerm) -> Arc<RwLock<ReprTree>> {
let rt = Arc::new(RwLock::new(ReprTree::new( TypeTerm::unit() ))); let rt = Arc::new(RwLock::new(ReprTree::new( TypeTerm::unit() )));
ctx.read().unwrap().morphisms.apply_morphism( rt.clone(), &TypeTerm::unit(), t ); ctx.read().unwrap().apply_morphism( &rt, &MorphismType{ src_type: TypeTerm::unit(), dst_type: t.clone() } );
rt rt
} }

2
lib-nested-core/src/repr_tree/mod.rs
View file

@ -10,7 +10,7 @@ pub use {
context::{Context}, context::{Context},
leaf::ReprLeaf, leaf::ReprLeaf,
node::ReprTree, node::ReprTree,
morphism::{MorphismType, GenericReprTreeMorphism, MorphismBase} morphism::{GenericReprTreeMorphism}
}; };
use { use {

270
lib-nested-core/src/repr_tree/morphism.rs
View file

@ -1,5 +1,5 @@
use { use {
laddertypes::{TypeTerm, TypeID}, laddertypes::{TypeTerm, TypeID, morphism::Morphism},
r3vi::view::{AnyOuterViewPort, port::UpdateTask}, r3vi::view::{AnyOuterViewPort, port::UpdateTask},
crate::{ crate::{
repr_tree::{ReprTree, ReprTreeExt, ReprLeaf}, repr_tree::{ReprTree, ReprTreeExt, ReprLeaf},
@ -10,232 +10,102 @@ use {
} }
}; };
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> pub use laddertypes::morphism::MorphismType;
#[derive(Clone, Hash, PartialEq, Eq, Debug)] //<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
pub struct MorphismType {
pub src_type: TypeTerm,
pub dst_type: TypeTerm,
}
#[derive(Clone)] #[derive(Clone)]
pub struct GenericReprTreeMorphism { pub struct GenericReprTreeMorphism {
morph_type: MorphismType, pub(super) morph_type: MorphismType,
setup_projection: Arc< pub(super) setup_projection: Arc<
dyn Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> ) dyn Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
// -> Result< ReprLeaf, () > // -> Result< ReprLeaf, () >
+ Send + Sync + Send + Sync
> >
} }
#[derive(Clone)] impl Morphism for GenericReprTreeMorphism {
pub struct MorphismBase { fn get_type(&self) -> MorphismType {
morphisms: Vec< GenericReprTreeMorphism > self.morph_type.clone()
} }
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>> fn list_map_morphism(&self, list_typeid: TypeID) -> Option< GenericReprTreeMorphism > {
self.into_list_map_dyn(list_typeid)
impl MorphismBase {
pub fn new() -> Self {
MorphismBase {
morphisms: Vec::new()
} }
} }
pub fn add_morphism( impl GenericReprTreeMorphism {
&mut self, pub fn new(
morph_type: MorphismType, src_type: TypeTerm,
setup_projection: dst_type: TypeTerm,
impl Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
// -> Result< ReprLeaf, () /* TODO: error */ > setup: impl Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
+ Send + Sync + 'static + Send + Sync + 'static
) { ) -> Self {
self.morphisms.push(
GenericReprTreeMorphism { GenericReprTreeMorphism {
morph_type: MorphismType { morph_type: MorphismType {
src_type: morph_type.src_type.normalize(), src_type, dst_type
dst_type: morph_type.dst_type.normalize() }.normalize(),
},
setup_projection: Arc::new(setup_projection)
}
);
}
pub fn find_morphism( setup_projection: Arc::new(setup)
&self,
src_type: &TypeTerm,
dst_type: &TypeTerm
) -> Option<(GenericReprTreeMorphism, HashMap<TypeID, TypeTerm>)> {
// try list-map morphism
if let Ok(σ) = laddertypes::UnificationProblem::new(vec![
(src_type.clone().param_normalize(), TypeTerm::App(vec![ TypeTerm::TypeID(TypeID::Fun(10)), TypeTerm::TypeID(TypeID::Var(100)) ])),
(dst_type.clone().param_normalize(), TypeTerm::App(vec![ TypeTerm::TypeID(TypeID::Fun(10)), TypeTerm::TypeID(TypeID::Var(101)) ])),
]).solve() {
let src_item_type = σ.get(&TypeID::Var(100)).unwrap().clone();
let dst_item_type = σ.get(&TypeID::Var(101)).unwrap().clone();
/*
eprintln!("Got a List- Type, check if we find a list-map morphism");
eprintln!("src-item-type : {:?}", src_item_type);
eprintln!("dst-item-type : {:?}", dst_item_type);
*/
let src_item_type_lnf = src_item_type.clone().get_lnf_vec();
let dst_item_type_lnf = dst_item_type.clone().get_lnf_vec();
/* if src_item_type ~== "Char",
dst_item_type ~== "machine.UInt64"
*/
if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(0))) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(4)))
{
if let Some((m, σ)) = self.find_list_map_morphism::< char, u64 >( src_item_type, dst_item_type ) {
return Some((m, σ));
} }
} }
/* if src_item_type ~== "machine.UInt64", pub fn into_list_map< SrcItem, DstItem >(&self, list_typeid: TypeID)
dst_item_type ~== "Char" -> GenericReprTreeMorphism
*/ where
else if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(4))) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(0)))
{
if let Some((m, σ)) = self.find_list_map_morphism::< u64, char >( src_item_type, dst_item_type ) {
return Some((m, σ));
}
}
/* if src_item_type ~== "Char"
dst_item_type ~== "EditTree"
*/
else if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(0))) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(TypeID::Fun(1)))
{
if let Some((m, σ)) = self.find_list_map_morphism::< char, Arc<RwLock<crate::edit_tree::EditTree>> >( src_item_type, dst_item_type ) {
return Some((m, σ));
}
}
}
// otherwise
for m in self.morphisms.iter() {
let unification_problem = laddertypes::UnificationProblem::new(
vec![
( src_type.clone().normalize(), m.morph_type.src_type.clone() ),
( dst_type.clone().normalize(), m.morph_type.dst_type.clone() )
]
);
let unification_result = unification_problem.solve();
if let Ok(σ) = unification_result {
return Some((m.clone(), σ));
}
}
None
}
pub fn find_morphism_ladder(
&self,
src_type: &TypeTerm,
dst_type: &TypeTerm,
) -> Option<(
GenericReprTreeMorphism,
TypeTerm,
HashMap<TypeID, TypeTerm>
)> {
let mut src_lnf = src_type.clone().get_lnf_vec();
let mut dst_lnf = dst_type.clone().get_lnf_vec();
let mut halo = vec![];
while src_lnf.len() > 0 && dst_lnf.len() > 0 {
if let Some((m, σ)) = self.find_morphism( &TypeTerm::Ladder(src_lnf.clone()), &TypeTerm::Ladder(dst_lnf.clone()) ) {
return Some((m, TypeTerm::Ladder(halo), σ));
} else {
if src_lnf[0] == dst_lnf[0] {
src_lnf.remove(0);
halo.push(dst_lnf.remove(0));
} else {
return None;
}
}
}
None
}
pub fn apply_morphism(
&self,
repr_tree: Arc<RwLock<ReprTree>>,
src_type: &TypeTerm,
dst_type: &TypeTerm
) {
if let Some((m, s, σ)) = self.find_morphism_ladder( &src_type, dst_type ) {
//eprintln!("apply morphism on subtree {:?}", s);
let mut rt = repr_tree.descend( s ).expect("descend");
(m.setup_projection)( &mut rt, &σ );
} else {
eprintln!("could not find morphism\n {:?}\n ====>\n {:?}", src_type, dst_type);
}
}
pub fn find_list_map_morphism<
SrcItem: Clone + Send + Sync + 'static, SrcItem: Clone + Send + Sync + 'static,
DstItem: Clone + Send + Sync + 'static DstItem: Clone + Send + Sync + 'static
>(
&self,
mut src_item_type: TypeTerm,
mut dst_item_type: TypeTerm
) -> Option<
( GenericReprTreeMorphism, HashMap< TypeID, TypeTerm > )
>
{ {
if let Some((item_morphism, σ)) = self.find_morphism( &src_item_type, &dst_item_type ) { let mut lst_map_type = MorphismType {
(&mut src_item_type).apply_substitution( &|v| σ.get(v).clone().cloned() ); src_type: TypeTerm::App(vec![
(&mut dst_item_type).apply_substitution( &|v| σ.get(v).clone().cloned() ); TypeTerm::TypeID(list_typeid),
self.morph_type.src_type.clone()
]),
dst_type: TypeTerm::App(vec![
TypeTerm::TypeID(list_typeid),
self.morph_type.dst_type.clone()
])
}.normalize();
let src_lst_type = let item_morph = self.clone();
TypeTerm::App(vec![
TypeTerm::TypeID(TypeID::Fun(10 /* FIXME: remove magic */)),
src_item_type.clone()
]);
let dst_lst_type =
TypeTerm::App(vec![
TypeTerm::TypeID(TypeID::Fun(10 /* FIXME: remove magic */)),
dst_item_type.clone()
]);
let sigmalol = σ.clone(); GenericReprTreeMorphism{
let m = GenericReprTreeMorphism{ morph_type: lst_map_type.clone(),
morph_type: MorphismType {
src_type: src_lst_type.clone(),
dst_type: dst_lst_type.clone(),
},
setup_projection: Arc::new(move |repr_tree, subst| { setup_projection: Arc::new(move |repr_tree, subst| {
let src_port = repr_tree.descend( src_lst_type.clone() ).expect("descend src seq") let mut lst_map_type = lst_map_type.clone();
lst_map_type.src_type.apply_substitution( &|x| subst.get(x).cloned() );
lst_map_type.dst_type.apply_substitution( &|x| subst.get(x).cloned() );
eprintln!(
"lst map type : {:?}", lst_map_type
);
let src_port = repr_tree
.descend( lst_map_type.src_type.clone() )
.expect("descend src seq")
.view_list::<SrcItem>(); .view_list::<SrcItem>();
let src_item_type = src_item_type.clone();
let dst_item_type = dst_item_type.clone();
let item_morphism = item_morphism.clone();
let subst = subst.clone(); let subst = subst.clone();
let item_morph = item_morph.clone();
let dst_view = src_port.map( let dst_view = src_port.map(
move |x| { move |x| {
let mut item_ladder = src_item_type.clone().get_lnf_vec(); let mut item_ladder = item_morph.morph_type.src_type.clone().get_lnf_vec();
let mut item_rt = ReprTree::from_singleton_buffer( let mut item_rt = ReprTree::from_singleton_buffer(
item_ladder.remove( item_ladder.len() - 1 ), item_ladder.remove( item_ladder.len() - 1 ),
r3vi::buffer::singleton::SingletonBuffer::new(x.clone()) r3vi::buffer::singleton::SingletonBuffer::new(x.clone())
); );
// TODO: required?
while item_ladder.len() > 0 { while item_ladder.len() > 0 {
let mut n = ReprTree::new_arc( item_ladder.remove( item_ladder.len() - 1) ); let mut n = ReprTree::new_arc( item_ladder.remove( item_ladder.len() - 1) );
n.insert_branch( item_rt ); n.insert_branch( item_rt );
item_rt = n; item_rt = n;
} }
(item_morphism.setup_projection)( &mut item_rt, &subst ); (item_morph.setup_projection)( &mut item_rt, &subst );
item_rt.descend( dst_item_type.clone() ).expect("descend to item rt") item_rt.descend( item_morph.morph_type.dst_type.clone() ).expect("descend to item rt")
.view_singleton::< DstItem >() .view_singleton::< DstItem >()
.get_view().unwrap() .get_view().unwrap()
.get() .get()
@ -243,15 +113,41 @@ impl MorphismBase {
); );
repr_tree.attach_leaf_to( repr_tree.attach_leaf_to(
dst_lst_type.clone(), lst_map_type.dst_type.clone(),
dst_view as r3vi::view::OuterViewPort::< dyn r3vi::view::list::ListView<DstItem> > dst_view as r3vi::view::OuterViewPort::< dyn r3vi::view::list::ListView<DstItem> >
); );
}) })
}; }
}
Some((m, σ)) pub fn into_list_map_dyn(&self, typeid_list: TypeID)
} else { -> Option< GenericReprTreeMorphism >
// eprintln!("could not find item morphism\n"); {
let typeid_char = TypeID::Fun(1);
let typeid_u64 = TypeID::Fun(5);
let typeid_edittree = TypeID::Fun(2);
let src_item_type_lnf = self.morph_type.src_type.clone().get_lnf_vec();
let dst_item_type_lnf = self.morph_type.dst_type.clone().get_lnf_vec();
if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_char)) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_u64))
{
Some( self.into_list_map::< char, u64 >(typeid_list) )
}
else if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_u64)) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_char))
{
Some( self.into_list_map::< u64, char >(typeid_list) )
}
else if src_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_char)) &&
dst_item_type_lnf.last() == Some(&TypeTerm::TypeID(typeid_edittree))
{
Some( self.into_list_map::< char, Arc<RwLock<crate::edit_tree::EditTree>> >(typeid_list) )
}
else
{
eprintln!("no list map type for {:?}", dst_item_type_lnf.last());
None None
} }
} }

13
lib-nested-core/src/repr_tree/node.rs
View file

@ -13,7 +13,7 @@ use {
}, },
buffer::{singleton::*, vec::*} buffer::{singleton::*, vec::*}
}, },
laddertypes::{TypeTerm}, laddertypes::{TypeTerm, TypeID},
std::{ std::{
collections::HashMap, collections::HashMap,
sync::{Arc, RwLock}, sync::{Arc, RwLock},
@ -197,6 +197,17 @@ impl ReprTree {
>::new() >::new()
); );
leaf.attach_to(src_port);
self.leaf = Some(leaf);
}
else if self.type_tag == TypeTerm::App(vec![
TypeTerm::TypeID(TypeID::Fun(11)),
TypeTerm::TypeID(TypeID::Fun(1))
]) {
let mut leaf = ReprLeaf::from_vec_buffer(
VecBuffer::<char>::new()
);
leaf.attach_to(src_port); leaf.attach_to(src_port);
self.leaf = Some(leaf); self.leaf = Some(leaf);
} else { } else {

24
lib-nested-core/src/repr_tree/tests.rs
View file

@ -83,10 +83,12 @@ fn digit_projection_char_to_u64() {
//<><><><> //<><><><>
// add another representation // add another representation
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_digit.clone(), rt_digit.clone(),
&Context::parse(&ctx, "<Digit 16>~Char"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64") src_type: Context::parse(&ctx, "<Digit 16>~Char"),
dst_type: Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64")
}
); );
let digit_u64_view = rt_digit let digit_u64_view = rt_digit
@ -121,10 +123,12 @@ fn digit_projection_u64_to_char() {
//<><><><> //<><><><>
// add another representation // add another representation
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_digit.clone(), rt_digit.clone(),
&Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<Digit 16>~Char") src_type: Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64"),
dst_type: Context::parse(&ctx, "<Digit 16>~Char")
}
); );
let digit_u64_view = rt_digit let digit_u64_view = rt_digit
@ -170,10 +174,12 @@ fn char_buffered_projection() {
assert_eq!( digit_char_view.get_view().unwrap().get(), '5' ); assert_eq!( digit_char_view.get_view().unwrap().get(), '5' );
// now we attach the char-repr to the u64-repr // now we attach the char-repr to the u64-repr
ctx.read().unwrap().morphisms.apply_morphism( ctx.read().unwrap().apply_morphism(
rt_digit.clone(), rt_digit.clone(),
&Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64"), &laddertypes::MorphismType {
&Context::parse(&ctx, "<Digit 16>~Char") src_type: Context::parse(&ctx, "<Digit 16>~ℤ_2^64~machine.UInt64"),
dst_type: Context::parse(&ctx, "<Digit 16>~Char")
}
); );
// char buffer and view should now follow the u64-buffer // char buffer and view should now follow the u64-buffer

10
lib-nested-tty/src/editors/list.rs
View file

@ -228,10 +228,12 @@ impl PTYListController {
rt.read().unwrap().get_type().clone(), rt.read().unwrap().get_type().clone(),
ctx.type_term_from_str("EditTree").expect("") ctx.type_term_from_str("EditTree").expect("")
]); ]);
ctx.morphisms.apply_morphism( ctx.apply_morphism(
rt.clone(), &rt,
&rt.get_type(), &laddertypes::MorphismType {
&ladder src_type: rt.get_type(),
dst_type: ladder
}
); );
let new_edittree = ctx.setup_edittree( let new_edittree = ctx.setup_edittree(