101 lines
3.2 KiB
Rust
101 lines
3.2 KiB
Rust
use std::rc::Rc;
|
|
|
|
use futures::future::join_all;
|
|
use orchid_api_derive::{Coding, Hierarchy};
|
|
use orchid_base::name::Sym;
|
|
use orchid_base::reqnot::Receipt;
|
|
use orchid_base::sym;
|
|
use orchid_extension::atom::{AtomDynfo, AtomicFeatures};
|
|
use orchid_extension::context::i;
|
|
use orchid_extension::conv::ToExpr;
|
|
use orchid_extension::entrypoint::ExtReq;
|
|
use orchid_extension::expr::Expr;
|
|
use orchid_extension::lexer::LexerObj;
|
|
use orchid_extension::parser::ParserObj;
|
|
use orchid_extension::system::{System, SystemCard};
|
|
use orchid_extension::system_ctor::SystemCtor;
|
|
use orchid_extension::tree::{GenMember, merge_trivial};
|
|
|
|
use super::number::num_lib::gen_num_lib;
|
|
use super::string::str_atom::{IntStrAtom, StrAtom};
|
|
use super::string::str_lib::gen_str_lib;
|
|
use crate::std::number::num_lexer::NumLexer;
|
|
use crate::std::option::{OptAtom, gen_option_lib};
|
|
use crate::std::protocol::proto_parser::{AsProtoParser, ProtoParser};
|
|
use crate::std::protocol::type_parser::{AsTypeParser, TypeParser};
|
|
use crate::std::protocol::types::{Tag, Tagged, gen_protocol_lib};
|
|
use crate::std::record::record_atom::Record;
|
|
use crate::std::record::record_lib::gen_record_lib;
|
|
use crate::std::reflection::sym_atom::{CreateSymAtom, SymAtom, gen_sym_lib};
|
|
use crate::std::string::str_lexer::StringLexer;
|
|
use crate::std::string::to_string::AsStrTag;
|
|
use crate::std::tuple::{CreateTuple, Tuple, TupleBuilder, gen_tuple_lib};
|
|
use crate::{Float, Int};
|
|
|
|
#[derive(Clone, Debug, Coding, Hierarchy)]
|
|
#[extendable]
|
|
pub enum StdReq {
|
|
CreateTuple(CreateTuple),
|
|
CreateSymAtom(CreateSymAtom),
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct StdSystem;
|
|
impl SystemCtor for StdSystem {
|
|
type Deps = ();
|
|
type Instance = Self;
|
|
const NAME: &'static str = "orchid::std";
|
|
const VERSION: f64 = 0.00_01;
|
|
fn inst(_: ()) -> Self::Instance { Self }
|
|
}
|
|
impl SystemCard for StdSystem {
|
|
type Ctor = Self;
|
|
type Req = StdReq;
|
|
fn atoms() -> impl IntoIterator<Item = Option<Box<dyn AtomDynfo>>> {
|
|
[
|
|
Some(Int::dynfo()),
|
|
Some(Float::dynfo()),
|
|
Some(StrAtom::dynfo()),
|
|
Some(IntStrAtom::dynfo()),
|
|
Some(OptAtom::dynfo()),
|
|
Some(Record::dynfo()),
|
|
Some(Tuple::dynfo()),
|
|
Some(TupleBuilder::dynfo()),
|
|
Some(Tag::dynfo()),
|
|
Some(Tagged::dynfo()),
|
|
Some(AsStrTag::dynfo()),
|
|
]
|
|
}
|
|
}
|
|
impl System for StdSystem {
|
|
async fn request(xreq: ExtReq<'_>, req: Self::Req) -> Receipt<'_> {
|
|
match req {
|
|
StdReq::CreateTuple(ref req @ CreateTuple(ref items)) => {
|
|
let tpl = Tuple(Rc::new(join_all(items.iter().copied().map(Expr::deserialize)).await));
|
|
let tk = tpl.to_expr().await.serialize().await;
|
|
xreq.handle(req, &tk).await
|
|
},
|
|
StdReq::CreateSymAtom(ref req @ CreateSymAtom(sym_tok)) => {
|
|
let sym_atom = SymAtom(Sym::from_api(sym_tok, &i()).await);
|
|
xreq.handle(req, &sym_atom.to_expr().await.serialize().await).await
|
|
},
|
|
}
|
|
}
|
|
fn lexers() -> Vec<LexerObj> { vec![&StringLexer, &NumLexer] }
|
|
fn parsers() -> Vec<ParserObj> { vec![&AsTypeParser, &TypeParser, &AsProtoParser, &ProtoParser] }
|
|
async fn env() -> Vec<GenMember> {
|
|
merge_trivial([
|
|
gen_num_lib(),
|
|
gen_str_lib(),
|
|
gen_option_lib(),
|
|
gen_record_lib(),
|
|
gen_tuple_lib(),
|
|
gen_protocol_lib(),
|
|
gen_sym_lib().await,
|
|
])
|
|
}
|
|
async fn prelude() -> Vec<Sym> {
|
|
vec![sym!(std; i()), sym!(std::tuple; i()), sym!(std::option; i())]
|
|
}
|
|
}
|