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,
* this synchronizes the buffers
*/
ctx.read().unwrap().morphisms.apply_morphism(
rt_digit.clone(),
&Context::parse(&ctx, "<Digit 16>~Char"),
&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>~ℤ_2^64~machine.UInt64")
}
);
ctx.read().unwrap().morphisms.apply_morphism(
rt_digit.clone(),
&Context::parse(&ctx, "<Digit 16>~Char"),
&Context::parse(&ctx, "<Digit 16>~EditTree")
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")
}
);
/* 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 vec = VecBuffer::<Arc<RwLock<EditTree>>>::new();
rt_string.insert_leaf(
Context::parse(&ctx, "<List EditTree> ~ <Vec EditTree>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( vec.clone() )
Context::parse(&ctx, "<List~Vec EditTree>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( VecBuffer::<Arc<RwLock<EditTree>>>::new() )
);
let v2 = VecBuffer::<char>::new();
rt_string.insert_leaf(
Context::parse(&ctx, "<Vec Char>"),
nested::repr_tree::ReprLeaf::from_vec_buffer( v2.clone() )
);
ctx.read().unwrap().morphisms.apply_morphism(
rt_string.clone(),
&Context::parse(&ctx, "<List Char~EditTree> ~ <Vec EditTree>"),
&Context::parse(&ctx, "<List Char> ~ EditTree")
ctx.read().unwrap().apply_morphism(
&rt_string,
&laddertypes::MorphismType {
src_type: Context::parse(&ctx, "<List Char~EditTree>~<Vec EditTree>"),
dst_type: Context::parse(&ctx, "<List Char> ~ EditTree")
}
);
/* 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
* the value from each EditTree and shows them in a ListView.
*/
ctx.read().unwrap().morphisms.apply_morphism(
rt_string.clone(),
&Context::parse(&ctx, "<List Char>~EditTree"),
&Context::parse(&ctx, "<List Char>")
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.
@ -91,10 +88,12 @@ async fn main() {
/* Lets add another morphism which will store the values
* of the character-list in a `Vec<char>`
*/
ctx.read().unwrap().morphisms.apply_morphism(
rt_string.clone(),
&Context::parse(&ctx, "<List Char>"),
&Context::parse(&ctx, "<List Char>~<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>)

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

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

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

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

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

@ -9,28 +9,21 @@ use {
}
},
crate::{
repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf},
repr_tree::{Context, ReprTree, ReprTreeExt, ReprLeaf, GenericReprTreeMorphism},
editors::digit::DigitEditor,
},
std::sync::{Arc, RwLock}
};
pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
// todo: proper scoping of Radix variable
ctx.write().unwrap().add_varname("Radix");
let morphtype =
crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<Digit Radix>~Char"),
dst_type: Context::parse(&ctx, "<Digit Radix>~EditTree")
};
let digit_morph_char_to_edittree = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<Digit Radix>~Char"),
Context::parse(&ctx, "<Digit Radix>~EditTree"),
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{
{
let ctx = ctx.clone();
move |src_rt, σ| {
let radix =
@ -39,32 +32,14 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
_ => 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
*/
let mut edittree = DigitEditor::new(
ctx.clone(),
radix,
src_rt.descend(
Context::parse(&ctx, "Char")
).unwrap()
.singleton_buffer::<char>()
src_rt
.descend( Context::parse(&ctx, "Char") ).unwrap()
.singleton_buffer::<char>()
).into_node(
r3vi::buffer::singleton::SingletonBuffer::<usize>::new(0).get_port()
);
@ -77,22 +52,16 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
)
);
}
}
);
}
);
let morphtype =
crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<Digit Radix>~Char"),
dst_type: Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64")
};
let digit_morph_char_to_u64 = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<Digit Radix>~Char"),
Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"),
ctx.write().unwrap()
.morphisms
.add_morphism(
morphtype,
{
let ctx = ctx.clone();
move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| {
{
let ctx = ctx.clone();
move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| {
/* infer radix from type
*/
let radix_typeid = ctx.read().unwrap().get_var_typeid("Radix").unwrap();
@ -123,19 +92,15 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
} else {
eprintln!("radix too large ({})", radix);
}
}
}
);
}
);
let morphtype =
crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"),
dst_type: Context::parse(&ctx, "<Digit Radix>~Char")
};
ctx.write().unwrap().morphisms
.add_morphism(morphtype, {
let digit_morph_u64_to_char = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<Digit Radix>~ℤ_2^64~machine.UInt64"),
Context::parse(&ctx, "<Digit Radix>~Char"),
{
let ctx = ctx.clone();
move |rt: &mut Arc<RwLock<ReprTree>>, σ: &std::collections::HashMap<laddertypes::TypeID, TypeTerm>| {
/* infer radix from type
@ -163,7 +128,13 @@ pub fn init_ctx( ctx: Arc<RwLock<Context>> ) {
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 );
}

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

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

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

@ -10,11 +10,11 @@ use {
},
laddertypes::{TypeTerm},
crate::{
repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt},
repr_tree::{Context, ReprTree, ReprLeaf, ReprTreeExt, GenericReprTreeMorphism},
edit_tree::{EditTree},
editors::{
char::{CharEditor},
list::{ListEditor}//, PTYListController, PTYListStyle}
list::{ListEditor}
}
},
std::sync::{Arc, RwLock}
@ -25,49 +25,46 @@ use {
pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
ctx.write().unwrap().add_varname("Item");
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List Item>~<List EditTree>~<Vec EditTree>"),
dst_type: Context::parse(&ctx, "<List Item>~EditTree")
};
let list_morph_editsetup1 = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<List Item>~<List EditTree>~<Vec EditTree>"),
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() );
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()
)
.expect("cant descend src repr");
ctx.write().unwrap().morphisms.add_morphism(mt, {
let ctx = ctx.clone();
move |src_rt, σ| {
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()
)
.expect("cant descend src repr");
let item_vec_buffer = item_vec_rt.vec_buffer::< Arc<RwLock<EditTree>> >();
let item_vec_buffer = item_vec_rt.vec_buffer::< Arc<RwLock<EditTree>> >();
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(),
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)))
)
);
} else {
eprintln!("no item type");
ReprLeaf::from_singleton_buffer(
SingletonBuffer::new(Arc::new(RwLock::new(edittree_list)))
)
);
} else {
eprintln!("no item type");
}
}
}
});
);
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List Char>~EditTree"),
dst_type: Context::parse(&ctx, "<List Char>")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
let list_morph_editsetup2 = GenericReprTreeMorphism::new(
Context::parse(&ctx, "<List Char>~EditTree"),
Context::parse(&ctx, "<List Char>"),
{
let ctx = ctx.clone();
move |src_rt, σ| {
@ -93,54 +90,43 @@ pub fn init_ctx(ctx: Arc<RwLock<Context>>) {
)
);
}
}
);
/* todo : unify the following two morphims with generic item parameter ?
*/
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 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, σ| {
let list_view = src_rt.view_list::<char>();
src_rt
.attach_leaf_to(
Context::parse(&ctx, "<Vec Char>"),
list_view
);
src_rt.attach_leaf_to(
Context::parse(&ctx, "<Vec Char>"),
src_rt.view_list::<char>()
);
}
}
);
let mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List Char>~<Vec Char>"),
dst_type: Context::parse(&ctx, "<List Char>")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
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 mt = crate::repr_tree::MorphismType {
src_type: Context::parse(&ctx, "<List EditTree>"),
dst_type: Context::parse(&ctx, "<List EditTree>~<Vec EditTree>")
};
ctx.write().unwrap().morphisms.add_morphism(
mt,
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, σ| {
@ -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 {
r3vi::{view::{OuterViewPort, singleton::*}, buffer::{singleton::*}},
laddertypes::{TypeDict, TypeTerm, TypeID},
laddertypes::{TypeDict, TypeTerm, TypeID, MorphismType, MorphismBase, Morphism},
crate::{
repr_tree::{ReprTree, ReprTreeExt, MorphismType, GenericReprTreeMorphism, MorphismBase},
repr_tree::{ReprTree, ReprTreeExt, GenericReprTreeMorphism},
edit_tree::EditTree
},
std::{
@ -18,7 +18,7 @@ pub struct Context {
/// assigns a name to every type
pub type_dict: Arc<RwLock<TypeDict>>,
pub morphisms: MorphismBase,
pub morphisms: laddertypes::morphism::MorphismBase< GenericReprTreeMorphism >,
/// named vertices of the graph
nodes: HashMap< String, Arc<RwLock<ReprTree>> >,
@ -39,12 +39,15 @@ impl Context {
pub fn with_parent(
parent: Option<Arc<RwLock<Context>>>
) -> Self {
let mut dict = TypeDict::new();
let list_typeid = dict.add_typename("List".into());
Context {
type_dict: match parent.as_ref() {
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(),
list_types: match parent.as_ref() {
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>> {
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
}

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

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

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

@ -1,5 +1,5 @@
use {
laddertypes::{TypeTerm, TypeID},
laddertypes::{TypeTerm, TypeID, morphism::Morphism},
r3vi::view::{AnyOuterViewPort, port::UpdateTask},
crate::{
repr_tree::{ReprTree, ReprTreeExt, ReprLeaf},
@ -10,248 +10,144 @@ 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)]
pub struct GenericReprTreeMorphism {
morph_type: MorphismType,
setup_projection: Arc<
pub(super) morph_type: MorphismType,
pub(super) setup_projection: Arc<
dyn Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
// -> Result< ReprLeaf, () >
+ Send + Sync
>
}
#[derive(Clone)]
pub struct MorphismBase {
morphisms: Vec< GenericReprTreeMorphism >
impl Morphism for GenericReprTreeMorphism {
fn get_type(&self) -> MorphismType {
self.morph_type.clone()
}
fn list_map_morphism(&self, list_typeid: TypeID) -> Option< GenericReprTreeMorphism > {
self.into_list_map_dyn(list_typeid)
}
}
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
impl GenericReprTreeMorphism {
pub fn new(
src_type: TypeTerm,
dst_type: TypeTerm,
impl MorphismBase {
pub fn new() -> Self {
MorphismBase {
morphisms: Vec::new()
setup: impl Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
+ Send + Sync + 'static
) -> Self {
GenericReprTreeMorphism {
morph_type: MorphismType {
src_type, dst_type
}.normalize(),
setup_projection: Arc::new(setup)
}
}
pub fn add_morphism(
&mut self,
morph_type: MorphismType,
setup_projection:
impl Fn( &mut Arc<RwLock<ReprTree>>, &HashMap<TypeID, TypeTerm> )
// -> Result< ReprLeaf, () /* TODO: error */ >
+ Send + Sync + 'static
) {
self.morphisms.push(
GenericReprTreeMorphism {
morph_type: MorphismType {
src_type: morph_type.src_type.normalize(),
dst_type: morph_type.dst_type.normalize()
},
setup_projection: Arc::new(setup_projection)
}
);
}
pub fn find_morphism(
&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",
dst_item_type ~== "Char"
*/
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<
pub fn into_list_map< SrcItem, DstItem >(&self, list_typeid: TypeID)
-> GenericReprTreeMorphism
where
SrcItem: 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 ) {
(&mut src_item_type).apply_substitution( &|v| σ.get(v).clone().cloned() );
(&mut dst_item_type).apply_substitution( &|v| σ.get(v).clone().cloned() );
let mut lst_map_type = MorphismType {
src_type: TypeTerm::App(vec![
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 =
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 item_morph = self.clone();
let sigmalol = σ.clone();
let m = GenericReprTreeMorphism{
morph_type: MorphismType {
src_type: src_lst_type.clone(),
dst_type: dst_lst_type.clone(),
},
setup_projection: Arc::new(move |repr_tree, subst| {
let src_port = repr_tree.descend( src_lst_type.clone() ).expect("descend src seq")
.view_list::<SrcItem>();
GenericReprTreeMorphism{
morph_type: lst_map_type.clone(),
setup_projection: Arc::new(move |repr_tree, subst| {
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() );
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();
eprintln!(
"lst map type : {:?}", lst_map_type
);
let dst_view = src_port.map(
let src_port = repr_tree
.descend( lst_map_type.src_type.clone() )
.expect("descend src seq")
.view_list::<SrcItem>();
let subst = subst.clone();
let item_morph = item_morph.clone();
let dst_view = src_port.map(
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(
item_ladder.remove( item_ladder.len() - 1 ),
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) );
n.insert_branch( item_rt );
item_rt = n;
}
(item_morphism.setup_projection)( &mut item_rt, &subst );
item_rt.descend( dst_item_type.clone() ).expect("descend to item rt")
(item_morph.setup_projection)( &mut item_rt, &subst );
item_rt.descend( item_morph.morph_type.dst_type.clone() ).expect("descend to item rt")
.view_singleton::< DstItem >()
.get_view().unwrap()
.get()
}
);
);
repr_tree.attach_leaf_to(
dst_lst_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> >
);
})
}
}
Some((m, σ))
} else {
// eprintln!("could not find item morphism\n");
pub fn into_list_map_dyn(&self, typeid_list: TypeID)
-> Option< GenericReprTreeMorphism >
{
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
}
}

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

@ -13,7 +13,7 @@ use {
},
buffer::{singleton::*, vec::*}
},
laddertypes::{TypeTerm},
laddertypes::{TypeTerm, TypeID},
std::{
collections::HashMap,
sync::{Arc, RwLock},
@ -197,12 +197,23 @@ impl ReprTree {
>::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);
self.leaf = Some(leaf);
} else {
self.leaf = Some(ReprLeaf::from_view(src_port));
}
}
}
}
pub fn detach(&mut self, ctx: &Arc<RwLock<Context>>) {

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

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

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

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