diff --git a/src/Binder/Binder.cpp b/src/Binder/Binder.cpp
index ae66b68..58abb00 100644
--- a/src/Binder/Binder.cpp
+++ b/src/Binder/Binder.cpp
@@ -187,10 +187,10 @@ namespace Porygon::Binder {
             assignmentKey = assignment.GetKey();
         }
 
-        auto boundBlock = this->BindBlockStatement(functionStatement->GetBlock());
+        auto boundBlock = dynamic_cast<BoundBlockStatement*>(this->BindBlockStatement(functionStatement->GetBlock()));
         this->_scope->GoOuterScope();
         this->_currentFunction = nullptr;
-        return new BoundFunctionDeclarationStatement(type, assignmentKey, (BoundBlockStatement *) boundBlock);
+        return new BoundFunctionDeclarationStatement(type, assignmentKey, boundBlock);
     }
 
     BoundStatement *Binder::BindReturnStatement(const ParsedStatement *statement) {
@@ -696,14 +696,13 @@ namespace Porygon::Binder {
         auto innerScope = new BoundScope(tableScope);
         auto currentScope = this->_scope;
         this->_scope = innerScope;
-        auto block = this->BindBlockStatement(expression->GetBlock());
+        auto block = dynamic_cast<BoundBlockStatement*>(this->BindBlockStatement(expression->GetBlock()));
         this->_scope = currentScope;
 
         auto tableType = std::make_shared<TableScriptType>(tableScope, innerScope->GetLocalVariableCount());
         delete innerScope;
 
-        return new BoundTableExpression((BoundBlockStatement *) block, tableType, expression->GetStartPosition(),
-                                        expression->GetLength());
+        return new BoundTableExpression(block, tableType, expression->GetStartPosition(), expression->GetLength());
     }
 
 }
