aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/ast.rs12
-rw-r--r--src/bidirectional.rs18
-rw-r--r--src/effects.rs19
-rw-r--r--src/lib.rs4
-rw-r--r--src/main.rs2
-rw-r--r--src/parser.rs20
-rw-r--r--src/util.rs37
7 files changed, 42 insertions, 70 deletions
diff --git a/src/ast.rs b/src/ast.rs
index 60e4db9..6b3826a 100644
--- a/src/ast.rs
+++ b/src/ast.rs
@@ -2,7 +2,7 @@ use std::collections::{BTreeMap, HashMap};
pub type Result<T> = core::result::Result<T, Box<dyn std::error::Error>>;
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, PartialEq, Default)]
pub struct Context(HashMap<Identifier, Term>, HashMap<Signature, Expression>);
pub type Identifier = String;
@@ -173,7 +173,7 @@ impl core::fmt::Display for Type {
write!(f, "union[")?;
for (i, val) in data.iter().enumerate() {
write!(f, "{}", val)?;
- if !(i == data.len() - 1) {
+ if i != data.len() - 1 {
write!(f, ", ")?;
}
}
@@ -183,7 +183,7 @@ impl core::fmt::Display for Type {
write!(f, "struct[")?;
for (i, (key, val)) in data.iter().enumerate() {
write!(f, "{}: {}", key, val)?;
- if !(i == data.len() - 1) {
+ if i != data.len() - 1 {
write!(f, ", ")?;
}
}
@@ -196,7 +196,7 @@ impl core::fmt::Display for Type {
Some(key) => write!(f, "{}: {}", key, val)?,
None => write!(f, "{}", val)?
}
- if !(i == data.len() - 1) {
+ if i != data.len() - 1 {
write!(f, ", ")?;
}
}
@@ -207,7 +207,7 @@ impl core::fmt::Display for Type {
write!(f, "interface[")?;
for (i, sig) in data.iter().enumerate() {
write!(f, "func {}({}): {}", sig.name, sig.from, sig.to)?;
- if !(i == data.len() - 1) {
+ if i != data.len() - 1 {
write!(f, ", ")?;
}
}
@@ -222,7 +222,7 @@ impl core::fmt::Display for Type {
if let Some(data) = data {
for (i, kind) in data.iter().enumerate() {
write!(f, "{}", kind)?;
- if !(i == data.len() - 1) {
+ if i != data.len() - 1 {
write!(f, ", ")?;
}
}
diff --git a/src/bidirectional.rs b/src/bidirectional.rs
index 4e69372..272ccab 100644
--- a/src/bidirectional.rs
+++ b/src/bidirectional.rs
@@ -7,20 +7,20 @@ impl Context {
// fall through to inference mode
Expression::Annotation { expr, kind } => {
let result = self.infer(Expression::Annotation { expr, kind })?;
- return match self.subtype(&result, &target) {
+ match self.subtype(&result, target) {
true => Ok(()),
false => Err(format!("inferred type {result} does not match target {target}").into())
}
},
// Bt-CheckInfer
- Expression::Constant { term } => match self.subtype(&term.convert()?, &target) {
+ Expression::Constant { term } => match self.subtype(&term.convert()?, target) {
true => Ok(()),
false => Err(format!("constant is of wrong type, expected {target}").into())
// false => Ok(()) // all our constants are Empty for now
},
// Bt-CheckInfer
Expression::Variable { id } => match self.get_term(&id) {
- Some(term) if self.subtype(&term.convert()?, &target) => Ok(()),
+ Some(term) if self.subtype(&term.convert()?, target) => Ok(()),
Some(_) => Err(format!("variable {id} is of wrong type").into()),
None => Err(format!("failed to find variable {id} in context").into())
},
@@ -29,14 +29,14 @@ impl Context {
Type::Function(from, to) => {
let mut context = self.clone();
context.insert_term(param, from.default()?);
- return context.check(*func, &to);
+ return context.check(*func, to);
},
_ => Err(format!("attempting to check an abstraction with a non-function type {target}").into())
},
// fall through to inference mode
Expression::Application { func, arg } => {
let result = &self.infer(Expression::Application { func, arg })?;
- return match self.subtype(result, target) {
+ match self.subtype(result, target) {
true => Ok(()),
false => Err(format!("inferred type {result} does not match {target}").into())
}
@@ -44,9 +44,9 @@ impl Context {
// T-If
Expression::Conditional { if_cond, if_then, if_else } => {
self.check(*if_cond, &Type::Boolean)?;
- self.check(*if_then, &target)?;
- self.check(*if_else, &target)?;
- return Ok(());
+ self.check(*if_then, target)?;
+ self.check(*if_else, target)?;
+ Ok(())
}
}
}
@@ -65,7 +65,7 @@ impl Context {
},
// Bt-App
Expression::Application { func, arg } => match self.infer(*func)? {
- Type::Function(from, to) => self.check(*arg, &*from).map(|x| *to),
+ Type::Function(from, to) => self.check(*arg, &from).map(|x| *to),
_ => Err("application abstraction is not a function type".into())
},
// inference from an abstraction is always an error
diff --git a/src/effects.rs b/src/effects.rs
deleted file mode 100644
index 4c4c110..0000000
--- a/src/effects.rs
+++ /dev/null
@@ -1,19 +0,0 @@
-// Simple types for effects
-
-use crate::ast::*;
-
-// bad and wrong and useless
-pub struct Effection {
- expr: Expression,
- effect: Effect,
-}
-
-// yeah i'm not dealing with this yet
-pub enum Effect {
- Empty,
- Total,
- Exn,
- Pure,
- IO,
-}
-
diff --git a/src/lib.rs b/src/lib.rs
index 372d8d9..b0098a6 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,10 +1,8 @@
-#![allow(unused_variables, non_upper_case_globals)]
+#![allow(unused_variables, non_upper_case_globals, clippy::iter_nth_zero)]
#![feature(let_chains)]
pub mod ast;
pub mod bidirectional;
-// pub mod classes;
-// pub mod effects;
pub mod parser;
pub mod util;
pub mod simple;
diff --git a/src/main.rs b/src/main.rs
index b93e778..efcefc1 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -2,8 +2,6 @@ use std::io::{Write, stdout, stdin};
use chrysanthemum::*;
use chrysanthemum::ast::*;
-use chrysanthemum::bidirectional::*;
-use chrysanthemum::simple::*;
fn main() {
println!("chrysanthemum");
diff --git a/src/parser.rs b/src/parser.rs
index 9051bfb..7d3ca65 100644
--- a/src/parser.rs
+++ b/src/parser.rs
@@ -19,8 +19,8 @@ pub fn parse_lambda(input: &str) -> Result<Expression> {
rule num() -> Expression = p:"-"? c:['0'..='9']+ {
let value = c.iter().collect::<String>().parse::<usize>().unwrap();
Expression::Constant {
- term: if let Some(_) = p {
- Term::Integer(-1 * isize::try_from(value).unwrap())
+ term: if p.is_some() {
+ Term::Integer(-isize::try_from(value).unwrap())
} else {
Term::Natural(value)
}
@@ -98,14 +98,14 @@ pub fn parse_lambda(input: &str) -> Result<Expression> {
}
}
}
- return Ok(lambda::expr(input.trim())?);
+ Ok(lambda::expr(input.trim())?)
}
const operators: [char; 17] =
['=', '+', '-', '*', '/', '<', '>', '@', '$', '~', '&', '%', '|', '!', '?', '^', '\\'];
const brackets: [char; 6] = ['(', ')', '{', '}', '[', ']'];
const special: [char; 7] = ['.', ',', ':', ';', '`', '\'', '"'];
-const keywords: [&'static str; 3] = ["if", "else", "func"];
+const keywords: [&str; 3] = ["if", "else", "func"];
pub enum Token {
Operator(String),
@@ -148,7 +148,7 @@ pub fn lex(input: &str) -> Result<Vec<Token>> {
match state {
State::Default => match c {
' ' if indent.blank => indent.count += 1,
- ' ' if buffer.len() > 0 => {
+ ' ' if !buffer.is_empty() => {
result.push(parse_token(&buffer)?);
buffer.clear();
},
@@ -206,7 +206,7 @@ pub fn lex(input: &str) -> Result<Vec<Token>> {
buffer.clear();
},
_ if brackets.contains(&c) || special.contains(&c) => {
- if buffer.len() > 0 {
+ if !buffer.is_empty() {
result.push(parse_token(&buffer)?);
buffer.clear();
}
@@ -284,7 +284,7 @@ pub fn lex(input: &str) -> Result<Vec<Token>> {
},
}
}
- return Ok(result);
+ Ok(result)
}
fn parse_token(token: &str) -> Result<Token> {
@@ -307,7 +307,7 @@ fn is_operator(token: &str) -> bool {
return false;
}
}
- return true;
+ true
}
fn is_value(token: &str) -> bool {
@@ -321,7 +321,7 @@ fn is_value(token: &str) -> bool {
return false;
}
}
- return true;
+ true
}
fn is_identifier(token: &str) -> bool {
@@ -335,5 +335,5 @@ fn is_identifier(token: &str) -> bool {
return false;
}
}
- return true;
+ true
}
diff --git a/src/util.rs b/src/util.rs
index 1962fb4..a575e27 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -7,53 +7,48 @@ use crate::ast::*;
pub fn unique_ident(count: &mut u8) -> String {
*count += 1;
if *count == 0 {
- panic!("we've overflowed!");
+ panic!("we've overflowed!")
} else {
- return String::from(format!("{:X}", count));
+ format!("{:X}", count)
}
}
pub fn Ann(expr: Expression, kind: Type) -> Expression {
- return Expression::Annotation {
- expr: Box::new(expr),
- kind: kind
- };
+ Expression::Annotation { expr: Box::new(expr), kind }
}
pub fn Const(term: Term) -> Expression {
- return Expression::Constant { term };
+ Expression::Constant { term }
}
pub fn Var(id: &str) -> Expression {
- return Expression::Variable {
- id: String::from(id)
- };
+ Expression::Variable { id: String::from(id) }
}
pub fn Abs(param: &str, func: Expression) -> Expression {
- return Expression::Abstraction {
+ Expression::Abstraction {
param: String::from(param),
- func: Box::new(func),
- };
+ func: Box::new(func)
+ }
}
pub fn App(func: Expression, arg: Expression) -> Expression {
- return Expression::Application {
+ Expression::Application {
func: Box::new(func),
arg: Box::new(arg)
- };
+ }
}
pub fn Cond(if_cond: Expression, if_then: Expression, if_else: Expression) -> Expression {
- return Expression::Conditional {
+ Expression::Conditional {
if_cond: Box::new(if_cond),
if_then: Box::new(if_then),
if_else: Box::new(if_else)
- };
+ }
}
pub fn Func(from: Type, to: Type) -> Type {
- return Type::Function(Box::new(from), Box::new(to))
+ Type::Function(Box::new(from), Box::new(to))
}
pub const Empty: Type = Type::Empty;
@@ -64,13 +59,13 @@ pub const Nat: Type = Type::Natural;
pub const Int: Type = Type::Integer;
pub fn Float(term: f32) -> Term {
- return Term::Float(term)
+ Term::Float(term)
}
pub fn Str(data: &str) -> Term {
- return Term::String(data.into())
+ Term::String(data.into())
}
pub fn Union(data: Term) -> Term {
- return Term::Union(Box::new(data))
+ Term::Union(Box::new(data))
}