Removed sfml specific stuff
Merge branch 'remove-sfml'
Restructured scheme type head organization. They are no longer dependent on any inclusion order.
Renamed folder schemeTypeSystem => typeSystem
Implemented new type info system.
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h
new file mode 100644
index 0000000..ab0738c
--- /dev/null
+++ b/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h
@@ -0,0 +1,32 @@
+inline
+bool
+lcpp::SchemeObject::operator !=(const SchemeObject& rhs) const
+{
+    return !(*this == rhs);
+}
+
+//////////////////////////////////////////////////////////////////////////
+
+template<typename Derived, typename Base>
+inline
+const lcpp::SchemeTypeId&
+lcpp::SchemeExtend<Derived, Base>::type() const
+{
+    return SchemeTypeInfo<Derived>::type();
+}
+
+template<typename Derived, typename Base>
+inline
+bool
+lcpp::SchemeExtend<Derived, Base>::is(const SchemeTypeId& type) const
+{
+    return type.id == SchemeTypeInfo<Derived>::type().id;
+}
+
+template<typename Derived, typename Base>
+inline
+void
+lcpp::SchemeExtend<Derived, Base>::copyTo(void* mem) const
+{
+    new (mem) Derived(*static_cast<const Derived*>(this));
+}
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h
new file mode 100644
index 0000000..9f03aec
--- /dev/null
+++ b/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h
@@ -0,0 +1,24 @@
+inline
+lcpp::SchemeTypeId::SchemeTypeId() :
+    id(makeUniqueId()),
+    name(nullptr),
+    size(0),
+    alignment(0)
+{
+}
+
+inline
+ezUInt64
+lcpp::SchemeTypeId::makeUniqueId()
+{
+    // TODO Find a more elegant solution?
+    static ezUInt64 counter = 0;
+    return counter++;
+}
+
+inline
+bool
+lcpp::operator ==(const SchemeTypeId& lhs, const SchemeTypeId& rhs)
+{
+    return lhs.id == rhs.id;
+}
\ No newline at end of file
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/object.h b/source/lcppCore/include/lcpp/core/typeSystem/object.h
index ed456f2..aefcd1a 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/object.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/object.h
@@ -18,29 +18,28 @@ namespace lcpp

         virtual ~SchemeObject() = 0 {}
         virtual bool operator ==(const SchemeObject& other) const = 0;
-        virtual bool operator !=(const SchemeObject& rhs) const { return !(*this == rhs); }
+        virtual bool operator !=(const SchemeObject& rhs) const;
         virtual ezString toString() const = 0;

-        virtual SchemeType::Enum type() const = 0;
-        virtual bool is(SchemeType::Enum type) const = 0;
+        virtual const SchemeTypeId& type() const = 0;
+        virtual bool is(const SchemeTypeId& type) const = 0;

         virtual void copyTo(void* mem) const = 0;
-
-        virtual size_t size() const = 0;
-        virtual size_t alignment() const = 0;
-
-        virtual const char* name() const = 0;
     };
-
+
     template<>
-    struct SchemeTypeInfo<SchemeObject>
+    struct SchemeTypeInfo< SchemeObject >
     {
-        static size_t size() { return sizeof(SchemeObject); }
-        static SchemeType::Enum type() { return SchemeType::Object; }
-        static const char* name() { return "SchemeObject"; }
+        static const SchemeTypeId& type()
+        {
+            static SchemeTypeId instance;
+            instance.name = "SchemeNumber";
+            instance.size = instance.alignment = sizeof(SchemeObject);
+            return instance;
+        }
     };

-    /// \brief ...
+    /// \brief Class used to generate default overrides of SchemeObject.
     ///
     /// Has to derive from SchemeObject at some point!
     template<typename Derived, typename Base>
@@ -49,14 +48,11 @@ namespace lcpp
     public:
         virtual ~SchemeExtend() = 0 {}

-        virtual SchemeType::Enum type() const override { return SchemeTypeInfo<Derived>::type(); }
-        virtual bool is(SchemeType::Enum type) const override { return type == SchemeTypeInfo<Derived>::type(); }
+        virtual const SchemeTypeId& type() const override;
+        virtual bool is(const SchemeTypeId& type) const override;

-        virtual void copyTo(void* mem) const override { new (mem) Derived(*static_cast<const Derived*>(this)); }
-
-        virtual size_t size() const override { return sizeof(Derived); }
-        virtual size_t alignment() const override { return EZ_ALIGNMENT_OF(Derived); }
-
-        virtual const char* name() const override { return SchemeTypeInfo<Derived>::name(); }
+        virtual void copyTo(void* mem) const override;
     };
 }
