retoor/orchid
1
0
Fork 0
forked from Orchid/orchid
Code Pull Requests 1 Activity

Preparation for sharing

Browse Source 
- rustfmt
- clippy
- comments
- README
This commit is contained in:
Lawrence Bethlenfalvy
2023-05-25 19:14:24 +01:00
parent e99ade92ba
commit bc2714aad8
144 changed files with 3734 additions and 3243 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
src/foreign_macros/atomic_defaults.rs
View File

@@ -1,13 +1,16 @@
#[allow(unused)] // for the doc comments
use crate::foreign::Atomic;
/// A macro that generates the straightforward, syntactically invariant part of implementing
/// [Atomic]. Implemented fns are [Atomic::as_any], [Atomic::definitely_eq] and [Atomic::hash].
///
/// A macro that generates the straightforward, syntactically invariant part of
/// implementing [Atomic]. Implemented fns are [Atomic::as_any],
/// [Atomic::definitely_eq] and [Atomic::hash].
///
/// It depends on [Eq] and [Hash]
#[macro_export]
macro_rules! atomic_defaults {
() => {
fn as_any(&self) -> &dyn std::any::Any { self }
fn as_any(&self) -> &dyn std::any::Any {
self
}
};
}
}

89
src/foreign_macros/atomic_impl.rs
View File

