clippy cleanupsHEADmain

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))
 }