+
+#include "lcpp/core/typeSystem/implementation/object_inl.h"
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/type.h b/source/lcppCore/include/lcpp/core/typeSystem/type.h
index a5575af..8712563 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/type.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/type.h
@@ -2,43 +2,58 @@

 namespace lcpp
 {
-    struct SchemeType
+    /// \brief Describes a scheme type
+    struct SchemeTypeId
     {
-        enum Enum
-        {
-            INVALID = -1,
-
-            Object,
-            Void,
-            Nil,
-            Bool,
-            Symbol,
-            Cons,
-            Number,
-            String,
-
-            NUM_ELEMENTS
-        };
-
-        LCPP_DISALLOW_CONSTRUCTION(SchemeType);
+        /// Is set automatically and will be unique for every new instance.
+        const ezUInt64 id;
+
+        /// \brief A human-readable name of this type.
+        const char* name;
+
+        /// \brief Number of bytes of this scheme type. Typically sizeof(T).
+        size_t size;
+
+        size_t alignment;
+
+
+        SchemeTypeId();
+
+    private:
+        static ezUInt64 makeUniqueId();
+
+        // Disallow assignment
+        void operator =(const SchemeTypeId&);
     };

+    bool operator ==(const SchemeTypeId& lhs, const SchemeTypeId& rhs);
+
     /// \brief Class that provides information about scheme types statically.
     /// \remark You have to specialize this template for all your scheme types!
+    ///         In order to make this easier, you can use the macros defined at
+    ///         the end of this file.
     template<typename T>
     struct SchemeTypeInfo
     {
-        /// \brief
-        static SchemeType::Enum type();
+        /// \brief Gets the instance of the SchemeType associated with T
+        static const SchemeTypeId& type();
+    };
+}

-        /// \brief Number of bytes an instance of T allocates. Typically sizeof(T).
-        static size_t size();
+#define DECLARE_SCHEME_TYPE_INFO_WITH_NAME(theType, theName) template<> \
+    struct SchemeTypeInfo<theType>                                      \
+    {                                                                   \
+        static const SchemeTypeId& type()                               \
+        {                                                               \
+            static SchemeTypeId instance;                               \
+            instance.name = theName;                                    \
+            instance.size = sizeof(theType);                            \
+            instance.alignment = EZ_ALIGNMENT_OF(theType);              \
+            return instance;                                            \
+        }                                                               \
+    }

-        /// \brief A human-readable name of this type.
-        static const char* name();
-    };
+#define DECLARE_SCHEME_TYPE_INFO(type) DECLARE_SCHEME_TYPE_INFO_WITH_NAME(type, #type)

-// Assumes that the type is called Scheme<typeValue>, e.g. for typeValue = Bool => SchemeBool
-#define LCPP_SCHEME_TYPE_DECLARATION(typeValue) virtual ::lcpp::SchemeType::Enum type() const override { return ::lcpp::SchemeType::typeValue; }\
-    virtual bool is(::lcpp::SchemeType::Enum type) const override { return type == ::lcpp::SchemeType::typeValue; }
-}
+
+#include "lcpp/core/typeSystem/implementation/type_inl.h"
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/bool.h b/source/lcppCore/include/lcpp/core/typeSystem/types/bool.h
index 5e08a2c..4391720 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/bool.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/bool.h
@@ -14,24 +14,20 @@ namespace lcpp
         SchemeBool(bool value);
         virtual ~SchemeBool();

-        virtual bool operator==(const SchemeObject& obj) const override;
+        virtual bool operator==(const SchemeObject& rhs) const override;
         virtual ezString toString() const override;

-        bool operator ==(const SchemeBool& rhs) const;
-
         operator bool() const;

+        bool value() const;
+
     private:
         const bool m_value;
     };

-    template<>
-    struct SchemeTypeInfo<SchemeBool>
-    {
-        inline static size_t size() { return sizeof(SchemeBool); }
-        inline static SchemeType::Enum type() { return SchemeType::Bool; }
-        inline static const char* name() { return "SchemeBool"; }
-    };
+    DECLARE_SCHEME_TYPE_INFO(SchemeBool);
+
+    bool operator ==(const SchemeBool& lhs, const SchemeBool& rhs);

 #define SCHEME_TRUE (::lcpp::SchemeBool::trueInstance())
 #define SCHEME_FALSE (::lcpp::SchemeBool::falseInstance())
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/cons.h b/source/lcppCore/include/lcpp/core/typeSystem/types/cons.h
index 17f6541..511907e 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/cons.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/cons.h
@@ -43,13 +43,7 @@ namespace lcpp
         void set(const SchemeObject*& member, const SchemeObject& from);
     };

-    template<>
-    struct SchemeTypeInfo<SchemeCons>
-    {
-        inline static size_t size() { return sizeof(SchemeCons); }
-        inline static SchemeType::Enum type() { return SchemeType::Cons; }
-        inline static const char* name() { return "SchemeCons"; }
-    };
+    DECLARE_SCHEME_TYPE_INFO(SchemeCons);
 }

 #include "lcpp/core/typeSystem/types/implementation/cons_inl.h"
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
index cd0a389..c0094a5 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
@@ -30,31 +30,41 @@ lcpp::SchemeBool::~SchemeBool()

 inline
 bool
-lcpp::SchemeBool::operator ==( const SchemeObject& obj ) const
+lcpp::SchemeBool::operator ==( const SchemeObject& rhs ) const
 {
-    if (obj.is(SchemeType::Bool))
+    if (rhs.is(SchemeTypeInfo<SchemeBool>::type()))
     {
-        return static_cast<const SchemeBool&>(obj) == *this;
+        return *this == static_cast<const SchemeBool&>(rhs);
     }
     return false;
 }

 inline
-bool
-lcpp::SchemeBool::operator ==( const SchemeBool& rhs ) const
+ezString
+lcpp::SchemeBool::toString() const
 {
-    return rhs.m_value == m_value;
+    static ezString trueString("#t");
+    static ezString falseString("#f");
+
+    return m_value ? trueString : falseString;
 }

 inline
