diff --git a/headers/ASTPrinter.h b/headers/ASTPrinter.h
index db3e8f4..64a823f 100644
--- a/headers/ASTPrinter.h
+++ b/headers/ASTPrinter.h
@@ -1,18 +1,20 @@
 #pragma once
 #include "Expression.h"
 #include "TypeWrapper.h"
+#include "helperFunctions/ShortHands.h"
 #include <string>
 #include <initializer_list>
 
-class ASTPrinter : public Visitor<std::shared_ptr<Object>>
+
+class ASTPrinter : public Visitor
 {
-    std::shared_ptr<Object> visitBinaryExpr(BinaryExpr<std::shared_ptr<Object>>* expression) override;
-    std::shared_ptr<Object> visitGroupingExpr(GroupingExpr<std::shared_ptr<Object>>* expression) override;
-    std::shared_ptr<Object> visitLiteralExpr(LiteralExpr<std::shared_ptr<Object>>* expression) override;
-    std::shared_ptr<Object> visitUnaryExpr(UnaryExpr<std::shared_ptr<Object>>* expression) override;
+    sptr(Object) visitBinaryExpr(BinaryExpr* expression) override;
+    sptr(Object) visitGroupingExpr(GroupingExpr* expression) override;
+    sptr(Object) visitLiteralExpr(LiteralExpr* expression) override;
+    sptr(Object) visitUnaryExpr(UnaryExpr* expression) override;
 public:
-    std::shared_ptr<Object> print(Expr<std::shared_ptr<Object>>* expr);
+    sptr(Object) print(Expr* expr);
 private:
-    std::shared_ptr<Object> parenthesize(std::string name,  std::vector<std::shared_ptr<Expr<std::shared_ptr<Object>>>> exprs);
+    sptr(Object) parenthesize(std::string name,  std::vector<sptr(Expr)> exprs);
 
 };
\ No newline at end of file
diff --git a/headers/Expression.h b/headers/Expression.h
index 177f5e5..d87497e 100644
--- a/headers/Expression.h
+++ b/headers/Expression.h
@@ -3,76 +3,81 @@
 //
 
 #pragma once
-#include "Lexer.h"
 #include <iostream>
+#include "Lexer.h"
+#include "helperFunctions/ShortHands.h"
+#include "TypeWrapper.h"
+
+struct BinaryExpr;
+struct GroupingExpr;
+struct LiteralExpr;
+struct UnaryExpr;
+
+struct Visitor
+{
+    virtual sptr(Object) visitBinaryExpr(BinaryExpr* expression) = 0;
+    virtual sptr(Object) visitGroupingExpr(GroupingExpr* expression) = 0;
+    virtual sptr(Object) visitLiteralExpr(LiteralExpr* expression) = 0;
+    virtual sptr(Object) visitUnaryExpr(UnaryExpr* expression) = 0;
+};
 
-template <typename T>
-struct Visitor;
 
-template <typename T>
 struct Expr{
-    virtual T accept(Visitor<T>* visitor) = 0;
+    virtual sptr(Object) accept(Visitor* visitor) = 0;
     virtual ~Expr(){}
 };
 
