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

restructure TypeTerm

Browse source
This commit is contained in:
Michael Sippel 2023-08-12 19:03:14 +02:00
parent 64dc82dfbb
commit 2d46ac95bd
Signed by: senvas
GPG key ID: F96CF119C34B64A6
15 changed files with 312 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
nested/src/editors/integer/editor.rs
View file

@ -117,12 +117,7 @@ impl DigitEditor {
}
pub fn get_type(&self) -> TypeTerm {
TypeTerm::Type {
id: self.ctx.read().unwrap().get_fun_typeid("Digit").unwrap(),
args: vec![
TypeTerm::Num(self.radix as i64).into()
]
}
TypeTerm::TypeID(self.ctx.read().unwrap().get_typeid("Digit").unwrap())
}
pub fn get_data(&self) -> Arc<RwLock<ReprTree>> {
@ -163,17 +158,12 @@ impl PosIntEditor {
let data = node.data.clone().unwrap();
node = node.set_data(ReprTree::ascend(
&data,
TypeTerm::Type {
id: ctx.read().unwrap().get_fun_typeid("PosInt").unwrap(),
args: vec![
TypeTerm::App(vec![
TypeTerm::TypeID(ctx.read().unwrap().get_typeid("PosInt").unwrap()),
TypeTerm::Num(radix as i64).into(),
TypeTerm::Type {
id: ctx.read().unwrap().get_fun_typeid("BigEndian").unwrap(),
args: vec![]
}.into()
TypeTerm::TypeID(ctx.read().unwrap().get_typeid("BigEndian").unwrap())
]
}
));
)));
PosIntEditor {
radix,

8
nested/src/editors/list/commander.rs
View file

@ -32,7 +32,13 @@ impl ListCmd {
)
}
}
/*
impl Into< Arc<RwLock<ReprTree>> > for (&Arc<RwLock<Context>>, ListCmd) {
fn into(self) -> Arc<RwLock<ReprTree>> {
self.1.into_repr_tree(self.0)
}
}
*/
impl ObjCommander for ListEditor {
fn send_cmd_obj(&mut self, cmd_obj: Arc<RwLock<ReprTree>>) -> TreeNavResult {
let cmd_repr = cmd_obj.read().unwrap();

16
nested/src/editors/list/editor.rs
View file

@ -38,11 +38,9 @@ impl ListEditor {
"List", Arc::new(
|ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: usize| {
match ty {
TypeTerm::Type {
id: _, args
} => {
if args.len() > 0 {
let typ = (args[0].clone().0)[0].clone();
TypeTerm::App(args) => {
if args.len() > 1 {
let typ = args[1].clone();
let mut node = ListEditor::new(ctx.clone(), typ).into_node(depth);
@ -160,10 +158,10 @@ impl ListEditor {
}
pub fn get_seq_type(&self) -> TypeTerm {
TypeTerm::Type {
id: self.ctx.read().unwrap().get_fun_typeid("List").unwrap(),
args: vec![ self.get_item_type().into() ]
}
TypeTerm::App(vec![
TypeTerm::TypeID(self.ctx.read().unwrap().get_typeid("List").unwrap()),
self.get_item_type().into()
])
}
pub fn get_cursor_port(&self) -> OuterViewPort<dyn SingletonView<Item = ListCursor>> {

10
nested/src/editors/product/editor.rs
View file

@ -10,7 +10,7 @@ use {
}
},
crate::{
type_system::{TypeLadder, Context},
type_system::{Context, TypeTerm},
terminal::{
TerminalEditor, TerminalEditorResult,
TerminalEvent, TerminalView
@ -79,7 +79,7 @@ impl ProductEditor {
self
}
pub fn with_n(mut self, pos: Point2<i16>, n: TypeLadder) -> Self {
pub fn with_n(mut self, pos: Point2<i16>, n: &TypeTerm) -> Self {
self.segments.insert(pos, ProductEditorSegment::N{
t: n.clone(),
editor: None,
@ -90,7 +90,7 @@ impl ProductEditor {
self.n_indices.push(pos);
let mut b = VecBuffer::new();
b.push(crate::diagnostics::make_todo(crate::terminal::make_label(&format!("complete {}", self.ctx.read().unwrap().type_term_to_str(&n.0[0])))));
b.push(crate::diagnostics::make_todo(crate::terminal::make_label(&format!("complete {}", self.ctx.read().unwrap().type_term_to_str(n)))));
self.msg_buf.push(Some(b.get_port().to_sequence()));
self
}
@ -157,7 +157,7 @@ impl ProductEditor {
self.msg_buf.update(idx as usize, Some(e.get_msg_port()));
} else {
let mut b = VecBuffer::new();
b.push(crate::diagnostics::make_todo(crate::terminal::make_label(&format!("complete {}", self.ctx.read().unwrap().type_term_to_str(&t.0[0])))));
b.push(crate::diagnostics::make_todo(crate::terminal::make_label(&format!("complete {}", self.ctx.read().unwrap().type_term_to_str(&t)))));
self.msg_buf.update(idx as usize, Some(b.get_port().to_sequence()));
@ -238,7 +238,7 @@ impl ObjCommander for ProductEditor {
}
}
} else {
let mut e = Context::make_node(&self.ctx, t.0[0].clone(), *ed_depth+1).unwrap();
let mut e = Context::make_node(&self.ctx, t.clone(), *ed_depth+1).unwrap();
*editor = Some(e.clone());
update_segment = true;

4
nested/src/editors/product/nav.rs
View file

@ -71,7 +71,7 @@ impl TreeNav for ProductEditor {
e.goto(c.clone());
} else if c.tree_addr.len() > 0 {
// create editor
let mut e = Context::make_node(&self.ctx, t.0[0].clone(), *ed_depth+1).unwrap();
let mut e = Context::make_node(&self.ctx, t.clone(), *ed_depth+1).unwrap();
*editor = Some(e.clone());
e.goto(c.clone());
}
@ -128,7 +128,7 @@ impl TreeNav for ProductEditor {
} else {
// create editor
let mut e = Context::make_node(&self.ctx, t.0[0].clone(), *ed_depth+1).unwrap();
let mut e = Context::make_node(&self.ctx, t.clone(), *ed_depth+1).unwrap();
*editor = Some(e.clone());
e.goby(direction);
}

6
nested/src/editors/product/segment.rs
View file

@ -5,7 +5,7 @@ use {
}
},
crate::{
type_system::{TypeLadder, Context},
type_system::{Context, TypeTerm},
terminal::{
TerminalStyle, TerminalView,
make_label
@ -20,7 +20,7 @@ use {
pub enum ProductEditorSegment {
T( String, usize ),
N {
t: TypeLadder,
t: TypeTerm,
editor: Option<NestedNode>,
ed_depth: usize,
cur_depth: usize,
@ -65,7 +65,7 @@ impl ProductEditorSegment {
}),
ProductEditorSegment::N{ t, editor: None, ed_depth, cur_depth, cur_dist } =>
make_label(&ctx.read().unwrap().type_term_to_str(&t.0[0]))
make_label(&ctx.read().unwrap().type_term_to_str(t))
.map_item({
let _cur_depth = *cur_depth;
let _ed_depth = *ed_depth;

6
nested/src/tree/treetype.rs
View file

@ -1,14 +1,14 @@
use {
crate::{
type_system::TypeLadder,
type_system::{TypeTerm, TypeID},
tree::{TreeAddr}
}
};
pub trait TreeType {
fn get_type(&self, _addr: &TreeAddr) -> TypeLadder {
vec![].into()
fn get_type(&self, _addr: &TreeAddr) -> TypeTerm {
TypeTerm::new(TypeID::Var(0))
}
}

28
nested/src/type_system/context.rs
View file

@ -1,6 +1,6 @@
use {
crate::{
type_system::{TypeDict, TypeTerm, TypeID, ReprTree, TypeLadder},
type_system::{TypeDict, TypeTerm, TypeID, ReprTree},
tree::NestedNode
},
std::{
@ -46,16 +46,22 @@ pub struct MorphismTypePattern {
impl From<MorphismType> for MorphismTypePattern {
fn from(value: MorphismType) -> MorphismTypePattern {
fn strip( x: &TypeTerm ) -> TypeID {
match x {
TypeTerm::TypeID(id) => id.clone(),
TypeTerm::App(args) => strip(&args[0]),
TypeTerm::Ladder(args) => strip(&args[0]),
_ => unreachable!()
}
}
MorphismTypePattern {
src_tyid: match value.src_type {
Some(TypeTerm::Type { id, args: _ }) => Some(TypeID::Fun(id)),
Some(TypeTerm::TypeID(id)) => Some(id),
_ => None,
},
dst_tyid: match value.dst_type {
TypeTerm::Type { id, args: _ } => TypeID::Fun(id),
_ => unreachable!()
}
dst_tyid: strip(&value.dst_type)
}
}
}
@ -138,8 +144,8 @@ impl Context {
pub fn is_list_type(&self, t: &TypeTerm) -> bool {
match t {
TypeTerm::Type { id, args: _ } => {
self.list_types.contains(&TypeID::Fun(*id))
TypeTerm::TypeID(id) => {
self.list_types.contains(id)
}
_ => false
}
@ -156,6 +162,10 @@ impl Context {
}
}
pub fn get_typename(&self, tid: &TypeID) -> Option<String> {
self.type_dict.read().unwrap().get_typename(tid)
}
pub fn get_var_typeid(&self, tn: &str) -> Option<u64> {
match self.get_typeid(tn) {
Some(TypeID::Var(x)) => Some(x),
@ -219,7 +229,7 @@ impl Context {
let mk_node = ctx.read().unwrap().get_morphism(MorphismType {
src_type: None,
dst_type: type_term.clone()
})?;
}).expect("morphism");
mk_node(NestedNode::new(depth).set_ctx(
Arc::new(RwLock::new(

6
nested/src/type_system/dict.rs
View file

@ -1,7 +1,7 @@
use {
crate::{
utils::Bimap,
type_system::{TypeTerm, TypeLadder}
type_system::{TypeTerm}
}
};
@ -61,10 +61,6 @@ impl TypeDict {
pub fn type_term_to_str(&self, term: &TypeTerm) -> String {
term.to_str(&self.typenames.my)
}
pub fn type_ladder_to_str(&self, ladder: &TypeLadder) -> String {
ladder.to_str1(&self.typenames.my)
}
}
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>

91
nested/src/type_system/editor.rs
View file

@ -6,7 +6,7 @@ use {
projection::flatten_singleton::*
},
crate::{
type_system::{Context, TypeTerm, ReprTree, MorphismTypePattern},
type_system::{Context, TypeID, TypeTerm, ReprTree, MorphismTypePattern},
terminal::{TerminalEvent},
editors::{sum::*, list::{ListCursorMode, ListEditor, PTYListStyle, PTYListController}},
tree::{NestedNode, TreeNav, TreeNavResult, TreeCursor},
@ -32,6 +32,7 @@ enum State {
pub struct TypeTermEditor {
ctx: Arc<RwLock<Context>>,
data: Arc<RwLock<ReprTree>>,
editor: SingletonBuffer<
Option< Arc<dyn Any + Send + Sync> >
>,
@ -43,6 +44,9 @@ pub struct TypeTermEditor {
impl TypeTermEditor {
pub fn init_ctx(ctx: &mut Context) {
ctx.add_list_typename("TypeTerm".into());
ctx.add_list_typename("TypeSymbol".into());
ctx.add_list_typename("TypeSymbol::Function".into());
ctx.add_list_typename("TypeSymbol::Variable".into());
ctx.add_node_ctor(
"TypeTerm", Arc::new(
|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: usize| {
@ -98,6 +102,17 @@ impl TypeTermEditor {
grid.get_port()
.flatten()
);
self.data.write().unwrap().insert_leaf(
vec![].into_iter(),
node.data.clone().unwrap().read().unwrap()
.get_port::<dyn SingletonView<Item = char>>().unwrap()
.map(
|c| TypeTerm::Char(c)
)
.into()
);
node
}
State::List => {
@ -106,6 +121,18 @@ impl TypeTermEditor {
PTYListController::for_node( &mut node, Some(' '), Some('>') );
PTYListStyle::for_node( &mut node, ("<"," ",">") );
self.data.write().unwrap().insert_leaf(
vec![].into_iter(),
node.data.clone().unwrap().read().unwrap()
.get_port::<dyn SequenceView<Item = NestedNode>>().unwrap()
.map(
|node| {
node.data.as_ref().unwrap().read().unwrap().get_port::<dyn SingletonView<Item = TypeTerm>>().unwrap()
}
)
.into()
);
node
}
State::Symbol => {
@ -131,9 +158,16 @@ impl TypeTermEditor {
}
fn with_node(ctx: Arc<RwLock<Context>>, depth: usize, node: NestedNode, state: State) -> NestedNode {
let buffer = SingletonBuffer::<Option<TypeTerm>>::new( None );
let data = Arc::new(RwLock::new(ReprTree::new(
(&ctx, "( TypeTerm )")
)));
let mut editor = TypeTermEditor {
ctx: ctx.clone(),
state,
data: data.clone(),
cur_node: SingletonBuffer::new(node),
editor: SingletonBuffer::new(None)
};
@ -161,14 +195,54 @@ impl TypeTermEditor {
let mut node = NestedNode::new(depth)
.set_ctx(ctx)
.set_view(view)
.set_data(data)
.set_nav(editor.clone())
.set_cmd(editor.clone())
.set_editor(editor.clone());
node.close_char.set(cc.get());
editor.write().unwrap().editor = node.editor.clone();
node
}
fn get_typeterm(&self) -> Option<TypeTerm> {
match self.state {
State::Any => None,
State::Symbol => {
/*
let x = self.data.descend_ladder(vec![
(&ctx, "( FunctionID )").into(),
(&ctx, "( Symbol )").into(),
(&ctx, "( List Char )").into(),
].into_iter());
let fun_name = /* x...*/ "PosInt";
let fun_id = self.ctx.read().unwrap().get_typeid( fun_name );
self.data.add_repr(
vec![
(&ctx, "( FunctionID )").into(),
(&ctx, "( MachineInt )").into()
]
);
*/
Some(TypeTerm::new(TypeID::Fun(0)))
},
State::List => {
Some(TypeTerm::new(TypeID::Fun(0)))
},
State::Char => {
Some(TypeTerm::Char('c'))
}
State::Num => {
Some(TypeTerm::Num(44))
}
_ => {None}
}
}
}
impl TreeNav for TypeTermEditor {
@ -252,6 +326,8 @@ impl ObjCommander for TypeTermEditor {
}
State::List => {
self.cur_node.get_mut().send_cmd_obj( co )
/*
match self.cur_node.get_mut().send_cmd_obj( co ) {
TreeNavResult::Continue => {
TreeNavResult::Continue
@ -280,6 +356,7 @@ impl ObjCommander for TypeTermEditor {
}
}
}
*/
}
_ => {
@ -290,7 +367,17 @@ impl ObjCommander for TypeTermEditor {
TreeNavResult::Exit
}
} else {
self.cur_node.get_mut().send_cmd_obj( co )
// eprintln!("undefined comd object");
match &self.state {
State::Any => {
eprintln!("undefined comd object set to listl");
self.set_state( State::List );
self.cur_node.get_mut().goto(TreeCursor::home());
}
_ => {}
}
self.cur_node.get().cmd.get().unwrap().write().unwrap().send_cmd_obj( co )
}
}
}

2
nested/src/type_system/ladder.rs
View file

@ -61,7 +61,7 @@ impl TypeLadder {
s = s + "~";
}
first = false;
s = s + &t.to_str1(names);
s = s + &t.to_str(names);
}
s
}

187
nested/src/type_system/make_editor.rs
View file

@ -22,10 +22,8 @@ pub fn init_mem_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
"Vec", Arc::new(
|ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: usize| {
match ty {
TypeTerm::Type {
id: _, args
} => {
if args.len() > 0 {
TypeTerm::App(args) => {
if args.len() > 1 {
let buf = r3vi::buffer::vec::VecBuffer::<char>::new();
let data = ReprTree::new_leaf(
ctx.read().unwrap().type_term_from_str("( Char )").unwrap(),
@ -52,9 +50,12 @@ pub fn init_mem_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
}
pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
let ctx = Arc::new(RwLock::new(Context::with_parent(Some(parent))));
let ctx0 = Arc::new(RwLock::new(Context::with_parent(Some(parent))));
ListEditor::init_ctx( &ctx0 );
ctx.write().unwrap().add_node_ctor(
let mut ctx = ctx0.write().unwrap();
ctx.add_node_ctor(
"Char", Arc::new(
|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, _depth: usize| {
Some(CharEditor::new_node(ctx))
@ -62,50 +63,51 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
ctx.write().unwrap().add_list_typename("Seq".into());
ctx.write().unwrap().add_list_typename("Sequence".into());
ctx.write().unwrap().add_list_typename("SepSeq".into());
ctx.write().unwrap().add_typename("NestedNode".into());
ListEditor::init_ctx( &ctx );
ctx.add_list_typename("Seq".into());
ctx.add_list_typename("Sequence".into());
ctx.add_list_typename("SepSeq".into());
ctx.add_typename("NestedNode".into());
ctx.write().unwrap().add_list_typename("Symbol".into());
ctx.add_list_typename("Symbol".into());
let pattern = MorphismTypePattern {
src_tyid: ctx.read().unwrap().get_typeid("List"),
dst_tyid: ctx.read().unwrap().get_typeid("Symbol").unwrap()
src_tyid: ctx.get_typeid("List"),
dst_tyid: ctx.get_typeid("Symbol").unwrap()
};
ctx.write().unwrap().add_morphism(pattern,
ctx.add_morphism(pattern,
Arc::new(
|mut node, _dst_type:_| {
PTYListController::for_node( &mut node, None, None );
PTYListStyle::for_node( &mut node, ("","","") );
Some(node)
}
)
);
ctx.write().unwrap().add_node_ctor(
ctx.add_node_ctor(
"Symbol", Arc::new(
|ctx: Arc<RwLock<Context>>, dst_typ: TypeTerm, depth: usize| {
let mut node = Context::make_node(
&ctx,
(&ctx, "( List Char )").into(),
depth+1
).unwrap();
).expect("nested node");
node = node.morph(dst_typ);
//node = node.morph(dst_typ);
Some(node)
}
)
);
ctx.write().unwrap().add_list_typename("String".into());
ctx.add_list_typename("String".into());
let pattern = MorphismTypePattern {
src_tyid: ctx.read().unwrap().get_typeid("List"),
dst_tyid: ctx.read().unwrap().get_typeid("String").unwrap()
src_tyid: ctx.get_typeid("List"),
dst_tyid: ctx.get_typeid("String").unwrap()
};
ctx.write().unwrap().add_morphism(pattern,
ctx.add_morphism(pattern,
Arc::new(
|mut node, _dst_type:_| {
PTYListController::for_node( &mut node, None, Some('\"') );
@ -115,17 +117,15 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
ctx.write().unwrap().add_node_ctor(
ctx.add_node_ctor(
"String", Arc::new(
|ctx: Arc<RwLock<Context>>, dst_typ: TypeTerm, depth: usize| {
let mut node = Context::make_node(
&ctx,
TypeTerm::Type {
id: ctx.read().unwrap().get_fun_typeid("List").unwrap(),
args: vec![
TypeTerm::new(ctx.read().unwrap().get_typeid("Char").unwrap()).into()
]
},
TypeTerm::App(vec![
TypeTerm::TypeID(ctx.read().unwrap().get_typeid("List").unwrap()),
TypeTerm::new(ctx.read().unwrap().get_typeid("Char").unwrap())
]),
depth+1
).unwrap();
@ -136,8 +136,8 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
/*
ctx.write().unwrap().add_list_typename("TypeTerm".into());
ctx.write().unwrap().add_node_ctor(
ctx.add_list_typename("TypeTerm".into());
ctx.add_node_ctor(
"TypeTerm", Arc::new(
|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: usize| {
Some(TypeTermEditor::new(ctx, depth).into_node(depth))
@ -145,27 +145,29 @@ pub fn init_editor_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
*/
ctx.write().unwrap().add_typename("TerminalEvent".into());
ctx
ctx.add_typename("TerminalEvent".into());
drop(ctx);
ctx0
}
pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
let ctx = Arc::new(RwLock::new(Context::with_parent(Some(parent))));
let ctx0 = Arc::new(RwLock::new(Context::with_parent(Some(parent))));
ctx.write().unwrap().add_typename("MachineInt".into());
ctx.write().unwrap().add_typename("u32".into());
ctx.write().unwrap().add_typename("LittleEndian".into());
ctx.write().unwrap().add_typename("BigEndian".into());
let mut ctx = ctx0.write().unwrap();
ctx.add_typename("MachineInt".into());
ctx.add_typename("u32".into());
ctx.add_typename("u64".into());
ctx.add_typename("LittleEndian".into());
ctx.add_typename("BigEndian".into());
ctx.write().unwrap().add_node_ctor(
ctx.add_node_ctor(
"Digit", Arc::new(
|ctx: Arc<RwLock<Context>>, ty: TypeTerm, depth: usize| {
match ty {
TypeTerm::Type {
id: _, args
} => {
if args.len() > 0 {
match (args[0].0)[0] {
TypeTerm::App(args) => {
if args.len() > 1 {
match args[1] {
TypeTerm::Num(radix) => {
let node = DigitEditor::new(ctx.clone(), radix as u32).into_node(depth);
Some(
@ -184,12 +186,12 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
ctx.write().unwrap().add_list_typename("PosInt".into());
ctx.add_list_typename("PosInt".into());
let pattern = MorphismTypePattern {
src_tyid: ctx.read().unwrap().get_typeid("List"),
dst_tyid: ctx.read().unwrap().get_typeid("PosInt").unwrap()
src_tyid: ctx.get_typeid("List"),
dst_tyid: ctx.get_typeid("PosInt").unwrap()
};
ctx.write().unwrap().add_morphism(pattern,
ctx.add_morphism(pattern,
Arc::new(
|mut node, dst_type| {
let depth = node.depth.get();
@ -198,11 +200,9 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
// todo: check src_type parameter to be ( Digit radix )
match dst_type {
TypeTerm::Type {
id: _, args
} => {
if args.len() > 0 {
match (args[0].0)[0] {
TypeTerm::App(args) => {
if args.len() > 1 {
match args[1] {
TypeTerm::Num(_radix) => {
PTYListController::for_node(
&mut node,
@ -229,28 +229,26 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
ctx.write().unwrap().add_node_ctor(
ctx.add_node_ctor(
"PosInt", Arc::new(
|ctx: Arc<RwLock<Context>>, dst_typ: TypeTerm, depth: usize| {
|ctx0: Arc<RwLock<Context>>, dst_typ: TypeTerm, depth: usize| {
match dst_typ.clone() {
TypeTerm::Type {
id: _, args
} => {
if args.len() > 0 {
match (args[0].0)[0] {
TypeTerm::App(args) => {
if args.len() > 1 {
match args[1] {
TypeTerm::Num(radix) => {
let ctx = ctx0.read().unwrap();
let mut node = Context::make_node(
&ctx,
TypeTerm::Type {
id: ctx.read().unwrap().get_fun_typeid("List").unwrap(),
args: vec![
TypeTerm::new(ctx.read().unwrap().get_typeid("Digit").unwrap())
&ctx0,
TypeTerm::App(vec![
TypeTerm::TypeID(ctx.get_typeid("List").unwrap()),
TypeTerm::TypeID(
ctx.get_typeid("Digit").unwrap()
)
.num_arg(radix)
.clone()
.into()
]
},
]),
depth+1
).unwrap();
@ -270,51 +268,14 @@ pub fn init_math_ctx(parent: Arc<RwLock<Context>>) -> Arc<RwLock<Context>> {
)
);
ctx.write().unwrap().add_list_typename("RGB".into());
ctx.write().unwrap().add_node_ctor(
"RGB", Arc::new(
|ctx: Arc<RwLock<Context>>, _ty: TypeTerm, depth: usize| {
let editor = ProductEditor::new(depth, ctx.clone())
.with_t(Point2::new(0, 0), "r: ")
.with_n(Point2::new(1, 0),
vec![
ctx.read().unwrap().type_term_from_str("( PosInt 16 BigEndian )").unwrap()
].into())
.with_t(Point2::new(0, 1), "g: ")
.with_n(Point2::new(1, 1),
vec![
ctx.read().unwrap().type_term_from_str("( PosInt 16 BigEndian )").unwrap()
].into())
.with_t(Point2::new(0, 2), "b: ")
.with_n(Point2::new(1, 2),
vec![
ctx.read().unwrap().type_term_from_str("( PosInt 16 BigEndian )").unwrap()
].into()
);
ctx.add_typename("Date".into());
ctx.add_typename("ISO-8601".into());
ctx.add_typename("TimeSinceEpoch".into());
ctx.add_typename("Duration".into());
ctx.add_typename("Seconds".into());
ctx.add_typename("ℕ".into());
let view = editor.get_term_view();
let diag = editor.get_msg_port();
let editor = Arc::new(RwLock::new(editor));
let node = NestedNode::new(depth)
.set_ctx(ctx)
.set_cmd(editor.clone())
.set_nav(editor.clone())
.set_view(view)
.set_diag(diag)
;
Some(node)
}
));
ctx.write().unwrap().add_typename("Date".into());
ctx.write().unwrap().add_typename("ISO-8601".into());
ctx.write().unwrap().add_typename("TimeSinceEpoch".into());
ctx.write().unwrap().add_typename("Duration".into());
ctx.write().unwrap().add_typename("Seconds".into());
ctx.write().unwrap().add_typename("ℕ".into());
ctx
drop(ctx);
ctx0
}

4
nested/src/type_system/mod.rs
View file

@ -2,14 +2,14 @@ pub mod context;
pub mod dict;
pub mod term;
pub mod ladder;
//pub mod ladder;
pub mod repr_tree;
pub mod make_editor;
pub mod editor;
pub use {
dict::*,
ladder::*,
// ladder::*,
repr_tree::*,
term::*,
context::{Context, MorphismMode, MorphismType, MorphismTypePattern},

3
nested/src/type_system/repr_tree.rs
View file

@ -89,8 +89,7 @@ impl ReprTree {
self.port
.clone()?
.downcast::<V>()
.ok()
.unwrap()
.ok()?
)
}

143
nested/src/type_system/term.rs
View file

@ -1,45 +1,56 @@
use {
crate::{
type_system::{TypeLadder, TypeID}
type_system::{TypeID}
},
std::collections::HashMap
};
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
pub enum TypeTerm {
/* TODO: refactor into this:
Nominal {
id: u64,
args: Vec< TypeTerm >
},
Ladder(Vec< TypeTerm >),
*/
Type {
id: u64,
args: Vec< TypeLadder >
},
Var(u64),
/* Atomic Terms */
// Base types from dictionary
TypeID(TypeID),
// Literals
Num(i64),
Char(char)
Char(char),
/* Complex Terms */
// Type Parameters
// avoid currying to save space & indirection
App(Vec< TypeTerm >),
// Type Ladders
Ladder(Vec< TypeTerm >),
}
//<<<<>>>><<>><><<>><<<*>>><<>><><<>><<<<>>>>
impl TypeTerm {
pub fn new(id: TypeID) -> Self {
match id {
TypeID::Fun(id) => TypeTerm::Type { id, args: vec![] },
TypeID::Var(_) => {unreachable!();}
}
TypeTerm::TypeID(id)
}
pub fn arg(&mut self, t: impl Into<TypeLadder>) -> &mut Self {
if let TypeTerm::Type { id: _, args } = self {
pub fn arg(&mut self, t: impl Into<TypeTerm>) -> &mut Self {
match self {
TypeTerm::App(args) => {
args.push(t.into());
}
_ => {
*self = TypeTerm::App(vec![
self.clone(),
t.into()
])
}
}
self
}
@ -51,6 +62,29 @@ impl TypeTerm {
self.arg(TypeTerm::Char(c))
}
/* TODO
// summarize all curried applications into one vec
pub fn decurry() {}
// transmute into Ladder-Normal-Form
pub fn normalize(&mut self) {
match self {
TypeTerm::Apply{ id, args } => {
}
}
}
pub fn is_supertype_of(&self, t: &TypeTerm) -> bool {
t.is_subtype_of(self)
}
pub fn is_subtype_of(&self, t: &TypeTerm) -> bool {
false
}
*/
pub fn from_str(s: &str, names: &HashMap<String, TypeID>) -> Option<Self> {
let mut term_stack = Vec::<Option<TypeTerm>>::new();
@ -111,53 +145,42 @@ impl TypeTerm {
None
}
// only adds parenthesis where args.len > 0
pub fn to_str1(&self, names: &HashMap<TypeID, String>) -> String {
match self {
TypeTerm::Type { id, args } => {
if args.len() > 0 {
format!(
"<{}{}>",
names[&TypeID::Fun(*id)],
if args.len() > 0 {
args.iter().fold(String::new(), |str, term| {
format!("{} {}", str, term.to_str1(names))
})
} else {
String::new()
}
)
} else {
names[&TypeID::Fun(*id)].clone()
}
}
TypeTerm::Num(n) => format!("{}", n),
TypeTerm::Char('\n') => format!("'\\n'"),
TypeTerm::Char(c) => format!("'{}'", c),
TypeTerm::Var(varid) => format!("T"),
}
}
// always adds an enclosing pair of parenthesis
pub fn to_str(&self, names: &HashMap<TypeID, String>) -> String {
match self {
TypeTerm::Type { id, args } => format!(
"<{}{}>",
names[&TypeID::Fun(*id)],
if args.len() > 0 {
args.iter().fold(String::new(), |str, term| {
format!("{} {}", str, term.to_str1(names))
})
} else {
String::new()
TypeTerm::App(args) => {
let mut out = String::new();
out.push_str(&"<");
for x in args.iter() {
out.push_str(&" ");
out.push_str(&x.to_str(names));
}
out.push_str(&">");
out
}
TypeTerm::Ladder(l) => {
let mut out = String::new();
let mut first = true;
for x in l.iter() {
if !first {
out.push_str(&"~");
first = false;
}
out.push_str(&x.to_str(names));
}
out
}
),
TypeTerm::Num(n) => format!("{}", n),
TypeTerm::Char('\n') => format!("'\\n'"),
TypeTerm::Char(c) => format!("'{}'", c),
TypeTerm::Var(varid) => format!("T"),
TypeTerm::TypeID(id) => format!("{}", names[id]),
}
}
}