diff --git a/Cargo.toml b/Cargo.toml
index 1d4db82..a848b85 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,8 +1,3 @@
-[package]
-name = "benda"
-version = "0.1.0"
-edition = "2021"
-
 [workspace]
 resolver = "2"
 members = ["crates/*"]
diff --git a/crates/benda/src/benda_ffi/mod.rs b/crates/benda/src/benda_ffi/mod.rs
index 854d336..072b2e4 100644
--- a/crates/benda/src/benda_ffi/mod.rs
+++ b/crates/benda/src/benda_ffi/mod.rs
@@ -1,15 +1,23 @@
-use bend::{
-    diagnostics::{ Diagnostics, DiagnosticsConfig },
-    fun::{ Book, Term },
-    CompileOpts,
-    RunOpts,
-};
+use bend::diagnostics::{Diagnostics, DiagnosticsConfig};
+use bend::fun::{Book, Term};
+use bend::{CompileOpts, RunOpts};
 
 pub fn run(book: &Book) -> Option<(Term, String, Diagnostics)> {
-    let run_opts = RunOpts { linear_readback: false, pretty: false };
+    let run_opts = RunOpts {
+        linear_readback: false,
+        pretty: false,
+    };
     let compile_opts = CompileOpts::default();
     let diagnostics_cfg = DiagnosticsConfig::default();
     let args = None;
 
-    bend::run_book(book.clone(), run_opts, compile_opts, diagnostics_cfg, args, "run-c").unwrap()
+    bend::run_book(
+        book.clone(),
+        run_opts,
+        compile_opts,
+        diagnostics_cfg,
+        args,
+        "run-c",
+    )
+    .unwrap()
 }
diff --git a/crates/benda/src/lib.rs b/crates/benda/src/lib.rs
index de395a8..df9f778 100644
--- a/crates/benda/src/lib.rs
+++ b/crates/benda/src/lib.rs
@@ -1,11 +1,12 @@
 use num_traits::ToPrimitive;
 use parser::Parser;
-use pyo3::{ prelude::*, types::{ PyFunction, PyString, PyTuple } };
-use rustpython_parser::{ parse, Mode };
+use pyo3::prelude::*;
+use pyo3::types::{PyFunction, PyString, PyTuple};
+use rustpython_parser::{parse, Mode};
 use types::u24::u24;
-mod types;
-mod parser;
 mod benda_ffi;