@@ -1,33 +1,39 @@
#[allow(unused)] // for the doc comments
use crate::representations::Primitive;
#[allow(unused)] // for the doc comments
use crate::foreign::{Atomic, ExternFn};
#[allow(unused)] // for the doc comments
use std::any::Any;
#[allow(unused)] // for the doc comments
use dyn_clone::DynClone;
#[allow(unused)] // for the doc comments
use std::fmt::Debug;
/// A macro that generates implementations of [Atomic] to simplify the development of
/// external bindings for Orchid.
///
/// The macro depends on implementations of [AsRef<Clause>] and [From<(&Self, Clause)>] for
/// extracting the clause to be processed and then reconstructing the [Atomic]. Naturally,
/// supertraits of [Atomic] are also dependencies. These are [Any], [Debug] and [DynClone].
///
/// The simplest form just requires the typename to be specified. This additionally depends on an
/// implementation of [ExternFn] because after the clause is fully normalized it returns `Self`
/// wrapped in a [Primitive::ExternFn]. It is intended for intermediary
/// stages of the function where validation and the next state are defined in [ExternFn::apply].
///
#[allow(unused)] // for the doc comments
use dyn_clone::DynClone;
#[allow(unused)] // for the doc comments
use crate::foreign::{Atomic, ExternFn};
#[allow(unused)] // for the doc comments
use crate::representations::Primitive;
/// A macro that generates implementations of [Atomic] to simplify the
/// development of external bindings for Orchid.
///
/// The macro depends on implementations of [AsRef<Clause>] and [From<(&Self,
/// Clause)>] for extracting the clause to be processed and then reconstructing
/// the [Atomic]. Naturally, supertraits of [Atomic] are also dependencies.
/// These are [Any], [Debug] and [DynClone].
///
/// The simplest form just requires the typename to be specified. This
/// additionally depends on an implementation of [ExternFn] because after the
/// clause is fully normalized it returns `Self` wrapped in a
/// [Primitive::ExternFn]. It is intended for intermediary stages of the
/// function where validation and the next state are defined in
/// [ExternFn::apply].
///
/// ```
/// atomic_impl!(Multiply1)
/// ```
///
/// The last stage of the function should use the extended form of the macro which takes an
/// additional closure to explicitly describe what happens when the argument is fully processed.
///
///
/// The last stage of the function should use the extended form of the macro
/// which takes an additional closure to explicitly describe what happens when
/// the argument is fully processed.
///
/// ```
/// // excerpt from the exact implementation of Multiply
/// atomic_impl!(Multiply0, |Self(a, cls): &Self| {
@@ -35,45 +41,44 @@ use std::fmt::Debug;
/// Ok(*a * b).into())
/// })
/// ```
///
#[macro_export]
macro_rules! atomic_impl {
($typ:ident) => {
atomic_impl!{$typ, |this: &Self, _: $crate::interpreter::Context| {
atomic_impl! {$typ, |this: &Self, _: $crate::interpreter::Context| {
use $crate::foreign::ExternFn;
Ok(this.clone().to_xfn_cls())
}}
};
($typ:ident, $next_phase:expr) => {
impl $crate::foreign::Atomic for $typ {
$crate::atomic_defaults!{}
$crate::atomic_defaults! {}
fn run(&self, ctx: $crate::interpreter::Context)
-> $crate::foreign::AtomicResult
{
fn run(
&self,
ctx: $crate::interpreter::Context,
) -> $crate::foreign::AtomicResult {
// extract the expression
let expr = <Self as
AsRef<$crate::foreign::RcExpr>
>::as_ref(self).clone();
let expr =
<Self as AsRef<$crate::foreign::RcExpr>>::as_ref(self).clone();
// run the expression
let ret = $crate::interpreter::run(expr, ctx.clone())?;
let $crate::interpreter::Return{ gas, state, inert } = ret;
let $crate::interpreter::Return { gas, state, inert } = ret;
// rebuild the atomic
let next_self = <Self as
From<(&Self, $crate::foreign::RcExpr)>
>::from((self, state));
let next_self =
<Self as From<(&Self, $crate::foreign::RcExpr)>>::from((self, state));
// branch off or wrap up
let clause = if inert {
match ($next_phase)(&next_self, ctx) {
let closure = $next_phase;
match closure(&next_self, ctx) {
Ok(r) => r,
Err(e) => return Err(
$crate::interpreter::RuntimeError::Extern(e)
)
Err(e) => return Err($crate::interpreter::RuntimeError::Extern(e)),
}
} else { next_self.to_atom_cls() };
} else {
next_self.to_atom_cls()
};
// package and return
Ok($crate::foreign::AtomicReturn{ clause, gas, inert: false })
Ok($crate::foreign::AtomicReturn { clause, gas, inert: false })
}
}
};
}
}

30
src/foreign_macros/atomic_inert.rs
View File

@@ -1,29 +1,33 @@
#[allow(unused)] // for the doc comments
use crate::foreign::Atomic;
#[allow(unused)] // for the doc comments
use std::any::Any;
#[allow(unused)] // for the doc comments
use dyn_clone::DynClone;
#[allow(unused)] // for the doc comments
use std::fmt::Debug;
/// Implement [Atomic] for a structure that cannot be transformed any further. This would be optimal
/// for atomics encapsulating raw data. [Atomic] depends on [Any], [Debug] and [DynClone].
#[allow(unused)] // for the doc comments
use dyn_clone::DynClone;
#[allow(unused)] // for the doc comments
use crate::foreign::Atomic;
/// Implement [Atomic] for a structure that cannot be transformed any further.
/// This would be optimal for atomics encapsulating raw data. [Atomic] depends
/// on [Any], [Debug] and [DynClone].
#[macro_export]
macro_rules! atomic_inert {
($typ:ident) => {
impl $crate::foreign::Atomic for $typ {
$crate::atomic_defaults!{}
$crate::atomic_defaults! {}
fn run(&self, ctx: $crate::interpreter::Context)
-> $crate::foreign::AtomicResult
{
Ok($crate::foreign::AtomicReturn{
fn run(
&self,
ctx: $crate::interpreter::Context,
) -> $crate::foreign::AtomicResult {
Ok($crate::foreign::AtomicReturn {
clause: self.clone().to_atom_cls(),
gas: ctx.gas,
inert: true
inert: true,
})
}
}
};
}
}

25
src/foreign_macros/atomic_redirect.rs
View File

@@ -1,30 +1,33 @@
#[allow(unused)]
use super::atomic_impl;
/// Implement the traits required by [atomic_impl] to redirect run_* functions to a field
/// with a particular name.
/// Implement the traits required by [atomic_impl] to redirect run_* functions
/// to a field with a particular name.
#[macro_export]
macro_rules! atomic_redirect {
($typ:ident) => {
impl AsRef<$crate::foreign::RcExpr> for $typ {
fn as_ref(&self) -> &Clause { &self.0 }
fn as_ref(&self) -> &Clause {
&self.0
}
}
impl From<(&Self, $crate::foreign::RcExpr)> for $typ {
fn from((old, clause): (&Self, Clause)) -> Self {
Self{ 0: clause, ..old.clone() }
Self { 0: clause, ..old.clone() }
}
}
};
($typ:ident, $field:ident) => {
impl AsRef<$crate::foreign::RcExpr>
for $typ {
fn as_ref(&self) -> &$crate::foreign::RcExpr { &self.$field }
impl AsRef<$crate::foreign::RcExpr> for $typ {
fn as_ref(&self) -> &$crate::foreign::RcExpr {
&self.$field
}
}
impl From<(&Self, $crate::foreign::RcExpr)>
for $typ {
impl From<(&Self, $crate::foreign::RcExpr)> for $typ {
#[allow(clippy::needless_update)]
fn from((old, $field): (&Self, $crate::foreign::RcExpr)) -> Self {
Self{ $field, ..old.clone() }
Self { $field, ..old.clone() }
}
}
};
}
}

54
src/foreign_macros/externfn_impl.rs
View File

@@ -1,41 +1,47 @@
#[allow(unused)] // for the doc comments
use crate::{atomic_impl, atomic_redirect};
#[allow(unused)] // for the doc comments
use crate::representations::Primitive;
#[allow(unused)] // for the doc comments
use crate::foreign::{Atomic, ExternFn};
#[allow(unused)] // for the doc comments
use std::any::Any;
#[allow(unused)] // for the doc comments
use std::fmt::Debug;
#[allow(unused)] // for the doc comments
use std::hash::Hash;
#[allow(unused)] // for the doc comments
use dyn_clone::DynClone;
#[allow(unused)] // for the doc comments
use std::fmt::Debug;
/// Implement [ExternFn] with a closure that produces an [Atomic] from a reference to self
/// and a closure. This can be used in conjunction with [atomic_impl] and [atomic_redirect]
/// to normalize the argument automatically before using it.
#[allow(unused)] // for the doc comments
use crate::foreign::{Atomic, ExternFn};
#[allow(unused)] // for the doc comments
use crate::representations::Primitive;
#[allow(unused)] // for the doc comments
use crate::{atomic_impl, atomic_redirect};
/// Implement [ExternFn] with a closure that produces an [Atomic] from a
/// reference to self and a closure. This can be used in conjunction with
/// [atomic_impl] and [atomic_redirect] to normalize the argument automatically
/// before using it.
#[macro_export]
macro_rules! externfn_impl {
($typ:ident, $next_atomic:expr) => {
impl $crate::foreign::ExternFn for $typ {
fn name(&self) -> &str {stringify!($typ)}
fn apply(&self,
fn name(&self) -> &str {
stringify!($typ)
}
fn apply(
&self,
arg: $crate::foreign::RcExpr,
_ctx: $crate::interpreter::Context
_ctx: $crate::interpreter::Context,
) -> $crate::foreign::XfnResult {
match ($next_atomic)(self, arg) { // ? casts the result but we want to strictly forward it
Ok(r) => Ok(
$crate::representations::interpreted::Clause::P(
$crate::representations::Primitive::Atom(
$crate::foreign::Atom::new(r)
)
)
),
Err(e) => Err(e)
let closure = $next_atomic;
match closure(self, arg) {
// ? casts the result but we want to strictly forward it
Ok(r) => Ok($crate::representations::interpreted::Clause::P(
$crate::representations::Primitive::Atom(
$crate::foreign::Atom::new(r),
),
)),
Err(e) => Err(e),
}
}
}
};
}
}

2
src/foreign_macros/mod.rs
View File

@@ -2,4 +2,4 @@ mod atomic_defaults;
mod atomic_impl;
mod atomic_inert;
mod atomic_redirect;
mod externfn_impl;
mod externfn_impl;