orchid/notes/papers/demo/slides.md

marp, class

marp	class
true	invert

Orchid

some tagline

---

Syntax

basically lambda calc

half := \n. div n 2
pair := \a.\b. \f. f a b
increment := add 1

---

Macros

match and replace token sequences

if ...$cond then ...$true else ...$false ==> (ifthenelse (...$cond) (...$true) (...$false))

...while keeping parameters intact

$data -- a single token (including parenthesized sequences)
...$data -- at least one token
..$data -- zero or more tokens

---

Macros

define operators...

...$a + ...$b ==> (add (...$a) (...$b))

...and name bindings...

let $name = ...$value in ...$body ==> (\$name. ...$body) ...$value

...and control structures

loop $r on (...$parameters) with ...$tail ==> Y (\$r.
  bind_names (...$parameters) (...$tail)
) ...$parameters

-- bind each of the names in the first argument as a parameter for the second argument
bind_names ($name ..$rest) $payload ==> \$name. bind_names (..$rest) $payload
bind_names () (...$payload) ==> ...$payload

---

Macros

can expose interfaces...

do { ...$statement ; ...$rest } ==> (statement (...$statement) do { ...$rest })
do { ...$return } ==> (...$return)

...to be used by others...

statement (let $name = ...$value) ...$next ==> ((\$name. ...$next) (...$value))
statement (cps $name = ...$operation) ...$next ==> ((...$operation) \$name. ...$next)
statement (cps ...$operation) ...$next ==> ((...$operation) (...$next))

...to define any syntax

export main := do{
  cps data = readline;
  let double = parse_float data * 2;
  cps print (to_string double ++ "\n")
}

---

Control

remains with the embedder

	extension	supervision
pipeline	external libraries	file IO interception
macros		step-by-step execution
interpreter	constants, input	gas

---

Extensions

use std::fmt::Debug;
use crate::external::litconv::with_lit;
use crate::representations::{interpreted::ExprInst, Literal};
use crate::{atomic_impl, atomic_redirect, externfn_impl};

#[derive(Clone)]
pub struct ToString1;
externfn_impl!(ToString1, |_: &Self, x: ExprInst| Ok(ToString0{x}));

#[derive(Debug, Clone)]
pub struct ToString0{ x: ExprInst }
atomic_redirect!(ToString0, x);
atomic_impl!(ToString0, |Self{ x }: &Self, _| {
  let string = with_lit(x, |l| Ok(match l {
    Literal::Char(c) => c.to_string(),
    Literal::Uint(i) => i.to_string(),
    Literal::Num(n) => n.to_string(),
    Literal::Str(s) => s.clone()
  }))?;
  Ok(string.into())
});