-template <typename T>
-struct BinaryExpr : Expr<T>
-{
-    const std::shared_ptr<Expr<T>> left;
-    const Token oper;
-    const std::shared_ptr<Expr<T>> right;
 
-    BinaryExpr(std::shared_ptr<Expr<T>> left, Token oper, std::shared_ptr<Expr<T>> right) : left(left), oper(oper), right(right)
+struct BinaryExpr : Expr
+{
+    const std::shared_ptr<Expr> left;
+    const Token oper;
+    const std::shared_ptr<Expr> right;
+
+    BinaryExpr(sptr(Expr) left, Token oper, sptr(Expr) right) : left(left), oper(oper), right(right)
     {
     }
-    T accept(Visitor<T>* visitor) override{
+    sptr(Object) accept(Visitor* visitor) override{
         return visitor->visitBinaryExpr(this);
     }
 };
-template <typename T>
-struct GroupingExpr : Expr<T>
-{
-    const std::shared_ptr<Expr<T>> expression;
 
-    GroupingExpr(std::shared_ptr<Expr<T>> expression) : expression(expression)
+struct GroupingExpr : Expr
+{
+    const std::shared_ptr<Expr> expression;
+
+    GroupingExpr(sptr(Expr) expression) : expression(expression)
     {
     }
-    T accept(Visitor<T>* visitor) override{
+    sptr(Object) accept(Visitor* visitor) override{
         return visitor->visitGroupingExpr(this);
     }
 };
-template <typename T>
-struct LiteralExpr : Expr<T>
+
+struct LiteralExpr : Expr
 {
     const std::string value;
     const bool isNumber;
     LiteralExpr(std::string value, bool isNumber) : value(value), isNumber(isNumber)
     {
     }
-    T accept(Visitor<T>* visitor) override{
+    sptr(Object) accept(Visitor* visitor) override{
         return visitor->visitLiteralExpr(this);
     }
 };
-template <typename T>
-struct UnaryExpr : Expr<T>
+
+struct UnaryExpr : Expr
 {
     const Token oper;
-    const std::shared_ptr<Expr<T>> right;
+    const std::shared_ptr<Expr> right;
 
-    UnaryExpr(Token oper, std::shared_ptr<Expr<T>> right) : oper(oper), right(right)
+    UnaryExpr(Token oper, sptr(Expr) right) : oper(oper), right(right)
     {
     }
-    T accept(Visitor<T>* visitor) override{
+    sptr(Object) accept(Visitor* visitor) override{
         return visitor->visitUnaryExpr(this);
     }
 };
 
 ////
-template <typename T>
-struct Visitor
-{
-    virtual T visitBinaryExpr(BinaryExpr<T>* expression) = 0;
-    virtual T visitGroupingExpr(GroupingExpr<T>* expression) = 0;
-    virtual T visitLiteralExpr(LiteralExpr<T>* expression) = 0;
-    virtual T visitUnaryExpr(UnaryExpr<T>* expression) = 0;
-};
+
diff --git a/headers/Parser.h b/headers/Parser.h
index 6ced167..236acf6 100644
--- a/headers/Parser.h
+++ b/headers/Parser.h
@@ -4,6 +4,7 @@
 #include "Lexer.h"
 #include "Expression.h"
 #include "TypeWrapper.h"
+#include "helperFunctions/ShortHands.h"
 
 class Parser
 {
@@ -13,16 +14,16 @@ private:
 
 public:
     explicit Parser(std::vector<Token> tokens) : tokens(std::move(tokens)){};
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> parse();
+    sptr(Expr) parse();
 
 private:
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> expression();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> equality();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> comparison();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> term();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> factor();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> unary();
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> primary();
+    sptr(Expr) expression();
+    sptr(Expr) equality();
+    sptr(Expr) comparison();
+    sptr(Expr) term();
+    sptr(Expr) factor();
+    sptr(Expr) unary();
+    sptr(Expr) primary();
 
     bool match(std::vector<TokenType> types);
 
diff --git a/headers/TypeWrapper.h b/headers/TypeWrapper.h
index 5fbf9c5..8145cbc 100644
--- a/headers/TypeWrapper.h
+++ b/headers/TypeWrapper.h
@@ -2,9 +2,7 @@
 #include <string>
 struct Object
 {
-    static int count;
-    Object();
-    virtual ~Object();
+    virtual ~Object(){};
 };
 
 struct Number : public Object
diff --git a/headers/helperFunctions/ShortHands.h b/headers/helperFunctions/ShortHands.h
new file mode 100644
index 0000000..578a452
--- /dev/null
+++ b/headers/helperFunctions/ShortHands.h
@@ -0,0 +1,5 @@
+#pragma once
+#include <memory>
+
+#define sptr(T) std::shared_ptr<T>
+#define msptr(T) std::make_shared<T>
diff --git a/source/ASTPrinter.cpp b/source/ASTPrinter.cpp
index a1748c2..18f849c 100644
--- a/source/ASTPrinter.cpp
+++ b/source/ASTPrinter.cpp
@@ -4,40 +4,38 @@
 #include "../headers/ASTPrinter.h"
 
 
-std::shared_ptr<Object> ASTPrinter::visitBinaryExpr(BinaryExpr<std::shared_ptr<Object>>* expression){
+sptr(Object) ASTPrinter::visitBinaryExpr(BinaryExpr* expression){
     std::cout << expression->left << std::endl;
-    return parenthesize(expression->oper.lexeme, std::vector<std::shared_ptr<Expr<std::shared_ptr<Object>>>>{expression->left, expression->right});
+    return parenthesize(expression->oper.lexeme, std::vector<sptr(Expr)>{expression->left, expression->right});
 }
 
-std::shared_ptr<Object> ASTPrinter::visitGroupingExpr(GroupingExpr<std::shared_ptr<Object>>* expression){
-    return parenthesize("group", std::vector<std::shared_ptr<Expr<std::shared_ptr<Object>>>>{expression->expression});
+sptr(Object) ASTPrinter::visitGroupingExpr(GroupingExpr* expression){
+    return parenthesize("group", std::vector<sptr(Expr)>{expression->expression});
 }
-std::shared_ptr<Object> ASTPrinter::visitLiteralExpr(LiteralExpr<std::shared_ptr<Object>>* expression){
-    return std::make_shared<String>(expression->value);
+sptr(Object) ASTPrinter::visitLiteralExpr(LiteralExpr* expression){
+    return msptr(String)(expression->value);
 }
-std::shared_ptr<Object> ASTPrinter::visitUnaryExpr(UnaryExpr<std::shared_ptr<Object>>* expression){
-    return parenthesize(expression->oper.lexeme, std::vector<std::shared_ptr<Expr<std::shared_ptr<Object>>>>{expression->right});
+sptr(Object) ASTPrinter::visitUnaryExpr(UnaryExpr* expression){
+    return parenthesize(expression->oper.lexeme, std::vector<sptr(Expr)>{expression->right});
 }
 
-std::shared_ptr<Object> ASTPrinter::print(Expr<std::shared_ptr<Object>> *expr) {
+sptr(Object) ASTPrinter::print(Expr *expr) {
     return expr->accept(this);
 }
 
-std::shared_ptr<Object> ASTPrinter::parenthesize(std::string name, std::vector<std::shared_ptr<Expr<std::shared_ptr<Object>>>> exprs) {
+sptr(Object) ASTPrinter::parenthesize(std::string name, std::vector<sptr(Expr)> exprs) {
     std::string builder;
 
     builder += "(" + name;
 
-    for(const std::shared_ptr<Expr<std::shared_ptr<Object>>>& expr : exprs)
+    for(const sptr(Expr)& expr : exprs)
     {
-
-
         builder += " ";
         builder += std::dynamic_pointer_cast<String>(expr->accept(this))->value;
     }
 
     builder += ")";
 
-    return std::make_shared<String>(builder);
+    return msptr(String)(builder);
 
 }
diff --git a/source/Parser.cpp b/source/Parser.cpp
index 1bef3db..518879c 100644
--- a/source/Parser.cpp
+++ b/source/Parser.cpp
@@ -8,94 +8,94 @@
 // to all the morons on facebook who don't know what pemdas is, fuck you
 ///////////////////////////////////////////
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::expression()
+sptr(Expr) Parser::expression()
 {
     return equality();
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::equality()
+sptr(Expr) Parser::equality()
 {
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> expr = comparison();
+    sptr(Expr) expr = comparison();
 
     while(match({BANG_EQUAL, DOUBLE_EQUAL}))
     {
         Token op = previous();
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> right = comparison();
-        expr = std::make_shared<BinaryExpr<std::shared_ptr<Object>>>(expr, op, right);
+        sptr(Expr) right = comparison();
+        expr = msptr(BinaryExpr)(expr, op, right);
     }
 
     return expr;
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::comparison()
+sptr(Expr) Parser::comparison()
 {
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> expr = term();
+    sptr(Expr) expr = term();
 
     while(match({GREATER, GREATER_EQUAL, LESS, LESS_EQUAL}))
     {
         Token op = previous();
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> right = term();
-        expr = std::make_shared<BinaryExpr<std::shared_ptr<Object>>>(expr, op, right);
+        sptr(Expr) right = term();
+        expr = msptr(BinaryExpr)(expr, op, right);
     }
 
     return expr;
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::term()
+sptr(Expr) Parser::term()
 {
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> expr = factor();
+    sptr(Expr) expr = factor();
 
     while(match({MINUS, PLUS}))
     {
         std::cout << "Found comparison" << std::endl;
         Token op = previous();
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> right = factor();
-        expr = std::make_shared<BinaryExpr<std::shared_ptr<Object>>>(expr, op, right);
+        sptr(Expr) right = factor();
+        expr = msptr(BinaryExpr)(expr, op, right);
     }
 
     return expr;
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::factor()
+sptr(Expr) Parser::factor()
 {
-    std::shared_ptr<Expr<std::shared_ptr<Object>>> expr = unary();
+    sptr(Expr) expr = unary();
 
     while(match({SLASH, STAR}))
     {
         Token op = previous();
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> right = unary();
-        expr = std::make_shared<BinaryExpr<std::shared_ptr<Object>>>(expr, op, right);
+        sptr(Expr) right = unary();
+        expr = msptr(BinaryExpr)(expr, op, right);
     }
 
     return expr;
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::unary()
+sptr(Expr) Parser::unary()
 {
     if(match({BANG, MINUS}))
     {
         Token op = previous();
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> right = unary();
-        return std::make_shared<UnaryExpr<std::shared_ptr<Object>>>(op, right);
+        sptr(Expr) right = unary();
+        return msptr(UnaryExpr)(op, right);
     }
 
     return primary();
 }
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::primary()
+sptr(Expr) Parser::primary()
 {
-    if(match({FALSE})) return std::make_shared<LiteralExpr<std::shared_ptr<Object>>>("true", false);
-    if(match({TRUE})) return std::make_shared<LiteralExpr<std::shared_ptr<Object>>>("true", false);
-    if(match({NONE})) return std::make_shared<LiteralExpr<std::shared_ptr<Object>>>("none", false);
+    if(match({FALSE})) return msptr(LiteralExpr)("true", false);
+    if(match({TRUE})) return msptr(LiteralExpr)("true", false);
+    if(match({NONE})) return msptr(LiteralExpr)("none", false);
 
-    if(match({NUMBER})) return std::make_shared<LiteralExpr<std::shared_ptr<Object>>>(previous().lexeme, true);
-    if(match({STRING})) return std::make_shared<LiteralExpr<std::shared_ptr<Object>>>(previous().lexeme, false);
+    if(match({NUMBER})) return msptr(LiteralExpr)(previous().lexeme, true);
+    if(match({STRING})) return msptr(LiteralExpr)(previous().lexeme, false);
 
     if(match({OPEN_PAREN}))
     {
-        std::shared_ptr<Expr<std::shared_ptr<Object>>> expr = expression();
+        sptr(Expr) expr = expression();
         consume(CLOSE_PAREN, "Expected ')' after expression on line " + std::to_string(peek().line));
-        return std::make_shared<GroupingExpr<std::shared_ptr<Object>>>(expr);
+        return msptr(GroupingExpr)(expr);
     }
 
     throw std::runtime_error("Expression expected at: " + std::to_string(peek().line));
@@ -104,7 +104,7 @@ std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::primary()
 ///////////////////////////////////////////
 
 
-std::shared_ptr<Expr<std::shared_ptr<Object>>> Parser::parse() {
+sptr(Expr) Parser::parse() {
 
         return expression();
 
diff --git a/source/TypeWrapper.cpp b/source/TypeWrapper.cpp
index 2e5e9a8..2366674 100644
--- a/source/TypeWrapper.cpp
+++ b/source/TypeWrapper.cpp
@@ -4,15 +4,3 @@
 #include "../headers/TypeWrapper.h"
 #include <iostream>
 
-int Object::count;
-
-Object::Object() {
-    std::cout << "Inc"<<std::endl;
-    Object::count += 1;
-}
-
-Object::~Object() {
-    std::cout << "dec"<<std::endl;
-
-    Object::count -= 1;
-}
diff --git a/source/bob.cpp b/source/bob.cpp
index 8d61d7e..689e1c2 100644
--- a/source/bob.cpp
+++ b/source/bob.cpp
@@ -50,7 +50,7 @@ void Bob::run(string source)
     try {
         vector<Token> tokens = lexer.Tokenize(source);
         Parser p(tokens);
-        shared_ptr<Expr<shared_ptr<Object>>> expr = p.parse();
+        shared_ptr<Expr> expr = p.parse();
 
 
         ASTPrinter printer;
@@ -59,7 +59,7 @@ void Bob::run(string source)
 
 
         for(Token t : tokens){
-            //cout << "{type: " << t.type << ", value: " << t.lexeme << "}" << endl;
+            cout << "{type: " << t.type << ", value: " << t.lexeme << "}" << endl;
         }
 
 
@@ -70,7 +70,7 @@ void Bob::run(string source)
         return;
     }
 
-    cout << "Current object count: " << Object::count << endl;
+
 
 }
 
diff --git a/source/main.cpp b/source/main.cpp
index 0e034f1..902b4af 100644
--- a/source/main.cpp
+++ b/source/main.cpp
@@ -9,7 +9,6 @@
 #include "../headers/ASTPrinter.h"
 #include "../headers/TypeWrapper.h"
 int main(){
-    Object::count = 0;
     Bob bobLang;
 
     //bobLang.runFile("source.bob");