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

Added define_fn

Browse Source 
- updated write_fn_step to support attributes, bind names and
  explicit argument types
- added define_fn to generate write_fn_step sequences
- updated concatenate to define_fn as an example
This commit is contained in:
Lawrence Bethlenfalvy
2023-06-02 18:21:10 +01:00
parent 01aa37b27d
commit 5bb8a12fc2
9 changed files with 184 additions and 64 deletions
Download Patch File Download Diff File Expand all files Collapse all files

128
src/foreign_macros/define_fn.rs Normal file
View File

@@ -0,0 +1,128 @@
#[allow(unused)] // for doc
use crate::foreign::ExternFn;
#[allow(unused)] // for doc
use crate::interpreted::ExprInst;
#[allow(unused)] // for doc
use crate::write_fn_step;
/// Define a simple n-ary nonvariadic Orchid function with static argument
/// types.
///
/// This macro relies on [write_fn_step] to define a struct for each step.
/// Because of how Orchid handles state, the arguments must implement [Clone]
/// and [Debug]. All expressions and arguments are accessible as references.
///
/// First, the alias for the newly introduced [ExprInst] is specified. This step
/// is necessary and a default cannot be provided because any name defined in
/// the macro is invisible to the calling code. In the example, the name `x` is
/// selected.
///
/// Then a name and optional visibility is specified for the entry point. This
/// will be a zero-size marker struct implementing [ExternFn]. It can also have
/// documentation and attributes.
///
/// This is followed by the table of arguments. Each defines a name, value type,
/// and a conversion expression which references the [ExprInst] by the name
/// defined in the first step and returns a [Result] of the success type or
/// `Rc<dyn ExternError>`.
///
/// Finally, the body of the function is provided as an expression which can
/// reference all of the arguments by their names, each bound to a ref of the
/// specified type.
///
/// ```
/// use orchidlang::interpreted::Clause;
/// use orchidlang::stl::litconv::with_str;
/// use orchidlang::{define_fn, Literal, Primitive};
///
/// define_fn! {expr=x in
/// /// Append a string to another
/// pub Concatenate {
/// a: String as with_str(x, |s| Ok(s.clone())),
/// b: String as with_str(x, |s| Ok(s.clone()))
/// } => {
/// Ok(Clause::P(Primitive::Literal(Literal::Str(a.to_owned() + &b))))
/// }
/// }
/// ```
#[macro_export]
macro_rules! define_fn {
(expr=$xname:ident in
$( #[ $attr:meta ] )*
$qual:vis $name:ident {
$arg0:ident: $typ0:ty as $parse0:expr
$(, $arg:ident: $typ:ty as $parse:expr )*
} => $body:expr
) => {paste::paste!{
// Generate initial state
$crate::write_fn_step!(
$( #[ $attr ] )* $qual $name
>
[< Internal $name >]
);
// Enter loop to generate intermediate states
$crate::define_fn!(@MIDDLE $xname [< Internal $name >] ($body)
()
(
($arg0: $typ0 as $parse0)
$( ($arg: $typ as $parse) )*
)
);
}};
// Recursive case
(@MIDDLE $xname:ident $name:ident ($body:expr)
// fields that should be included in this struct
(
$(
( $arg_prev:ident: $typ_prev:ty )
)*
)
// later fields
(
// field that should be processed by this step
( $arg0:ident: $typ0:ty as $parse0:expr )
// ensure that we have a next stage
$(
( $arg:ident: $typ:ty as $parse:expr )
)+
)
) => {paste::paste!{
$crate::write_fn_step!(
$name
{
$( $arg_prev:ident : $typ_prev:ty ),*
}
[< $name $arg0:upper >]
where $arg0:$typ0 = $xname => $parse0;
);
$crate::define_fn!(@MIDDLE $xname [< $name $arg0:upper >] ($body)
(
$( ($arg_prev: $typ_prev) )*
($arg0: $typ0)
)
(
$( ($arg: $typ as $parse) )+
)
);
}};
// recursive base case
(@MIDDLE $xname:ident $name:ident ($body:expr)
// all but one field is included in this struct
(
$( ($arg_prev:ident: $typ_prev:ty) )*
)
// the last one is initialized before the body runs
(
($arg0:ident: $typ0:ty as $parse0:expr)
)
) => {
$crate::write_fn_step!(
$name
{
$( $arg_prev: $typ_prev ),*
}
$arg0:$typ0 = $xname => $parse0;
$body
);
};
}

1
src/foreign_macros/mod.rs
View File

@@ -2,5 +2,6 @@ mod atomic_defaults;
mod atomic_impl;
mod atomic_inert;
mod atomic_redirect;
mod define_fn;
mod externfn_impl;
mod write_fn_step;

55
src/foreign_macros/write_fn_step.rs
View File

@@ -1,14 +1,18 @@
#[allow(unused)] // for doc
use crate::define_fn;
#[allow(unused)] // for doc
use crate::foreign::ExternFn;
#[allow(unused)] // for doc
use crate::interpreted::ExprInst;
/// Write one step in the state machine representing a simple n-ary non-variadic
/// Orchid function.
/// Orchid function. There are no known use cases for it that aren't expressed
/// better with [define_fn] which generates calls to this macro.
///
/// There are three ways to call this macro for the initial state, internal
/// state, and exit state. All of them are demonstrated in one example and
/// discussed below.
/// discussed below. The newly bound names (here `s` and `i` before `=`) can
/// also receive type annotations.
///
/// ```
/// use orchidlang::{write_fn_step, Literal, Primitive};
@@ -21,13 +25,13 @@ use crate::interpreted::ExprInst;
/// // Middle state
/// write_fn_step!(
/// CharAt1 {}
/// CharAt0 where s = |x| with_str(x, |s| Ok(s.clone()))
/// CharAt0 where s = x => with_str(x, |s| Ok(s.clone()));
/// );
/// // Exit state
/// write_fn_step!(
/// CharAt0 { s: String }
/// i = |x| with_uint(x, Ok)
/// => {
/// i = x => with_uint(x, Ok);
/// {
/// if let Some(c) = s.chars().nth(i as usize) {
/// Ok(Clause::P(Primitive::Literal(Literal::Char(c))))
/// } else {
@@ -47,12 +51,12 @@ use crate::interpreted::ExprInst;
/// The middle state defines a sequence of arguments with types similarly to a
/// struct definition. A field called `expr_inst` of type [ExprInst] is added
/// implicitly, so the first middle state has an empty field list. The next
/// state is also provided, alongside the name and conversion function of the
/// next parameter which is [FnOnce(&ExprInst) -> Result<_, RuntimeError>]. The
/// success type is inferred from the type of the field at the place of its
/// actual definition. This conversion is done in the implementation of
/// [ExternFn] which also places the new [ExprInst] into `expr_inst` on the next
/// state.
/// state is also provided, alongside the name and conversion of the next
/// parameter from a [&ExprInst] under the provided alias to a
/// `Result<_, Rc<dyn ExternError>>`. The success type is inferred from the
/// type of the field at the place of its actual definition. This conversion is
/// done in the implementation of [ExternFn] which also places the new
/// [ExprInst] into `expr_inst` on the next state.
///
/// The final state defines the sequence of all arguments except for the last
/// one with the same syntax used by the middle state, and the name and
@@ -65,7 +69,9 @@ use crate::interpreted::ExprInst;
/// before the body is evaluated.
#[macro_export]
macro_rules! write_fn_step {
($quant:vis $name:ident > $next:ident) => {
// write entry stage
( $( #[ $attr:meta ] )* $quant:vis $name:ident > $next:ident) => {
$( #[ $attr ] )*
#[derive(Clone)]
$quant struct $name;
$crate::externfn_impl!{
@@ -75,12 +81,15 @@ macro_rules! write_fn_step {
}
}
};
// write middle stage
(
$quant:vis $name:ident {
$( #[ $attr:meta ] )* $quant:vis $name:ident {
$( $arg:ident : $typ:ty ),*
}
$next:ident where $added:ident = $extract:expr
$next:ident where
$added:ident $( : $added_typ:ty )? = $xname:ident => $extract:expr ;
) => {
$( #[ $attr ] )*
#[derive(std::fmt::Debug, Clone)]
$quant struct $name {
$( $arg: $typ, )*
@@ -91,22 +100,24 @@ macro_rules! write_fn_step {
$crate::externfn_impl!(
$name,
|this: &Self, expr_inst: $crate::interpreted::ExprInst| {
let lambda = $extract;
let $xname = &this.expr_inst;
let $added $( :$added_typ )? = $extract?;
Ok($next{
$( $arg: this.$arg.clone(), )*
$added: lambda(&this.expr_inst)?,
expr_inst
$added, expr_inst
})
}
);
};
// write final stage
(
$quant:vis $name:ident {
$( #[ $attr:meta ] )* $quant:vis $name:ident {
$( $arg:ident: $typ:ty ),*
}
$added:ident = $extract:expr
=> $process:expr
$added:ident $(: $added_typ:ty )? = $xname:ident => $extract:expr ;
$process:expr
) => {
$( #[ $attr ] )*
#[derive(std::fmt::Debug, Clone)]
$quant struct $name {
$( $arg: $typ, )+
@@ -116,8 +127,8 @@ macro_rules! write_fn_step {
$crate::atomic_impl!(
$name,
|Self{ $($arg, )* expr_inst }: &Self, _| {
let lambda = $extract;
let $added = lambda(expr_inst)?;
let $xname = expr_inst;
let $added $(: $added_typ )? = $extract?;
$process
}
);