-ezString
-lcpp::SchemeBool::toString() const
+lcpp::SchemeBool::operator bool() const
 {
-    return m_value ? "#t" : "#f";
+    return m_value;
 }

 inline
-lcpp::SchemeBool::operator bool() const
+bool
+lcpp::SchemeBool::value() const
 {
     return m_value;
 }
+
+inline
+bool
+lcpp::operator ==(const SchemeBool& lhs, const SchemeBool& rhs)
+{
+    return lhs.value() == rhs.value();
+}
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
index a970d19..05c7090 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
@@ -97,7 +97,7 @@ inline
 bool
 lcpp::SchemeCons::operator ==(const SchemeObject& obj) const
 {
-    if (obj.is(SchemeType::Cons))
+    if (obj.is(SchemeTypeInfo<SchemeCons>::type()))
     {
         return static_cast<const SchemeCons&>(obj) == *this;
     }
@@ -129,7 +129,7 @@ lcpp::SchemeCons::toStringHelper(ezStringBuilder& builder) const
 {
     // car
     // \remark This is more efficient than simply calling m_car->toString()
-    if (m_car->is(SchemeType::Cons))
+    if (m_car->is(SchemeTypeInfo<SchemeCons>::type()))
     {
         builder.Append('(');
         static_cast<const SchemeCons*>(m_car)->toStringHelper(builder);
@@ -148,7 +148,7 @@ lcpp::SchemeCons::toStringHelper(ezStringBuilder& builder) const

     builder.Append(' ');

-    if (m_cdr->is(SchemeType::Cons))
+    if (m_cdr->is(SchemeTypeInfo<SchemeCons>::type()))
     {
         static_cast<const SchemeCons*>(m_cdr)->toStringHelper(builder);
     }
@@ -180,18 +180,18 @@ inline
 void
 lcpp::SchemeCons::set(const SchemeObject*& member, const SchemeObject& from)
 {
-    size_t size = from.size();
+    size_t size = from.type().size;
     void* mem = nullptr;

     if (member == nullptr)
     {
-        mem = getAllocator().Allocate(size, from.alignment());
+        mem = getAllocator().Allocate(size, from.type().alignment);
     }
-    else if (size > member->size())
+    else if (size > member->type().size)
     {
         member->~SchemeObject();
         getAllocator().Deallocate((void*)member);
-        mem = getAllocator().Allocate(size, from.alignment());
+        mem = getAllocator().Allocate(size, from.type().alignment);
     }
     else
     {
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
index a4d6590..37b4cd5 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
@@ -22,11 +22,12 @@ inline
 bool
 lcpp::SchemeNil::operator ==(const SchemeObject& obj) const
 {
-    return obj.is(SchemeType::Nil);
+    return obj.is(SchemeTypeInfo<SchemeNil>::type());
 }
 inline
 ezString
 lcpp::SchemeNil::toString() const
 {
-    return "()";
+    static ezString voidString("()");
+    return voidString;
 }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
index be980fd..e2478c3 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
@@ -3,7 +3,7 @@
 template<typename NUMBER_TYPE>
 inline
 lcpp::SchemeNumber_t<NUMBER_TYPE>::SchemeNumber_t(number_t value) :
-m_value(value)
+    m_value(value)
 {
 }

@@ -18,7 +18,7 @@ inline
 bool
 lcpp::SchemeNumber_t<NUMBER_TYPE>::operator ==(const SchemeObject& obj) const
 {
-    if (obj.is(SchemeType::Number))
+    if (obj.is(SchemeTypeInfo<SchemeNumber_t<NUMBER_TYPE>>::type()))
     {
         return *this == static_cast<const type_t&>(obj); // Call the specialized operator ==
     }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
index c21999d..e67bad5 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
@@ -22,12 +22,13 @@ inline
 bool
 lcpp::SchemeVoid::operator ==(const SchemeObject& obj) const
 {
-    return obj.is(SchemeType::Void);
+    return obj.is(SchemeTypeInfo<SchemeVoid>::type());
 }

 inline
 ezString
 lcpp::SchemeVoid::toString() const
 {
-    return "#v";
+    static ezString voidString("#v");
+    return voidString;
 }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/nil.h b/source/lcppCore/include/lcpp/core/typeSystem/types/nil.h
index 7dbb731..d882ba4 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/nil.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/nil.h
@@ -17,15 +17,8 @@ namespace lcpp
         virtual ezString toString() const override;
     };

-    template<>
-    struct SchemeTypeInfo<SchemeNil>
-    {
-        inline static size_t size() { return sizeof(SchemeNil); }
-        inline static SchemeType::Enum type() { return SchemeType::Nil; }
-        inline static const char* name() { return "SchemeNil"; }
-    };
-
-#define SCHEME_NIL (::lcpp::SchemeNil::instance())
+    DECLARE_SCHEME_TYPE_INFO(SchemeNil);
 }
+#define SCHEME_NIL (::lcpp::SchemeNil::instance())

 #include "lcpp/core/typeSystem/types/implementation/nil_inl.h"
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/number.h b/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
index de722bc..8098555 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
@@ -8,8 +8,6 @@ namespace lcpp
         public SchemeExtend<SchemeNumber_t<NUMBER_TYPE>, SchemeObject>
     {
     public:
-        LCPP_SCHEME_TYPE_DECLARATION(Number);
-
         typedef NUMBER_TYPE number_t;
         typedef SchemeNumber_t<number_t> type_t;

@@ -216,9 +214,14 @@ namespace lcpp
     template<typename T>
     struct SchemeTypeInfo< SchemeNumber_t<T> >
     {
-        inline static size_t size() { return sizeof(SchemeNumber_t<T>); }
-        inline static SchemeType::Enum type() { return SchemeType::Number; }
-        inline static const char* name() { return "SchemeNumber"; }
+        static const SchemeTypeId& type()
+        {
+            static SchemeTypeId instance;
+            instance.name = "SchemeNumber";
+            instance.size = sizeof(SchemeNumber_t<T>);
+            instance.alignment = EZ_ALIGNMENT_OF(SchemeNumber_t<T>);
+            return instance;
+        }
     };
 }

diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/void.h b/source/lcppCore/include/lcpp/core/typeSystem/types/void.h
index 87b2f69..7eb62ad 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/void.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/void.h
@@ -17,15 +17,9 @@ namespace lcpp
         virtual ezString toString() const override;
     };

-    template<>
-    struct SchemeTypeInfo<SchemeVoid>
-    {
-        inline static size_t size() { return sizeof(SchemeVoid); }
-        inline static SchemeType::Enum type() { return SchemeType::Void; }
-        inline static const char* name() { return "SchemeVoid"; }
-    };
+    DECLARE_SCHEME_TYPE_INFO(SchemeVoid);
+}

 #define SCHEME_VOID (::lcpp::SchemeVoid::instance())
-}

 #include "lcpp/core/typeSystem/types/implementation/void_inl.h"
diff --git a/source/lcppCore/lcppCore.vcxproj b/source/lcppCore/lcppCore.vcxproj
index 2051c62..94210b6 100755
--- a/source/lcppCore/lcppCore.vcxproj
+++ b/source/lcppCore/lcppCore.vcxproj
@@ -23,6 +23,8 @@
     <ClInclude Include="include\lcpp\api_inl.h" />
     <ClInclude Include="include\lcpp\core\reader.h" />
     <ClInclude Include="include\lcpp\core\typeSystem.h" />
+    <ClInclude Include="include\lcpp\core\typeSystem\implementation\object_inl.h" />
+    <ClInclude Include="include\lcpp\core\typeSystem\implementation\type_inl.h" />
     <ClInclude Include="include\lcpp\core\typeSystem\types\bool.h" />
     <ClInclude Include="include\lcpp\core\typeSystem\types\cons.h" />
     <ClInclude Include="include\lcpp\core\typeSystem\types\implementation\bool_inl.h" />
diff --git a/source/lcppCore/src/lcpp/core/reader.cpp b/source/lcppCore/src/lcpp/core/reader.cpp
index 0261890..c4ad8b5 100755
--- a/source/lcppCore/src/lcpp/core/reader.cpp
+++ b/source/lcppCore/src/lcpp/core/reader.cpp
@@ -3,14 +3,12 @@

 #include "lcpp/exceptions/exceptions.h"

-lcpp::Reader::
-Reader()
+lcpp::Reader::Reader()
 {
     printf("Created reader.\n");
 }

-lcpp::Reader::
-~Reader()
+lcpp::Reader::~Reader()
 {
     printf("Destroyed reader.\n");
 }
diff --git a/source/lcppCore_unittests/include/toString.h b/source/lcppCore_unittests/include/toString.h
index 7703327..9d215b4 100755
--- a/source/lcppCore_unittests/include/toString.h
+++ b/source/lcppCore_unittests/include/toString.h
@@ -1,49 +1,68 @@
 #pragma once
-#define LCPP_UNITTESTS_FRAMEWORK_TOSTRING(typeName) namespace Microsoft {\
-namespace VisualStudio {\
-namespace CppUnitTestFramework { \
-    template<>                                                    \
-    static std::wstring ToString<typeName>(const typeName& value) \
-    {                                                             \
-        ezStringWChar result = value.toString().GetData();        \
-        return result.GetData();                                  \
-    }                                                             \
-}}}

