diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index d94001c..26c151a 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -9,13 +9,23 @@
   <component name="ChangeListManager">
     <list default="true" id="6ca282eb-dc8c-4af0-945c-cd77d70c6194" name="Changes" comment="Added first inline function">
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/add.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/int/add.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.asm" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.asm" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.o" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.o" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/build/out.out" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.out" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/main.why" beforeDir="false" afterPath="$PROJECT_DIR$/main.why" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/root/builtin/int/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/int/mod.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/builtin/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/mod.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/compiler/assembly/utils.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/assembly/utils.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_evaluable.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_evaluable.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/errors/evaluable_errors.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/errors/evaluable_errors.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/errors/name_resolver_errors.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/errors/name_resolver_errors.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/errors/parser_errors.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/errors/parser_errors.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/root/name_resolver/name_resolvers.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/name_resolvers.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/shared/common.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/shared/common.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/name_resolver/resolve_names.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/resolve_names.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/name_resolver/resolve_type_sizes.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/resolve_type_sizes.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_operator.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_operator.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_name.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_name.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/shared/types.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/shared/types.rs" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
     <option name="HIGHLIGHT_CONFLICTS" value="true" />
@@ -152,6 +162,7 @@
       <workItem from="1717561847985" duration="16546000" />
       <workItem from="1717596741505" duration="3353000" />
       <workItem from="1717612974234" duration="7780000" />
+      <workItem from="1717700319820" duration="4539000" />
     </task>
     <task id="LOCAL-00001" summary="Changes">
       <option name="closed" value="true" />
diff --git a/build/out.asm b/build/out.asm
index 09080e1..0d28169 100644
--- a/build/out.asm
+++ b/build/out.asm
@@ -5,13 +5,21 @@
 main:
     push rbp
     mov  rbp, rsp
-    sub  rsp, 32
+    sub  rsp, 64
     
-	mov qword [rbp-8], 110
-    mov rax, qword [rbp-8]
-    mov qword [rbp-16], rax
+    mov qword [rbp-16], 100
+    mov qword [rbp-24], 100
     mov rax, qword [rbp-16]
-    mov qword [rbp-24], rax
-	mov rax, qword [rbp-24]
+    add rax, qword [rbp-24]
+    mov qword [rbp-8], rax
+    mov rax, qword [rbp-8]
+    mov qword [rbp-40], rax
+    mov qword [rbp-48], 10
+    mov rax, qword [rbp-40]
+    add rax, qword [rbp-48]
+    mov qword [rbp-32], rax
+    mov rax, qword [rbp-32]
+    mov qword [rbp-56], rax
+	mov rax, qword [rbp-56]
 	leave
 	ret
