633 lines
22 KiB
Rust
633 lines
22 KiB
Rust
use crate::value::*;
|
|
use imbl::*;
|
|
use ran::ran_f64;
|
|
use std::rc::Rc;
|
|
|
|
#[derive(Clone, Debug)]
|
|
pub enum Base<'src> {
|
|
Nullary(fn() -> Value<'src>),
|
|
Unary(fn(&Value<'src>) -> Value<'src>),
|
|
Binary(fn(&Value<'src>, &Value<'src>) -> Value<'src>),
|
|
Ternary(fn(&Value<'src>, &Value<'src>, &Value<'src>) -> Value<'src>),
|
|
}
|
|
|
|
pub fn eq<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
Value::Boolean(x == y)
|
|
}
|
|
|
|
pub fn add<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x + y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn sub<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x - y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn unbox<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::Box(_, cell) => cell.borrow().clone(),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn store<'src>(b: &Value<'src>, val: &Value<'src>) -> Value<'src> {
|
|
if let Value::Box(_, cell) = b {
|
|
cell.replace(val.clone());
|
|
val.clone()
|
|
} else {
|
|
unreachable!("internal Ludus error")
|
|
}
|
|
}
|
|
|
|
// TODO: do better than returning just the docstr
|
|
// name, patterns, AND docstring
|
|
pub fn doc<'src>(f: &Value<'src>) -> Value<'src> {
|
|
match f {
|
|
Value::Fn(f) => {
|
|
let name = &f.name;
|
|
let doc = &f.doc;
|
|
if let Some(docstr) = doc {
|
|
Value::AllocatedString(Rc::new(format!("{name}: {docstr}")))
|
|
} else {
|
|
Value::AllocatedString(Rc::new(format!("{name}: no documentation found")))
|
|
}
|
|
}
|
|
_ => Value::InternedString("no documentation found"),
|
|
}
|
|
}
|
|
|
|
pub fn and<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
Value::Boolean(x.bool() && y.bool())
|
|
}
|
|
|
|
pub fn assoc<'src>(dict: &Value<'src>, key: &Value<'src>, value: &Value<'src>) -> Value<'src> {
|
|
match (dict, key) {
|
|
(Value::Dict(d), Value::Keyword(k)) => Value::Dict(d.update(k, value.clone())),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn r#bool<'src>(x: &Value<'src>) -> Value<'src> {
|
|
Value::Boolean(x.bool())
|
|
}
|
|
|
|
pub fn chars<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::InternedString(s) => {
|
|
let chars = s.chars();
|
|
|
|
let mut charlist = vector![];
|
|
for char in chars {
|
|
if char.is_ascii() {
|
|
charlist.push_back(Value::AllocatedString(Rc::new(char.to_string())))
|
|
} else {
|
|
return Value::Tuple(Rc::new(vec![
|
|
Value::Keyword("err"),
|
|
Value::AllocatedString(Rc::new(format!(
|
|
"{char} is not an ascii character"
|
|
))),
|
|
]));
|
|
}
|
|
}
|
|
Value::Tuple(Rc::new(vec![Value::Keyword("ok"), Value::List(charlist)]))
|
|
}
|
|
Value::AllocatedString(s) => {
|
|
let chars = s.chars();
|
|
|
|
let mut charlist = vector![];
|
|
for char in chars {
|
|
if char.is_ascii() {
|
|
charlist.push_back(Value::AllocatedString(Rc::new(char.to_string())))
|
|
} else {
|
|
return Value::Tuple(Rc::new(vec![
|
|
Value::Keyword("err"),
|
|
Value::AllocatedString(Rc::new(format!(
|
|
"{char} is not an ascii character"
|
|
))),
|
|
]));
|
|
}
|
|
}
|
|
Value::Tuple(Rc::new(vec![Value::Keyword("ok"), Value::List(charlist)]))
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
// TODO: figure out how to get to opportunistic mutation here
|
|
pub fn concat<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::InternedString(x), Value::InternedString(y)) => {
|
|
Value::AllocatedString(Rc::new(format!("{x}{y}")))
|
|
}
|
|
(Value::AllocatedString(x), Value::AllocatedString(y)) => {
|
|
Value::AllocatedString(Rc::new(format!("{x}{y}")))
|
|
}
|
|
(Value::AllocatedString(x), Value::InternedString(y)) => {
|
|
Value::AllocatedString(Rc::new(format!("{x}{y}")))
|
|
}
|
|
(Value::InternedString(x), Value::AllocatedString(y)) => {
|
|
Value::AllocatedString(Rc::new(format!("{x}{y}")))
|
|
}
|
|
(Value::List(x), Value::List(y)) => {
|
|
let mut newlist = x.clone();
|
|
newlist.append(y.clone());
|
|
Value::List(newlist)
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn append<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::List(list) => {
|
|
let mut newlist = list.clone();
|
|
newlist.push_back(y.clone());
|
|
Value::List(newlist)
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn dec<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::Number(n) => Value::Number(n - 1.0),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn inc<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::Number(n) => Value::Number(n + 1.0),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn div<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x / y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn mult<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x * y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn dissoc<'src>(dict: &Value<'src>, key: &Value<'src>) -> Value<'src> {
|
|
match (dict, key) {
|
|
(Value::Dict(dict), Value::Keyword(key)) => {
|
|
let mut new = dict.clone();
|
|
new.remove(key);
|
|
Value::Dict(new)
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn first<'src>(ordered: &Value<'src>) -> Value<'src> {
|
|
match ordered {
|
|
Value::List(list) => match list.front() {
|
|
Some(n) => n.clone(),
|
|
None => Value::Nil,
|
|
},
|
|
Value::Tuple(tuple) => match tuple.first() {
|
|
Some(n) => n.clone(),
|
|
None => Value::Nil,
|
|
},
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
// TODO: figure out how to handle negative numbers
|
|
// the cast from f64 to usize discards sign info
|
|
pub fn at<'src>(ordered: &Value<'src>, i: &Value<'src>) -> Value<'src> {
|
|
match (ordered, i) {
|
|
(Value::List(list), Value::Number(n)) => {
|
|
let i = *n as usize;
|
|
match list.get(i) {
|
|
Some(n) => n.clone(),
|
|
None => Value::Nil,
|
|
}
|
|
}
|
|
(Value::Tuple(tuple), Value::Number(n)) => {
|
|
let i = *n as usize;
|
|
match tuple.get(i) {
|
|
Some(n) => n.clone(),
|
|
None => Value::Nil,
|
|
}
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn get<'src>(dict: &Value<'src>, key: &Value<'src>) -> Value<'src> {
|
|
match (dict, key) {
|
|
(Value::Dict(dict), Value::Keyword(key)) => match dict.get(key) {
|
|
Some(x) => x.clone(),
|
|
None => Value::Nil,
|
|
},
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn last<'src>(ordered: &Value<'src>) -> Value<'src> {
|
|
match ordered {
|
|
Value::List(list) => match list.last() {
|
|
Some(x) => x.clone(),
|
|
None => Value::Nil,
|
|
},
|
|
Value::Tuple(tuple) => match tuple.last() {
|
|
Some(x) => x.clone(),
|
|
None => Value::Nil,
|
|
},
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn or<'src>(x: &Value<'src>, y: &Value<'src>) -> Value<'src> {
|
|
Value::Boolean(x.bool() || y.bool())
|
|
}
|
|
|
|
pub fn print<'src>(x: &Value<'src>) -> Value<'src> {
|
|
println!("{}", x);
|
|
Value::Keyword("ok")
|
|
}
|
|
|
|
pub fn show<'src>(x: &Value<'src>) -> Value<'src> {
|
|
Value::AllocatedString(Rc::new(format!("{x}")))
|
|
}
|
|
|
|
pub fn rest<'src>(ordered: &Value<'src>) -> Value<'src> {
|
|
match ordered {
|
|
Value::List(list) => Value::List(list.clone().split_at(1).1),
|
|
Value::Tuple(tuple) => Value::List(Vector::from_iter(tuple.iter().next().cloned())),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn count<'src>(coll: &Value<'src>) -> Value<'src> {
|
|
match coll {
|
|
Value::Dict(d) => Value::Number(d.len() as f64),
|
|
Value::List(l) => Value::Number(l.len() as f64),
|
|
Value::Tuple(t) => Value::Number(t.len() as f64),
|
|
Value::AllocatedString(s) => Value::Number(s.len() as f64),
|
|
Value::InternedString(s) => Value::Number(s.len() as f64),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn range<'src>(start: &Value<'src>, end: &Value<'src>) -> Value<'src> {
|
|
match (start, end) {
|
|
(Value::Number(start), Value::Number(end)) => {
|
|
let start = *start as isize;
|
|
let end = *end as isize;
|
|
let mut range = Vector::new();
|
|
for n in start..end {
|
|
range.push_back(Value::Number(n as f64))
|
|
}
|
|
Value::List(range)
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn slice<'src>(ordered: &Value<'src>, start: &Value<'src>, end: &Value<'src>) -> Value<'src> {
|
|
match (ordered, start, end) {
|
|
(Value::List(list), Value::Number(start), Value::Number(end)) => {
|
|
let mut newlist = list.clone();
|
|
let start = std::cmp::max(*start as usize, 0);
|
|
let end = std::cmp::min(*end as usize, list.len());
|
|
Value::List(newlist.slice(start..end))
|
|
}
|
|
// TODO: figure out something better to do than return an empty string on a bad slice
|
|
(Value::AllocatedString(string), Value::Number(start), Value::Number(end)) => {
|
|
let start = std::cmp::max(*start as usize, 0);
|
|
let end = std::cmp::min(*end as usize, string.len());
|
|
Value::AllocatedString(Rc::new(
|
|
string
|
|
.clone()
|
|
.as_str()
|
|
.get(start..end)
|
|
.unwrap_or("")
|
|
.to_string(),
|
|
))
|
|
}
|
|
(Value::InternedString(string), Value::Number(start), Value::Number(end)) => {
|
|
let start = std::cmp::max(*start as usize, 0);
|
|
let end = std::cmp::min(*end as usize, string.len());
|
|
Value::AllocatedString(Rc::new(string.get(start..end).unwrap_or("").to_string()))
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn list<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::List(_) => x.clone(),
|
|
Value::Tuple(t) => Value::List(Vector::from_iter(t.iter().cloned())),
|
|
Value::Dict(d) => {
|
|
let kvs = d.iter();
|
|
let mut list = vector![];
|
|
for (key, value) in kvs {
|
|
let kv = Value::Tuple(Rc::new(vec![Value::Keyword(key), value.clone()]));
|
|
list.push_back(kv);
|
|
}
|
|
Value::List(list)
|
|
}
|
|
_ => Value::List(vector![x.clone()]),
|
|
}
|
|
}
|
|
|
|
pub fn number<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::InternedString(string) => match string.parse::<f64>() {
|
|
Ok(n) => Value::Tuple(Rc::new(vec![Value::Keyword("ok"), Value::Number(n)])),
|
|
Err(_) => Value::Tuple(Rc::new(vec![
|
|
Value::Keyword("err"),
|
|
Value::AllocatedString(Rc::new(format!("could not parse `{string}` as a number"))),
|
|
])),
|
|
},
|
|
Value::AllocatedString(string) => match string.parse::<f64>() {
|
|
Ok(n) => Value::Tuple(Rc::new(vec![Value::Keyword("ok"), Value::Number(n)])),
|
|
Err(_) => Value::Tuple(Rc::new(vec![
|
|
Value::Keyword("err"),
|
|
Value::AllocatedString(Rc::new(format!("could not parse `{string}` as a number"))),
|
|
])),
|
|
},
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn r#type<'src>(x: &Value<'src>) -> Value<'src> {
|
|
match x {
|
|
Value::Nil => Value::Keyword("nil"),
|
|
Value::Number(_) => Value::Keyword("number"),
|
|
Value::Boolean(_) => Value::Keyword("boolean"),
|
|
Value::Keyword(_) => Value::Keyword("keyword"),
|
|
Value::Tuple(_) => Value::Keyword("tuple"),
|
|
Value::InternedString(_) => Value::Keyword("string"),
|
|
Value::AllocatedString(_) => Value::Keyword("string"),
|
|
Value::List(_) => Value::Keyword("list"),
|
|
Value::Dict(_) => Value::Keyword("dict"),
|
|
Value::Fn(_) => Value::Keyword("fn"),
|
|
Value::Box(_, _) => Value::Keyword("box"),
|
|
Value::Placeholder => unreachable!("internal Ludus error"),
|
|
Value::Args(_) => unreachable!("internal Ludus error"),
|
|
Value::Base(_) => Value::Keyword("fn"),
|
|
Value::Recur(..) => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn split<'src>(source: &Value<'src>, splitter: &Value) -> Value<'src> {
|
|
match (source, splitter) {
|
|
(Value::AllocatedString(source), Value::AllocatedString(splitter)) => {
|
|
let parts = source.split_terminator(splitter.as_str());
|
|
let mut list = vector![];
|
|
for part in parts {
|
|
list.push_back(Value::AllocatedString(Rc::new(part.to_string())));
|
|
}
|
|
Value::List(list)
|
|
}
|
|
(Value::AllocatedString(source), Value::InternedString(splitter)) => {
|
|
let parts = source.split_terminator(splitter);
|
|
let mut list = vector![];
|
|
for part in parts {
|
|
list.push_back(Value::AllocatedString(Rc::new(part.to_string())));
|
|
}
|
|
Value::List(list)
|
|
}
|
|
(Value::InternedString(source), Value::AllocatedString(splitter)) => {
|
|
let parts = source.split_terminator(splitter.as_str());
|
|
let mut list = vector![];
|
|
for part in parts {
|
|
list.push_back(Value::AllocatedString(Rc::new(part.to_string())));
|
|
}
|
|
Value::List(list)
|
|
}
|
|
(Value::InternedString(source), Value::InternedString(splitter)) => {
|
|
let parts = source.split_terminator(splitter);
|
|
let mut list = vector![];
|
|
for part in parts {
|
|
list.push_back(Value::AllocatedString(Rc::new(part.to_string())));
|
|
}
|
|
Value::List(list)
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn upcase<'src>(string: &Value<'src>) -> Value<'src> {
|
|
match string {
|
|
Value::AllocatedString(string) => Value::AllocatedString(Rc::new(string.to_uppercase())),
|
|
Value::InternedString(string) => Value::AllocatedString(Rc::new(string.to_uppercase())),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn downcase<'src>(string: &Value<'src>) -> Value<'src> {
|
|
match string {
|
|
Value::AllocatedString(string) => Value::AllocatedString(Rc::new(string.to_lowercase())),
|
|
Value::InternedString(string) => Value::AllocatedString(Rc::new(string.to_lowercase())),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn trim<'src>(string: &Value<'src>) -> Value<'src> {
|
|
match string {
|
|
Value::AllocatedString(string) => {
|
|
Value::AllocatedString(Rc::new(string.trim().to_string()))
|
|
}
|
|
Value::InternedString(string) => Value::AllocatedString(Rc::new(string.trim().to_string())),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn triml<'src>(string: &Value<'src>) -> Value<'src> {
|
|
match string {
|
|
Value::AllocatedString(string) => {
|
|
Value::AllocatedString(Rc::new(string.trim_start().to_string()))
|
|
}
|
|
Value::InternedString(string) => {
|
|
Value::AllocatedString(Rc::new(string.trim_start().to_string()))
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn trimr<'src>(string: &Value<'src>) -> Value<'src> {
|
|
match string {
|
|
Value::AllocatedString(string) => {
|
|
Value::AllocatedString(Rc::new(string.trim_end().to_string()))
|
|
}
|
|
Value::InternedString(string) => {
|
|
Value::AllocatedString(Rc::new(string.trim_end().to_string()))
|
|
}
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn atan_2<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x.atan2(*y)),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn ceil<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.ceil()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn cos<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.cos()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn floor<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.floor()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn random<'src>() -> Value<'src> {
|
|
Value::Number(ran_f64())
|
|
}
|
|
|
|
pub fn round<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.round()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn sin<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.sin()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn sqrt<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.sqrt()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn tan<'src>(x: &Value) -> Value<'src> {
|
|
match x {
|
|
Value::Number(x) => Value::Number(x.tan()),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn gt<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Boolean(x > y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn gte<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Boolean(x >= y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn lt<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Boolean(x < y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn lte<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Boolean(x <= y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn r#mod<'src>(x: &Value, y: &Value) -> Value<'src> {
|
|
match (x, y) {
|
|
(Value::Number(x), Value::Number(y)) => Value::Number(x % y),
|
|
_ => unreachable!("internal Ludus error"),
|
|
}
|
|
}
|
|
|
|
pub fn base<'src>() -> Vec<(String, Value<'src>)> {
|
|
vec![
|
|
("add".to_string(), Value::Base(Base::Binary(add))),
|
|
("and".to_string(), Value::Base(Base::Binary(and))),
|
|
("append".to_string(), Value::Base(Base::Binary(append))),
|
|
("assoc".to_string(), Value::Base(Base::Ternary(assoc))),
|
|
("at".to_string(), Value::Base(Base::Binary(at))),
|
|
("atan_2".to_string(), Value::Base(Base::Binary(atan_2))),
|
|
("bool".to_string(), Value::Base(Base::Unary(r#bool))),
|
|
("ceil".to_string(), Value::Base(Base::Unary(ceil))),
|
|
("chars".to_string(), Value::Base(Base::Unary(chars))),
|
|
("concat".to_string(), Value::Base(Base::Binary(concat))),
|
|
("cos".to_string(), Value::Base(Base::Unary(cos))),
|
|
("count".to_string(), Value::Base(Base::Unary(count))),
|
|
("dec".to_string(), Value::Base(Base::Unary(dec))),
|
|
("dissoc".to_string(), Value::Base(Base::Binary(dissoc))),
|
|
("div".to_string(), Value::Base(Base::Binary(div))),
|
|
("doc!".to_string(), Value::Base(Base::Unary(doc))),
|
|
("downcase".to_string(), Value::Base(Base::Unary(downcase))),
|
|
("eq?".to_string(), Value::Base(Base::Binary(eq))),
|
|
("first".to_string(), Value::Base(Base::Unary(first))),
|
|
("floor".to_string(), Value::Base(Base::Unary(floor))),
|
|
("get".to_string(), Value::Base(Base::Binary(get))),
|
|
("gt?".to_string(), Value::Base(Base::Binary(gt))),
|
|
("gte?".to_string(), Value::Base(Base::Binary(gte))),
|
|
("inc".to_string(), Value::Base(Base::Unary(inc))),
|
|
("last".to_string(), Value::Base(Base::Unary(last))),
|
|
("list".to_string(), Value::Base(Base::Unary(list))),
|
|
("lt?".to_string(), Value::Base(Base::Binary(lt))),
|
|
("lte?".to_string(), Value::Base(Base::Binary(lte))),
|
|
("mod".to_string(), Value::Base(Base::Binary(r#mod))),
|
|
("mult".to_string(), Value::Base(Base::Binary(mult))),
|
|
("number".to_string(), Value::Base(Base::Unary(number))),
|
|
("or".to_string(), Value::Base(Base::Binary(or))),
|
|
("pi".to_string(), Value::Number(std::f64::consts::PI)),
|
|
("print!".to_string(), Value::Base(Base::Unary(print))),
|
|
("random".to_string(), Value::Base(Base::Nullary(random))),
|
|
("range".to_string(), Value::Base(Base::Binary(range))),
|
|
("rest".to_string(), Value::Base(Base::Unary(rest))),
|
|
("round".to_string(), Value::Base(Base::Unary(round))),
|
|
("show".to_string(), Value::Base(Base::Unary(show))),
|
|
("sin".to_string(), Value::Base(Base::Unary(sin))),
|
|
("slice".to_string(), Value::Base(Base::Ternary(slice))),
|
|
("split".to_string(), Value::Base(Base::Binary(split))),
|
|
("sqrt".to_string(), Value::Base(Base::Unary(sqrt))),
|
|
(
|
|
"sqrt_2".to_string(),
|
|
Value::Number(std::f64::consts::SQRT_2),
|
|
),
|
|
("store!".to_string(), Value::Base(Base::Binary(store))),
|
|
("sub".to_string(), Value::Base(Base::Binary(sub))),
|
|
("tan".to_string(), Value::Base(Base::Unary(tan))),
|
|
("trim".to_string(), Value::Base(Base::Unary(trim))),
|
|
("triml".to_string(), Value::Base(Base::Unary(triml))),
|
|
("trimr".to_string(), Value::Base(Base::Unary(trimr))),
|
|
("type".to_string(), Value::Base(Base::Unary(r#type))),
|
|
("unbox".to_string(), Value::Base(Base::Unary(unbox))),
|
|
("upcase".to_string(), Value::Base(Base::Unary(upcase))),
|
|
]
|
|
}
|