AbleScript
/
ablescript
3
4
Fork 1
Code Issues Pull Requests Projects Releases 7 Wiki Activity

Removed Booleans 

We have Abooleans (where Always = true, Never = false), so why to duplicate stuff?

This PR was lying around unmerged for quite some time, merged without review.
pull/7/head
ondra05 2022-04-01 23:37:10 +00:00
parent 7cc456ee40 6cfd26dcc2
commit bd05ceb086
5 changed files with 36 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

59
ablescript/src/base_55.rs
View File

@ -1,62 +1,13 @@
pub fn char2num(character: char) -> isize {
match character {
'Z' => -26,
'Y' => -25,
'X' => -24,
'W' => -23,
'V' => -22,
'U' => -210,
'T' => -20,
'R' => -18,
'S' => -19,
'Q' => -17,
'P' => -16,
'O' => -15,
'N' => -14,
'M' => -13,
'L' => -12,
'K' => -11,
'J' => -10,
'I' => -9,
'H' => -8,
'G' => -7,
'F' => -6,
'E' => -5,
'D' => -4,
'C' => -3,
'B' => -2,
'A' => -1,
pub fn char2num(c: char) -> isize {
match c {
' ' => 0,
'a' => 1,
'b' => 2,
'c' => 3,
'd' => 4,
'e' => 5,
'f' => 6,
'g' => 7,
'h' => 8,
'i' => 9,
'j' => 10,
'k' => 11,
'l' => 12,
'm' => 13,
'n' => 14,
'o' => 15,
'p' => 16,
'q' => 17,
'r' => 18,
's' => 19,
't' => 20,
'u' => 21,
'v' => 22,
'w' => 23,
'x' => 24,
'y' => 25,
'z' => 26,
// NOTE(Able): Why does it jump to 53 here? MY REASONS ARE BEYOND YOUR UNDERSTANDING MORTAL
'/' => 53,
'\\' => 54,
'.' => 55,
'U' => -210,
'A'..='Z' => 0 - (c as isize) + 64,
'a'..='z' => (c as isize) - 96,
_ => 0,
}
}

2
ablescript/src/consts.rs
View File

@ -31,8 +31,6 @@ pub fn ablescript_consts() -> HashMap<String, Variable> {
("OCTOTHORPE", Str("#".to_owned())), // It's an octothorpe
("ANSWER", Int(ANSWER)),
("nul", Nul),
("true", Bool(true)),
("false", Bool(false)),
("always", Abool(crate::variables::Abool::Always)),
("sometimes", Abool(crate::variables::Abool::Sometimes)),
("never", Abool(crate::variables::Abool::Never)),

23
ablescript/src/interpret.rs
View File

@ -164,10 +164,10 @@ impl ExecEnv {
Subtract => lhs - rhs,
Multiply => lhs * rhs,
Divide => lhs / rhs,
Greater => Value::Bool(lhs > rhs),
Less => Value::Bool(lhs < rhs),
Equal => Value::Bool(lhs == rhs),
NotEqual => Value::Bool(lhs != rhs),
Greater => Value::Abool((lhs > rhs).into()),
Less => Value::Abool((lhs < rhs).into()),
Equal => Value::Abool((lhs == rhs).into()),
NotEqual => Value::Abool((lhs != rhs).into()),
}
}
Not(expr) => !self.eval_expr(expr)?,
@ -249,7 +249,7 @@ impl ExecEnv {
);
}
StmtKind::If { cond, body } => {
if self.eval_expr(cond)?.into_bool() {
if self.eval_expr(cond)?.into_abool().to_bool() {
return self.eval_stmts_hs(&body.block, true);
}
}
@ -459,10 +459,7 @@ impl ExecEnv {
Ok(())
}
fn deinterlace(
args: &[ValueRef],
arities: (usize, usize),
) -> (Vec<ValueRef>, Vec<ValueRef>) {
fn deinterlace(args: &[ValueRef], arities: (usize, usize)) -> (Vec<ValueRef>, Vec<ValueRef>) {
let n_alternations = usize::min(arities.0, arities.1);
let (extra_l, extra_r) = match Ord::cmp(&arities.0, &arities.1) {
Ordering::Less => (0, arities.1 - arities.0),
@ -630,8 +627,10 @@ mod tests {
#[test]
fn type_coercions() {
// The sum of an integer and a boolean causes a boolean
// The sum of an integer and an aboolean causes an aboolean
// coercion.
use crate::variables::Abool;
let env = ExecEnv::new();
assert_eq!(
env.eval_expr(&Expr {
@ -641,7 +640,7 @@ mod tests {
span: 1..1,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Bool(true)),
kind: ExprKind::Literal(Value::Abool(Abool::Always)),
span: 1..1,
}),
kind: crate::ast::BinOpKind::Add,
@ -752,7 +751,7 @@ mod tests {
let mut env = ExecEnv::new();
eval(
&mut env,
"var foo = 1; foo = 2; if (true) { var foo = 3; foo = 4; }",
"var foo = 1; foo = 2; if (always) { var foo = 3; foo = 4; }",
)
.unwrap();

2
ablescript/src/parser.rs
View File

@ -639,7 +639,7 @@ mod tests {
span: 4..5,
}),
rhs: Box::new(Expr {
kind: ExprKind::Literal(Value::Abool(crate::variables::Abool::Always)),
kind: ExprKind::Variable("always".to_owned()),
span: 9..15,
}),
kind: BinOpKind::Equal,

85
ablescript/src/variables.rs
View File

@ -21,6 +21,15 @@ pub enum Abool {
Always = 1,
}
impl Abool {
pub fn to_bool(&self) -> bool {
match self {
Self::Always => true,
Self::Sometimes if rand::random() => true,
_ => false,
}
}
}
impl Display for Abool {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
@ -31,12 +40,12 @@ impl Display for Abool {
}
}
impl From<Abool> for bool {
fn from(val: Abool) -> Self {
match val {
Abool::Never => false,
Abool::Always => true,
Abool::Sometimes => rand::thread_rng().gen(), // NOTE(Able): This is amazing and should be applied anywhere abooleans exist
impl From<bool> for Abool {
fn from(b: bool) -> Self {
if b {
Abool::Always
} else {
Abool::Never
}
}
}
@ -135,7 +144,6 @@ pub enum Value {
Nul,
Str(String),
Int(isize),
Bool(bool),
Abool(Abool),
Functio(Functio),
Cart(Cart),
@ -154,7 +162,6 @@ impl Hash for Value {
Value::Nul => (),
Value::Str(v) => v.hash(state),
Value::Int(v) => v.hash(state),
Value::Bool(v) => v.hash(state),
Value::Abool(v) => v.to_string().hash(state),
Value::Functio(statements) => statements.hash(state),
Value::Cart(_) => self.to_string().hash(state),
@ -178,7 +185,6 @@ impl Value {
pub fn into_isize(self) -> isize {
match self {
Value::Abool(a) => a as _,
Value::Bool(b) => b as _,
Value::Functio(f) => match f {
Functio::Bf {
instructions,
@ -215,51 +221,21 @@ impl Value {
}
}
/// Coerce a value to a boolean.
pub fn into_bool(self) -> bool {
match self {
Value::Abool(b) => b.into(),
Value::Bool(b) => b,
Value::Functio(_) => true,
Value::Int(x) => x != 0,
Value::Nul => false,
Value::Str(s) => match s.to_lowercase().as_str() {
"false" | "no" | "🇳🇴" => false,
"true" | "yes" => true,
s => !s.is_empty(),
},
Value::Cart(c) => !c.is_empty(),
}
}
/// Coerce a value to an aboolean.
pub fn into_abool(self) -> Abool {
match self {
Value::Nul => Abool::Never,
Value::Str(s) => match s.to_lowercase().as_str() {
"never" => Abool::Never,
"never" | "no" | "🇳🇴" => Abool::Never,
"sometimes" => Abool::Sometimes,
"always" => Abool::Always,
s => {
if s.is_empty() {
Abool::Never
} else {
Abool::Always
}
}
"always" | "yes" => Abool::Always,
s => (!s.is_empty()).into(),
},
Value::Int(x) => match x.cmp(&0) {
std::cmp::Ordering::Less => Abool::Never,
std::cmp::Ordering::Equal => Abool::Sometimes,
std::cmp::Ordering::Greater => Abool::Always,
},
Value::Bool(b) => {
if b {
Abool::Always
} else {
Abool::Never
}
}
Value::Abool(a) => a,
Value::Functio(f) => match f {
Functio::Bf {
@ -282,7 +258,7 @@ impl Value {
Value::Int((params + body) % 3 - 1).into_abool()
}
Functio::Builtin(b) => Value::Bool(b.fn_addr() % b.arity == 0).into_abool(),
Functio::Builtin(b) => (b.fn_addr() % b.arity == 0).into(),
Functio::Chain { functios, kind } => {
let (lhs, rhs) = *functios;
match kind {
@ -328,14 +304,6 @@ impl Value {
},
tape_len: crate::brian::DEFAULT_TAPE_SIZE_LIMIT,
},
Value::Bool(b) => Functio::Eval(
if b {
r#"loop{"Buy Able products!"print;}"#
} else {
""
}
.to_owned(),
),
Value::Abool(a) => Functio::Eval(match a {
Abool::Never => "".to_owned(),
Abool::Sometimes => {
@ -388,7 +356,6 @@ impl Value {
})
.collect(),
Value::Int(i) => Value::Str(i.to_string()).into_cart(),
Value::Bool(b) => Value::Str(b.to_string()).into_cart(),
Value::Abool(a) => Value::Str(a.to_string()).into_cart(),
Value::Functio(f) => match f {
Functio::Able { params, body } => {
@ -487,8 +454,6 @@ impl Value {
Value::Nul => 0,
Value::Str(s) => s.len() as _,
Value::Int(i) => i.count_zeros() as _,
Value::Bool(b) if *b => -2,
Value::Bool(_) => 2,
Value::Abool(a) => match a {
Abool::Never => -3,
Abool::Sometimes => {
@ -541,14 +506,12 @@ impl ops::Add for Value {
Value::Nul => Value::Nul,
Value::Str(_) => Value::Str(self.to_string()) + rhs,
Value::Int(_) => Value::Int(self.into_isize()) + rhs,
Value::Bool(_) => Value::Bool(self.into_bool()) + rhs,
Value::Abool(_) => Value::Abool(self.into_abool()) + rhs,
Value::Functio(_) => Value::Functio(self.into_functio()) + rhs,
Value::Cart(_) => Value::Cart(self.into_cart()) + rhs,
},
Value::Str(s) => Value::Str(format!("{s}{rhs}")),
Value::Int(i) => Value::Int(i.wrapping_add(rhs.into_isize())),
Value::Bool(b) => Value::Bool(b || rhs.into_bool()),
Value::Abool(_) => {
Value::Abool(Value::Int(self.into_isize().max(rhs.into_isize())).into_abool())
}
@ -572,14 +535,12 @@ impl ops::Sub for Value {
Value::Nul => Value::Nul,
Value::Str(_) => Value::Str(self.to_string()) - rhs,
Value::Int(_) => Value::Int(self.into_isize()) - rhs,
Value::Bool(_) => Value::Bool(self.into_bool()) - rhs,
Value::Abool(_) => Value::Abool(self.into_abool()) - rhs,
Value::Functio(_) => Value::Functio(self.into_functio()) - rhs,
Value::Cart(_) => Value::Cart(self.into_cart()) - rhs,
},
Value::Str(s) => Value::Str(s.replace(&rhs.to_string(), "")),
Value::Int(i) => Value::Int(i.wrapping_sub(rhs.into_isize())),
Value::Bool(b) => Value::Bool(b ^ rhs.into_bool()),
Value::Abool(_) => (self.clone() + rhs.clone()) * !(self * rhs),
Value::Functio(f) => Value::Functio(match f {
Functio::Bf {
@ -691,14 +652,12 @@ impl ops::Mul for Value {
Value::Nul => Value::Nul,
Value::Str(_) => Value::Str(self.to_string()) * rhs,
Value::Int(_) => Value::Int(self.into_isize()) * rhs,
Value::Bool(_) => Value::Bool(self.into_bool()) * rhs,
Value::Abool(_) => Value::Abool(self.into_abool()) * rhs,
Value::Functio(_) => Value::Functio(self.into_functio()) * rhs,
Value::Cart(_) => Value::Cart(self.into_cart()) * rhs,
},
Value::Str(s) => Value::Str(s.repeat(rhs.into_isize() as usize)),
Value::Int(i) => Value::Int(i.wrapping_mul(rhs.into_isize())),
Value::Bool(b) => Value::Bool(b && rhs.into_bool()),
Value::Abool(_) => {
Value::Abool(Value::Int(self.into_isize().min(rhs.into_isize())).into_abool())
}
@ -734,7 +693,6 @@ impl ops::Div for Value {
Value::Nul => Value::Nul,
Value::Str(_) => Value::Str(self.to_string()) / rhs,
Value::Int(_) => Value::Int(self.into_isize()) / rhs,
Value::Bool(_) => Value::Bool(self.into_bool()) / rhs,
Value::Abool(_) => Value::Abool(self.into_abool()) / rhs,
Value::Functio(_) => Value::Functio(self.into_functio()) / rhs,
Value::Cart(_) => Value::Cart(self.into_cart()) / rhs,
@ -754,7 +712,6 @@ impl ops::Div for Value {
0 => consts::ANSWER,
x => x,
})),
Value::Bool(b) => Value::Bool(!b || rhs.into_bool()),
Value::Abool(_) => !self + rhs,
Value::Functio(f) => Value::Functio(match f {
Functio::Bf {
@ -832,7 +789,6 @@ impl ops::Not for Value {
Value::Nul => Value::Nul,
Value::Str(s) => Value::Str(s.chars().rev().collect()),
Value::Int(i) => Value::Int(i.swap_bytes()),
Value::Bool(b) => Value::Bool(!b),
Value::Abool(a) => Value::Abool(match a {
Abool::Never => Abool::Always,
Abool::Sometimes => Abool::Sometimes,
@ -895,7 +851,6 @@ impl PartialEq for Value {
Value::Nul => matches!(other, Value::Nul),
Value::Str(s) => *s == other.to_string(),
Value::Int(i) => *i == other.into_isize(),
Value::Bool(b) => *b == other.into_bool(),
Value::Abool(a) => *a == other.into_abool(),
Value::Functio(f) => *f == other.into_functio(),
Value::Cart(c) => *c == other.into_cart(),
@ -920,7 +875,6 @@ impl PartialOrd for Value {
}
Value::Str(s) => Some(s.cmp(&other.to_string())),
Value::Int(i) => Some(i.cmp(&other.into_isize())),
Value::Bool(b) => Some(b.cmp(&other.into_bool())),
Value::Abool(a) => a.partial_cmp(&other.into_abool()),
Value::Functio(_) => self.clone().into_isize().partial_cmp(&other.into_isize()),
Value::Cart(c) => Some(c.len().cmp(&other.into_cart().len())),
@ -934,7 +888,6 @@ impl Display for Value {
Value::Nul => write!(f, "nul"),
Value::Str(v) => write!(f, "{}", v),
Value::Int(v) => write!(f, "{}", v),
Value::Bool(v) => write!(f, "{}", v),
Value::Abool(v) => write!(f, "{}", v),
Value::Functio(v) => match v {
Functio::Bf {