\ No newline at end of file
diff --git a/build/out.o b/build/out.o
index 34244f4..5990296 100644
Binary files a/build/out.o and b/build/out.o differ
diff --git a/build/out.out b/build/out.out
index 272fa11..789be94 100755
Binary files a/build/out.out and b/build/out.out differ
diff --git a/main.why b/main.why
index 829ec96..a1a6dd8 100644
--- a/main.why
+++ b/main.why
@@ -5,6 +5,6 @@ struct A {
 
 fn main() -> int {
     let a: int = 100 + 100;
-    let b: int = a;
+    let b: int = a + 10;
     return b;
 }
diff --git a/src/root/builtin/int/mod.rs b/src/root/builtin/int/mod.rs
index f4f29c5..d95273e 100644
--- a/src/root/builtin/int/mod.rs
+++ b/src/root/builtin/int/mod.rs
@@ -10,7 +10,7 @@ use crate::root::shared::common::{AddressedTypeRef, ByteSize, FunctionID, LocalA
 use crate::root::shared::types::Type;
 
 pub fn register_int(global_table: &mut GlobalDefinitionTable) {
-    global_table.register_builtin_type("int".to_string(), b!(IntType{}));
+    global_table.register_builtin_type(b!(IntType{}));
     global_table.register_inline_function(&IntAdd{});
 }
 
@@ -31,6 +31,10 @@ impl Type for IntType {
         ByteSize(8)
     }
 
+    fn name(&self) -> &str {
+        "int"
+    }
+
     fn instantiate_from_literal(&self, location: &LocalAddress, literal: &LiteralToken) -> Result<String, WErr> {
         Ok(match literal.literal() {
             LiteralTokens::Bool(value) => {
diff --git a/src/root/compiler/compile.rs b/src/root/compiler/compile.rs
index bf57a54..bb510c7 100644
--- a/src/root/compiler/compile.rs
+++ b/src/root/compiler/compile.rs
@@ -16,7 +16,10 @@ pub fn compile(mut global_table: GlobalDefinitionTable, unprocessed_functions: H
         let current_function = *open_set.iter().next().unwrap();
         open_set.remove(&current_function);
 
-        let current_function_token = unprocessed_functions.remove(&current_function).unwrap();
+        let Some(current_function_token) = unprocessed_functions.remove(&current_function)
+            else {
+                continue; // Inline function
+            };
 
         let (compiled, called_functions) = compile_function(current_function, current_function_token, &mut global_table)?;
         compiled_len += compiled.len() + 10;
diff --git a/src/root/compiler/compile_evaluable.rs b/src/root/compiler/compile_evaluable.rs
index 6736a17..7f43685 100644
--- a/src/root/compiler/compile_evaluable.rs
+++ b/src/root/compiler/compile_evaluable.rs
@@ -1,12 +1,13 @@
+use std::any::Any;
 use std::collections::HashSet;
 use crate::root::compiler::assembly::utils::copy;
 use crate::root::compiler::local_variable_table::LocalVariableTable;
 use crate::root::errors::evaluable_errors::EvalErrs;
+use crate::root::errors::evaluable_errors::EvalErrs::{OpNoReturn, OpWrongReturnType};
 use crate::root::errors::name_resolver_errors::NRErrors;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::{GlobalDefinitionTable, NameResult};
 use crate::root::parser::parse_function::parse_evaluable::{EvaluableToken, EvaluableTokens};
-use crate::root::parser::parse_function::parse_operator::get_method_name;
 use crate::root::shared::common::{FunctionID, Indirection, TypeRef};
 use crate::root::shared::common::AddressedTypeRef;
 
@@ -85,7 +86,52 @@ pub fn compile_evaluable_into(
 
             t.instantiate_from_literal(target.local_address(), literal)?
         }
-        EvaluableTokens::InfixOperator(lhs, op, rhs) => todo!(),
+        EvaluableTokens::InfixOperator(lhs, op, rhs) => {
+            if op.is_prefix_opt_t() {
+                return Err(WErr::n(EvalErrs::FoundPrefixNotInfixOp(op.operator().to_str().to_string()), op.location().clone()));
+            }
+
+            let (mut code, lhs) = compile_evaluable(fid, lhs, local_variables, global_table, function_calls)?;
+            code += "\n";
+            let op_fn = global_table.get_operator_function(*lhs.type_ref().type_id(), op)?;
+            let signature = global_table.get_function_signature(op_fn);
+
+            if signature.args().len() != 2 {
+                return Err(
+                    WErr::n(
+                        EvalErrs::OpWrongArgumentCount(
+                            op.operator().to_str().to_string(),
+                            global_table.get_type(*lhs.type_ref().type_id()).name().to_string(),
+                            op.operator().get_method_name().to_string(),
+                            signature.args().len()
+                        ),
+                        op.location().clone()
+                    )
+                );
+            }
+
+            match signature.return_type() {
+                None => {
+                    return Err(WErr::n(OpNoReturn(global_table.get_type_name(target.type_ref())), op.location().clone()))
+                }
+                Some(rt) => {
+                    if rt != target.type_ref() {
+                        return Err(WErr::n(OpWrongReturnType(global_table.get_type_name(target.type_ref()), global_table.get_type_name(rt)), op.location().clone()))
+                    }
+                }
+            }
+
+            let rhs_type_target = signature.args()[1].1.clone();
+            let rhs_box = global_table.add_local_variable_unnamed_base(rhs_type_target, local_variables);
+            code += &compile_evaluable_into(fid, rhs, rhs_box.clone(), local_variables, global_table, function_calls)?;
+            code += "\n";
+
+            code += &global_table.call_function(op_fn, &[*lhs.local_address(), *rhs_box.local_address()], Some(*target.local_address()))?;
+
+            function_calls.insert(op_fn);
+
+            code
+        },
         EvaluableTokens::PrefixOperator(_, _) => todo!(),
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
diff --git a/src/root/errors/evaluable_errors.rs b/src/root/errors/evaluable_errors.rs
index cded1b4..97c0c32 100644
--- a/src/root/errors/evaluable_errors.rs
+++ b/src/root/errors/evaluable_errors.rs
@@ -8,4 +8,12 @@ pub enum EvalErrs {
     FunctionMustBeCalled(String),
     #[error("Cannot evaluate a standalone type ({0})")]
     CannotEvalStandaloneType(String),
+    #[error("Operator ({0}) can only be used as a prefix operator, not infix")]
+    FoundPrefixNotInfixOp(String),
+    #[error("Infix operator ({0}) can only be used for type ({1}) if method ({2}) accepting 2 arguments is implemented for ({1}). ({2}) implementation only accepts ({3}) arguments")]
+    OpWrongArgumentCount(String, String, String, usize),
+    #[error("Expected operation to return type ({0}) but found ({1})")]
+    OpWrongReturnType(String, String),
+    #[error("Expected operation to return type ({0}) but found no return")]
+    OpNoReturn(String)
 }
diff --git a/src/root/errors/name_resolver_errors.rs b/src/root/errors/name_resolver_errors.rs
index 56b3ea9..8a4c4be 100644
--- a/src/root/errors/name_resolver_errors.rs
+++ b/src/root/errors/name_resolver_errors.rs
@@ -25,5 +25,7 @@ pub enum NRErrors {
     #[error("Cannot find name ({0})")]
     CannotFindName(String),
     #[error("Cannot find constant attribute ({0})")]
-    CannotFindConstantAttribute(String)
+    CannotFindConstantAttribute(String),
+    #[error("Method ({0}) not implemented for type ({1}) required for operator ({2})")]
+    OpMethodNotImplemented(String, String, String)
 }
diff --git a/src/root/errors/parser_errors.rs b/src/root/errors/parser_errors.rs
index 0276cbc..732f642 100644
--- a/src/root/errors/parser_errors.rs
+++ b/src/root/errors/parser_errors.rs
@@ -2,6 +2,6 @@ use thiserror::Error;
 
 #[derive(Error, Debug)]
 pub enum ParseError {
-    // #[error("Names cannot contain character '{0}' (UTF-8 Code: {1:?})")]
-    // BadName(char, Vec<u8>),
+    #[error("Parser Error (rich parser errors have not been implemented yet)")]
+    ParserErrorsNotImplemented
 }
diff --git a/src/root/name_resolver/name_resolvers.rs b/src/root/name_resolver/name_resolvers.rs
index 947443b..9cba5ed 100644
--- a/src/root/name_resolver/name_resolvers.rs
+++ b/src/root/name_resolver/name_resolvers.rs
@@ -15,7 +15,7 @@ use crate::root::parser::parse::Location;
 use crate::root::shared::types::Type;
 use crate::root::parser::parse_function::FunctionToken;
 use crate::root::parser::parse_function::parse_evaluable::{FullNameToken, FullNameTokens, FullNameWithIndirectionToken};
-use crate::root::parser::parse_function::parse_operator::OperatorToken;
+use crate::root::parser::parse_function::parse_operator::{OperatorToken};
 use crate::root::parser::parse_name::SimpleNameToken;
 use crate::root::parser::parse_struct::StructToken;
 use crate::root::POINTER_SIZE;
@@ -90,10 +90,10 @@ impl GlobalDefinitionTable {
             builtin_function_name_table: Default::default(),
         }
     }
-    pub fn register_builtin_type(&mut self, name: String, t: Box<dyn Type>) {
+    pub fn register_builtin_type(&mut self, t: Box<dyn Type>) {
         let id = t.id();
+        self.builtin_type_name_table.insert(t.name().to_string(), id);
         self.type_definitions.insert(id, t);
-        self.builtin_type_name_table.insert(name, id);
     }
 
     // pub fn register_builtin_function(&mut self, name: String, t: FunctionSignature, id: FunctionID) {
@@ -260,6 +260,10 @@ impl GlobalDefinitionTable {
         self.type_definitions.get(&type_id).as_ref().unwrap()
     }
 
+    pub fn get_type_name(&self, type_ref: &TypeRef) -> String {
+        format!("{:&^1$}", self.get_type(*type_ref.type_id()).name(), type_ref.indirection().0)
+    }
+
     pub fn resolve_name(&mut self, name: &SimpleNameToken, containing_class: Option<&SimpleNameToken>, local_variable_table: &LocalVariableTable) -> Result<NameResult, WErr> {
         if let Some(variable) = local_variable_table.get_name(name.name()) {
             return Ok(NameResult::Variable(variable))
@@ -298,6 +302,16 @@ impl GlobalDefinitionTable {
         Err(WErr::n(NRErrors::CannotFindName(name.name().clone()), name.location().clone()))
     }
 
+    pub fn get_operator_function(&self, lhs: TypeID, operator: &OperatorToken) -> Result<FunctionID, WErr> {
+        let op_name = operator.operator().get_method_name();
+        self.impl_definitions.get(&lhs).and_then(|f| f.get(op_name)).ok_or(
+            WErr::n(
+                NRErrors::OpMethodNotImplemented(op_name.to_string(), self.get_type(lhs).name().to_string(), operator.operator().to_str().to_string()),
+                operator.location().clone()
+            )
+        ).copied()
+    }
+
     pub fn call_function(&self, function: FunctionID, arguments: &[LocalAddress], return_address: Option<LocalAddress>) -> Result<String, WErr> {
         if let Some(inline) = self.inline_functions.get(&function) {
             return Ok(inline(arguments, return_address));
diff --git a/src/root/name_resolver/resolve_names.rs b/src/root/name_resolver/resolve_names.rs
index ded83c6..1cd1e23 100644
--- a/src/root/name_resolver/resolve_names.rs
+++ b/src/root/name_resolver/resolve_names.rs
@@ -24,14 +24,15 @@ use crate::root::shared::types::Type;
 #[derive(Getters)]
 pub struct UserType {
     id: TypeID,
+    name: String,
     size: ByteSize,
     attributes: Vec<(usize, SimpleNameToken, TypeRef)>,
     location: Location
 }
 
 impl UserType {
-    pub fn new(id: TypeID, size: ByteSize, attributes: Vec<(usize, SimpleNameToken, TypeRef)>, location: Location) -> UserType {
-        UserType { id, size, attributes, location }
+    pub fn new(id: TypeID, name: String, size: ByteSize, attributes: Vec<(usize, SimpleNameToken, TypeRef)>, location: Location) -> UserType {
+        UserType { id, name, size, attributes, location }
     }
 }
 
@@ -44,6 +45,10 @@ impl Type for UserType {
         self.size
     }
 
+    fn name(&self) -> &str {
+        &self.name
+    }
+
     fn instantiate_from_literal(&self, location: &LocalAddress, literal: &LiteralToken) -> Result<String, WErr> {
         todo!()
     }
@@ -77,7 +82,7 @@ pub fn resolve_names(ast: Vec<TopLevelTokens>, global_table: &mut GlobalDefiniti
     for symbol in ast {
         match symbol {
             TopLevelTokens::Struct(st) => {
-                let (location, _, attributes, id) = st.dissolve();
+                let (location, name, attributes, id) = st.dissolve();
                 let id = id.unwrap();
 
                 let mut p_attributes: Vec<(SimpleNameToken, TypeRef)> = Vec::new();
@@ -91,7 +96,7 @@ pub fn resolve_names(ast: Vec<TopLevelTokens>, global_table: &mut GlobalDefiniti
                     }
                     p_attributes.push((name, type_ref))
                 }
-                unsized_final_types.insert(id, UnsizedUserType::new(id, p_attributes, location));
+                unsized_final_types.insert(id, UnsizedUserType::new(id, name.take_name(), p_attributes, location));
             }
             TopLevelTokens::Impl(it) => {
                 let (location, name, functions) = it.dissolve();
diff --git a/src/root/name_resolver/resolve_type_sizes.rs b/src/root/name_resolver/resolve_type_sizes.rs
index 14b728d..96ddc1d 100644
--- a/src/root/name_resolver/resolve_type_sizes.rs
+++ b/src/root/name_resolver/resolve_type_sizes.rs
@@ -11,13 +11,14 @@ use crate::root::shared::common::{ByteSize, TypeID};
 #[derive(Dissolve)]
 pub struct UnsizedUserType {
     id: TypeID,
+    name: String,
     attributes: Vec<(SimpleNameToken, TypeRef)>,
     location: Location
 }
 
 impl UnsizedUserType {
-    pub fn new(id: TypeID, attributes: Vec<(SimpleNameToken, TypeRef)>, location: Location) -> UnsizedUserType {
-        UnsizedUserType { id, attributes, location }
+    pub fn new(id: TypeID, name: String, attributes: Vec<(SimpleNameToken, TypeRef)>, location: Location) -> UnsizedUserType {
+        UnsizedUserType { id, name, attributes, location }
     }
 }
 
@@ -28,7 +29,7 @@ pub fn resolve_type_sizes(
     global_table: &GlobalDefinitionTable,
     path: &mut Vec<TypeID>
 ) -> ByteSize {
-    let (id, attributes, location) = unsized_type.dissolve();
+    let (id, name, attributes, location) = unsized_type.dissolve();
 
     if path.contains(&id) {
         // TODO: Circular type def error
@@ -60,7 +61,7 @@ pub fn resolve_type_sizes(
         processed_attributes.push((offset.0, attribute_name, attribute_type));
     }
 
-    final_types.insert(id, UserType::new(id, size, processed_attributes, location));
+    final_types.insert(id, UserType::new(id, name, size, processed_attributes, location));
 
     size
 }
diff --git a/src/root/parser/parse.rs b/src/root/parser/parse.rs
index 909f336..88b80fb 100644
--- a/src/root/parser/parse.rs
+++ b/src/root/parser/parse.rs
@@ -11,6 +11,7 @@ use std::rc::Rc;
 use color_print::cformat;
 use derive_getters::Getters;
 use lazy_static::lazy_static;
+use crate::root::errors::parser_errors::ParseError;
 use crate::root::errors::WErr;
 use crate::root::parser::parse_toplevel::TopLevelTokens;
 
@@ -152,7 +153,10 @@ pub fn parse(path: PathBuf) -> Result<Vec<TopLevelTokens>, WErr> {
 
     let (remaining, output) = match parse_toplevel::parse_toplevel(base) {
         Ok(v) => v,
-        Err(_) => todo!()
+        Err(_) => {
+            // TODO:
+            return Err(WErr::n(ParseError::ParserErrorsNotImplemented, Location::builtin()));
+        }
     };
     debug_assert!(remaining.is_empty());
 
diff --git a/src/root/parser/parse_function/parse_operator.rs b/src/root/parser/parse_function/parse_operator.rs
index 35fd49e..78e3698 100644
--- a/src/root/parser/parse_function/parse_operator.rs
+++ b/src/root/parser/parse_function/parse_operator.rs
@@ -14,34 +14,6 @@ const OPERATOR_MAPS: [(&str, OperatorTokens, bool, &'static str); 4] = [
     ("!", OperatorTokens::Not, true, "not"),
 ];
 
-// TODO: Implement functionally
-pub fn is_prefix_op(operator: &OperatorTokens) -> bool {
-    for (_, op, prefix, _) in &OPERATOR_MAPS {
-        if operator == op {
-            return *prefix;
-        }
-    }
-    panic!()
-}
-
-pub fn get_method_name(operator: &OperatorTokens) -> &'static str {
-    for (_, op, _, name) in &OPERATOR_MAPS {
-        if operator == op {
-            return *name;
-        }
-    }
-    panic!()
-}
-
-pub fn get_priority(operator: &OperatorTokens) -> usize {
-    for (p, (_, op, _, _)) in OPERATOR_MAPS.iter().enumerate() {
-        if operator == op {
-            return p;
-        }
-    }
-    panic!()
-}
-
 #[derive(Debug, Clone, Getters)]
 pub struct OperatorToken {
     location: Location,
@@ -50,11 +22,11 @@ pub struct OperatorToken {
 
 impl OperatorToken {
     pub fn is_prefix_opt_t(&self) -> bool {
-        is_prefix_op(&self.operator)
+        self.operator.is_prefix_op()
     }
 
     pub fn get_priority_t(&self) -> usize {
-        get_priority(&self.operator)
+        self.operator.get_priority()
     }
 }
 
@@ -67,12 +39,41 @@ pub enum OperatorTokens {
 }
 
 impl OperatorTokens {
-    pub fn is_prefix_opt_t(&self) -> bool {
-        is_prefix_op(&self)
+    // TODO: Implement functionally
+    pub fn is_prefix_op(&self) -> bool {
+        for (_, op, prefix, _) in &OPERATOR_MAPS {
+            if self == op {
+                return *prefix;
+            }
+        }
+        panic!()
     }
 
-    pub fn get_priority_t(&self) -> usize {
-        get_priority(&self)
+    pub fn get_method_name(&self) -> &'static str {
+        for (_, op, _, name) in &OPERATOR_MAPS {
+            if self == op {
+                return *name;
+            }
+        }
+        panic!()
+    }
+
+    pub fn get_priority(&self) -> usize {
+        for (p, (_, op, _, _)) in OPERATOR_MAPS.iter().enumerate() {
+            if self == op {
+                return p;
+            }
+        }
+        panic!()
+    }
+
+    pub fn to_str(&self) -> &'static str {
+        for (s, op, _, _) in &OPERATOR_MAPS {
+            if self == op {
+                return *s;
+            }
+        }
+        panic!()
     }
 }
 
diff --git a/src/root/parser/parse_name.rs b/src/root/parser/parse_name.rs
index ee1f174..d4e4aeb 100644
--- a/src/root/parser/parse_name.rs
+++ b/src/root/parser/parse_name.rs
@@ -24,6 +24,10 @@ impl SimpleNameToken {
             name: s.to_string()
         }
     }
+
+    pub fn take_name(self) -> String {
+        self.name
+    }
 }
 
 pub fn parse_simple_name<'a>(s: Span<'a>) -> ParseResult<'a, Span, SimpleNameToken> {
diff --git a/src/root/shared/types.rs b/src/root/shared/types.rs
index 2968244..3f113e1 100644
--- a/src/root/shared/types.rs
+++ b/src/root/shared/types.rs
@@ -7,5 +7,7 @@ pub trait Type {
 
     fn size(&self) -> ByteSize;
 
+    fn name(&self) -> &str;
+
     fn instantiate_from_literal(&self, location: &LocalAddress, literal: &LiteralToken) -> Result<String, WErr>;
 }