+mod parser;
+mod types;
 
 #[pyfunction]
 fn sum_as_string(a: usize, b: usize) -> PyResult<String> {
@@ -21,25 +22,31 @@ fn switch() -> PyResult<String> {
 fn bjit(fun: Bound<PyFunction>, py: Python) -> PyResult<Py<PyAny>> {
     let arg_names_temp: Bound<PyAny>;
 
-    let (name, filename, arg_names, argcount) = match fun.clone().downcast::<PyFunction>() {
-        Ok(inner) => {
-            let name = inner.getattr("__name__").unwrap();
-            let code = inner.getattr("__code__").unwrap();
-            let filename = code.getattr("co_filename").unwrap();
+    let (name, filename, arg_names, argcount) =
+        match fun.clone().downcast::<PyFunction>() {
+            Ok(inner) => {
+                let name = inner.getattr("__name__").unwrap();
+                let code = inner.getattr("__code__").unwrap();
+                let filename = code.getattr("co_filename").unwrap();
 
-            arg_names_temp = code.getattr("co_varnames").unwrap();
-            let arg_names = arg_names_temp.downcast::<PyTuple>().unwrap();
-            let argcount = code.getattr("co_argcount").unwrap().to_string().parse::<u32>().unwrap();
+                arg_names_temp = code.getattr("co_varnames").unwrap();
+                let arg_names = arg_names_temp.downcast::<PyTuple>().unwrap();
+                let argcount = code
+                    .getattr("co_argcount")
+                    .unwrap()
+                    .to_string()
+                    .parse::<u32>()
+                    .unwrap();
 
-            (name, filename, arg_names, argcount)
-        }
-        Err(_) => todo!(),
-    };
+                (name, filename, arg_names, argcount)
+            }
+            Err(_) => todo!(),
+        };
 
     let code = std::fs::read_to_string(filename.to_string()).unwrap();
     let module = parse(code.as_str(), Mode::Module, "main.py").unwrap();
 
-    let mut arg_list: Vec<String> = vec!();
+    let mut arg_list: Vec<String> = vec![];
 
     for (index, arg) in arg_names.iter().enumerate() {
         if index >= argcount.to_usize().unwrap() {
@@ -54,11 +61,14 @@ fn bjit(fun: Bound<PyFunction>, py: Python) -> PyResult<Py<PyAny>> {
     match module {
         rustpython_parser::ast::Mod::Module(mods) => {
             for stmt in mods.body.iter() {
-                if let rustpython_parser::ast::Stmt::FunctionDef(fun_def) = stmt {
+                if let rustpython_parser::ast::Stmt::FunctionDef(fun_def) = stmt
+                {
                     if fun_def.name == name.to_string() {
                         let mut parser = Parser::new(mods.body.clone(), 0);
-                        let return_val = parser.parse(fun_def.name.as_ref(), &arg_list);
-                        val = Some(PyString::new_bound(py, return_val.as_str()));
+                        let return_val =
+                            parser.parse(fun_def.name.as_ref(), &arg_list);
+                        val =
+                            Some(PyString::new_bound(py, return_val.as_str()));
                     }
                 }
             }
@@ -68,13 +78,18 @@ fn bjit(fun: Bound<PyFunction>, py: Python) -> PyResult<Py<PyAny>> {
 
     let fun: Py<PyAny> = PyModule::from_code_bound(
         py,
-        format!("def test({}):
-            return {}", "tree", val.clone().unwrap()).as_str(),
+        format!(
+            "def test({}):
+            return {}",
+            "tree",
+            val.clone().unwrap()
+        )
+        .as_str(),
+        "",
         "",
-        ""
     )?
-        .getattr("test")?
-        .into();
+    .getattr("test")?
+    .into();
 
     Ok(fun)
 }
diff --git a/crates/benda/src/main.rs b/crates/benda/src/main.rs
index dd4703d..5b76290 100644
--- a/crates/benda/src/main.rs
+++ b/crates/benda/src/main.rs
@@ -2,8 +2,7 @@ mod parser;
 
 use parser::Parser;
 use pyo3::prelude::*;
-
-use rustpython_parser::{ parse, Mode };
+use rustpython_parser::{parse, Mode};
 
 mod benda_ffi;
 
diff --git a/crates/benda/src/parser/mod.rs b/crates/benda/src/parser/mod.rs
index 4e18cde..670fa9a 100644
--- a/crates/benda/src/parser/mod.rs
+++ b/crates/benda/src/parser/mod.rs
@@ -2,18 +2,17 @@
 use core::panic;
 use std::vec;
 
-use bend::{ fun::{ Adt, Book, CtrField, Name, Op, STRINGS }, imp::{ self, Expr, MatchArm, Stmt } };
+use bend::fun::{Adt, Book, CtrField, Name, Op, STRINGS};
+use bend::imp::{self, Expr, MatchArm, Stmt};
 use indexmap::IndexMap;
-use rustpython_parser::{ ast::{ located, ExprBinOp, StmtAssign, StmtMatch }, text_size::TextRange };
-
-use rustpython_parser::ast::Expr as rExpr;
-use rustpython_parser::ast::Stmt as rStmt;
-use rustpython_parser::ast::CmpOp as rCmpOp;
-use rustpython_parser::ast::Operator as rOperator;
-use rustpython_parser::ast::Pattern as rPattern;
+use num_traits::cast::ToPrimitive;
+use rustpython_parser::ast::{
+    located, CmpOp as rCmpOp, Expr as rExpr, ExprBinOp, Operator as rOperator,
+    Pattern as rPattern, Stmt as rStmt, StmtAssign, StmtMatch,
+};
+use rustpython_parser::text_size::TextRange;
 
 use crate::benda_ffi::run;
-use num_traits::cast::ToPrimitive;
 
 #[derive(Clone, Debug)]
 enum FromExpr {
@@ -24,7 +23,11 @@ enum FromExpr {
 
 impl FromExpr {
     pub fn get_var_name(&self) -> Option<Name> {
-        if let FromExpr::Expr(Expr::Var { nam }) = self { Some(nam.clone()) } else { None }
+        if let FromExpr::Expr(Expr::Var { nam }) = self {
+            Some(nam.clone())
+        } else {
+            None
+        }
     }
 }
 
@@ -61,16 +64,18 @@ impl Parser {
     fn parse_expr_type(&self, expr: rExpr<TextRange>) -> Option<FromExpr> {
         match expr {
             rExpr::Attribute(att) => {
-                if let Some(lib) = self.parse_expr_type(*att.value).unwrap().get_var_name() {
+                if let Some(lib) =
+                    self.parse_expr_type(*att.value).unwrap().get_var_name()
+                {
                     let fun = att.attr.to_string();
                     if lib.to_string() == "benda" && fun == "switch" {
-                        return Some(
-                            FromExpr::Expr(Expr::Call {
-                                fun: Box::new(Expr::Var { nam: Name::new("switch") }),
-                                args: vec!(),
-                                kwargs: vec!(),
-                            })
-                        );
+                        return Some(FromExpr::Expr(Expr::Call {
+                            fun: Box::new(Expr::Var {
+                                nam: Name::new("switch"),
+                            }),
+                            args: vec![],
+                            kwargs: vec![],
+                        }));
                     }
                 }
                 None
@@ -94,45 +99,43 @@ impl Parser {
                     rCmpOp::NotIn => todo!(),
                 };
 
-                if let (FromExpr::Expr(left), FromExpr::Expr(right)) = (left, right) {
-                    return Some(
-                        FromExpr::Expr(Expr::Bin {
-                            op,
-                            lhs: Box::new(left),
-                            rhs: Box::new(right),
-                        })
-                    );
+                if let (FromExpr::Expr(left), FromExpr::Expr(right)) =
+                    (left, right)
+                {
+                    return Some(FromExpr::Expr(Expr::Bin {
+                        op,
+                        lhs: Box::new(left),
+                        rhs: Box::new(right),
+                    }));
                 }
                 None
             }
-            rExpr::BinOp(bin_op) => { self.parse_bin_op(bin_op) }
-            rExpr::Constant(c) => {
-                match c.value {
-                    located::Constant::None => todo!(),
-                    located::Constant::Bool(_) => todo!(),
-                    located::Constant::Str(str) => {
-                        let nam = Name::new(str.clone());
-                        let adt = self.book.adts.get(&nam);
-
-                        if let Some(_adt) = adt {
-                            return Some(FromExpr::Expr(imp::Expr::Var { nam }));
-                        }
-                        Some(FromExpr::Expr(Expr::Str { val: STRINGS.get(str.as_str()) }))
-                    }
-                    located::Constant::Bytes(_) => todo!(),
-                    located::Constant::Int(val) => {
-                        Some(
-                            FromExpr::Expr(imp::Expr::Num {
-                                val: bend::fun::Num::U24(val.to_u32().unwrap()),
-                            })
-                        )
+            rExpr::BinOp(bin_op) => self.parse_bin_op(bin_op),
+            rExpr::Constant(c) => match c.value {
+                located::Constant::None => todo!(),
+                located::Constant::Bool(_) => todo!(),
+                located::Constant::Str(str) => {
+                    let nam = Name::new(str.clone());
+                    let adt = self.book.adts.get(&nam);
+
+                    if let Some(_adt) = adt {
+                        return Some(FromExpr::Expr(imp::Expr::Var { nam }));
                     }
-                    located::Constant::Tuple(_) => todo!(),
-                    located::Constant::Float(_) => todo!(),
-                    located::Constant::Complex { real: _, imag: _ } => todo!(),
-                    located::Constant::Ellipsis => todo!(),
+                    Some(FromExpr::Expr(Expr::Str {
+                        val: STRINGS.get(str.as_str()),
+                    }))
                 }
-            }
+                located::Constant::Bytes(_) => todo!(),
+                located::Constant::Int(val) => {
+                    Some(FromExpr::Expr(imp::Expr::Num {
+                        val: bend::fun::Num::U24(val.to_u32().unwrap()),
+                    }))
+                }
+                located::Constant::Tuple(_) => todo!(),
+                located::Constant::Float(_) => todo!(),
+                located::Constant::Complex { real: _, imag: _ } => todo!(),
+                located::Constant::Ellipsis => todo!(),
+            },
 
             rExpr::Name(n) => {
                 let mut name = n.id.to_string();
@@ -141,13 +144,19 @@ impl Parser {
                     if ctx.now == CurContext::Match {
                         for var in &ctx.vars {
                             if *var == n.id.to_string() {
-                                name = format!("{}.{}", ctx.subs.first().unwrap(), var);
+                                name = format!(
+                                    "{}.{}",
+                                    ctx.subs.first().unwrap(),
+                                    var
+                                );
                             }
                         }
                     }
                 }
 
-                Some(FromExpr::Expr(imp::Expr::Var { nam: Name::new(name) }))
+                Some(FromExpr::Expr(imp::Expr::Var {
+                    nam: Name::new(name),
+                }))
             }
 
             rExpr::Call(c) => {
@@ -167,21 +176,19 @@ impl Parser {
                     }
 
                     if let Some(val) = self.find_in_ctrs(nam) {
-                        return Some(
-                            FromExpr::Expr(imp::Expr::Constructor {
-                                name: val.clone(),
-                                args,
-                                kwargs: vec![],
-                            })
-                        );
-                    }
-                    return Some(
-                        FromExpr::Expr(imp::Expr::Call {
-                            fun: Box::new(Expr::Var { nam: Name::new(nam.to_string()) }),
+                        return Some(FromExpr::Expr(imp::Expr::Constructor {
+                            name: val.clone(),
                             args,
-                            kwargs: vec!(),
-                        })
-                    );
+                            kwargs: vec![],
+                        }));
+                    }
+                    return Some(FromExpr::Expr(imp::Expr::Call {
+                        fun: Box::new(Expr::Var {
+                            nam: Name::new(nam.to_string()),
+                        }),
+                        args,
+                        kwargs: vec![],
+                    }));
                 }
                 expr
             }
@@ -211,7 +218,9 @@ impl Parser {
             rOperator::FloorDiv => todo!(),
         };
 
-        if let (Some(nam_l), Some(nam_r)) = (left.get_var_name(), right.get_var_name()) {
+        if let (Some(nam_l), Some(nam_r)) =
+            (left.get_var_name(), right.get_var_name())
+        {
             let adt_l = self.book.adts.get(&nam_l);
             let adt_r = self.book.adts.get(&nam_r);
 
@@ -227,8 +236,14 @@ impl Parser {
             let mut fields: Vec<CtrField> = vec![];
 
             if is_adt {
-                fields.push(CtrField { nam: nam_l.clone(), rec: false });
-                fields.push(CtrField { nam: nam_r.clone(), rec: false });
+                fields.push(CtrField {
+                    nam: nam_l.clone(),
+                    rec: false,
+                });
+                fields.push(CtrField {
+                    nam: nam_r.clone(),
+                    rec: false,
+                });
             }
 
             return Some(FromExpr::CtrField(fields));
@@ -246,7 +261,10 @@ impl Parser {
         todo!()
     }
 
-    fn parse_assign(&mut self, assign: &StmtAssign<TextRange>) -> Option<FromExpr> {
+    fn parse_assign(
+        &mut self,
+        assign: &StmtAssign<TextRange>,
+    ) -> Option<FromExpr> {
         self.parse_expr_type(*assign.value.clone())
     }
 
@@ -254,7 +272,7 @@ impl Parser {
         &mut self,
         m: &StmtMatch<TextRange>,
         stmts: &Vec<rStmt<TextRange>>,
-        index: &usize
+        index: &usize,
     ) -> Option<imp::Stmt> {
         let mut arms: Vec<imp::MatchArm> = vec![];
         let mut patt: Vec<String> = vec![];
@@ -262,9 +280,10 @@ impl Parser {
         for case in &m.cases {
             let pat = match &case.pattern {
                 rPattern::MatchValue(val) => {
-                    let expr = self.parse_expr_type(*val.value.clone()).unwrap();
+                    let expr =
+                        self.parse_expr_type(*val.value.clone()).unwrap();
                     match expr {
-                        FromExpr::Expr(imp::Expr::Var { nam }) => { Some(nam) }
+                        FromExpr::Expr(imp::Expr::Var { nam }) => Some(nam),
                         _ => None,
                     }
                 }
@@ -272,7 +291,8 @@ impl Parser {
                 rPattern::MatchSequence(_) => todo!(),
                 rPattern::MatchMapping(_) => todo!(),
                 rPattern::MatchClass(class) => {
-                    let expr = self.parse_expr_type(*class.cls.clone()).unwrap();
+                    let expr =
+                        self.parse_expr_type(*class.cls.clone()).unwrap();
 
                     for val in class.patterns.clone() {
                         if let rPattern::MatchAs(match_as) = val {
@@ -283,7 +303,7 @@ impl Parser {
                     }
 
                     match expr {
-                        FromExpr::Expr(imp::Expr::Var { nam }) => { Some(nam) }
+                        FromExpr::Expr(imp::Expr::Var { nam }) => Some(nam),
                         _ => None,
                     }
                 }
@@ -315,17 +335,19 @@ impl Parser {
 
         self.ctx = None;
 
-        if let Some(FromExpr::Expr(subj)) = self.parse_expr_type(*m.subject.clone()) {
+        if let Some(FromExpr::Expr(subj)) =
+            self.parse_expr_type(*m.subject.clone())
+        {
             let nxt = self.parse_vec(stmts, index + 1);
 
             let my_nxt: Option<Box<Stmt>> = match nxt {
-                Some(FromExpr::Statement(s)) => { Some(Box::new(s)) }
+                Some(FromExpr::Statement(s)) => Some(Box::new(s)),
                 _ => None,
             };
 
             let name = match subj.clone() {
-                Expr::Var { nam } => { Some(nam) }
-                _ => { None }
+                Expr::Var { nam } => Some(nam),
+                _ => None,
             };
 
             let ret_match = imp::Stmt::Match {
@@ -345,7 +367,7 @@ impl Parser {
         name: &String,
         nxt: &Option<FromExpr>,
         stmts: &[rStmt<TextRange>],
-        index: &usize
+        index: &usize,
     ) -> Option<FromExpr> {
         let mut arms: Vec<imp::Stmt> = vec![];
         if let Some(rStmt::Match(m)) = stmts.get(index + 1) {
@@ -357,21 +379,21 @@ impl Parser {
                 }
             }
 
-            if let Some(FromExpr::Expr(expr)) = self.parse_expr_type(*m.subject.clone()) {
-                return Some(
-                    FromExpr::Statement(imp::Stmt::Switch {
-                        arg: Box::new(expr),
-                        bind: Some(Name::new(name)),
-                        arms,
-                        nxt: nxt.clone().map(|n| {
-                            if let FromExpr::Statement(n) = n {
-                                return Box::new(n);
-                            }
+            if let Some(FromExpr::Expr(expr)) =
+                self.parse_expr_type(*m.subject.clone())
+            {
+                return Some(FromExpr::Statement(imp::Stmt::Switch {
+                    arg: Box::new(expr),
+                    bind: Some(Name::new(name)),
+                    arms,
+                    nxt: nxt.clone().map(|n| {
+                        if let FromExpr::Statement(n) = n {
+                            return Box::new(n);
+                        }
 
-                            todo!()
-                        }),
-                    })
-                );
+                        todo!()
+                    }),
+                }));
             }
         }
         None
@@ -388,9 +410,13 @@ impl Parser {
         None
     }
 
-    fn parse_vec(&mut self, stmts: &Vec<rStmt<TextRange>>, index: usize) -> Option<FromExpr> {
+    fn parse_vec(
+        &mut self,
+        stmts: &Vec<rStmt<TextRange>>,
+        index: usize,
+    ) -> Option<FromExpr> {
         let stmt = match stmts.get(index) {
-            Some(s) => { s }
+            Some(s) => s,
             None => {
                 return None;
             }
@@ -399,63 +425,71 @@ impl Parser {
         match stmt {
             rStmt::Assign(assign) => {
                 let value = self.parse_assign(assign).unwrap();
-                let name = assign.targets
+                let name = assign
+                    .targets
                     .first()
                     .unwrap()
                     .clone()
                     .name_expr()
                     .unwrap()
-                    .id.to_string();
+                    .id
+                    .to_string();
 
                 if let Some(ctx) = &self.ctx {
                     if ctx.now == CurContext::Main {
-                        if
-                            let FromExpr::Expr(Expr::Call { fun, args: _, kwargs: _ }) =
-                                value.clone()
+                        if let FromExpr::Expr(Expr::Call {
+                            fun,
+                            args: _,
+                            kwargs: _,
+                        }) = value.clone()
                         {
                             if let Expr::Var { nam } = *fun {
-                                if &nam.to_string() == ctx.subs.first().unwrap() {
+                                if &nam.to_string() == ctx.subs.first().unwrap()
+                                {
                                     if let FromExpr::Expr(e) = value.clone() {
-                                        return Some(
-                                            FromExpr::Statement(Stmt::Return {
-                                                term: Box::new(e),
-                                            })
-                                        );
+                                        return Some(FromExpr::Statement(
+                                            Stmt::Return { term: Box::new(e) },
+                                        ));
                                     }
                                 }
                             }
                         }
                     }
 
-                    if ctx.now == CurContext::Main && !ctx.vars.contains(&name) {
+                    if ctx.now == CurContext::Main && !ctx.vars.contains(&name)
+                    {
                         return self.parse_vec(stmts, index + 1);
                     }
                 }
 
                 let nxt = self.parse_vec(stmts, index + 1);
 
-                if let FromExpr::Expr(Expr::Call { fun, args: _, kwargs: _ }) = value.clone() {
+                if let FromExpr::Expr(Expr::Call {
+                    fun,
+                    args: _,
+                    kwargs: _,
+                }) = value.clone()
+                {
                     if let Expr::Var { nam } = *fun {
                         if nam.to_string() == "switch" {
-                            return self.parse_switch(&name, &nxt, stmts, &index);
+                            return self
+                                .parse_switch(&name, &nxt, stmts, &index);
                         }
                     }
                 }
 
                 if let FromExpr::Expr(val) = value {
-                    return Some(
-                        FromExpr::Statement(imp::Stmt::Assign {
-                            pat: imp::AssignPattern::Var(Name::new(name)),
-                            val: Box::new(val),
-                            nxt: nxt.map(|n| {
-                                if let FromExpr::Statement(n) = n {
-                                    return Box::new(n);
-                                }
+                    return Some(FromExpr::Statement(imp::Stmt::Assign {
+                        pat: imp::AssignPattern::Var(Name::new(name)),
+                        val: Box::new(val),
+                        nxt: nxt.map(|n| {
+                            if let FromExpr::Statement(n) = n {
+                                return Box::new(n);
+                            }
 
-                                todo!()
-                            }),
-                        })
-                    );
+                            todo!()
+                        }),
+                    }));
                 }
 
                 Some(value)
@@ -478,48 +512,51 @@ impl Parser {
                         Some(FromExpr::Statement(then)),
                         Some(FromExpr::Statement(otherwise)),
                         b_nxt,
-                    ) => {
-                        Some(
-                            FromExpr::Statement(Stmt::If {
-                                cond: Box::new(cond),
-                                then: Box::new(then),
-                                otherwise: Box::new(otherwise),
-                                nxt: b_nxt,
-                            })
-                        )
+                    ) => Some(FromExpr::Statement(Stmt::If {
+                        cond: Box::new(cond),
+                        then: Box::new(then),
+                        otherwise: Box::new(otherwise),
+                        nxt: b_nxt,
+                    })),
+                    (_, _, _, _) => {
+                        panic!("If Statement must have an else.")
                     }
-                    (_, _, _, _) => { panic!("If Statement must have an else.") }
                 }
             }
-            rStmt::Return(r) => {
-                match &r.value {
-                    Some(val) => {
-                        let term = self.parse_expr_type(*val.clone()).unwrap();
-                        if let FromExpr::Expr(term) = term {
-                            return Some(
-                                FromExpr::Statement(imp::Stmt::Return { term: Box::new(term) })
-                            );
-                        }
-
-                        todo!()
+            rStmt::Return(r) => match &r.value {
+                Some(val) => {
+                    let term = self.parse_expr_type(*val.clone()).unwrap();
+                    if let FromExpr::Expr(term) = term {
+                        return Some(FromExpr::Statement(imp::Stmt::Return {
+                            term: Box::new(term),
+                        }));
                     }
-                    None => None,
+
+                    todo!()
                 }
-            }
+                None => None,
+            },
             rStmt::Expr(expr) => {
                 if let Some(ctx) = &self.ctx {
                     if ctx.now == CurContext::Main {
                         let val = self.parse_expr_type(*expr.value.clone());
 
                         if let Some(FromExpr::Expr(call)) = val {
-                            if let Expr::Call { fun, args: _, kwargs: _ } = call.clone() {
+                            if let Expr::Call {
+                                fun,
+                                args: _,
+                                kwargs: _,
+                            } = call.clone()
+                            {
                                 if let imp::Expr::Var { nam } = *fun {
-                                    if nam.to_string() == *ctx.subs.first().unwrap() {
-                                        return Some(
-                                            FromExpr::Statement(Stmt::Return {
+                                    if nam.to_string()
+                                        == *ctx.subs.first().unwrap()
+                                    {
+                                        return Some(FromExpr::Statement(
+                                            Stmt::Return {
                                                 term: Box::new(call),
-                                            })
-                                        );
+                                            },
+                                        ));
                                     }
                                 }
                             }
@@ -543,7 +580,10 @@ impl Parser {
     fn add_adt(&mut self, nam: Name, adt: Adt) {
         if let Some(adt) = self.book.adts.get(&nam) {
             if adt.builtin {
-                panic!("{} is a built-in datatype and should not be overridden.", nam);
+                panic!(
+                    "{} is a built-in datatype and should not be overridden.",
+                    nam
+                );
             } else {
                 panic!("Repeated datatype '{}'", nam);
             }
@@ -554,7 +594,12 @@ impl Parser {
                         _ = e.insert(nam.clone());
                     }
                     indexmap::map::Entry::Occupied(e) => {
-                        if self.book.adts.get(e.get()).is_some_and(|adt| adt.builtin) {
+                        if self
+                            .book
+                            .adts
+                            .get(e.get())
+                            .is_some_and(|adt| adt.builtin)
+                        {
                             panic!(
                                 "{} is a built-in constructor and should not be overridden.",
                                 e.key()
@@ -569,7 +614,11 @@ impl Parser {
         self.book.adts.insert(nam.clone(), adt);
     }
 
-    pub fn parse_main(&mut self, fun_name: &str, py_args: &[String]) -> Option<imp::Definition> {
+    pub fn parse_main(
+        &mut self,
+        fun_name: &str,
+        py_args: &[String],
+    ) -> Option<imp::Definition> {
         self.ctx = Some(Context {
             now: CurContext::Main,
             vars: py_args.to_vec(),
@@ -580,7 +629,8 @@ impl Parser {
             if let rStmt::Assign(assi) = stmt {
                 if let rExpr::Name(target) = assi.targets.first().unwrap() {
                     if py_args.contains(target.id.as_ref()) {
-                        let new_body = self.parse_vec(&self.statements.clone(), index);
+                        let new_body =
+                            self.parse_vec(&self.statements.clone(), index);
                         if let Some(FromExpr::Statement(st)) = new_body {
                             return Some(imp::Definition {
                                 name: Name::new("main"),
@@ -637,15 +687,22 @@ impl Parser {
 
                     if let rExpr::Name(iden) = iden {
                         name = iden.id.to_string();
-                        let mut adt = Adt { ctrs: IndexMap::new(), builtin: false };
+                        let mut adt = Adt {
+                            ctrs: IndexMap::new(),
+                            builtin: false,
+                        };
 
                         let body = self.parse_expr_type(*assign.value);
 
                         if let Some(FromExpr::CtrField(ctr)) = body {
                             for ct in ctr.clone() {
-                                let new_ctr = self.book.ctrs.swap_remove(&ct.nam);
+                                let new_ctr =
+                                    self.book.ctrs.swap_remove(&ct.nam);
 
-                                let new_adt = self.book.adts.swap_remove(&new_ctr.unwrap());
+                                let new_adt = self
+                                    .book
+                                    .adts
+                                    .swap_remove(&new_ctr.unwrap());
 
                                 let mut ctrs: Vec<CtrField> = vec![];
                                 for ca in new_adt.unwrap().ctrs.values() {
@@ -656,7 +713,7 @@ impl Parser {
 
                                 adt.ctrs.insert(
                                     Name::new(format!("{}/{}", name, ct.nam)),
-                                    ctrs.clone()
+                                    ctrs.clone(),
                                 );
                             }
                         }
@@ -675,18 +732,26 @@ impl Parser {
                     });
 
                     let iden = class.name.to_string();
-                    let mut adt = Adt { ctrs: IndexMap::new(), builtin: false };
+                    let mut adt = Adt {
+                        ctrs: IndexMap::new(),
+                        builtin: false,
+                    };
 
                     if is_dataclass {
                         for stmt in class.body {
                             match stmt {
                                 rStmt::AnnAssign(assign) => {
                                     let mut target = String::default();
-                                    if let rExpr::Name(nam) = *assign.target.clone() {
+                                    if let rExpr::Name(nam) =
+                                        *assign.target.clone()
+                                    {
                                         target = nam.id.to_string();
                                     }
 
-                                    let ctr_field = CtrField { nam: Name::new(target), rec: true };
+                                    let ctr_field = CtrField {
+                                        nam: Name::new(target),
+                                        rec: true,
+                                    };
 
                                     let new_name = Name::new(iden.to_string());
 
@@ -695,7 +760,10 @@ impl Parser {
                                             vec.push(ctr_field);
                                         }
                                         None => {
-                                            adt.ctrs.insert(new_name.clone(), vec![ctr_field]);
+                                            adt.ctrs.insert(
+                                                new_name.clone(),
+                                                vec![ctr_field],
+                                            );
                                         }
                                     }
                                 }
@@ -718,7 +786,9 @@ impl Parser {
 
         let main_def = self.parse_main(fun, py_args).unwrap();
 
-        self.book.defs.insert(Name::new("main"), main_def.to_fun(true).unwrap());
+        self.book
+            .defs
+            .insert(Name::new("main"), main_def.to_fun(true).unwrap());
 
         self.book.entrypoint = None;
 
@@ -727,7 +797,7 @@ impl Parser {
         let return_val = run(&self.book);
 
         match return_val {
-            Some(val) => { val.0.to_string() }
+            Some(val) => val.0.to_string(),
             None => panic!("Could not run Bend code."),
         }
     }
diff --git a/crates/benda/src/types/mod.rs b/crates/benda/src/types/mod.rs
index 9b252f0..0d93d55 100644
--- a/crates/benda/src/types/mod.rs
+++ b/crates/benda/src/types/mod.rs
@@ -1 +1 @@
-pub mod u24;
\ No newline at end of file
+pub mod u24;
diff --git a/crates/benda/src/types/u24.rs b/crates/benda/src/types/u24.rs
index a4a161c..5bc29ea 100644
--- a/crates/benda/src/types/u24.rs
+++ b/crates/benda/src/types/u24.rs
@@ -1,6 +1,6 @@
-use std::ops::{ Add, Sub };
+use std::ops::{Add, Sub};
 
-use pyo3::{ pyclass, pymethods };
+use pyo3::{pyclass, pymethods};
 
 #[pyclass(module = "benda_py")]
 #[allow(non_camel_case_types)]