diff --git a/src/Binder/Binder.hpp b/src/Binder/Binder.hpp
index 5d842c7..96d4125 100644
--- a/src/Binder/Binder.hpp
+++ b/src/Binder/Binder.hpp
@@ -46,6 +46,12 @@ namespace Porygon::Binder {
         BoundExpression *BindPeriodIndexExpression(const PeriodIndexExpression *expression, bool setter);
 
     public:
+        Binder(){
+            _scriptData = nullptr;
+            _scope = nullptr;
+            _currentFunction = nullptr;
+        }
+
         static BoundScriptStatement *
         Bind(Porygon::Script *script, const ParsedScriptStatement *s, BoundScope *scriptScope);
 
diff --git a/src/Diagnostics/Diagnostic.hpp b/src/Diagnostics/Diagnostic.hpp
index 88ee57e..acb4752 100644
--- a/src/Diagnostics/Diagnostic.hpp
+++ b/src/Diagnostics/Diagnostic.hpp
@@ -18,13 +18,10 @@ namespace Porygon::Diagnostics {
         std::vector<std::string> _arguments;
         std::string* _message;
     public:
-        Diagnostic(DiagnosticSeverity severity, DiagnosticCode code, unsigned int start, unsigned int length, std::vector<std::string> arguments) {
-            _severity = severity;
-            _code = code;
-            _start = start;
-            _length = length;
-            _arguments = std::move(arguments);
-            _message = nullptr;
+        Diagnostic(DiagnosticSeverity severity, DiagnosticCode code, unsigned int start, unsigned int length, std::vector<std::string> arguments)
+            : _severity(severity), _code(code), _start(start), _length(length), _arguments(std::move(arguments)), _message(
+                nullptr)
+        {
         }
 
         ~Diagnostic(){
diff --git a/src/Diagnostics/DiagnosticsHolder.hpp b/src/Diagnostics/DiagnosticsHolder.hpp
index 6341153..74c7b49 100644
--- a/src/Diagnostics/DiagnosticsHolder.hpp
+++ b/src/Diagnostics/DiagnosticsHolder.hpp
@@ -19,9 +19,7 @@ namespace Porygon::Diagnostics {
         vector<size_t> _lineLength;
 
     public:
-        explicit DiagnosticsHolder(const u16string& str) {
-            _hasErrors = false;
-            _lineStarts = vector<size_t>{0};
+        explicit DiagnosticsHolder(const u16string& str) :_hasErrors(false), _lineStarts(vector<size_t>{0}) {
             size_t lineLength = 0;
             for (size_t i = 0; i < str.size(); i++){
                 lineLength++;
diff --git a/src/Evaluator/EvalValues/NumericEvalValue.cpp b/src/Evaluator/EvalValues/NumericEvalValue.cpp
index e2e4c4a..06b1c7d 100644
--- a/src/Evaluator/EvalValues/NumericEvalValue.cpp
+++ b/src/Evaluator/EvalValues/NumericEvalValue.cpp
@@ -69,7 +69,7 @@ namespace Porygon::Evaluation {
     const bool NumericEvalValue::operator==(EvalValue *b) const {
         if (b->GetTypeClass() != TypeClass::Number)
             return false;
-        auto numVal = (NumericEvalValue *) b;
+        auto numVal = dynamic_cast<NumericEvalValue*>(b);
         if (this->IsFloat() != numVal->IsFloat())
             return false;
 
diff --git a/src/Evaluator/EvalValues/StringEvalValue.hpp b/src/Evaluator/EvalValues/StringEvalValue.hpp
index c782946..03c7730 100644
--- a/src/Evaluator/EvalValues/StringEvalValue.hpp
+++ b/src/Evaluator/EvalValues/StringEvalValue.hpp
@@ -13,8 +13,7 @@ namespace Porygon::Evaluation {
         u16string _value;
         size_t _hash;
     public:
-        explicit StringEvalValue(u16string s) {
-            _value = move(s);
+        explicit StringEvalValue(u16string s) : _value(move(s)){
             _hash = Utilities::HashedString::ConstHash(_value.c_str());
         }
 
diff --git a/src/Evaluator/EvaluationScope/EvaluationScope.cpp b/src/Evaluator/EvaluationScope/EvaluationScope.cpp
index 5e188e1..ec6cf2f 100644
--- a/src/Evaluator/EvaluationScope/EvaluationScope.cpp
+++ b/src/Evaluator/EvaluationScope/EvaluationScope.cpp
@@ -5,9 +5,8 @@
 
 namespace Porygon::Evaluation {
     EvaluationScope::EvaluationScope(map<Utilities::HashedString, shared_ptr<EvalValue>> *scriptVariables,
-                                     int localVariableCount) {
-        _scriptScope = scriptVariables;
-        _localScope = map<uint64_t, shared_ptr<EvalValue>>();
+                                     int localVariableCount) : _scriptScope(scriptVariables),
+                                     _localScope(map<uint64_t, shared_ptr<EvalValue>>()) {
     }
 
     void EvaluationScope::CreateVariable(const BoundVariableKey *key, const shared_ptr<EvalValue> &value) {
diff --git a/src/Evaluator/Evaluator.cpp b/src/Evaluator/Evaluator.cpp
index 00b8fd9..a094db4 100644
--- a/src/Evaluator/Evaluator.cpp
+++ b/src/Evaluator/Evaluator.cpp
@@ -33,7 +33,7 @@ namespace Porygon::Evaluation {
             case BoundStatementKind::Script:
                 throw; // Should never happen
             case BoundStatementKind::Block:
-                return this->EvaluateBlockStatement((BoundBlockStatement *) statement);
+                return this->EvaluateBlockStatement((BoundBlockStatement*)statement);
             case BoundStatementKind::Expression:
                 return this->EvaluateExpressionStatement((BoundExpressionStatement *) statement);
             case BoundStatementKind::Assignment:
@@ -382,7 +382,7 @@ namespace Porygon::Evaluation {
         auto opt = func->GetOption(option->GetOptionId());
         if (option -> IsScriptFunction()){
             auto parameterTypes = option->GetParameterTypes();
-            auto scriptFunctionType = (ScriptFunctionOption*)option;
+            auto scriptFunctionType = dynamic_cast<const ScriptFunctionOption*>(option);
             auto parameterKeys = scriptFunctionType->GetParameterKeys();
             auto originalScope = this->_evaluationScope;
             auto scriptOption = dynamic_pointer_cast<EvaluationScriptFunctionOption>(opt);
@@ -413,7 +413,7 @@ namespace Porygon::Evaluation {
     const shared_ptr<EvalValue> Evaluator::EvaluateFunction(const GenericFunctionEvalValue *function,
                                                             const vector<EvalValue *> &parameters) {
         auto type = std::dynamic_pointer_cast<GenericFunctionScriptType>(function->GetType());
-        auto option = (ScriptFunctionOption*)type-> GetFirstOption();
+        auto option = dynamic_cast<const ScriptFunctionOption*>(type->GetFirstOption());
 
         auto parameterTypes = option->GetParameterTypes();
         auto parameterKeys = option->GetParameterKeys();
diff --git a/src/Evaluator/Evaluator.hpp b/src/Evaluator/Evaluator.hpp
index 349432c..b98d4e4 100644
--- a/src/Evaluator/Evaluator.hpp
+++ b/src/Evaluator/Evaluator.hpp
@@ -59,12 +59,9 @@ namespace Porygon::Evaluation{
 
         const shared_ptr<EvalValue> GetVariable(const BoundVariableExpression *expression);
     public:
-        explicit Evaluator(map<Utilities::HashedString, shared_ptr<EvalValue>>* scriptVariables){
-            _scriptVariables = scriptVariables;
-            _hasReturned = false;
-            _hasBroken = false;
-            _returnValue = nullptr;
-            _evaluationScope = nullptr;
+        explicit Evaluator(map<Utilities::HashedString, shared_ptr<EvalValue>>* scriptVariables)
+            : _scriptVariables(scriptVariables), _hasReturned(false), _hasBroken(false), _returnValue(nullptr),
+            _evaluationScope(nullptr){
         }
 
         EvalValue* Evaluate(const BoundScriptStatement* statement);
diff --git a/src/FunctionScriptType.hpp b/src/FunctionScriptType.hpp
index 9cc4534..22eaa7a 100644
--- a/src/FunctionScriptType.hpp
+++ b/src/FunctionScriptType.hpp
@@ -2,6 +2,7 @@
 #ifndef PORYGONLANG_FUNCTIONSCRIPTTYPE_HPP
 #define PORYGONLANG_FUNCTIONSCRIPTTYPE_HPP
 
+#include <utility>
 #include "ScriptType.hpp"
 
 namespace Porygon {
@@ -10,9 +11,8 @@ namespace Porygon {
         vector<shared_ptr<ScriptType>> _parameterTypes;
         size_t _option = 0;
     public:
-        GenericFunctionOption(shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes){
-            _returnType = move(returnType);
-            _parameterTypes = move(parameterTypes);
+        GenericFunctionOption(shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes)
+            : _returnType(std::move(returnType)), _parameterTypes(std::move(parameterTypes)){
         }
 
         virtual ~GenericFunctionOption() = default;
@@ -93,8 +93,7 @@ namespace Porygon {
     public:
         ScriptFunctionOption(shared_ptr<ScriptType> returnType, vector<shared_ptr<ScriptType>> parameterTypes,
                            vector<shared_ptr<Porygon::Binder::BoundVariableKey>> parameterKeys)
-                : GenericFunctionOption(move(returnType), std::move(parameterTypes)) {
-            _parameterKeys = move(parameterKeys);
+                : GenericFunctionOption(move(returnType), std::move(parameterTypes)), _parameterKeys(move(parameterKeys)) {
         }
 
         const vector<shared_ptr<Porygon::Binder::BoundVariableKey>> GetParameterKeys() const {
diff --git a/src/Parser/ParsedExpressions/ParsedExpression.hpp b/src/Parser/ParsedExpressions/ParsedExpression.hpp
index a467400..5fbb254 100644
--- a/src/Parser/ParsedExpressions/ParsedExpression.hpp
+++ b/src/Parser/ParsedExpressions/ParsedExpression.hpp
@@ -72,7 +72,7 @@ namespace Porygon::Parser {
             return ParsedExpressionKind::LiteralInteger;
         }
 
-        explicit LiteralIntegerExpression(IntegerToken *token)
+        explicit LiteralIntegerExpression(const IntegerToken *token)
                 : ParsedExpression(token->GetStartPosition(), token->GetLength()),
                   _value(token->GetValue()) {
         }
@@ -89,7 +89,7 @@ namespace Porygon::Parser {
             return ParsedExpressionKind::LiteralFloat;
         }
 
-        explicit LiteralFloatExpression(FloatToken *token)
+        explicit LiteralFloatExpression(const FloatToken *token)
                 : ParsedExpression(token->GetStartPosition(), token->GetLength()),
                   _value(token->GetValue()) {
         }
@@ -106,7 +106,7 @@ namespace Porygon::Parser {
             return ParsedExpressionKind::LiteralString;
         }
 
-        explicit LiteralStringExpression(StringToken *token)
+        explicit LiteralStringExpression(const StringToken *token)
                 : ParsedExpression(token->GetStartPosition(), token->GetLength()),
                   _value(std::move(token->GetValue())) {
         }
@@ -140,7 +140,7 @@ namespace Porygon::Parser {
             return ParsedExpressionKind::Variable;
         }
 
-        explicit VariableExpression(IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
+        explicit VariableExpression(const IdentifierToken *token) : ParsedExpression(token->GetStartPosition(),
                                                                                token->GetLength()),
                                                               _value(HashedString(token->GetValue())) {
         }
@@ -314,12 +314,11 @@ namespace Porygon::Parser {
 
 
     class ParsedNumericalTableExpression : public ParsedExpression {
-        vector<const ParsedExpression *> _expressions;
+        const vector<const ParsedExpression *> _expressions;
     public:
         ParsedNumericalTableExpression(vector<const ParsedExpression *> expressions, unsigned int start,
                                        unsigned int length)
-                : ParsedExpression(start, length) {
-            _expressions = std::move(expressions);
+                : ParsedExpression(start, length), _expressions(std::move(expressions)) {
         }
 
         ~ParsedNumericalTableExpression() final {
diff --git a/src/Parser/ParsedStatements/ParsedStatement.hpp b/src/Parser/ParsedStatements/ParsedStatement.hpp
index 1c91afa..e08540f 100644
--- a/src/Parser/ParsedStatements/ParsedStatement.hpp
+++ b/src/Parser/ParsedStatements/ParsedStatement.hpp
@@ -73,16 +73,13 @@ namespace Porygon::Parser {
     class ParsedBlockStatement : public ParsedStatement {
         const std::vector<const ParsedStatement *> _statements;
     public:
-        explicit ParsedBlockStatement(std::vector<const ParsedStatement *> statements)
+        explicit ParsedBlockStatement(const std::vector<const ParsedStatement *>& statements)
                 : ParsedStatement(statements.front()->GetStartPosition(),
                                   statements.back()->GetEndPosition() - statements.front()->GetStartPosition()),
                   _statements(statements) {}
 
         ParsedBlockStatement(std::vector<const ParsedStatement *> statements, unsigned int start) : ParsedStatement(
-                start, 0),
-                                                                                                    _statements(
-                                                                                                            std::move(
-                                                                                                                    statements)) {
+                start, 0), _statements(std::move(statements)) {
         }
 
 
diff --git a/src/Parser/Parser.cpp b/src/Parser/Parser.cpp
index 54465e4..8d20fe1 100644
--- a/src/Parser/Parser.cpp
+++ b/src/Parser/Parser.cpp
@@ -89,7 +89,7 @@ namespace Porygon::Parser {
         }
 
         auto start = current->GetStartPosition();
-        return new ParsedAssignmentStatement(isLocal, ((IdentifierToken *) identifier)->GetValue(), expression, start,
+        return new ParsedAssignmentStatement(isLocal, (dynamic_cast<const IdentifierToken*>(identifier))->GetValue(), expression, start,
                                              expression->GetEndPosition() - start);
     }
 
@@ -102,7 +102,7 @@ namespace Porygon::Parser {
     }
 
 
-    ParsedStatement *
+    ParsedBlockStatement *
     Parser::ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements) {
         auto statements = openStatements;
         auto start = this->_position;
@@ -168,8 +168,8 @@ namespace Porygon::Parser {
                 hasErrors = true;
                 continue;
             }
-            auto typeToken = (IdentifierToken *) type;
-            auto identifierToken = (IdentifierToken *) identifier;
+            auto typeToken = dynamic_cast<const IdentifierToken*>(type);
+            auto identifierToken = dynamic_cast<const IdentifierToken*>(identifier);
             parameters.push_back(new TypedVariableIdentifier(typeToken->GetValue(), identifierToken->GetValue()));
 
             auto nextKind = next->GetKind();
@@ -190,9 +190,9 @@ namespace Porygon::Parser {
         if (block->GetKind() == ParsedStatementKind::Bad) {
             return new ParsedBadStatement(start, block->GetEndPosition() - start);
         }
-        auto functionIdentifier = ((IdentifierToken *) functionIdentifierToken)->GetValue();
+        auto functionIdentifier = dynamic_cast<const IdentifierToken*>(functionIdentifierToken)->GetValue();
         return new ParsedFunctionDeclarationStatement(HashedString(functionIdentifier), parameters,
-                                                      (ParsedBlockStatement *) block, start,
+                                                      block, start,
                                                       block->GetEndPosition() - start);
     }
 
@@ -239,7 +239,7 @@ namespace Porygon::Parser {
     }
 
     ParsedStatement *Parser::ParseNumericForStatement(const IToken *current) {
-        auto identifier = (IdentifierToken*)current;
+        auto identifier = dynamic_cast<const IdentifierToken*>(current);
         this->Next(); // consume assignment token
         bool hasErrors = false;
         auto start = this ->ParseExpression(this ->Next());
@@ -271,8 +271,8 @@ namespace Porygon::Parser {
     }
 
     ParsedStatement *Parser::ParseGenericForStatement(const IToken *current) {
-        auto keyIdentifier = ((IdentifierToken*) current)->GetValue();
-        IdentifierToken* valueIdentifierToken = nullptr;
+        auto keyIdentifier = dynamic_cast<const IdentifierToken*>(current)->GetValue();
+        const IdentifierToken* valueIdentifierToken = nullptr;
         bool hasErrors = false;
         auto next = this -> Next();
         if (next -> GetKind() == TokenKind::CommaToken){
@@ -282,7 +282,7 @@ namespace Porygon::Parser {
                 this->ScriptData->Diagnostics->LogError(Diagnostics::DiagnosticCode::UnexpectedToken, next->GetStartPosition(),
                                                         next->GetLength());
             } else{
-                valueIdentifierToken = (IdentifierToken*) next;
+                valueIdentifierToken = dynamic_cast<const IdentifierToken*>(next);
                 next = this -> Next();
             }
         }
@@ -477,17 +477,17 @@ namespace Porygon::Parser {
     ParsedExpression *Parser::ParsePrimaryExpression(const IToken *current) {
         switch (current->GetKind()) {
             case TokenKind::Integer:
-                return new LiteralIntegerExpression((IntegerToken *) current);
+                return new LiteralIntegerExpression(dynamic_cast<const IntegerToken*>(current));
             case TokenKind::Float:
-                return new LiteralFloatExpression((FloatToken *) current);
+                return new LiteralFloatExpression(dynamic_cast<const FloatToken*>(current));
             case TokenKind::String:
-                return new LiteralStringExpression((StringToken *) current);
+                return new LiteralStringExpression(dynamic_cast<const StringToken*>(current));
             case TokenKind::TrueKeyword:
                 return new LiteralBoolExpression(current);
             case TokenKind::FalseKeyword:
                 return new LiteralBoolExpression(current);
             case TokenKind::Identifier:
-                return new VariableExpression((IdentifierToken *) current);
+                return new VariableExpression(dynamic_cast<const IdentifierToken*>(current));
             case TokenKind::OpenParenthesis:
                 return this->ParseParenthesizedExpression(current);
             case TokenKind::OpenCurlyBracket:
@@ -566,7 +566,7 @@ namespace Porygon::Parser {
                                      identifier->GetEndPosition() - indexingExpression->GetStartPosition());
         }
         auto start = indexingExpression->GetStartPosition();
-        return new PeriodIndexExpression(indexingExpression, ((IdentifierToken *) identifier)->GetValue(), start,
+        return new PeriodIndexExpression(indexingExpression, dynamic_cast<const IdentifierToken*>(identifier)->GetValue(), start,
                                          identifier->GetEndPosition() - start);
     }
 
@@ -582,7 +582,7 @@ namespace Porygon::Parser {
         // If the first item is an expression, and is followed by a comma, we're dealing with a simple {1, 2, 3} kind of array
         if (firstItem->GetKind() == ParsedStatementKind::Expression &&
             (this->Peek()->GetKind() == TokenKind::CommaToken)) {
-            auto statement = ((ParsedExpressionStatement *) firstItem);
+            auto statement = dynamic_cast<ParsedExpressionStatement*>(firstItem);
             auto expr = statement->GetExpression();
             statement->NullifyExpression();
             delete statement;
@@ -607,7 +607,7 @@ namespace Porygon::Parser {
         }
             // Otherwise we have a more complex table, which can be defined by a block
         else {
-            auto block = (ParsedBlockStatement *) this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
+            auto block = this->ParseBlock({TokenKind::CloseCurlyBracket}, {firstItem});
             auto closeToken = this->PeekAt(-1);
             return new ParsedTableExpression(block, start, closeToken->GetEndPosition() - start);
         }
diff --git a/src/Parser/Parser.hpp b/src/Parser/Parser.hpp
index 0519600..cfb96d5 100644
--- a/src/Parser/Parser.hpp
+++ b/src/Parser/Parser.hpp
@@ -34,7 +34,7 @@ namespace Porygon::Parser {
         ParsedStatement *ParseStatement(const IToken *current);
         ParsedStatement *ParseVariableAssignment(const IToken *current);
         ParsedStatement *ParseIndexAssignment(ParsedExpression *indexer);
-        ParsedStatement *ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
+        ParsedBlockStatement *ParseBlock(const vector<TokenKind> &endTokens, const vector<const ParsedStatement *> &openStatements = {});
         ParsedStatement *ParseFunctionDeclaration(const IToken *current);
         ParsedStatement *ParseReturnStatement(const IToken *current);
         ParsedStatement *ParseIfStatement(const IToken *current);
@@ -57,10 +57,8 @@ namespace Porygon::Parser {
     public:
         ParsedScriptStatement *Parse();
 
-        explicit Parser(const vector<const IToken *> &tokens, Porygon::Script *scriptData) {
-            _tokens = tokens;
-            _position = 0;
-            ScriptData = scriptData;
+        explicit Parser(const vector<const IToken *> &tokens, Porygon::Script *scriptData) : _tokens(tokens), _position(0),
+        ScriptData(scriptData){
         }
 
     };
diff --git a/src/Script.cpp b/src/Script.cpp
index 5679cae..ecb9f92 100644
--- a/src/Script.cpp
+++ b/src/Script.cpp
@@ -24,13 +24,12 @@ Porygon::Script *Porygon::Script::Create(const string &script) {
     return Script::Create(To_UTF16(script));
 }
 
-Porygon::Script::Script(const u16string& s) {
-    Diagnostics = make_shared<Diagnostics::DiagnosticsHolder>(s);
-    _boundScript = nullptr;
-
-    _scriptVariables = new map<Utilities::HashedString, shared_ptr<EvalValue>>();
+Porygon::Script::Script(const u16string& s)
+    :   Diagnostics(make_shared<Diagnostics::DiagnosticsHolder>(s)),
+        _boundScript(nullptr),
+        _scriptVariables(new map<Utilities::HashedString, shared_ptr<EvalValue>>())
+{
     _evaluator = new Evaluator(this -> _scriptVariables);
-
     this -> Parse(s);
 }
 
@@ -99,10 +98,11 @@ Porygon::Script *Porygon::Script::Clone(const Porygon::Script *script) {
 }
 
 Porygon::Script::Script(shared_ptr<BoundScriptStatement> boundScript,
-                        shared_ptr<Porygon::Diagnostics::DiagnosticsHolder> diagnostics) {
-    _boundScript = std::move(boundScript);
-    Diagnostics = std::move(diagnostics);
-    _scriptVariables = new map<Utilities::HashedString, shared_ptr<EvalValue>>();
+                        shared_ptr<Porygon::Diagnostics::DiagnosticsHolder> diagnostics)
+                        : _boundScript(std::move(boundScript)),
+                          Diagnostics(std::move(diagnostics)),
+                          _scriptVariables(new map<Utilities::HashedString, shared_ptr<EvalValue>>())
+                        {
     _evaluator = new Evaluator(_scriptVariables);
 }
 
diff --git a/src/ScriptType.cpp b/src/ScriptType.cpp
index 8ce6790..c0e4607 100644
--- a/src/ScriptType.cpp
+++ b/src/ScriptType.cpp
@@ -3,11 +3,10 @@
 
 namespace Porygon{
     const bool ScriptType::CanBeIndexedWith(ScriptType *indexer) const{
-        // String type is the only simple script type we want to
-        return _class == TypeClass::String && indexer->_class == TypeClass::Number && !((NumericScriptType*)indexer)->IsFloat();
+        return false;
     }
 
-    const shared_ptr<ScriptType> ScriptType::GetIndexedType(ScriptType *indexer) const{
+    const shared_ptr<ScriptType> ScriptType::GetIndexedType(ScriptType*) const{
         if (_class == TypeClass::String){
             return make_shared<ScriptType>(TypeClass::String);
         }
diff --git a/src/ScriptType.hpp b/src/ScriptType.hpp
index acfbb29..db2fb0f 100644
--- a/src/ScriptType.hpp
+++ b/src/ScriptType.hpp
@@ -1,3 +1,5 @@
+#include <utility>
+
 
 #ifndef PORYGONLANG_SCRIPTTYPE_HPP
 #define PORYGONLANG_SCRIPTTYPE_HPP
@@ -97,6 +99,17 @@ namespace Porygon{
             _hashValue = hashValue;
         }
 
+        const bool CanBeIndexedWith(ScriptType* indexer) const final{
+            if (indexer -> GetClass() != TypeClass::Number)
+                return false;
+            auto num = dynamic_cast<NumericScriptType*>(indexer);
+            return !(num->IsAwareOfFloat() && num->IsFloat());
+        }
+
+        const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
+            return make_shared<StringScriptType>(false, 0);
+        }
+
         const bool IsKnownAtBind() const{
             return _isKnownAtBind;
         }
@@ -110,14 +123,14 @@ namespace Porygon{
         shared_ptr<ScriptType> _valueType;
         // Consider adding a check whether the table actually contains a type if every key is static.
     public:
-        explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType) : ScriptType(TypeClass::Table){
-            _valueType = std::move(valueType);
+        explicit NumericalTableScriptType(shared_ptr<ScriptType> valueType)
+            : ScriptType(TypeClass::Table), _valueType(std::move(valueType)){
         }
 
         const bool CanBeIndexedWith(ScriptType* indexer) const final{
             if (indexer -> GetClass() != TypeClass::Number)
                 return false;
-            auto num =(NumericScriptType*)indexer;
+            auto num = dynamic_cast<NumericScriptType*>(indexer);
             return !(num->IsAwareOfFloat() && num->IsFloat());
         }
 
diff --git a/src/TableScriptType.hpp b/src/TableScriptType.hpp
index 5719565..be09760 100644
--- a/src/TableScriptType.hpp
+++ b/src/TableScriptType.hpp
@@ -31,7 +31,7 @@ namespace Porygon{
         }
 
         const shared_ptr<ScriptType> GetIndexedType(ScriptType* indexer) const final{
-            auto stringKey = (StringScriptType*)indexer;
+            auto stringKey = dynamic_cast<StringScriptType*>(indexer);
             if (stringKey->IsKnownAtBind()){
                 return _values-> at(Utilities::HashedString::CreateLookup(stringKey->GetHashValue()))->GetType();
             }
diff --git a/src/UserData/UserDataField.hpp b/src/UserData/UserDataField.hpp
index b161c76..ce320c5 100644
--- a/src/UserData/UserDataField.hpp
+++ b/src/UserData/UserDataField.hpp
@@ -12,10 +12,8 @@ namespace Porygon::UserData{
         Evaluation::EvalValue* (*_get)(void* obj);
         void (*_set)(void* obj, Evaluation::EvalValue* val);
     public:
-        UserDataField(ScriptType* type, Evaluation::EvalValue* (*getter)(void* obj), void (*setter)(void* obj, Evaluation::EvalValue* val)){
-            _type = shared_ptr<ScriptType>(type);
-            _get = getter;
-            _set = setter;
+        UserDataField(ScriptType* type, Evaluation::EvalValue* (*getter)(void* obj), void (*setter)(void* obj, Evaluation::EvalValue* val))
+            : _type(shared_ptr<ScriptType>(type)), _get(getter), _set(setter){
         }
 
         shared_ptr<ScriptType> GetType(){
diff --git a/src/UserData/UserDataScriptType.hpp b/src/UserData/UserDataScriptType.hpp
index a7ef803..eb67cf4 100644
--- a/src/UserData/UserDataScriptType.hpp
+++ b/src/UserData/UserDataScriptType.hpp
@@ -24,7 +24,7 @@ namespace Porygon::UserData {
             if (indexer->GetClass() != TypeClass::String) {
                 return false;
             }
-            auto str = (StringScriptType *) indexer;
+            auto str = dynamic_cast<StringScriptType*>(indexer);
             if (!str->IsKnownAtBind())
                 return false;
             return _userData->ContainsField(str->GetHashValue());
@@ -39,7 +39,7 @@ namespace Porygon::UserData {
         }
 
         const shared_ptr<ScriptType> GetIndexedType(ScriptType *indexer) const final {
-            auto stringKey = (StringScriptType *) indexer;
+            auto stringKey = dynamic_cast<StringScriptType*>(indexer);
             if (stringKey->IsKnownAtBind()) {
                 return _userData->GetField(stringKey->GetHashValue())->GetType();
             }