-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeObject);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeVoid);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeBool);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeNil);
-
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeInt8);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeUInt8);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeInt16);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeUInt16);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeInt32);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeUInt32);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeInt64);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeUInt64);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeFloat);
-LCPP_UNITTESTS_FRAMEWORK_TOSTRING(lcpp::SchemeDouble);
+namespace lcpp { namespace unittests {

-namespace Microsoft { namespace VisualStudio { namespace CppUnitTestFramework {
+    template<typename T>
+    struct ToStringHelper
+    {
+        static std::wstring get(const T& object)
+        {
+            static_cast<const SchemeObject&>(object);

-    template<>
-    static std::wstring ToString<lcpp::SchemeType::Enum>(const lcpp::SchemeType::Enum& value)
+            ezStringWChar result(object.toString().GetData());
+            return result.GetData();
+        }
+    };
+
+    template<typename T>
+    struct ToStringHelper<SchemeNumber_t<T>>
     {
-        static_assert(lcpp::SchemeType::NUM_ELEMENTS == 8, "Keep this method in sync with lcpp::SchemeType::Enum!");
-        switch (value)
+        static std::wstring get(const SchemeNumber_t<T>& number)
         {
-        case lcpp::SchemeType::Object: return L"Object";
-        case lcpp::SchemeType::Void:   return L"Void";
-        case lcpp::SchemeType::Nil:    return L"Nil";
-        case lcpp::SchemeType::Bool:   return L"Bool";
-        case lcpp::SchemeType::Symbol: return L"Symbol";
-        case lcpp::SchemeType::Cons:   return L"Cons";
-        case lcpp::SchemeType::Number: return L"Number";
-        case lcpp::SchemeType::String: return L"String";
-        default: return L"<INVALID>";
+            ezStringWChar result = number.toString().GetData();
+            return result.GetData();
         }
+    };
+
+}}
+
+namespace Microsoft { namespace VisualStudio { namespace CppUnitTestFramework {
+
+    template<>
+    static std::wstring ToString<lcpp::SchemeTypeId>(const lcpp::SchemeTypeId& type)
+    {
+        ezStringWChar wide(type.name);
+        return wide.GetData();
+    }
+
+    template<>
+    static std::wstring ToString<lcpp::SchemeObject>(const lcpp::SchemeObject& object)
+    {
+        return lcpp::unittests::ToStringHelper<lcpp::SchemeObject>::get(object);
+    }
+
+    template<>
+    static std::wstring ToString<lcpp::SchemeVoid>(const lcpp::SchemeVoid& theVoid)
+    {
+        return lcpp::unittests::ToStringHelper<lcpp::SchemeVoid>::get(theVoid);
+    }
+
+    template<>
+    static std::wstring ToString<lcpp::SchemeBool>(const lcpp::SchemeBool& theBool)
+    {
+        return lcpp::unittests::ToStringHelper<lcpp::SchemeBool>::get(theBool);
+    }
+
+    template<>
+    static std::wstring ToString<lcpp::SchemeNil>(const lcpp::SchemeNil& nil)
+    {
+        return lcpp::unittests::ToStringHelper<lcpp::SchemeNil>::get(nil);
+    }
+
+    template<typename T>
+    static std::wstring ToString(const lcpp::SchemeNumber_t<T>& number)
+    {
+        return lcpp::unittests::ToStringHelper< lcpp::SchemeNumber_t<T> >::get(number);
     }

 // TODO: More here
diff --git a/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp b/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
index b6beee8..aa9daa0 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
@@ -9,12 +9,12 @@ namespace lcpp { namespace unittests {
     public:
         TEST_METHOD(type)
         {
-            Assert::AreEqual(SCHEME_VOID.type(), SchemeType::Void, L"SCHEME_VOID.type() did not return SchemeType::Void!");
-            Assert::IsTrue(SCHEME_VOID.is(SchemeType::Void), L"SCHEME_VOID.is() does not return true for argument SchemeType::Void!");
-            Assert::AreEqual(SCHEME_TRUE.type(), SchemeType::Bool, L"SCHEME_TRUE.type() did not return SchemeType::Bool!");
-            Assert::IsTrue(SCHEME_TRUE.is(SchemeType::Bool), L"SCHEME_TRUE.is() does not return true for argument SchemeType::Bool!");
-            Assert::AreEqual(SCHEME_FALSE.type(), SchemeType::Bool, L"SCHEME_FALSE.type() did not return SchemeType::Bool!");
-            Assert::IsTrue(SCHEME_FALSE.is(SchemeType::Bool), L"SCHEME_FALSE.is() does not return true for argument SchemeType::Bool!");
+            Assert::AreEqual(SCHEME_VOID.type(), SchemeTypeInfo<SchemeVoid>::type(), L"SCHEME_VOID.type() did not return SchemeType::Void!");
+            Assert::IsTrue(SCHEME_VOID.is(SchemeTypeInfo<SchemeVoid>::type()), L"SCHEME_VOID.is() does not return true for argument SchemeType::Void!");
+            Assert::AreEqual(SCHEME_TRUE.type(), SchemeTypeInfo<SchemeBool>::type(), L"SCHEME_TRUE.type() did not return SchemeType::Bool!");
+            Assert::IsTrue(SCHEME_TRUE.is(SchemeTypeInfo<SchemeBool>::type()), L"SCHEME_TRUE.is() does not return true for argument SchemeType::Bool!");
+            Assert::AreEqual(SCHEME_FALSE.type(), SchemeTypeInfo<SchemeBool>::type(), L"SCHEME_FALSE.type() did not return SchemeType::Bool!");
+            Assert::IsTrue(SCHEME_FALSE.is(SchemeTypeInfo<SchemeBool>::type()), L"SCHEME_FALSE.is() does not return true for argument SchemeType::Bool!");
         }
     };

diff --git a/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp b/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
index 8cf8b8d..2ec51ab 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
@@ -11,8 +11,8 @@ namespace lcpp { namespace unittests {

         TEST_METHOD(Type)
         {
-            Assert::IsTrue(SCHEME_TRUE.is(SchemeType::Bool), L"Wrong type declaration for SCHEME_TRUE!");
-            Assert::IsTrue(SCHEME_FALSE.is(SchemeType::Bool), L"Wrong type declaration for SCHEME_FALSE!");
+            Assert::IsTrue(SCHEME_TRUE.is(SchemeTypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_TRUE!");
+            Assert::IsTrue(SCHEME_FALSE.is(SchemeTypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_FALSE!");
         }

         TEST_METHOD(Equality)
diff --git a/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp b/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
index 9750182..0384bb6 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
@@ -10,8 +10,8 @@ namespace lcpp { namespace unittests {

         TEST_METHOD(Type)
         {
-            Assert::IsTrue(SCHEME_NIL.type() == SchemeType::Nil, L"SCHEME_NIL.type() does not return SchemeType::Nil!");
-            Assert::IsTrue(SCHEME_NIL.is(SchemeType::Nil), L"SCHEME_NIL.is(SchemeType::Nil returns false!");
+            Assert::AreEqual(SCHEME_NIL.type(), SchemeTypeInfo<SchemeNil>::type(), L"SCHEME_NIL.type() returns an incorrect type!");
+            Assert::IsTrue(SCHEME_NIL.is(SchemeTypeInfo<SchemeNil>::type()), L"SCHEME_NIL.is(...) is not working!");
         }

         TEST_METHOD(Equality)
Renamed SchemeTypeId => Type, SchemeTypeInfo => TypeInfo
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h
index ab0738c..77d02b4 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/implementation/object_inl.h
@@ -9,18 +9,18 @@ lcpp::SchemeObject::operator !=(const SchemeObject& rhs) const

 template<typename Derived, typename Base>
 inline
-const lcpp::SchemeTypeId&
+const lcpp::Type&
 lcpp::SchemeExtend<Derived, Base>::type() const
 {
-    return SchemeTypeInfo<Derived>::type();
+    return TypeInfo<Derived>::type();
 }

 template<typename Derived, typename Base>
 inline
 bool
-lcpp::SchemeExtend<Derived, Base>::is(const SchemeTypeId& type) const
+lcpp::SchemeExtend<Derived, Base>::is(const Type& type) const
 {
-    return type.id == SchemeTypeInfo<Derived>::type().id;
+    return type.id == TypeInfo<Derived>::type().id;
 }

 template<typename Derived, typename Base>
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h
index 9f03aec..135fe98 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/implementation/type_inl.h
@@ -1,5 +1,5 @@
 inline
-lcpp::SchemeTypeId::SchemeTypeId() :
+lcpp::Type::Type() :
     id(makeUniqueId()),
     name(nullptr),
     size(0),
@@ -9,7 +9,7 @@ lcpp::SchemeTypeId::SchemeTypeId() :

 inline
 ezUInt64
-lcpp::SchemeTypeId::makeUniqueId()
+lcpp::Type::makeUniqueId()
 {
     // TODO Find a more elegant solution?
     static ezUInt64 counter = 0;
@@ -18,7 +18,7 @@ lcpp::SchemeTypeId::makeUniqueId()

 inline
 bool
-lcpp::operator ==(const SchemeTypeId& lhs, const SchemeTypeId& rhs)
+lcpp::operator ==(const Type& lhs, const Type& rhs)
 {
     return lhs.id == rhs.id;
 }
\ No newline at end of file
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/object.h b/source/lcppCore/include/lcpp/core/typeSystem/object.h
index aefcd1a..d4c2922 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/object.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/object.h
@@ -21,21 +21,21 @@ namespace lcpp
         virtual bool operator !=(const SchemeObject& rhs) const;
         virtual ezString toString() const = 0;

-        virtual const SchemeTypeId& type() const = 0;
-        virtual bool is(const SchemeTypeId& type) const = 0;
+        virtual const Type& type() const = 0;
+        virtual bool is(const Type& type) const = 0;

         virtual void copyTo(void* mem) const = 0;
     };

     template<>
-    struct SchemeTypeInfo< SchemeObject >
+    struct TypeInfo< SchemeObject >
     {
-        static const SchemeTypeId& type()
+        static const Type& type()
         {
-            static SchemeTypeId instance;
-            instance.name = "SchemeNumber";
-            instance.size = instance.alignment = sizeof(SchemeObject);
-            return instance;
+            static Type theType;
+            theType.name = "SchemeObject";
+            theType.size = theType.alignment = sizeof(SchemeObject);
+            return theType;
         }
     };

@@ -48,8 +48,8 @@ namespace lcpp
     public:
         virtual ~SchemeExtend() = 0 {}

-        virtual const SchemeTypeId& type() const override;
-        virtual bool is(const SchemeTypeId& type) const override;
+        virtual const Type& type() const override;
+        virtual bool is(const Type& type) const override;

         virtual void copyTo(void* mem) const override;
     };
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/type.h b/source/lcppCore/include/lcpp/core/typeSystem/type.h
index 8712563..b9b781c 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/type.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/type.h
@@ -3,7 +3,7 @@
 namespace lcpp
 {
     /// \brief Describes a scheme type
-    struct SchemeTypeId
+    struct Type
     {
         /// Is set automatically and will be unique for every new instance.
         const ezUInt64 id;
@@ -17,35 +17,35 @@ namespace lcpp
         size_t alignment;

-        SchemeTypeId();
+        Type();

     private:
         static ezUInt64 makeUniqueId();

         // Disallow assignment
-        void operator =(const SchemeTypeId&);
+        void operator =(const Type&);
     };

-    bool operator ==(const SchemeTypeId& lhs, const SchemeTypeId& rhs);
+    bool operator ==(const Type& lhs, const Type& rhs);

     /// \brief Class that provides information about scheme types statically.
     /// \remark You have to specialize this template for all your scheme types!
     ///         In order to make this easier, you can use the macros defined at
     ///         the end of this file.
     template<typename T>
-    struct SchemeTypeInfo
+    struct TypeInfo
     {
-        /// \brief Gets the instance of the SchemeType associated with T
-        static const SchemeTypeId& type();
+        /// \brief Gets the instance of the Type associated with T
+        static const Type& type();
     };
 }

 #define DECLARE_SCHEME_TYPE_INFO_WITH_NAME(theType, theName) template<> \
-    struct SchemeTypeInfo<theType>                                      \
+    struct TypeInfo<theType>                                      \
     {                                                                   \
-        static const SchemeTypeId& type()                               \
+        static const Type& type()                               \
         {                                                               \
-            static SchemeTypeId instance;                               \
+            static Type instance;                               \
             instance.name = theName;                                    \
             instance.size = sizeof(theType);                            \
             instance.alignment = EZ_ALIGNMENT_OF(theType);              \
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
index c0094a5..c38aa89 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/bool_inl.h
@@ -32,7 +32,7 @@ inline
 bool
 lcpp::SchemeBool::operator ==( const SchemeObject& rhs ) const
 {
-    if (rhs.is(SchemeTypeInfo<SchemeBool>::type()))
+    if (rhs.is(TypeInfo<SchemeBool>::type()))
     {
         return *this == static_cast<const SchemeBool&>(rhs);
     }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
index 05c7090..46ceff0 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/cons_inl.h
@@ -97,7 +97,7 @@ inline
 bool
 lcpp::SchemeCons::operator ==(const SchemeObject& obj) const
 {
-    if (obj.is(SchemeTypeInfo<SchemeCons>::type()))
+    if (obj.is(TypeInfo<SchemeCons>::type()))
     {
         return static_cast<const SchemeCons&>(obj) == *this;
     }
@@ -129,7 +129,7 @@ lcpp::SchemeCons::toStringHelper(ezStringBuilder& builder) const
 {
     // car
     // \remark This is more efficient than simply calling m_car->toString()
-    if (m_car->is(SchemeTypeInfo<SchemeCons>::type()))
+    if (m_car->is(TypeInfo<SchemeCons>::type()))
     {
         builder.Append('(');
         static_cast<const SchemeCons*>(m_car)->toStringHelper(builder);
@@ -148,7 +148,7 @@ lcpp::SchemeCons::toStringHelper(ezStringBuilder& builder) const

     builder.Append(' ');

-    if (m_cdr->is(SchemeTypeInfo<SchemeCons>::type()))
+    if (m_cdr->is(TypeInfo<SchemeCons>::type()))
     {
         static_cast<const SchemeCons*>(m_cdr)->toStringHelper(builder);
     }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
index 37b4cd5..0001ea9 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/nil_inl.h
@@ -22,7 +22,7 @@ inline
 bool
 lcpp::SchemeNil::operator ==(const SchemeObject& obj) const
 {
-    return obj.is(SchemeTypeInfo<SchemeNil>::type());
+    return obj.is(TypeInfo<SchemeNil>::type());
 }
 inline
 ezString
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
index e2478c3..f40da4c 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/number_inl.h
@@ -18,7 +18,7 @@ inline
 bool
 lcpp::SchemeNumber_t<NUMBER_TYPE>::operator ==(const SchemeObject& obj) const
 {
-    if (obj.is(SchemeTypeInfo<SchemeNumber_t<NUMBER_TYPE>>::type()))
+    if (obj.is(TypeInfo<SchemeNumber_t<NUMBER_TYPE>>::type()))
     {
         return *this == static_cast<const type_t&>(obj); // Call the specialized operator ==
     }
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
index e67bad5..156da82 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/implementation/void_inl.h
@@ -22,7 +22,7 @@ inline
 bool
 lcpp::SchemeVoid::operator ==(const SchemeObject& obj) const
 {
-    return obj.is(SchemeTypeInfo<SchemeVoid>::type());
+    return obj.is(TypeInfo<SchemeVoid>::type());
 }

 inline
diff --git a/source/lcppCore/include/lcpp/core/typeSystem/types/number.h b/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
index 8098555..13a6b33 100644
--- a/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
+++ b/source/lcppCore/include/lcpp/core/typeSystem/types/number.h
@@ -212,11 +212,11 @@ namespace lcpp
     typedef SchemeNumber_t<double> SchemeDouble;

     template<typename T>
-    struct SchemeTypeInfo< SchemeNumber_t<T> >
+    struct TypeInfo< SchemeNumber_t<T> >
     {
-        static const SchemeTypeId& type()
+        static const Type& type()
         {
-            static SchemeTypeId instance;
+            static Type instance;
             instance.name = "SchemeNumber";
             instance.size = sizeof(SchemeNumber_t<T>);
             instance.alignment = EZ_ALIGNMENT_OF(SchemeNumber_t<T>);
diff --git a/source/lcppCore_unittests/include/toString.h b/source/lcppCore_unittests/include/toString.h
index 9d215b4..42cfa93 100755
--- a/source/lcppCore_unittests/include/toString.h
+++ b/source/lcppCore_unittests/include/toString.h
@@ -29,7 +29,7 @@ namespace lcpp { namespace unittests {
 namespace Microsoft { namespace VisualStudio { namespace CppUnitTestFramework {

     template<>
-    static std::wstring ToString<lcpp::SchemeTypeId>(const lcpp::SchemeTypeId& type)
+    static std::wstring ToString<lcpp::Type>(const lcpp::Type& type)
     {
         ezStringWChar wide(type.name);
         return wide.GetData();
diff --git a/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp b/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
index aa9daa0..5031892 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/basics.cpp
@@ -4,17 +4,17 @@ using namespace Microsoft::VisualStudio::CppUnitTestFramework;

 namespace lcpp { namespace unittests {

-    TEST_CLASS(SchemeTypeTests)
+    TEST_CLASS(TypeTests)
     {
     public:
         TEST_METHOD(type)
         {
-            Assert::AreEqual(SCHEME_VOID.type(), SchemeTypeInfo<SchemeVoid>::type(), L"SCHEME_VOID.type() did not return SchemeType::Void!");
-            Assert::IsTrue(SCHEME_VOID.is(SchemeTypeInfo<SchemeVoid>::type()), L"SCHEME_VOID.is() does not return true for argument SchemeType::Void!");
-            Assert::AreEqual(SCHEME_TRUE.type(), SchemeTypeInfo<SchemeBool>::type(), L"SCHEME_TRUE.type() did not return SchemeType::Bool!");
-            Assert::IsTrue(SCHEME_TRUE.is(SchemeTypeInfo<SchemeBool>::type()), L"SCHEME_TRUE.is() does not return true for argument SchemeType::Bool!");
-            Assert::AreEqual(SCHEME_FALSE.type(), SchemeTypeInfo<SchemeBool>::type(), L"SCHEME_FALSE.type() did not return SchemeType::Bool!");
-            Assert::IsTrue(SCHEME_FALSE.is(SchemeTypeInfo<SchemeBool>::type()), L"SCHEME_FALSE.is() does not return true for argument SchemeType::Bool!");
+            Assert::AreEqual(SCHEME_VOID.type(), TypeInfo<SchemeVoid>::type(), L"SCHEME_VOID.type() did not return Type::Void!");
+            Assert::IsTrue(SCHEME_VOID.is(TypeInfo<SchemeVoid>::type()), L"SCHEME_VOID.is() does not return true for argument Type::Void!");
+            Assert::AreEqual(SCHEME_TRUE.type(), TypeInfo<SchemeBool>::type(), L"SCHEME_TRUE.type() did not return Type::Bool!");
+            Assert::IsTrue(SCHEME_TRUE.is(TypeInfo<SchemeBool>::type()), L"SCHEME_TRUE.is() does not return true for argument Type::Bool!");
+            Assert::AreEqual(SCHEME_FALSE.type(), TypeInfo<SchemeBool>::type(), L"SCHEME_FALSE.type() did not return Type::Bool!");
+            Assert::IsTrue(SCHEME_FALSE.is(TypeInfo<SchemeBool>::type()), L"SCHEME_FALSE.is() does not return true for argument Type::Bool!");
         }
     };

diff --git a/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp b/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
index 2ec51ab..d4b6ea3 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/bool.cpp
@@ -11,8 +11,8 @@ namespace lcpp { namespace unittests {

         TEST_METHOD(Type)
         {
-            Assert::IsTrue(SCHEME_TRUE.is(SchemeTypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_TRUE!");
-            Assert::IsTrue(SCHEME_FALSE.is(SchemeTypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_FALSE!");
+            Assert::IsTrue(SCHEME_TRUE.is(TypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_TRUE!");
+            Assert::IsTrue(SCHEME_FALSE.is(TypeInfo<SchemeBool>::type()), L"Wrong type declaration for SCHEME_FALSE!");
         }

         TEST_METHOD(Equality)
diff --git a/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp b/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
index 0384bb6..36b9a6f 100755
--- a/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
+++ b/source/lcppCore_unittests/src/core/schemeTypes/nil.cpp
@@ -10,8 +10,8 @@ namespace lcpp { namespace unittests {

         TEST_METHOD(Type)
         {
-            Assert::AreEqual(SCHEME_NIL.type(), SchemeTypeInfo<SchemeNil>::type(), L"SCHEME_NIL.type() returns an incorrect type!");
-            Assert::IsTrue(SCHEME_NIL.is(SchemeTypeInfo<SchemeNil>::type()), L"SCHEME_NIL.is(...) is not working!");
+            Assert::AreEqual(SCHEME_NIL.type(), TypeInfo<SchemeNil>::type(), L"SCHEME_NIL.type() returns an incorrect type!");
+            Assert::IsTrue(SCHEME_NIL.is(TypeInfo<SchemeNil>::type()), L"SCHEME_NIL.is(...) is not working!");
         }

         TEST_METHOD(Equality)
diff --git a/source/lcppCore_unittests/src/setup.cpp b/source/lcppCore_unittests/src/setup.cpp
index e72d39b..3fe3991 100755
--- a/source/lcppCore_unittests/src/setup.cpp
+++ b/source/lcppCore_unittests/src/setup.cpp
@@ -2,12 +2,12 @@

 namespace lcpp { namespace unittests {

-    TEST_MODULE_INITIALIZE(SchemeTypeTests_Initialize)
+    TEST_MODULE_INITIALIZE(TypeTests_Initialize)
     {
         ezStartup::StartupCore();
     }

-    TEST_MODULE_CLEANUP(SchemeTypeTests_Cleanup)
+    TEST_MODULE_CLEANUP(TypeTests_Cleanup)
     {
         ezStartup::ShutdownBase();
     }
Converted all source files to utf-8 with BOM and unix line endings ('\n').
Enhanced scheme number operators and eliminated the use of the type_t typedef.