diff --git a/cmake/FetchBoost.cmake b/cmake/FetchBoost.cmake
index 73a7a2c6..eaddcacc 100644
--- a/cmake/FetchBoost.cmake
+++ b/cmake/FetchBoost.cmake
@@ -6,5 +6,5 @@ FetchContent_Declare(
         EXCLUDE_FROM_ALL
 )
 
-set(BOOST_INCLUDE_LIBRARIES any callable_traits mpl)
+set(BOOST_INCLUDE_LIBRARIES any assign bimap callable_traits mpl)
 FetchContent_MakeAvailable(Boost)
\ No newline at end of file
diff --git a/include/Oasis/Concepts.hpp b/include/Oasis/Concepts.hpp
index 94500df4..a5be810c 100644
--- a/include/Oasis/Concepts.hpp
+++ b/include/Oasis/Concepts.hpp
@@ -39,6 +39,9 @@ class BinaryExpression;
 template <template <IExpression> class DerivedT, IExpression OpT>
 class UnaryExpression;
 
+template <typename DerivedT>
+class LeafExpression;
+
 /**
  * Checks if type T is same as any of the provided types in U.
  *
@@ -59,6 +62,9 @@ concept DerivedFromUnaryExpression = requires(Derived& d) {
     []<template <typename> typename D, IExpression T>(UnaryExpression<D, T>&) { }(d);
 };
 
+template <typename T>
+concept DerivedFromLeafExpression = std::derived_from<T, LeafExpression<T>>;
+
 template <typename T>
 concept IVisitor = requires {
     typename T::RetT; // Checks for the type alias
diff --git a/io/CMakeLists.txt b/io/CMakeLists.txt
index 9ce85dea..ffa71a98 100644
--- a/io/CMakeLists.txt
+++ b/io/CMakeLists.txt
@@ -1,7 +1,12 @@
 set(OASIS_IO_SOURCES
     # cmake-format: sortable
-    src/FromPALM.cpp src/FromString.cpp src/InFixSerializer.cpp
-    src/MathMLSerializer.cpp src/TeXSerializer.cpp)
+    src/FromPALM.cpp
+    src/FromString.cpp
+    src/InFixSerializer.cpp
+    src/MathMLSerializer.cpp
+    src/PALMSerializer.cpp
+    src/PALMTokenizer.cpp
+    src/TeXSerializer.cpp)
 
 set(OASIS_IO_HEADERS
     # cmake-format: sortable
@@ -9,12 +14,21 @@ set(OASIS_IO_HEADERS
     include/Oasis/FromString.hpp
     include/Oasis/InFixSerializer.hpp
     include/Oasis/MathMLSerializer.hpp
-    include/Oasis/TeXSerializer.hpp)
+    include/Oasis/PALMSerializer.hpp
+    include/Oasis/TeXSerializer.hpp
+    src/PALMHelper.hpp)
 
 add_library(OasisIO ${OASIS_IO_SOURCES} ${OASIS_IO_HEADERS})
 add_library(Oasis::IO ALIAS OasisIO)
 
 target_include_directories(OasisIO PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include)
+if(NOT OASIS_BUILD_JS)
+    target_link_libraries(OasisIO PUBLIC Boost::bimap)
+    target_link_libraries(OasisIO PUBLIC Boost::assign)
+    target_include_directories(OasisIO PUBLIC ${Boost_INCLUDE_DIRS})
+    target_include_directories(OasisIO
+                               PRIVATE ${Boost_SOURCE_DIR}/libs/assign/include)
+endif()
 target_link_libraries(OasisIO PUBLIC Oasis::Oasis tinyxml2::tinyxml2)
 
 if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC")
diff --git a/io/include/Oasis/FromPALM.hpp b/io/include/Oasis/FromPALM.hpp
index c1ab5a6f..3ab558fd 100644
--- a/io/include/Oasis/FromPALM.hpp
+++ b/io/include/Oasis/FromPALM.hpp
@@ -6,25 +6,64 @@
 #define OASIS_FROMPALM_HPP
 
 #include "Oasis/Expression.hpp"
+#include "../src/PALMTypes.hpp"
 
 namespace Oasis {
 
-enum class ParseError {
+enum class ParseErrorOld {
     None,
-    UnexpectedToken,
-    MissingClosingParen,
-    InvalidNumberFormat,
-    IncompleteExpression,
-    UnknownOperator,
-    UnexpectedEndOfInput
+    IncompleteExpression, // expression opens but required operands/args missing
+    MissingClosingParen, // '(' without matching ')'
+    UnexpectedEndOfInput, // input ended while more tokens were required
+    UnexpectedToken, // token present but not valid in this position
+    InvalidNumberFormat, // number failed to parse
+    UnknownOperator, // operator not recognized
+    TooManyOperands, // more expressions than operator's arity allows
+    TooFewOperands, // fewer expressions than operator's arity requires
+    AmbiguousParse, // grammar ambiguity or overload not resolvable
+    LexicalError, // tokenization error (bad character, unterminated string)
+    Other // fallback
 };
 
+/* Represents a parse error in PALM parsing. */
+struct PALMParseError {
+    enum class PALMParseErrorType {
+        None,
+        InvalidNumberFormat,
+        InvalidVariableName,
+        InvalidOperator,
+        InvalidOperand,
+        NumberOutOfBounds,
+        LexicalError,
+        MissingOperator,
+        MissingOperand,
+        ExtraOperands,
+        UnexpectedToken,
+        UnexpectedEndOfInput,
+        MissingOpeningParenthesis,
+        MissingClosingParenthesis,
+    } type;
+
+    PALMToken token;
+    std::string message;
+};
+
+/** Equality operator for PALMParseError.
+ *
+ * @param lhs The left-hand side PALMParseError.
+ * @param rhs The right-hand side PALMParseError.
+ * @return True if the two errors are equal, false otherwise.
+ */
+bool operator==(const PALMParseError& lhs, const PALMParseError& rhs);
+
 /** Parses an expression from a PALM string.
  *
  * @param palmString The PALM string to parse.
  * @return The parsed expression, or nullptr if the string could not be parsed.
  */
-auto FromPALM(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto FromPALMOld(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
+
+auto FromPALM(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, PALMParseError>;
 }
 
 #endif // OASIS_FROMPALM_HPP
diff --git a/io/include/Oasis/PALMSerializer.hpp b/io/include/Oasis/PALMSerializer.hpp
new file mode 100644
index 00000000..34a77113
--- /dev/null
+++ b/io/include/Oasis/PALMSerializer.hpp
@@ -0,0 +1,102 @@
+//
+// Created by codin on 10/31/25.
+//
+
+#ifndef OASIS_PALMSERIALIZER_HPP
+#define OASIS_PALMSERIALIZER_HPP
+
+#include <format>
+#include <string>
+#include <vector>
+
+#include "../../src/PALMTypes.hpp"
+#include "Oasis/Visit.hpp"
+#include "Oasis/Expression.hpp"
+
+namespace Oasis {
+
+/** Options for PALM serialization. */
+struct PALMSerializationOpts {
+    enum class ImgSymType {
+        I,
+        J
+    } imaginarySymbol
+        = ImgSymType::I;
+
+    uint8_t numPlaces = 5;
+
+    std::string tokenSeparator = " ";
+
+    std::string expressionPadding = " ";
+};
+
+struct PALMSerializationError {
+    enum class PALMSerializationErrorType {
+        None,
+        InvalidIdentifier,
+        MissingOperand,
+        Other
+    } type;
+
+    const Expression* expression;
+    std::string message;
+};
+
+/** Equality operator for PALMSerializationError.
+ *
+ * @param lhs The left-hand side PALMSerializationError.
+ * @param rhs The right-hand side PALMSerializationError.
+ * @return True if the two errors are equal, false otherwise.
+ */
+bool operator==(const PALMSerializationError& lhs, const PALMSerializationError& rhs);
+
+inline std::string_view PALM_UNEXPECTED_NO_MOST_SIG_OP = "Expression missing most significant operand";
+inline std::string_view PALM_UNEXPECTED_NO_LEAST_SIG_OP = "Expression missing least significant operand";
+
+class PALMSerializer final : public TypedVisitor<std::expected<std::string, PALMSerializationError>> {
+public:
+    PALMSerializer()
+        : PALMSerializer(PALMSerializationOpts {})
+    {
+    }
+    explicit PALMSerializer(PALMSerializationOpts options)
+        : palmOptions(std::move(options))
+    {
+    }
+
+    auto TypedVisit(const Real& real) -> RetT override;
+    auto TypedVisit(const Imaginary& imaginary) -> RetT override;
+    auto TypedVisit(const Variable& variable) -> RetT override;
+    auto TypedVisit(const Undefined& undefined) -> RetT override;
+    auto TypedVisit(const Add<Expression, Expression>& add) -> RetT override;
+    auto TypedVisit(const Subtract<Expression, Expression>& subtract) -> RetT override;
+    auto TypedVisit(const Multiply<Expression, Expression>& multiply) -> RetT override;
+    auto TypedVisit(const Divide<Expression, Expression>& divide) -> RetT override;
+    auto TypedVisit(const Exponent<Expression, Expression>& exponent) -> RetT override;
+    auto TypedVisit(const Log<Expression, Expression>& log) -> RetT override;
+    auto TypedVisit(const Negate<Expression>& negate) -> RetT override;
+    auto TypedVisit(const Derivative<Expression, Expression>& derivative) -> RetT override;
+    auto TypedVisit(const Integral<Expression, Expression>& integral) -> RetT override;
+    auto TypedVisit(const Matrix& matrix) -> RetT override;
+    auto TypedVisit(const EulerNumber&) -> RetT override;
+    auto TypedVisit(const Pi&) -> RetT override;
+    auto TypedVisit(const Magnitude<Expression>& magnitude) -> RetT override;
+    ~PALMSerializer() override = default;
+
+private:
+    PALMSerializationOpts palmOptions {};
+
+    static inline auto OperatorToToken(ExpressionType op, const PALMSerializationOpts& options) -> std::string_view;
+    static inline auto PunctuatorToToken(PALMPunctuatorType punctuator, const PALMSerializationOpts& options) -> std::string_view;
+
+    [[nodiscard]] auto WrapExpression(ExpressionType expressionType, const std::initializer_list<std::expected<std::string, PALMSerializationError>>& operands = {}) const -> RetT;
+    static auto IsValidIdentifier(const std::string& string) -> bool;
+
+    auto SerializeExpression(const DerivedFromLeafExpression auto& expr) -> RetT;
+    auto SerializeExpression(const DerivedFromUnaryExpression auto& expr) -> RetT;
+    auto SerializeExpression(const DerivedFromBinaryExpression auto& expr) -> RetT;
+};
+
+}
+
+#endif // OASIS_PALMSERIALIZER_HPP
diff --git a/io/src/FromPALM.cpp b/io/src/FromPALM.cpp
index 4768ff33..a259f3ae 100644
--- a/io/src/FromPALM.cpp
+++ b/io/src/FromPALM.cpp
@@ -21,28 +21,10 @@
 #include "Oasis/Pi.hpp"
 #include "Oasis/Real.hpp"
 #include "Oasis/Subtract.hpp"
-
 #include "Oasis/Variable.hpp"
 
-// Define PALM tokens
-constexpr std::string_view PALM_OPEN_PARENS = "(";
-constexpr std::string_view PALM_CLOSE_PARENS = ")";
-
-constexpr std::string_view PALM_REAL = "real";
-constexpr std::array<std::string_view, 2> PALM_IMAGINARY = { "i", "j" };
-constexpr std::string_view PALM_VARIABLE = "var";
-constexpr std::string_view PALM_ADD = "+";
-constexpr std::string_view PALM_SUBTRACT = "-";
-constexpr std::string_view PALM_MULTIPLY = "*";
-constexpr std::string_view PALM_DIVIDE = "/";
-constexpr std::string_view PALM_EXPONENT = "^";
-constexpr std::string_view PALM_LOG = "log";
-constexpr std::string_view PALM_INTEGRAL = "int";
-constexpr std::string_view PALM_NEGATE = "neg";
-constexpr std::string_view PALM_DERIVATIVE = "d";
-// constexpr std::string_view PALM_MATRIX = "matrix";
-constexpr std::array<std::string_view, 1> PALM_PI = { "pi" };
-constexpr std::string_view PALM_EULER = "e";
+#include "PALMHelper.hpp"
+#include "PALMTokenizer.hpp"
 
 namespace Oasis {
 /** A simple token stream for parsing PALM strings.
@@ -122,119 +104,119 @@ auto isPiToken(const std::string& token) -> bool;
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseExpression(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseExpression(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an operation from a stream of tokens.
  * Operation -> Add | Subtract | Multiply | Divide | Exponent
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseOperation(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseOperation(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a real number from a stream of tokens.
  * Real -> std::stod(token)
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseReal(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseReal(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an imaginary unit from a stream of tokens.
  * Imaginary -> 'i' | 'j'
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseImaginary(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseImaginary(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a variable from a stream of tokens.
  * Variable -> std::string(token)
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseVariable(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseVariable(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an addition operation from a stream of tokens.
  * Add -> '+' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseAdd(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseAdd(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a subtraction operation from a stream of tokens.
  * Subtract -> '-' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseSubtract(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseSubtract(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a multiplication operation from a stream of tokens.
  * Multiply -> '*' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseMultiply(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseMultiply(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a division operation from a stream of tokens.
  * Divide -> '/' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseDivide(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseDivide(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an exponentiation operation from a stream of tokens.
  * Exponent -> '^' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseExponent(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseExponent(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a logarithm operation from a stream of tokens.
  * Log -> 'log' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseLog(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseLog(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an integral operation from a stream of tokens.
  * Integral -> 'int' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseIntegral(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseIntegral(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a negate operation from a stream of tokens.
  * Negate -> 'neg' UnaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseNegate(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseNegate(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a derivative operation from a stream of tokens.
  * Derivative -> 'd' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseDerivative(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseDerivative(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a matrix operation from a stream of tokens.
  * Matrix -> 'matrix' BinaryElements
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseMatrix(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseMatrix(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses a pi constant from a stream of tokens.
  * Pi -> 'pi' | '\pi' | 'π'
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParsePi(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParsePi(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an euler number constant from a stream of tokens.
  * EulerNumber -> 'e'
  * @param tokens The stream of tokens to parse.
  * @return The parsed expression.
  */
-auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an operation that takes two operands from a stream of tokens.
  * @param token The operator token.
@@ -243,7 +225,7 @@ auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expr
  */
 template <template <typename, typename> typename T>
     requires IAssociativeAndCommutative<T>
-auto ParseBinaryOperationAssociativeAndCommutative(std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseBinaryOperationAssociativeAndCommutative(std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses an operation that takes two operands from a stream of tokens.
  * @param token The operator token.
@@ -252,31 +234,35 @@ auto ParseBinaryOperationAssociativeAndCommutative(std::string_view token, Token
  */
 template <template <typename, typename> typename T>
     requires IExpression<T<Expression, Expression>> && (!IAssociativeAndCommutative<T>)
-auto ParseBinaryOperationNonAssociativeAndCommutative(std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>;
+auto ParseBinaryOperationNonAssociativeAndCommutative(std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>;
 
 /** Parses binary elements from a stream of tokens.
  * BinaryElements -> Expression Expression Expression*
  * @param tokens The stream of tokens to parse.
  * @return The parsed expressions.
  */
-auto ParseBinaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>;
+auto ParseBinaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>;
 
 /** Parses unary elements from a stream of tokens.
  * UnaryElements -> Expression Expression*
  * @param tokens The stream of tokens to parse.
  * @return The parsed expressions.
  */
-auto ParseUnaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>;
+auto ParseUnaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>;
 
 /** Parses nullary elements from a stream of tokens.
  * NullaryOperationElements -> Expression*
  * @param tokens The stream of tokens to parse.
  * @return The parsed expressions.
  */
-auto ParseNullaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>;
+auto ParseNullaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>;
 
+bool operator==(const PALMParseError& lhs, const PALMParseError& rhs)
+{
+    return lhs.token == rhs.token && lhs.type == rhs.type && lhs.message == rhs.message;
+}
 // PALM Grammar Start -> Expression $$
-auto FromPALM(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto FromPALMOld(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Tokenize the input string
     auto tokens = TokenizePALM(palmString);
@@ -292,7 +278,31 @@ auto FromPALM(const std::string& palmString) -> std::expected<std::unique_ptr<Ex
     }
 
     // Parsing failed
-    return std::unexpected { ParseError::UnexpectedToken };
+    return std::unexpected { ParseErrorOld::UnexpectedToken };
+}
+auto FromPALM(const std::string& palmString) -> std::expected<std::unique_ptr<Expression>, PALMParseError>
+{
+    // String to input stream
+    auto inputStream = std::istringstream(palmString);
+    auto tokenizer = PALMTokenizer(inputStream);
+
+    auto token = tokenizer.lookahead();
+
+    while (!tokenizer.eof()) {
+        // Process token
+        tokenizer.match(token);
+        token = tokenizer.lookahead();
+    }
+
+    if (auto oldResult = FromPALMOld(palmString)) {
+        return std::move(*oldResult);
+    }
+
+    return std::unexpected { PALMParseError {
+        .type = PALMParseError::PALMParseErrorType::None,
+        .token = token,
+        .message = "FromPALMNew not yet implemented."
+    } };
 }
 
 auto TokenizePALM(const std::string& palmString) -> TokenStream
@@ -317,7 +327,7 @@ auto isPiToken(const std::string& token) -> bool
     return isTokenFromArray(token, PALM_PI);
 }
 
-auto ParseExpression(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseExpression(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Expression -> '(' Operation ')'
     if (tokens.peek() == PALM_OPEN_PARENS) {
@@ -332,20 +342,20 @@ auto ParseExpression(TokenStream& tokens) -> std::expected<std::unique_ptr<Expre
 
         // Consume ')'
         if (tokens.pop() != PALM_CLOSE_PARENS)
-            return std::unexpected { ParseError::MissingClosingParen };
+            return std::unexpected { ParseErrorOld::MissingClosingParen };
 
         return innerExpr;
     }
 
     if (tokens.peek().empty()) {
-        return std::unexpected { ParseError::UnexpectedEndOfInput };
+        return std::unexpected { ParseErrorOld::UnexpectedEndOfInput };
     }
 
     // Unable to parse expression
-    return std::unexpected { ParseError::UnexpectedToken };
+    return std::unexpected { ParseErrorOld::UnexpectedToken };
 }
 
-auto ParseOperation(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseOperation(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     std::string token = tokens.peek();
@@ -420,14 +430,14 @@ auto ParseOperation(TokenStream& tokens) -> std::expected<std::unique_ptr<Expres
     }
 
     // Unable to parse operation
-    return std::unexpected { ParseError::UnknownOperator };
+    return std::unexpected { ParseErrorOld::UnknownOperator };
 }
 
-auto ParseReal(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseReal(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (tokens.peek() != PALM_REAL) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
     // Consume 'real'
     tokens.pop();
@@ -436,17 +446,17 @@ auto ParseReal(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>
     try {
         return std::make_unique<Real>(std::stod(tokens.pop()));
     } catch (const std::invalid_argument&) {
-        return std::unexpected { ParseError::InvalidNumberFormat };
+        return std::unexpected { ParseErrorOld::InvalidNumberFormat };
     } catch (const std::out_of_range&) {
-        return std::unexpected { ParseError::InvalidNumberFormat };
+        return std::unexpected { ParseErrorOld::InvalidNumberFormat };
     }
 }
 
-auto ParseImaginary(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseImaginary(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (!isTokenFromArray(tokens.peek(), PALM_IMAGINARY)) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume 'i' or 'j'
@@ -455,11 +465,11 @@ auto ParseImaginary(TokenStream& tokens) -> std::expected<std::unique_ptr<Expres
     return std::make_unique<Imaginary>();
 }
 
-auto ParseVariable(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseVariable(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (tokens.peek() != PALM_VARIABLE) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume 'var'
@@ -468,52 +478,52 @@ auto ParseVariable(TokenStream& tokens) -> std::expected<std::unique_ptr<Express
     // Consume Variable Name
     std::string varName = tokens.pop();
     if (varName.empty() || varName == PALM_CLOSE_PARENS) {
-        return std::unexpected { ParseError::IncompleteExpression };
+        return std::unexpected { ParseErrorOld::IncompleteExpression };
     }
 
     return std::make_unique<Variable>(varName);
 }
 
-auto ParseAdd(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseAdd(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationAssociativeAndCommutative<Add>(PALM_ADD, tokens);
 }
 
-auto ParseSubtract(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseSubtract(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationNonAssociativeAndCommutative<Subtract>(PALM_SUBTRACT, tokens);
 }
 
-auto ParseMultiply(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseMultiply(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationAssociativeAndCommutative<Multiply>(PALM_MULTIPLY, tokens);
 }
 
-auto ParseDivide(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseDivide(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationNonAssociativeAndCommutative<Divide>(PALM_DIVIDE, tokens);
 }
 
-auto ParseExponent(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseExponent(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationNonAssociativeAndCommutative<Exponent>(PALM_EXPONENT, tokens);
 }
 
-auto ParseLog(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseLog(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationNonAssociativeAndCommutative<Log>(PALM_LOG, tokens);
 }
 
-auto ParseIntegral(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseIntegral(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationAssociativeAndCommutative<Integral>(PALM_INTEGRAL, tokens);
 }
 
-auto ParseNegate(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseNegate(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (tokens.peek() != PALM_NEGATE) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume 'neg'
@@ -528,15 +538,15 @@ auto ParseNegate(TokenStream& tokens) -> std::expected<std::unique_ptr<Expressio
     return std::make_unique<Negate<>>(std::move(**expr));
 }
 
-auto ParseDerivative(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseDerivative(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     return ParseBinaryOperationNonAssociativeAndCommutative<Derivative>(PALM_DERIVATIVE, tokens);
 }
 
-auto ParsePi(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParsePi(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     if (!isPiToken(tokens.peek())) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume 'pi' | 'π'
@@ -544,10 +554,10 @@ auto ParsePi(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>,
     return std::make_unique<Pi>();
 }
 
-auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     if (tokens.peek() != PALM_EULER) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume 'e'
@@ -557,11 +567,11 @@ auto ParseEulerNumber(TokenStream& tokens) -> std::expected<std::unique_ptr<Expr
 
 template <template <typename, typename> typename T>
     requires IAssociativeAndCommutative<T>
-auto ParseBinaryOperationAssociativeAndCommutative(const std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseBinaryOperationAssociativeAndCommutative(const std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (tokens.peek() != token) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume operator
@@ -578,11 +588,11 @@ auto ParseBinaryOperationAssociativeAndCommutative(const std::string_view token,
 
 template <template <typename, typename> typename T>
     requires IExpression<T<Expression, Expression>> && (!IAssociativeAndCommutative<T>)
-auto ParseBinaryOperationNonAssociativeAndCommutative(const std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseError>
+auto ParseBinaryOperationNonAssociativeAndCommutative(const std::string_view token, TokenStream& tokens) -> std::expected<std::unique_ptr<Expression>, ParseErrorOld>
 {
     // Peek at the next token
     if (tokens.peek() != token) {
-        return std::unexpected { ParseError::UnexpectedToken };
+        return std::unexpected { ParseErrorOld::UnexpectedToken };
     }
 
     // Consume operator
@@ -605,29 +615,29 @@ auto ParseBinaryOperationNonAssociativeAndCommutative(const std::string_view tok
     return expr;
 }
 
-auto ParseBinaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>
+auto ParseBinaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>
 {
     auto elements = ParseNullaryOperationElements(tokens);
 
     if (!elements || elements->size() < 2) {
-        return std::unexpected { ParseError::IncompleteExpression };
+        return std::unexpected { ParseErrorOld::IncompleteExpression };
     }
 
     return elements;
 }
 
-auto ParseUnaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>
+auto ParseUnaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>
 {
     auto elements = ParseNullaryOperationElements(tokens);
 
     if (!elements || elements->empty()) {
-        return std::unexpected { ParseError::IncompleteExpression };
+        return std::unexpected { ParseErrorOld::IncompleteExpression };
     }
 
     return elements;
 }
 
-auto ParseNullaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseError>
+auto ParseNullaryOperationElements(TokenStream& tokens) -> std::expected<std::vector<std::unique_ptr<Expression>>, ParseErrorOld>
 {
     std::vector<std::unique_ptr<Expression>> elements;
 
@@ -651,4 +661,5 @@ auto ParseNullaryOperationElements(TokenStream& tokens) -> std::expected<std::ve
 
     return elements;
 }
+
 }
\ No newline at end of file
diff --git a/io/src/PALMConsts.hpp b/io/src/PALMConsts.hpp
new file mode 100644
index 00000000..b44e0681
--- /dev/null
+++ b/io/src/PALMConsts.hpp
@@ -0,0 +1,55 @@
+//
+// Created by codin on 11/9/25.
+//
+
+#ifndef OASIS_PALMCONSTS_HPP
+#define OASIS_PALMCONSTS_HPP
+
+#include "Oasis/Expression.hpp"
+#include "PALMTypes.hpp"
+
+#include <boost/assign/list_of.hpp>
+
+namespace Oasis {
+/** A mapping from PALM operator tokens to their corresponding ExpressionType. */
+inline const PALMOperatorBimap kPALMOperatorBimap = ::boost::assign::list_of<PALMOperatorBimap::relation>
+    ("undefined", ExpressionType::None)
+    ("real", ExpressionType::Real)
+    ("i", ExpressionType::Imaginary)
+    ("j", ExpressionType::Imaginary)
+    ("var", ExpressionType::Variable)
+    ("+", ExpressionType::Add)
+    ("-", ExpressionType::Subtract)
+    ("*", ExpressionType::Multiply)
+    ("/", ExpressionType::Divide)
+    ("^", ExpressionType::Exponent)
+    ("log", ExpressionType::Log)
+    ("int", ExpressionType::Integral)
+    ("d", ExpressionType::Derivative)
+    ("neg", ExpressionType::Negate)
+    ("matrix", ExpressionType::Matrix)
+    ("pi",  ExpressionType::Pi)
+    ("e", ExpressionType::EulerNumber)
+    ("magnitude", ExpressionType::Magnitude);
+
+/** Regular expression for valid PALM identifiers. */
+static constexpr std::string_view kPALMIdentifierRegex = R"(^[a-zA-Z_][a-zA-Z0-9_]*$)";
+
+/** PALM representations for special numeric values. */
+inline constexpr std::string_view kPALMNaN = "NaN";
+inline constexpr std::string_view kPALMInfinity = "Infinity";
+inline constexpr std::string_view kPALMNegativeInfinity = "-Infinity";
+
+/** Regular expression for valid PALM numbers. */
+// In `io/src/PALMConsts.hpp`
+static constexpr std::string_view kPALMNumberRegex =
+    R"(^([+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?|[+-]?(NaN|Infinity))$)";
+
+/** A mapping from PALM punctuator tokens to their corresponding PALMPunctuatorType. */
+inline const PALMPunctuatorBimap kPALMPunctuatorBimap = ::boost::assign::list_of<PALMPunctuatorBimap::relation>
+    ("(", PALMPunctuatorType::StartExpression)
+    (")", PALMPunctuatorType::EndExpression);
+
+}
+
+#endif // OASIS_PALMCONSTS_HPP
diff --git a/io/src/PALMHelper.hpp b/io/src/PALMHelper.hpp
new file mode 100644
index 00000000..35dbc3dd
--- /dev/null
+++ b/io/src/PALMHelper.hpp
@@ -0,0 +1,34 @@
+//
+// Created by codin on 10/31/25.
+//
+
+#ifndef OASIS_PALMCONST_HPP
+#define OASIS_PALMCONST_HPP
+
+#include <array>
+#include <string_view>
+
+
+namespace Oasis {
+
+// Define PALM tokens
+constexpr inline std::string_view PALM_OPEN_PARENS = "(";
+constexpr inline std::string_view PALM_CLOSE_PARENS = ")";
+
+constexpr inline std::string_view PALM_REAL = "real";
+constexpr inline std::array<std::string_view, 2> PALM_IMAGINARY = { "i", "j" };
+constexpr inline std::string_view PALM_VARIABLE = "var";
+constexpr inline std::string_view PALM_ADD = "+";
+constexpr inline std::string_view PALM_SUBTRACT = "-";
+constexpr inline std::string_view PALM_MULTIPLY = "*";
+constexpr inline std::string_view PALM_DIVIDE = "/";
+constexpr inline std::string_view PALM_EXPONENT = "^";
+constexpr inline std::string_view PALM_LOG = "log";
+constexpr inline std::string_view PALM_INTEGRAL = "int";
+constexpr inline std::string_view PALM_NEGATE = "neg";
+constexpr inline std::string_view PALM_DERIVATIVE = "d";
+constexpr std::string_view PALM_MATRIX = "matrix";
+constexpr inline std::array<std::string_view, 1> PALM_PI = { "pi" };
+constexpr inline std::string_view PALM_EULER = "e";
+}
+#endif // OASIS_PALMCONST_HPP
\ No newline at end of file
diff --git a/io/src/PALMSerializer.cpp b/io/src/PALMSerializer.cpp
new file mode 100644
index 00000000..ffd10ec2
--- /dev/null
+++ b/io/src/PALMSerializer.cpp
@@ -0,0 +1,317 @@
+//
+// Created by codin on 10/31/25.
+//
+
+#include <utility>
+
+#include "Oasis/PALMSerializer.hpp"
+#include "PALMConsts.hpp"
+
+#include "Oasis/Add.hpp"
+#include "Oasis/Derivative.hpp"
+#include "Oasis/Divide.hpp"
+#include "Oasis/EulerNumber.hpp"
+#include "Oasis/Exponent.hpp"
+#include "Oasis/FromPALM.hpp"
+#include "Oasis/Imaginary.hpp"
+#include "Oasis/Integral.hpp"
+#include "Oasis/Log.hpp"
+#include "Oasis/Magnitude.hpp"
+#include "Oasis/Multiply.hpp"
+#include "Oasis/Negate.hpp"
+#include "Oasis/Pi.hpp"
+#include "Oasis/Real.hpp"
+#include "Oasis/Subtract.hpp"
+#include "Oasis/Undefined.hpp"
+#include "Oasis/Variable.hpp"
+
+#include <regex>
+
+namespace Oasis {
+
+bool operator==(const PALMSerializationError& lhs, const PALMSerializationError& rhs)
+{
+    return lhs.type == rhs.type && lhs.message == rhs.message;
+}
+
+auto PALMSerializer::TypedVisit(const Real& real) -> RetT
+{
+    // Handle special numeric values
+    if (std::isnan(real.GetValue())) { // NaN check
+        return WrapExpression(ExpressionType::Real, { std::string { kPALMNaN } });
+    }
+
+    if (std::isinf(real.GetValue())) { // Infinity check
+        if (real.GetValue() > 0) { // Positive infinity
+            return WrapExpression(ExpressionType::Real, { std::string { kPALMInfinity } });
+        }
+        // Negative infinity
+        return WrapExpression(ExpressionType::Real, { std::string { kPALMNegativeInfinity } });
+    }
+
+    // Format the real number with the specified number of decimal places
+    auto realString = std::format("{:.{}}", real.GetValue(), palmOptions.numPlaces + 1);
+    return WrapExpression(ExpressionType::Real, { realString });
+}
+
+auto PALMSerializer::TypedVisit(const Imaginary& imaginary) -> RetT
+{
+    return SerializeExpression(imaginary);
+}
+
+auto PALMSerializer::TypedVisit(const Variable& variable) -> RetT
+{
+    // Validate the variable name
+    if (!IsValidIdentifier(variable.GetName())) {
+        return std::unexpected { PALMSerializationError {
+            .type = PALMSerializationError::PALMSerializationErrorType::InvalidIdentifier,
+            .expression = &variable,
+            .message = "Variable name '" + variable.GetName() + "' is not a valid identifier" } };
+    }
+
+    // Serialize the valid variable
+    return WrapExpression(ExpressionType::Variable, { variable.GetName() });
+}
+
+auto PALMSerializer::TypedVisit(const Undefined& undefined) -> RetT
+{
+    return SerializeExpression(undefined);
+}
+
+auto PALMSerializer::TypedVisit(const Add<>& add) -> RetT
+{
+    return SerializeExpression(add);
+}
+
+auto PALMSerializer::TypedVisit(const Subtract<>& subtract) -> RetT
+{
+    return SerializeExpression(subtract);
+}
+
+auto PALMSerializer::TypedVisit(const Multiply<>& multiply) -> RetT
+{
+    return SerializeExpression(multiply);
+}
+
+auto PALMSerializer::TypedVisit(const Divide<>& divide) -> RetT
+{
+    return SerializeExpression(divide);
+}
+
+auto PALMSerializer::TypedVisit(const Exponent<>& exponent) -> RetT
+{
+    return SerializeExpression(exponent);
+}
+
+auto PALMSerializer::TypedVisit(const Log<>& log) -> RetT
+{
+    return SerializeExpression(log);
+}
+
+auto PALMSerializer::TypedVisit(const Negate<>& negate) -> RetT
+{
+    return SerializeExpression(negate);
+}
+
+auto PALMSerializer::TypedVisit(const Derivative<>& derivative) -> RetT
+{
+    return SerializeExpression(derivative);
+}
+
+auto PALMSerializer::TypedVisit(const Integral<>& integral) -> RetT
+{
+    return SerializeExpression(integral);
+}
+
+auto PALMSerializer::TypedVisit(const Matrix& /*matrix*/) -> RetT
+{
+    // TODO: Implement Matrix serialization
+    return std::unexpected <PALMSerializationError> {
+        PALMSerializationError {
+            .type = PALMSerializationError::PALMSerializationErrorType::Other,
+            .message = "Matrix serialization not yet implemented"
+        }
+    };
+}
+
+auto PALMSerializer::TypedVisit(const EulerNumber& euler_number) -> RetT
+{
+    return SerializeExpression(euler_number);
+}
+
+auto PALMSerializer::TypedVisit(const Pi& pi) -> RetT
+{
+    return SerializeExpression(pi);
+}
+
+auto PALMSerializer::TypedVisit(const Magnitude<Expression>& magnitude) -> RetT
+{
+    return SerializeExpression(magnitude);
+}
+
+/** Convert an ExpressionType (Operator) to its corresponding PALM token.
+ *
+ * @param op The ExpressionType (Operator) to convert.
+ * @param options The PALM options to consider during conversion.
+ * @return The corresponding PALM token as a string view.
+ */
+auto PALMSerializer::OperatorToToken(const ExpressionType op, const PALMSerializationOpts& options) -> std::string_view
+{
+    switch (op) {
+    case ExpressionType::Imaginary:
+        switch (options.imaginarySymbol) {
+        case PALMSerializationOpts::ImgSymType::J:
+            return "j";
+        case PALMSerializationOpts::ImgSymType::I:
+        default:
+            return "i";
+        }
+
+    default:
+        return kPALMOperatorBimap.right.at(op);
+    }
+}
+
+/** Convert a PALMPunctuatorType to its corresponding PALM token.
+ *
+ * @param punctuator The PALMDelimiterType to convert.
+
+ * @return The corresponding PALM token as a string view.
+ */
+auto PALMSerializer::PunctuatorToToken(const PALMPunctuatorType punctuator, const PALMSerializationOpts& /*options*/) -> std::string_view
+{
+    return kPALMPunctuatorBimap.right.at(punctuator);
+}
+
+/** Serialize a generic expression.
+ *
+ * @tparam RetT The return type of the serialization (usually std::expected<std::string, std::string>)
+ * @param expressionType The type of the expression.
+ * @param operands The serialized operands of the expression.
+ * @return The serialized expression as a string, or an error if serialization fails.
+ */
+auto PALMSerializer::WrapExpression(const ExpressionType expressionType, const std::initializer_list<RetT>& operands) const -> RetT
+{
+    // Build the serialized string
+    std::ostringstream serialized;
+
+    // Start Expression
+    serialized
+        << PunctuatorToToken(PALMPunctuatorType::StartExpression, palmOptions)
+        << palmOptions.expressionPadding
+
+        // Add Operator
+        << OperatorToToken(expressionType, palmOptions);
+
+    // Add Operands
+    for (const auto& operand : operands) {
+        // Check for errors in operand serialization
+        auto value = operand;
+
+        if (!value.has_value()) {
+            return value;
+        }
+
+        // Add Separator and Operand Value
+        serialized
+            << palmOptions.tokenSeparator
+            << value.value();
+    }
+
+    // End Expression
+    serialized
+        << palmOptions.expressionPadding
+        << PunctuatorToToken(PALMPunctuatorType::EndExpression, palmOptions);
+
+    // Return the serialized string
+    return serialized.str();
+}
+
+/** Check if a string is a valid identifier.
+ *
+ * @param string The string to check.
+ * @return True if the string is a valid identifier, false otherwise.
+ */
+auto PALMSerializer::IsValidIdentifier(const std::string& string) -> bool
+{
+    // Empty string is not a valid identifier
+    if (string.empty()) {
+        return false;
+    }
+
+    // Reserved keywords are not valid identifiers
+    if (kPALMOperatorBimap.left.count(string) > 0) {
+        return false;
+    }
+
+    // Check against the identifier regex
+    static const std::regex identifierRegex { kPALMIdentifierRegex.data() };
+    return std::regex_match(string, identifierRegex);
+}
+
+/** Serialize a leaf expression.
+ *
+ * @tparam RetT The return type of the serialization (usually std::expected<std::string, std::string>)
+ * @param expr The leaf expression to serialize.
+ * @return The serialized expression as a string, or an error if serialization fails.
+ */
+auto PALMSerializer::SerializeExpression(const DerivedFromLeafExpression auto& expr) -> RetT
+{
+    return WrapExpression(expr.GetType());
+}
+
+/** Serialize a unary expression.
+ *
+ * @tparam RetT The return type of the serialization (usually std::expected<std::string, std::string>)
+ * @param expr The unary expression to serialize.
+ * @return The serialized expression as a string, or an error if serialization fails.
+ */
+auto PALMSerializer::SerializeExpression(const DerivedFromUnaryExpression auto& expr) -> RetT
+{
+    // Ensure the operand exists
+    if (!expr.HasOperand()) {
+        return std::unexpected { PALMSerializationError {
+            .type = PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+            .expression = &expr,
+            .message = "Expression missing operand" } };
+    }
+
+    // Serialize the operand
+    auto operandResult = expr.GetOperand().Accept(*this).value();
+
+    // Serialize the expression
+    return WrapExpression(expr.GetType(), { operandResult });
+}
+
+/** Serialize a binary expression.
+ *
+ * @tparam RetT The return type of the serialization (usually std::expected<std::string, std::string>)
+ * @param expr The binary expression to serialize.
+ * @return The serialized expression as a string, or an error if serialization fails.
+ */
+auto PALMSerializer::SerializeExpression(const DerivedFromBinaryExpression auto& expr) -> RetT
+{
+    // Ensure both operands exist
+    if (!expr.HasMostSigOp()) {
+        return std::unexpected { PALMSerializationError {
+            .type = PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+            .expression = &expr,
+            .message = "Expression missing most significant operand" } };
+    }
+
+    if (!expr.HasLeastSigOp()) {
+        return std::unexpected { PALMSerializationError {
+        .type = PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+            .expression = &expr,
+            .message = "Expression missing least significant operand" } };
+    }
+
+    // Serialize both operands
+    auto mostSigOpResult = expr.GetMostSigOp().Accept(*this).value();
+    auto leastSigOpResult = expr.GetLeastSigOp().Accept(*this).value();
+
+    // Serialize the expression
+    return WrapExpression(expr.GetType(), { mostSigOpResult, leastSigOpResult });
+}
+
+}
\ No newline at end of file
diff --git a/io/src/PALMTokenizer.cpp b/io/src/PALMTokenizer.cpp
new file mode 100644
index 00000000..ca0820cb
--- /dev/null
+++ b/io/src/PALMTokenizer.cpp
@@ -0,0 +1,233 @@
+//
+// Created by codin on 11/9/25.
+//
+
+#include "PALMTokenizer.hpp"
+
+/** Builds a set of all prefixes of PALM punctuators.
+ *
+ * If a punctuator is "===", its prefixes are "=", "==", and "===".
+ * @return A set of string views representing all prefixes of PALM punctuators.
+ */
+std::unordered_set<std::string_view> Oasis::PALMTokenizer::buildPunctuatorPrefixes()
+{
+    std::unordered_set<std::string_view> prefixes;
+    for (const auto& [text, _] : PALMPunctuatorBimap().left) {
+        for (size_t i = 1; i <= text.size(); ++i) {
+            prefixes.insert(text.substr(0, i));
+        }
+    }
+    return prefixes;
+}
+
+/** Returns the set of all prefixes of PALM punctuators.
+ *
+ * @return A reference to the set of string views representing all prefixes of PALM punctuators.
+ */
+const std::unordered_set<std::string_view>& Oasis::PALMTokenizer::punctuatorPrefixes()
+{
+    static const auto prefixes = buildPunctuatorPrefixes();
+    return prefixes;
+}
+
+/** Reads the next token from the input stream.
+ *
+ * @return The next PALM token.
+ */
+auto Oasis::PALMTokenizer::nextToken() const -> PALMToken
+{
+    // Create new token
+    PALMToken token = {};
+
+    if (currentToken) { // Update position based on previous token
+        token.tokenIndex = currentToken->tokenIndex + 1;
+        token.charOffset = currentToken->charOffset + currentToken->length;
+        token.line = currentToken->line;
+        token.column = currentToken->column + currentToken->length;
+    }
+
+    // Skip whitespace
+    char ch;
+    while (inputStream.get(ch)) {
+        if (!std::isspace(static_cast<unsigned char>(ch))) {
+            inputStream.unget(); // Put back the non-whitespace character
+            break;
+        }
+        if (ch == '\n') {
+            token.line++;
+            token.column = 1;
+        } else {
+            token.column++;
+        }
+        token.charOffset++;
+    }
+
+    // End of Input Token
+    if (!inputStream.get(ch)) {
+        token.type = PALMTokenType::EndOfInput;
+        token.lexeme = "";
+        token.length = 0;
+        return token;
+    }
+
+    // Put back the character for further processing
+    inputStream.unget();
+
+    // Punctuator Token
+    if (const auto punctuator = tryMatchPunctuator(inputStream); !punctuator.empty()) {
+        token.type = PALMTokenType::Punctuator;
+        token.lexeme = punctuator;
+        token.length = punctuator.length();
+        return token;
+    }
+
+    // Build lexeme until whitespace or punctuator
+    std::stringbuf lexemeBuffer;
+    std::streampos lexemeTail = inputStream.tellg();
+
+    while (inputStream.get(ch)) {
+        if (std::isspace(static_cast<unsigned char>(ch))) {
+            inputStream.unget(); // Put back the whitespace character
+            break;
+        }
+
+        // Check for punctuator match
+        inputStream.unget();
+        if (!tryMatchPunctuator(inputStream).empty()) { // Found a punctuator
+            inputStream.seekg(lexemeTail); // Reset to start of punctuator
+            break;
+        }
+        inputStream.get(ch); // Consume character
+        lexemeBuffer.sputc(ch);
+        lexemeTail = inputStream.tellg();
+    }
+
+    // Save lexeme info
+    token.lexeme = lexemeBuffer.str();
+    token.length = token.lexeme.length();
+
+    // Operator Token
+    if (isTokenPALMOperator(lexemeBuffer.str())) {
+        token.type = PALMTokenType::Operator;
+        return token;
+    }
+
+    // Identifier Token
+    if (isTokenPALMIdentifier(lexemeBuffer.str())) {
+        token.type = PALMTokenType::Identifier;
+        return token;
+    }
+
+    // Number Token
+    if (isTokenPALMNumber(lexemeBuffer.str())) {
+        token.type = PALMTokenType::Number;
+        return token;
+    }
+
+    // Unknown Token
+    token.type = PALMTokenType::Unknown;
+    return token;
+}
+
+/** Checks if a token is a PALM operator.
+ *
+ * @param token The token to check.
+ * @return True if the token is a PALM operator, false otherwise.
+ */
+auto Oasis::PALMTokenizer::isTokenPALMOperator(const std::string& token) -> bool
+{
+    return kPALMOperatorBimap.left.count(token) != 0;
+}
+
+/** Checks if a token is a PALM identifier.
+ *
+ * @param token The token to check.
+ * @return True if the token is a PALM identifier, false otherwise.
+ */
+auto Oasis::PALMTokenizer::isTokenPALMIdentifier(const std::string& token) -> bool
+{
+    static const std::regex identifierRegex { std::string(kPALMIdentifierRegex) };
+    return std::regex_match(token, identifierRegex);
+}
+
+/** Checks if a token is a PALM number.
+ *
+ * @param token The token to check.
+ * @return True if the token is a PALM number, false otherwise.
+ */
+auto Oasis::PALMTokenizer::isTokenPALMNumber(const std::string& token) -> bool
+{
+    static const std::regex numberRegex { std::string(kPALMNumberRegex) };
+    return std::regex_match(token, numberRegex);
+}
+
+/** Checks if a token is a PALM punctuator.
+ *
+ * @param token The token to check.
+ * @return True if the token is a PALM punctuator, false otherwise.
+ */
+auto Oasis::PALMTokenizer::isTokenPALMPunctuator(const std::string& token) -> bool
+{
+    return kPALMPunctuatorBimap.left.count(token) != 0;
+}
+
+/** Tries to match a PALM punctuator from the input stream.
+ *
+ * @param in The input stream to read from.
+ * @return The matched punctuator string, or an empty string if no match.
+ */
+auto Oasis::PALMTokenizer::tryMatchPunctuator(std::istream& in) -> std::string
+{
+    std::string buffer;
+    const std::streampos startPos = in.tellg();
+
+    // Find Matching Punctuator
+    while (true) {
+        char ch;
+        if (!in.get(ch)) {
+            break; // End of stream
+        }
+        buffer.push_back(ch);
+
+        if (isTokenPALMPunctuator(buffer)) {
+            // Found a matching punctuator
+            return buffer;
+        }
+
+        if (!punctuatorPrefixes().contains(buffer)) {
+            // No longer a valid prefix
+            break;
+        }
+    }
+
+    in.clear();
+    in.seekg(startPos); // Reset stream position
+    return ""; // No match found
+}
+
+auto Oasis::PALMTokenizer::lookahead() -> PALMToken
+{
+    if (!currentToken) {
+        currentToken = std::make_unique<PALMToken>(nextToken());
+    }
+    return *currentToken;
+}
+
+auto Oasis::PALMTokenizer::match(const PALMToken& token) -> bool
+{
+    return match(token.lexeme);
+}
+
+auto Oasis::PALMTokenizer::match(const std::string& lexeme) -> bool
+{
+    if (lookahead().lexeme == lexeme) {
+        currentToken = std::make_unique<PALMToken>(nextToken());
+        return true;
+    }
+    return false;
+}
+
+auto Oasis::PALMTokenizer::eof() const -> bool
+{
+    return inputStream.eof();
+}
diff --git a/io/src/PALMTokenizer.hpp b/io/src/PALMTokenizer.hpp
new file mode 100644
index 00000000..017487b6
--- /dev/null
+++ b/io/src/PALMTokenizer.hpp
@@ -0,0 +1,52 @@
+//
+// Created by codin on 11/9/25.
+//
+
+#ifndef OASIS_PALMTOKENIZER_HPP
+#define OASIS_PALMTOKENIZER_HPP
+
+#include "PALMConsts.hpp"
+#include "PALMTypes.hpp"
+
+#include <unordered_set>
+#include <regex>
+
+namespace Oasis {
+
+/** A tokenizer for the PALM language.
+ *
+ * This class reads from an input stream and produces PALM tokens.
+ */
+class PALMTokenizer {
+public:
+    explicit PALMTokenizer(std::istream& inputStream)
+        : inputStream(inputStream)
+        , currentToken(nullptr)
+    {
+    }
+
+    auto lookahead() -> PALMToken;
+    auto match(const PALMToken& token) -> bool;
+    auto match(const std::string& lexeme) -> bool;
+
+    auto eof() const -> bool;
+
+private:
+    std::istream& inputStream;
+    std::unique_ptr<PALMToken> currentToken;
+
+    static std::unordered_set<std::string_view> buildPunctuatorPrefixes();
+    static const std::unordered_set<std::string_view>& punctuatorPrefixes();
+
+    auto nextToken() const -> PALMToken;
+
+    static auto isTokenPALMOperator(const std::string& token) -> bool;
+    static auto isTokenPALMIdentifier(const std::string& token) -> bool;
+    static auto isTokenPALMNumber(const std::string& token) -> bool;
+    static auto isTokenPALMPunctuator(const std::string& token) -> bool;
+
+    static auto tryMatchPunctuator(std::istream& in) -> std::string;
+};
+
+}
+#endif // OASIS_PALMTOKENIZER_HPP
diff --git a/io/src/PALMTypes.hpp b/io/src/PALMTypes.hpp
new file mode 100644
index 00000000..c45206bd
--- /dev/null
+++ b/io/src/PALMTypes.hpp
@@ -0,0 +1,73 @@
+//
+// Created by codin on 11/9/25.
+//
+
+#ifndef OASIS_PALMTYPES_HPP
+#define OASIS_PALMTYPES_HPP
+
+#include "Oasis/Expression.hpp"
+
+#include <boost/bimap/bimap.hpp>
+#include <boost/bimap/unordered_multiset_of.hpp>
+#include <boost/bimap/unordered_set_of.hpp>
+#include <string>
+#include <string_view>
+
+namespace Oasis {
+/** Types of PALM tokens. */
+enum class PALMTokenType {
+    Operator,
+    Identifier,
+    Number,
+    Punctuator,
+    EndOfInput,
+    Unknown
+};
+
+/** Represents a token in the PALM language. */
+struct PALMToken {
+    PALMTokenType type;   // type of token
+    std::string lexeme;     // raw lexeme
+    size_t charOffset = 0;    // byte offset in source
+    size_t tokenIndex = 0; // index in token stream
+    size_t length = 0;    // length in bytes
+    size_t line = 1;      // optional
+    size_t column = 1;    // optional
+};
+
+/** Equality operator for PALMToken.
+ *
+ * @param lhs The left-hand side PALMToken.
+ * @param rhs The right-hand side PALMToken.
+ * @return True if the two tokens are equal, false otherwise.
+ */
+inline bool operator==(const PALMToken& lhs, const PALMToken& rhs)
+{
+    return lhs.type == rhs.type && lhs.lexeme == rhs.lexeme && lhs.charOffset == rhs.charOffset
+        && lhs.tokenIndex == rhs.tokenIndex && lhs.length == rhs.length && lhs.line == rhs.line
+        && lhs.column == rhs.column;
+}
+
+/** Operators are taken from ExpressionType enum in Expression.hpp
+ * @see ExpressionType
+ */
+
+/** Types of PALM punctuators. */
+enum class PALMPunctuatorType {
+    StartExpression,
+    EndExpression
+};
+
+/** Bi-directional mapping between PALM operator tokens and their corresponding ExpressionType. */
+using PALMOperatorBimap = boost::bimaps::bimap<
+    boost::bimaps::unordered_multiset_of<std::string_view>,
+    boost::bimaps::unordered_set_of<ExpressionType>>;
+
+/** Bi-directional mapping between PALM punctuator tokens and their corresponding PALMPunctuatorType. */
+using PALMPunctuatorBimap = boost::bimaps::bimap<std::string_view, PALMPunctuatorType>;
+
+
+
+}
+
+#endif // OASIS_PALMTYPES_HPP
diff --git a/io/tests/PALMTests.cpp b/io/tests/PALMTests.cpp
index 6cc3b19c..cadc2622 100644
--- a/io/tests/PALMTests.cpp
+++ b/io/tests/PALMTests.cpp
@@ -2,8 +2,12 @@
 
 #include "Oasis/RecursiveCast.hpp"
 #include "catch2/catch_test_macros.hpp"
+#include <catch2/catch_template_test_macros.hpp>
 
 #include "Oasis/FromPALM.hpp"
+#include "Oasis/PALMSerializer.hpp"
+
+#include "../src/PALMTypes.hpp"
 
 #include "Oasis/Add.hpp"
 #include "Oasis/Derivative.hpp"
@@ -13,849 +17,2012 @@
 #include "Oasis/Imaginary.hpp"
 #include "Oasis/Integral.hpp"
 #include "Oasis/Log.hpp"
+#include "Oasis/Magnitude.hpp"
 #include "Oasis/Matrix.hpp"
 #include "Oasis/Multiply.hpp"
 #include "Oasis/Negate.hpp"
 #include "Oasis/Pi.hpp"
 #include "Oasis/Real.hpp"
 #include "Oasis/Subtract.hpp"
+#include "Oasis/Undefined.hpp"
 #include "Oasis/Variable.hpp"
+#include "catch2/generators/catch_generators.hpp"
+
+// =====================
+// Test Helper Functions
+// =====================
+
+// ---------------------
+// Serialization Helpers
+// ---------------------
+void requireSuccessfulSerialization(
+    const Oasis::Expression& expr,
+    const std::string& expected,
+    const Oasis::PALMSerializationOpts& opts = {})
+{
+    Oasis::PALMSerializer serializer { opts };
+
+    const auto visit = expr.Accept(serializer);
+
+    const auto& result = visit.value();
+    if (!result.has_value()) {
+        CAPTURE(expected);
+        CAPTURE(opts.numPlaces);
+        FAIL("PALM serialization failed: " + result.error().message);
+    }
 
-/*
- * Real Operation
- */
-TEST_CASE("Parse Real", "[FromPALM][Parsing]")
+    const auto& actual = result.value();
+    CAPTURE(actual, expected, opts.numPlaces);
+    REQUIRE(actual == expected);
+}
+
+void requireFailedSerialization(
+    const Oasis::Expression& expr,
+    const Oasis::PALMSerializationError& expectedError,
+    const Oasis::PALMSerializationOpts& opts = {})
 {
-    const auto expr = Oasis::FromPALM("( real 5 )");
+    Oasis::PALMSerializer serializer { opts };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Real>());
+    const auto visit = expr.Accept(serializer);
+    REQUIRE(visit.has_value());
+
+    const auto& result = visit.value();
+    REQUIRE_FALSE(result.has_value());
 
-    const auto real = Oasis::RecursiveCast<Oasis::Real>(**expr);
-    REQUIRE(real->GetValue() == 5.0);
+    const auto& error = result.error();
+    CAPTURE(error.message, expectedError.message);
+    REQUIRE(error == expectedError);
 }
 
-TEST_CASE("Parse Multiple Real", "[FromPALM][Parsing]")
+void requireInvalidIdentifierSerializationError(
+    const Oasis::Variable& expr,
+    const std::string& expected,
+    const Oasis::PALMSerializationOpts& opts = {})
 {
-    const auto expr = Oasis::FromPALM("( real 5 3 )");
+    const auto expectedError = Oasis::PALMSerializationError {
+        .type = Oasis::PALMSerializationError::PALMSerializationErrorType::InvalidIdentifier,
+        .expression = &expr,
+        .message = "Variable name '" + expected + "' is not a valid identifier"
+    };
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::MissingClosingParen);
+    requireFailedSerialization(expr, expectedError, opts);
 }
 
-TEST_CASE("Parse Negative Integer", "[FromPALM][Parsing]")
+void requireMissingOperandSerializationError(
+    const Oasis::Expression& expr,
+    const Oasis::PALMSerializationOpts& opts = {})
 {
-    const auto expr = Oasis::FromPALM("( real -5 )");
+    const auto expectedError = Oasis::PALMSerializationError {
+        .type = Oasis::PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+        .expression = &expr,
+        .message = "Expression missing operand"
+    };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Real>());
+    requireFailedSerialization(expr, expectedError, opts);
+}
 
-    const auto real = Oasis::RecursiveCast<Oasis::Real>(**expr);
-    REQUIRE(real->GetValue() == -5.0);
+void requireMissingLeastSignificantOperandSerializationError(
+    const Oasis::Expression& expr,
+    const Oasis::PALMSerializationOpts& opts = {})
+{
+    const auto expectedError = Oasis::PALMSerializationError {
+        .type = Oasis::PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+        .expression = &expr,
+        .message = "Expression missing least significant operand"
+    };
+
+    requireFailedSerialization(expr, expectedError, opts);
 }
 
-TEST_CASE("Parse Float", "[FromPALM][Parsing]")
+void requireMissingMostSignificantOperandSerializationError(
+    const Oasis::Expression& expr,
+    const Oasis::PALMSerializationOpts& opts = {})
 {
-    const auto expr = Oasis::FromPALM("( real 5.5 )");
+    const auto expectedError = Oasis::PALMSerializationError {
+        .type = Oasis::PALMSerializationError::PALMSerializationErrorType::MissingOperand,
+        .expression = &expr,
+        .message = "Expression missing most significant operand"
+    };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Real>());
+    requireFailedSerialization(expr, expectedError, opts);
+}
+
+// ========================
+// PALM Serialization Tests
+// ========================
+
+// --------------
+// Operator Tests
+// --------------
 
-    const auto real = Oasis::RecursiveCast<Oasis::Real>(**expr);
-    REQUIRE(real->GetValue() == 5.5);
+// --- Undefined ---
+TEST_CASE("PALM Serialization of Undefined", "[PALM][Serializer][Operator][Undefined]")
+{
+    const Oasis::Undefined undefined {};
+    const std::string expected = "( undefined )";
+
+    requireSuccessfulSerialization(undefined, expected);
 }
 
-TEST_CASE("Parse Float with Exponent", "[FromPALM][Parsing]")
+// --- Real ---
+// Regular Values
+TEST_CASE("PALM Serialization of Real", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( real 5.5e3 )");
+    const Oasis::Real real { 42.0 };
+    const std::string expected = "( real 42 )";
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Real>());
+    requireSuccessfulSerialization(real, expected);
+}
 
-    const auto real = Oasis::RecursiveCast<Oasis::Real>(**expr);
-    REQUIRE(real->GetValue() == 5500.0);
+TEST_CASE("PALM Serialization of Real with decimal", "[PALM][Serializer][Operator][Real]")
+{
+    const Oasis::Real real { 3.14 };
+    const std::string expected = "( real 3.14 )";
+
+    requireSuccessfulSerialization(real, expected);
 }
 
-TEST_CASE("Parse Invalid Real", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Real with negative value", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( real five )");
+    const Oasis::Real real { -2.71828 };
+    const std::string expected = "( real -2.71828 )";
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::InvalidNumberFormat);
+    requireSuccessfulSerialization(real, expected);
 }
 
-TEST_CASE("Parse Out of Range Real", "[FromPALM][Parsing]")
+// Precision Tests
+TEST_CASE("PALM Serialization of Real with default precision", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( real 1e5000 )");
+    const Oasis::Real real { 2.718281828459045 };
+    const std::string expected = "( real 2.71828 )"; // Default precision is 5 decimal places
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::InvalidNumberFormat);
+    requireSuccessfulSerialization(real, expected);
 }
 
-/*
- * Imaginary Operation
- */
-TEST_CASE("Parse Imaginary i", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Real to 2 decimal places", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( i )");
+    const Oasis::Real real { 2.718281828459045 };
+    const std::string expected = "( real 2.72 )";
+    const Oasis::PALMSerializationOpts opts = { .numPlaces = 2 };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Imaginary>());
+    requireSuccessfulSerialization(real, expected, opts);
 }
 
-TEST_CASE("Parse Imaginary j", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Real to 0 decimal places", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( j )");
+    const Oasis::Real real { 2.718281828459045 };
+    const std::string expected = "( real 3 )";
+    const Oasis::PALMSerializationOpts opts = { .numPlaces = 0 };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Imaginary>());
+    requireSuccessfulSerialization(real, expected, opts);
 }
 
-/*
- * Variable Operation
- */
-TEST_CASE("Parse Single Letter Variable", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Real with negative value and 3 decimal places", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( var x )");
+    const Oasis::Real real { -2.71828 };
+    const std::string expected = "( real -2.718 )";
+    const Oasis::PALMSerializationOpts opts = { .numPlaces = 3 };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Variable>());
+    requireSuccessfulSerialization(real, expected, opts);
+}
+
+TEST_CASE("PALM Serialization of Real with NaN", "[PALM][Serializer][Operator][Real]")
+{
+    const Oasis::Real real { std::numeric_limits<double>::quiet_NaN() };
+    const std::string expected = "( real NaN )";
 
-    const auto var = Oasis::RecursiveCast<Oasis::Variable>(**expr);
-    REQUIRE(var->GetName() == "x");
+    requireSuccessfulSerialization(real, expected);
 }
 
-TEST_CASE("Parse Multi Letter Variable", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Real with Positive Infinity", "[PALM][Serializer][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( var myVariable )");
+    const Oasis::Real real { std::numeric_limits<double>::infinity() };
+    const std::string expected = "( real Infinity )";
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Variable>());
+    requireSuccessfulSerialization(real, expected);
+}
+
+TEST_CASE("PALM Serialization of Real with Negative Infinity", "[PALM][Serializer][Operator][Real]")
+{
+    const Oasis::Real real { -std::numeric_limits<double>::infinity() };
+    const std::string expected = "( real -Infinity )";
 
-    const auto var = Oasis::RecursiveCast<Oasis::Variable>(**expr);
-    REQUIRE(var->GetName() == "myVariable");
+    requireSuccessfulSerialization(real, expected);
 }
 
-TEST_CASE("Parse Variable With Numbers", "[FromPALM][Parsing]")
+// --- Imaginary ---
+// Default Values
+TEST_CASE("PALM Serialization of Imaginary", "[PALM][Serializer][Operator][Imaginary]")
 {
-    const auto expr = Oasis::FromPALM("( var var123 )");
+    const Oasis::Imaginary imaginary {};
+    const std::string expected = "( i )";
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Variable>());
+    requireSuccessfulSerialization(imaginary, expected);
+}
+
+// Different Symbols
+TEST_CASE("PALM Serialization of Imaginary with 'i' symbol", "[PALM][Serializer][Operator][Imaginary]")
+{
+    const Oasis::Imaginary imaginary {};
+    const std::string expected = "( i )";
+    const Oasis::PALMSerializationOpts opts = { .imaginarySymbol = Oasis::PALMSerializationOpts::ImgSymType::I };
 
-    const auto var = Oasis::RecursiveCast<Oasis::Variable>(**expr);
-    REQUIRE(var->GetName() == "var123");
+    requireSuccessfulSerialization(imaginary, expected, opts);
 }
 
-TEST_CASE("Parse Variable With Underscore", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Imaginary with 'j' symbol", "[PALM][Serializer][Operator][Imaginary]")
 {
-    const auto expr = Oasis::FromPALM("( var var_name )");
+    const Oasis::Imaginary imaginary {};
+    const std::string expected = "( j )";
+    const Oasis::PALMSerializationOpts opts = { .imaginarySymbol = Oasis::PALMSerializationOpts::ImgSymType::J };
 
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Variable>());
+    requireSuccessfulSerialization(imaginary, expected, opts);
+}
+
+// --- Variable ---
+// Accepted Identifiers
+TEST_CASE("PALM Serialization of Variable with Single Character", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "x" };
+    const std::string expected = "( var x )";
 
-    const auto var = Oasis::RecursiveCast<Oasis::Variable>(**expr);
-    REQUIRE(var->GetName() == "var_name");
+    requireSuccessfulSerialization(variable, expected);
 }
 
-TEST_CASE("Parse without Variable Name", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Variable with Multiple Characters", "[PALM][Serializer][Operator][Variable]")
 {
-    const auto expr = Oasis::FromPALM("( var )");
+    const Oasis::Variable variable { "velocity" };
+    const std::string expected = "( var velocity )";
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::IncompleteExpression);
+    requireSuccessfulSerialization(variable, expected);
 }
 
-/*
- * Addition Operation
- */
-TEST_CASE("Parse Simple Addition", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Variable with Underscore", "[PALM][Serializer][Operator][Variable]")
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Real { 3.0 }
-    };
+    const Oasis::Variable variable { "x_variable" };
+    const std::string expected = "( var x_variable )";
+
+    requireSuccessfulSerialization(variable, expected);
+}
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+// Rejected Identifiers
+TEST_CASE("PALM Serialization of Variable with Empty Identifier", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "" };
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( real 3 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireInvalidIdentifierSerializationError(variable, "");
+}
+
+TEST_CASE("PALM Serialization of Variable with Invalid Identifier", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "123invalid" };
+
+    requireInvalidIdentifierSerializationError(variable, "123invalid");
+}
+
+TEST_CASE("PALM Serialization of Variable with Special Characters", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "var$!" };
+
+    requireInvalidIdentifierSerializationError(variable, "var$!");
+}
+
+TEST_CASE("PALM Serialization of Variable with Space", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "my var" };
+
+    requireInvalidIdentifierSerializationError(variable, "my var");
+}
+
+TEST_CASE("PALM Serialization of Keyword as Variable", "[PALM][Serializer][Operator][Variable]")
+{
+    const Oasis::Variable variable { "real" };
+
+    requireInvalidIdentifierSerializationError(variable, "real");
+}
+
+// --- Addition ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Addition Operator Symbol", "[PALM][Serializer][Operator][Addition]")
+{
+    const Oasis::Add<> addition {
+        Oasis::Real { 1.0 },
+        Oasis::Real { 2.0 }
+    };
+    const std::string expected = "( + ( real 1 ) ( real 2 ) )";
+
+    requireSuccessfulSerialization(addition, expected);
 }
 
-TEST_CASE("Parse Nested Addition", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Nested Addition", "[PALM][Serializer][Addition]")
 {
-    const Oasis::Add expected {
+    const Oasis::Add<> addition {
         Oasis::Real { 5.0 },
         Oasis::Add {
             Oasis::Real { 3.0 },
             Oasis::Real { 2.0 } }
     };
+    const std::string expected = "( + ( real 5 ) ( + ( real 3 ) ( real 2 ) ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(addition, expected);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( + ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Addition Missing Least Significant Operand", "[PALM][Serializer][Addition]")
+{
+    Oasis::Add<Oasis::Real, Oasis::Expression> addition;
+    addition.SetMostSigOp(Oasis::Real { 5.0 });
+
+    requireMissingLeastSignificantOperandSerializationError(addition);
 }
 
-TEST_CASE("Parse Malformed Addition", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Addition Missing Most Significant Operand", "[PALM][Serializer][Addition]")
 {
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) )");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::IncompleteExpression);
+    Oasis::Add<Oasis::Expression, Oasis::Real> addition;
+    addition.SetLeastSigOp(Oasis::Real { 3.0 });
+
+    requireMissingMostSignificantOperandSerializationError(addition);
 }
 
-TEST_CASE("Parse Addition Multiple Elements", "[FromPALM][Parsing]")
+// --- Subtraction ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Subtraction", "[PALM][Serializer][Subtraction]")
 {
-    const Oasis::Add<> expected {
+    const Oasis::Subtract<> subtraction {
         Oasis::Real { 5.0 },
-        Oasis::Real { 3.0 },
-        Oasis::Real { 2.0 },
-        Oasis::Real { 1.0 }
+        Oasis::Real { 3.0 }
     };
+    const std::string expected = "( - ( real 5 ) ( real 3 ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
-
-    auto expr = Oasis::FromPALM("( + ( real 5 ) ( real 3 ) ( real 2 ) ( real 1 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireSuccessfulSerialization(subtraction, expected);
 }
 
-TEST_CASE("Parse Missing Parens", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Nested Subtraction", "[PALM][Serializer][Subtraction]")
 {
-    const auto expr = Oasis::FromPALM("( real 5 ");
+    const Oasis::Subtract<> subtraction {
+        Oasis::Real { 5.0 },
+        Oasis::Subtract {
+            Oasis::Real { 3.0 },
+            Oasis::Real { 2.0 } }
+    };
+    const std::string expected = "( - ( real 5 ) ( - ( real 3 ) ( real 2 ) ) )";
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::MissingClosingParen);
+    requireSuccessfulSerialization(subtraction, expected);
 }
 
-TEST_CASE("Parse Expression Unexpected Token", "[FromPALM][Parsing]")
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Subtraction Missing Least Significant Operand", "[PALM][Serializer][Subtraction]")
 {
-    const auto expr = Oasis::FromPALM("'");
+    Oasis::Subtract<Oasis::Real, Oasis::Expression> subtraction;
+    subtraction.SetMostSigOp(Oasis::Real { 5.0 });
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::UnexpectedToken);
+    requireMissingLeastSignificantOperandSerializationError(subtraction);
 }
 
-TEST_CASE("Parse Incomplete Expression", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Subtraction Missing Most Significant Operand", "[PALM][Serializer][Subtraction]")
 {
-    const auto expr = Oasis::FromPALM("( real 5 ) e ");
+    Oasis::Subtract<Oasis::Expression, Oasis::Real> subtraction;
+    subtraction.SetLeastSigOp(Oasis::Real { 3.0 });
 
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::UnexpectedToken);
+    requireMissingMostSignificantOperandSerializationError(subtraction);
 }
 
-/*
- * Subtraction Operation
- */
-TEST_CASE("Parse Simple Subtraction", "[FromPALM][Parsing]")
+// --- Multiplication ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Multiplication", "[PALM][Serializer][Multiplication]")
 {
-    const Oasis::Subtract expected {
+    const Oasis::Multiply<> multiplication {
         Oasis::Real { 5.0 },
         Oasis::Real { 3.0 }
     };
+    const std::string expected = "( * ( real 5 ) ( real 3 ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
-
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) ( real 3 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireSuccessfulSerialization(multiplication, expected);
 }
 
-TEST_CASE("Parse Nested Subtraction", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Nested Multiplication", "[PALM][Serializer][Multiplication]")
 {
-    const Oasis::Subtract expected {
+    const Oasis::Multiply<> multiplication {
         Oasis::Real { 5.0 },
-        Oasis::Subtract {
+        Oasis::Multiply {
             Oasis::Real { 3.0 },
             Oasis::Real { 2.0 } }
     };
+    const std::string expected = "( * ( real 5 ) ( * ( real 3 ) ( real 2 ) ) )";
+
+    requireSuccessfulSerialization(multiplication, expected);
+}
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Multiplication Missing Least Significant Operand", "[PALM][Serializer][Multiplication]")
+{
+    Oasis::Multiply<Oasis::Real, Oasis::Expression> multiplication;
+    multiplication.SetMostSigOp(Oasis::Real { 5.0 });
 
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) ( - ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireMissingLeastSignificantOperandSerializationError(multiplication);
 }
 
-TEST_CASE("Parse Subtraction Multiple Elements", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Multiplication Missing Most Significant Operand", "[PALM][Serializer][Multiplication]")
 {
-    const Oasis::Subtract<> expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
+    Oasis::Multiply<Oasis::Expression, Oasis::Real> multiplication;
+    multiplication.SetLeastSigOp(Oasis::Real { 3.0 });
+
+    requireMissingMostSignificantOperandSerializationError(multiplication);
+}
+
+// --- Division ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Division", "[PALM][Serializer][Division]")
+{
+    const Oasis::Divide<> division {
+        Oasis::Real { 6.0 },
+        Oasis::Real { 3.0 }
+    };
+    const std::string expected = "( / ( real 6 ) ( real 3 ) )";
+
+    requireSuccessfulSerialization(division, expected);
+}
+
+TEST_CASE("PALM Serialization of Nested Division", "[PALM][Serializer][Division]")
+{
+    const Oasis::Divide<> division {
+        Oasis::Real { 6.0 },
+        Oasis::Divide {
             Oasis::Real { 3.0 },
-            Oasis::Subtract {
-                Oasis::Real { 2.0 },
-                Oasis::Real { 1.0 } } }
+            Oasis::Real { 2.0 } }
     };
+    const std::string expected = "( / ( real 6 ) ( / ( real 3 ) ( real 2 ) ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(division, expected);
+}
 
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) ( real 3 ) ( real 2 ) ( real 1 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Division Missing Least Significant Operand", "[PALM][Serializer][Division]")
+{
+    Oasis::Divide<Oasis::Real, Oasis::Expression> division;
+    division.SetMostSigOp(Oasis::Real { 6.0 });
+
+    requireMissingLeastSignificantOperandSerializationError(division);
 }
 
-TEST_CASE("Parse Malformed Subtraction", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Division Missing Most Significant Operand", "[PALM][Serializer][Division]")
 {
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) )");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::IncompleteExpression);
+    Oasis::Divide<Oasis::Expression, Oasis::Real> division;
+    division.SetLeastSigOp(Oasis::Real { 3.0 });
+
+    requireMissingMostSignificantOperandSerializationError(division);
 }
 
-TEST_CASE("Parse Subtraction Invalid Subexpression", "[FromPALM][Parsing]")
+// --- Exponentiation ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Exponentiation", "[PALM][Serializer][Exponentiation]")
 {
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) ( + ( real 3 ) ) )");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::IncompleteExpression);
+    const Oasis::Exponent<> exponent {
+        Oasis::Real { 2.0 },
+        Oasis::Real { 3.0 }
+    };
+    const std::string expected = "( ^ ( real 2 ) ( real 3 ) )";
+
+    requireSuccessfulSerialization(exponent, expected);
 }
 
-/*
- * Mixed Addition and Subtraction
- */
-TEST_CASE("Parse Mixed Addition and Subtraction", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Nested Exponentiation", "[PALM][Serializer][Exponentiation]")
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
+    const Oasis::Exponent<> exponent {
+        Oasis::Real { 2.0 },
+        Oasis::Exponent {
             Oasis::Real { 3.0 },
             Oasis::Real { 2.0 } }
     };
+    const std::string expected = "( ^ ( real 2 ) ( ^ ( real 3 ) ( real 2 ) ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(exponent, expected);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Exponentiation Missing Least Significant Operand", "[PALM][Serializer][Exponentiation]")
+{
+    Oasis::Exponent<Oasis::Real, Oasis::Expression> exponent;
+    exponent.SetMostSigOp(Oasis::Real { 2.0 });
+
+    requireMissingLeastSignificantOperandSerializationError(exponent);
 }
 
-TEST_CASE("Parse Mixed Addition and Subtraction 2", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization of Exponentiation Missing Most Significant Operand", "[PALM][Serializer][Exponentiation]")
 {
-    const Oasis::Subtract expected {
-        Oasis::Real { 5.0 },
-        Oasis::Add {
-            Oasis::Real { 3.0 },
-            Oasis::Real { 2.0 } }
+    Oasis::Exponent<Oasis::Expression, Oasis::Real> exponent;
+    exponent.SetLeastSigOp(Oasis::Real { 3.0 });
+
+    requireMissingMostSignificantOperandSerializationError(exponent);
+}
+
+// --- Logarithm ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Logarithm", "[PALM][Serializer][Logarithm]")
+{
+    const Oasis::Log<> log {
+        Oasis::Real { 10.0 },
+        Oasis::Real { 1000.0 }
     };
+    const std::string expected = "( log ( real 10 ) ( real 1000 ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(log, expected);
+}
 
-    const auto expr = Oasis::FromPALM("( - ( real 5 ) ( + ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEST_CASE("PALM Serialization of Nested Logarithm", "[PALM][Serializer][Logarithm]")
+{
+    const Oasis::Log<> log {
+        Oasis::Real { 10.0 },
+        Oasis::Log {
+            Oasis::Real { 10.0 },
+            Oasis::Real { 1000.0 } }
+    };
+    const std::string expected = "( log ( real 10 ) ( log ( real 10 ) ( real 1000 ) ) )";
+
+    requireSuccessfulSerialization(log, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Logarithm Missing Least Significant Operand", "[PALM][Serializer][Logarithm]")
+{
+    Oasis::Log<Oasis::Real, Oasis::Expression> log;
+    log.SetMostSigOp(Oasis::Real { 10.0 });
+
+    requireMissingLeastSignificantOperandSerializationError(log);
+}
+
+TEST_CASE("PALM Serialization of Logarithm Missing Most Significant Operand", "[PALM][Serializer][Logarithm]")
+{
+    Oasis::Log<Oasis::Expression, Oasis::Real> log;
+    log.SetLeastSigOp(Oasis::Real { 1000.0 });
+
+    requireMissingMostSignificantOperandSerializationError(log);
+}
+
+// --- Negation ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Negation", "[PALM][Serializer][Negation]")
+{
+    const Oasis::Negate<> negate {
+        Oasis::Real { 5.0 }
+    };
+    const std::string expected = "( neg ( real 5 ) )";
+
+    requireSuccessfulSerialization(negate, expected);
+}
+
+TEST_CASE("PALM Serialization of Nested Negation", "[PALM][Serializer][Negation]")
+{
+    const Oasis::Negate<> negate {
+        Oasis::Negate {
+            Oasis::Real { 5.0 } }
+    };
+    const std::string expected = "( neg ( neg ( real 5 ) ) )";
+
+    requireSuccessfulSerialization(negate, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Negation Missing Operand", "[PALM][Serializer][Negation]")
+{
+    const Oasis::Negate<> negate;
+
+    requireMissingOperandSerializationError(negate);
+}
+
+// --- Derivative ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Derivative", "[PALM][Serializer][Derivative]")
+{
+    const Oasis::Derivative<> derivative {
+        Oasis::Variable { "x" },
+        Oasis::Real { 5.0 }
+    };
+    const std::string expected = "( d ( var x ) ( real 5 ) )";
+
+    requireSuccessfulSerialization(derivative, expected);
+}
+
+TEST_CASE("PALM Serialization of Nested Derivative", "[PALM][Serializer][Derivative]")
+{
+    const Oasis::Derivative<> derivative {
+        Oasis::Variable { "x" },
+        Oasis::Derivative {
+            Oasis::Variable { "y" },
+            Oasis::Real { 5.0 } }
+    };
+    const std::string expected = "( d ( var x ) ( d ( var y ) ( real 5 ) ) )";
+
+    requireSuccessfulSerialization(derivative, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Derivative Missing Least Significant Operand", "[PALM][Serializer][Derivative]")
+{
+    Oasis::Derivative<Oasis::Real, Oasis::Expression> derivative;
+    derivative.SetMostSigOp(Oasis::Real { 5.0 });
+
+    requireMissingLeastSignificantOperandSerializationError(derivative);
+}
+
+TEST_CASE("PALM Serialization of Derivative Missing Most Significant Operand", "[PALM][Serializer][Derivative]")
+{
+    Oasis::Derivative<Oasis::Expression, Oasis::Real> derivative;
+    derivative.SetLeastSigOp(Oasis::Real { 5.0 });
+
+    requireMissingMostSignificantOperandSerializationError(derivative);
 }
 
-TEST_CASE("Parse Mixed Addition and Subtraction Multiple Elements", "[FromPALM][Parsing]")
+// --- Integral ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Integral", "[PALM][Serializer][Integral]")
 {
-    const Oasis::Add<> expected {
+    const Oasis::Integral<> integral {
+        Oasis::Variable { "x" },
+        Oasis::Real { 5.0 }
+    };
+    const std::string expected = "( int ( var x ) ( real 5 ) )";
+
+    requireSuccessfulSerialization(integral, expected);
+}
+
+TEST_CASE("PALM Serialization of Nested Integral", "[PALM][Serializer][Integral]")
+{
+    const Oasis::Integral<> integral {
+        Oasis::Variable { "x" },
+        Oasis::Integral {
+            Oasis::Variable { "y" },
+            Oasis::Real { 5.0 } }
+    };
+    const std::string expected = "( int ( var x ) ( int ( var y ) ( real 5 ) ) )";
+
+    requireSuccessfulSerialization(integral, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Integral Missing Least Significant Operand", "[PALM][Serializer][Integral]")
+{
+    Oasis::Integral<Oasis::Variable, Oasis::Expression> integral;
+    integral.SetMostSigOp(Oasis::Variable { "x" });
+
+    requireMissingLeastSignificantOperandSerializationError(integral);
+}
+
+TEST_CASE("PALM Serialization of Integral Missing Most Significant Operand", "[PALM][Serializer][Integral]")
+{
+    Oasis::Integral<Oasis::Expression, Oasis::Real> integral;
+    integral.SetLeastSigOp(Oasis::Real { 5.0 });
+
+    requireMissingMostSignificantOperandSerializationError(integral);
+}
+
+// TODO: Implement Matrix
+
+// --- Euler Number ---
+TEST_CASE("PALM Serialization of Euler Number", "[PALM][Serializer][EulerNumber]")
+{
+    const Oasis::EulerNumber euler {};
+    const std::string expected = "( e )";
+
+    requireSuccessfulSerialization(euler, expected);
+}
+
+// --- Pi ---
+TEST_CASE("PALM Serialization of Pi", "[PALM][Serializer][Pi]")
+{
+    const Oasis::Pi pi {};
+    const std::string expected = "( pi )";
+
+    requireSuccessfulSerialization(pi, expected);
+}
+
+// --- Magnitude ---
+// --- Basic Tests ---
+TEST_CASE("PALM Serialization of Magnitude", "[PALM][Serializer][Magnitude]")
+{
+    const Oasis::Magnitude magnitude {
+        Oasis::Real { -5.0 }
+    };
+    const std::string expected = "( magnitude ( real -5 ) )";
+
+    requireSuccessfulSerialization(magnitude, expected);
+}
+
+TEST_CASE("PALM Serialization of Nested Magnitude", "[PALM][Serializer][Magnitude]")
+{
+    const Oasis::Magnitude<Oasis::Magnitude<Oasis::Real>> magnitude {
+        Oasis::Magnitude {
+            Oasis::Real { -5.0 } }
+    };
+    const std::string expected = "( magnitude ( magnitude ( real -5 ) ) )";
+
+    requireSuccessfulSerialization(magnitude, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Serialization of Magnitude Missing Operand", "[PALM][Serializer][Magnitude]")
+{
+    const Oasis::Magnitude<Oasis::Expression> magnitude;
+
+    requireMissingOperandSerializationError(magnitude);
+}
+
+// -------------------------
+// Compound Expression Tests
+// -------------------------
+
+// Basic Compound Expression Tests
+TEST_CASE("PALM Serialization of Compound Expression Add Multiply Exponent", "[PALM][Serializer][CompoundExpression]")
+{
+    auto serializer = Oasis::PALMSerializer();
+
+    const Oasis::Add<> expression {
         Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Add {
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
                 Oasis::Real { 2.0 },
-                Oasis::Real { 1.0 } } }
+                Oasis::Real { 3.0 } } }
     };
+    const std::string expected = "( + ( real 5 ) ( * ( var x ) ( ^ ( real 2 ) ( real 3 ) ) ) )";
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(expression, expected);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( + ( real 2 ) ( real 1 ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEST_CASE("PALM Serialization of Compound Expression Subtract Divide Log", "[PALM][Serializer][CompoundExpression]")
+{
+    const Oasis::Subtract<> expression {
+        Oasis::Divide {
+            Oasis::Real { 10.0 },
+            Oasis::Real { 2.0 } },
+        Oasis::Log {
+            Oasis::Real { 10.0 },
+            Oasis::Real { 100.0 } }
+    };
+    const std::string expected = "( - ( / ( real 10 ) ( real 2 ) ) ( log ( real 10 ) ( real 100 ) ) )";
+
+    requireSuccessfulSerialization(expression, expected);
 }
 
-/*
- * Multiplication Operation
- */
+// ---------------------------
+// Padding and Separator Tests
+// ---------------------------
 
-TEST_CASE("Parse Simple Multiplication", "[FromPALM][Parsing]")
+// Expression Padding Tests
+TEST_CASE("PALM Serialization with No Expression Padding", "[PALM][Serializer][NoPadding]")
 {
-    const Oasis::Multiply expected {
+    const Oasis::Add<> expression {
         Oasis::Real { 5.0 },
-        Oasis::Real { 3.0 }
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
     };
+    const std::string expected = "(+ (real 5) (* (var x) (^ (real 2) (real 3))))";
+    const Oasis::PALMSerializationOpts opts = { .expressionPadding = "" };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(expression, expected, opts);
+}
 
-    const auto expr = Oasis::FromPALM("( * ( real 5 ) ( real 3 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEST_CASE("PALM Serialization with Space Expression Padding", "[PALM][Serializer][SpacePadding]")
+{
+    const Oasis::Add<> expression {
+        Oasis::Real { 5.0 },
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
+    };
+    const std::string expected = "( + ( real 5 ) ( * ( var x ) ( ^ ( real 2 ) ( real 3 ) ) ) )";
+    const Oasis::PALMSerializationOpts opts = { .expressionPadding = " " };
+
+    requireSuccessfulSerialization(expression, expected, opts);
 }
 
-TEST_CASE("Parse Nested Multiplication", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization with Hyphen Expression Padding", "[PALM][Serializer][HyphenPadding]")
 {
-    const Oasis::Multiply expected {
+    const Oasis::Add<> expression {
         Oasis::Real { 5.0 },
         Oasis::Multiply {
-            Oasis::Real { 3.0 },
-            Oasis::Real { 2.0 } }
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
     };
+    const std::string expected = "(-+ (-real 5-) (-* (-var x-) (-^ (-real 2-) (-real 3-)-)-)-)";
+    const Oasis::PALMSerializationOpts opts = { .expressionPadding = "-" };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(expression, expected, opts);
+}
 
-    const auto expr = Oasis::FromPALM("( * ( real 5 ) ( * ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEST_CASE("PALM Serialization with Tab Padding", "[PALM][Serializer][TabPadding]")
+{
+    Oasis::PALMSerializer serializer({ .expressionPadding = "\t" });
+
+    const Oasis::Add<> expression {
+        Oasis::Real { 5.0 },
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
+    };
+    const std::string expected = "(\t+ (\treal 5\t) (\t* (\tvar x\t) (\t^ (\treal 2\t) (\treal 3\t)\t)\t)\t)";
+    const Oasis::PALMSerializationOpts opts = { .expressionPadding = "\t" };
+
+    requireSuccessfulSerialization(expression, expected, opts);
 }
 
-TEST_CASE("Parse Multiplication Multiple Elements", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization with %bruh% Padding", "[PALM][Serializer][BruhPadding]")
 {
-    const Oasis::Multiply<> expected {
+    const Oasis::Add<> expression {
         Oasis::Real { 5.0 },
-        Oasis::Real { 3.0 },
-        Oasis::Real { 2.0 },
-        Oasis::Real { 1.0 }
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
     };
+    const std::string expected = "(%bruh%+ (%bruh%real 5%bruh%) (%bruh%* (%bruh%var x%bruh%) (%bruh%^ (%bruh%real 2%bruh%) (%bruh%real 3%bruh%)%bruh%)%bruh%)%bruh%)";
+    const Oasis::PALMSerializationOpts opts = { .expressionPadding = "%bruh%" };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireSuccessfulSerialization(expression, expected, opts);
+}
 
-    const auto expr = Oasis::FromPALM("( * ( real 5 ) ( real 3 ) ( real 2 ) ( real 1 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+// Token Separator Tests
+TEST_CASE("PALM Serialization with Double Space Separator", "[PALM][Serializer][DoubleSpaceSeparator]")
+{
+    const Oasis::Add<> expression {
+        Oasis::Real { 5.0 },
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
+                Oasis::Real { 2.0 },
+                Oasis::Real { 3.0 } } }
+    };
+    const std::string expected = "( +  ( real  5 )  ( *  ( var  x )  ( ^  ( real  2 )  ( real  3 ) ) ) )";
+    const Oasis::PALMSerializationOpts opts = { .tokenSeparator = "  " };
+
+    requireSuccessfulSerialization(expression, expected, opts);
 }
 
-TEST_CASE("Parse Mixed Addition, Subtraction, and Multiplication", "[FromPALM][Parsing]")
+TEST_CASE("PALM Serialization with Percent Separator", "[PALM][Serializer][PercentSeparator]")
 {
-    const Oasis::Add expected {
+    const Oasis::Add<> expression {
         Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
+        Oasis::Multiply {
+            Oasis::Variable { "x" },
+            Oasis::Exponent {
                 Oasis::Real { 2.0 },
-                Oasis::Real { 4.0 } } }
+                Oasis::Real { 3.0 } } }
     };
+    const std::string expected = "( +%( real%5 )%( *%( var%x )%( ^%( real%2 )%( real%3 ) ) ) )";
+    const Oasis::PALMSerializationOpts opts = { .tokenSeparator = "%" };
+
+    requireSuccessfulSerialization(expression, expected, opts);
+}
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+// ==================
+// PALM Parsing Tests
+// ==================
+
+// ----------------
+// Helper Functions
+// ----------------
+// Success
+void requireSuccessfulParsing(
+    const std::string& palm,
+    const Oasis::Expression& expectedExpr)
+{
+    const auto expr = Oasis::FromPALM(palm);
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( real 4 ) ) ) )");
     REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    REQUIRE((*expr)->Equals(expectedExpr));
 }
 
-/*
- * Division Operation
- */
-TEST_CASE("Parse Simple Division", "[FromPALM][Parsing]")
+// Failure
+void requireFailedParsing(
+    const std::string& palm,
+    const Oasis::PALMParseError& expectedError)
 {
-    const Oasis::Divide expected {
-        Oasis::Real { 6.0 },
-        Oasis::Real { 3.0 }
+    const auto expr = Oasis::FromPALM(palm);
+
+    REQUIRE_FALSE(expr.has_value());
+
+    const auto& error = expr.error();
+    CAPTURE(error.message, expectedError.message);
+    REQUIRE(error == expectedError);
+}
+
+// --- Specific Error Types ---
+void requireExtraOperandParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::ExtraOperands,
+        .token = errorToken,
+        .message = "Unexpected token '" + errorToken.lexeme + "' found after parsing expression"
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireFailedParsing(palm, expectedError);
+}
 
-    const auto expr = Oasis::FromPALM("( / ( real 6 ) ( real 3 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+void requireMissingOperandParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::MissingOperand,
+        .token = errorToken,
+        .message = "Expected operand after token '" + errorToken.lexeme + "'"
+    };
+
+    requireFailedParsing(palm, expectedError);
 }
 
-TEST_CASE("Parse Nested Division", "[FromPALM][Parsing]")
+void requireInvalidNumberFormatParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
 {
-    const Oasis::Divide expected {
-        Oasis::Real { 6.0 },
-        Oasis::Divide {
-            Oasis::Real { 3.0 },
-            Oasis::Real { 2.0 } }
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::InvalidNumberFormat,
+        .token = errorToken,
+        .message = "Invalid number format: '" + errorToken.lexeme + "'"
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireFailedParsing(palm, expectedError);
+}
 
-    const auto expr = Oasis::FromPALM("( / ( real 6 ) ( / ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+void requireNumberOutOfBoundsParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::NumberOutOfBounds,
+        .token = errorToken,
+        .message = "Number out of bounds: '" + errorToken.lexeme + "'"
+    };
+
+    requireFailedParsing(palm, expectedError);
 }
 
-TEST_CASE("Parse Division Multiple Elements", "[FromPALM][Parsing]")
+void requireInvalidVariableNameParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
 {
-    const Oasis::Divide<> expected {
-        Oasis::Real { 6.0 },
-        Oasis::Divide {
-            Oasis::Real { 3.0 },
-            Oasis::Divide {
-                Oasis::Real { 2.0 },
-                Oasis::Real { 1.0 } } }
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::InvalidVariableName,
+        .token = errorToken,
+        .message = "Invalid identifier: '" + errorToken.lexeme + "'"
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireFailedParsing(palm, expectedError);
+}
 
-    const auto expr = Oasis::FromPALM("( / ( real 6 ) ( real 3 ) ( real 2 ) ( real 1 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+void requireInvalidOperandParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::InvalidOperand,
+        .token = errorToken,
+        .message = "Invalid operand: '" + errorToken.lexeme + "'. Expected an expression."
+    };
+
+    requireFailedParsing(palm, expectedError);
 }
 
-TEST_CASE("Parse Mixed Addition, Subtraction, Multiplication, and Division", "[FromPALM][Parsing]")
+void requireMissingOpeningParenthesisParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
-                Oasis::Real { 2.0 },
-                Oasis::Divide {
-                    Oasis::Real { 4.0 },
-                    Oasis::Real { 2.0 } } } }
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::MissingOpeningParenthesis,
+        .token = errorToken,
+        .message = "Expected '(' before expression starting with token '" + errorToken.lexeme + "'"
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireFailedParsing(palm, expectedError);
+}
+
+void requireMissingClosingParenthesisParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::MissingClosingParenthesis,
+        .token = errorToken,
+        .message = "Expected ')' to close expression starting with token '" + errorToken.lexeme + "'"
+    };
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( real 2 ) ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireFailedParsing(palm, expectedError);
 }
 
-/*
- * Exponent Operation
- */
-TEST_CASE("Parse Simple Exponent", "[FromPALM][Parsing]")
+void requireInvalidOperatorParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
 {
-    const Oasis::Exponent expected {
-        Oasis::Real { 2.0 },
-        Oasis::Real { 3.0 }
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::InvalidOperator,
+        .token = errorToken,
+        .message = "Invalid operator: '" + errorToken.lexeme + "'"
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireFailedParsing(palm, expectedError);
+}
 
-    const auto expr = Oasis::FromPALM("( ^ ( real 2 ) ( real 3 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+void requireUnexpectedEndOfInputParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::UnexpectedEndOfInput,
+        .token = errorToken,
+        .message = "Unexpected end of input while parsing expression"
+    };
+
+    requireFailedParsing(palm, expectedError);
 }
 
-TEST_CASE("Parse Nested Exponent", "[FromPALM][Parsing]")
+void requireMissingOperatorParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
 {
-    const Oasis::Exponent expected {
-        Oasis::Real { 2.0 },
-        Oasis::Exponent {
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::MissingOperator,
+        .token = errorToken,
+        .message = "Expected operator after token '" + errorToken.lexeme + "'"
+    };
+
+    requireFailedParsing(palm, expectedError);
+}
+
+void requireUnexpectedTokenParsingError(
+    const std::string& palm,
+    const Oasis::PALMToken& errorToken)
+{
+    const auto expectedError = Oasis::PALMParseError {
+        .type = Oasis::PALMParseError::PALMParseErrorType::UnexpectedToken,
+        .token = errorToken,
+        .message = "Unexpected token: '" + errorToken.lexeme + "'"
+    };
+
+    requireFailedParsing(palm, expectedError);
+}
+
+// --- Operator Mapping ---
+// Trait mapping operator class → symbol string
+template <typename T>
+struct OperatorSymbol;
+
+// Binary Operators
+template <>
+struct OperatorSymbol<Oasis::Add<>> {
+    static constexpr auto value = "+";
+};
+template <>
+struct OperatorSymbol<Oasis::Subtract<>> {
+    static constexpr auto value = "-";
+};
+template <>
+struct OperatorSymbol<Oasis::Multiply<>> {
+    static constexpr auto value = "*";
+};
+template <>
+struct OperatorSymbol<Oasis::Divide<>> {
+    static constexpr auto value = "/";
+};
+template <>
+struct OperatorSymbol<Oasis::Exponent<>> {
+    static constexpr auto value = "^";
+};
+template <>
+struct OperatorSymbol<Oasis::Log<>> {
+    static constexpr auto value = "log";
+};
+template <>
+struct OperatorSymbol<Oasis::Integral<>> {
+    static constexpr auto value = "int";
+};
+template <>
+struct OperatorSymbol<Oasis::Derivative<>> {
+    static constexpr auto value = "d";
+};
+
+// Unary Operators
+template <>
+struct OperatorSymbol<Oasis::Negate<>> {
+    static constexpr auto value = "neg";
+};
+template <>
+struct OperatorSymbol<Oasis::Magnitude<>> {
+    static constexpr auto value = "magnitude";
+};
+
+// Leaf Operators
+template <>
+struct OperatorSymbol<Oasis::Undefined> {
+    static constexpr auto value = "undefined";
+};
+template <>
+struct OperatorSymbol<Oasis::Imaginary> {
+    static constexpr auto value = "i";
+};
+template <>
+struct OperatorSymbol<Oasis::Pi> {
+    static constexpr auto value = "pi";
+};
+template <>
+struct OperatorSymbol<Oasis::EulerNumber> {
+    static constexpr auto value = "e";
+};
+
+// ------------------
+// Binary Expressions
+// ------------------
+
+// --- Basic Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions",
+    "[PALM][Parser][Operator][Template]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const TestType expected {
+        Oasis::Real { 3.0 },
+        Oasis::Real { 5.0 }
+    };
+
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 3 ) ( real 5 ) )";
+    requireSuccessfulParsing(palm, expected);
+}
+
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Nested Binary Expressions",
+    "[PALM][Parser][Operator][Template][Nested]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const TestType expected {
+        Oasis::Real { 5.0 },
+        TestType {
             Oasis::Real { 3.0 },
             Oasis::Real { 2.0 } }
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 5 ) ( " + op + " ( real 3 ) ( real 2 ) ) )";
+    requireSuccessfulParsing(palm, expected);
+}
+
+// --- Malformed Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions Missing Least Significant Operand",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 5 ) )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Punctuator,
+        .lexeme = ")",
+        .charOffset = palm.size() - 1,
+        .tokenIndex = 7,
+        .line = 1,
+        .column = palm.size(),
+    };
 
-    const auto expr = Oasis::FromPALM("( ^ ( real 2 ) ( ^ ( real 3 ) ( real 2 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireMissingOperandParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Exponent Multiple Elements", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions Missing Most Significant Operand",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
 {
-    const Oasis::Exponent<> expected {
-        Oasis::Real { 2.0 },
-        Oasis::Exponent {
-            Oasis::Real { 3.0 },
-            Oasis::Exponent {
-                Oasis::Real { 2.0 },
-                Oasis::Real { 1.0 } } }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Punctuator,
+        .lexeme = ")",
+        .charOffset = palm.size() - 1,
+        .tokenIndex = 3,
+        .line = 1,
+        .column = palm.size(),
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingOperandParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( ^ ( real 2 ) ( real 3 ) ( real 2 ) ( real 1 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions with Extra Tokens",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 3 ) ( real 5 ) extra_token )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = palm.size() - 13,
+        .tokenIndex = 8,
+        .line = 1,
+        .column = palm.size() - 12,
+    };
+
+    requireExtraOperandParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Mixed Addition, Subtraction, Multiplication, Division, and Exponent", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions with Identifier Operand",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
-                Oasis::Real { 2.0 },
-                Oasis::Divide {
-                    Oasis::Real { 4.0 },
-                    Oasis::Exponent {
-                        Oasis::Real { 2.0 },
-                        Oasis::Real { 3.0 } } } } }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 3 ) x )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "x",
+        .charOffset = palm.size() - 2,
+        .tokenIndex = 5,
+        .line = 1,
+        .column = palm.size() - 1,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    return requireInvalidOperandParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( ^ ( real 2 ) ( real 3 ) ) ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions with Number Operand",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 3 ) 42 )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Number,
+        .lexeme = "42",
+        .charOffset = palm.size() - 3,
+        .tokenIndex = 5,
+        .line = 1,
+        .column = palm.size() - 2,
+    };
+
+    return requireInvalidOperandParsingError(palm, errorToken);
 }
 
-/*
- * Logarithm Operation
- */
-TEST_CASE("Parse Simple Logarithm", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions Missing Opening Parentheses",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
 {
-    const Oasis::Log expected {
-        Oasis::Real { 2.0 },
-        Oasis::Real { 8.0 }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = " " + op + " ( real 3 ) ( real 5 ) )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = op,
+        .charOffset = 1,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 2,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( log ( real 2 ) ( real 8 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Binary Expressions Missing Closing Parentheses",
+    "[PALM][Parser][Operator][Template][Malformed]",
+    Oasis::Add<>,
+    Oasis::Subtract<>,
+    Oasis::Multiply<>,
+    Oasis::Divide<>,
+    Oasis::Exponent<>,
+    Oasis::Log<>,
+    Oasis::Integral<>,
+    Oasis::Derivative<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real 3 ) ( real 5 ) ";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = palm.size(),
+        .tokenIndex = 7,
+        .line = 1,
+        .column = palm.size() + 1,
+    };
+
+    requireMissingClosingParenthesisParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Nested Logarithm", "[FromPALM][Parsing]")
+// -----------------
+// Unary Expressions
+// -----------------
+
+// --- Basic Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions",
+    "[PALM][Parser][Operator][Template][Unary]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
 {
-    const Oasis::Log expected {
-        Oasis::Real { 2.0 },
-        Oasis::Log {
-            Oasis::Real { 3.0 },
-            Oasis::Real { 9.0 } }
+    const TestType expected {
+        Oasis::Real { -7.0 }
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real -7 ) )";
 
-    const auto expr = Oasis::FromPALM("( log ( real 2 ) ( log ( real 3 ) ( real 9 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireSuccessfulParsing(palm, expected);
 }
 
-TEST_CASE("Parse Logarithm Multiple Elements", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Nested Unary Expressions",
+    "[PALM][Parser][Operator][Template][Unary][Nested]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
 {
-    const Oasis::Log<> expected {
-        Oasis::Real { 2.0 },
-        Oasis::Log {
-            Oasis::Real { 3.0 },
-            Oasis::Log {
-                Oasis::Real { 4.0 },
-                Oasis::Real { 16.0 } } }
+    const TestType expected {
+        TestType {
+            Oasis::Real { -7.0 } }
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( " + op + " ( real -7 ) ) )";
 
-    const auto expr = Oasis::FromPALM("( log ( real 2 ) ( real 3 ) ( real 4 ) ( real 16 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireSuccessfulParsing(palm, expected);
 }
 
-TEST_CASE("Parse Mixed Many", "[FromPALM][Parsing]")
+// --- Malformed Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions Missing Operand",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
-                Oasis::Real { 2.0 },
-                Oasis::Divide {
-                    Oasis::Real { 4.0 },
-                    Oasis::Exponent {
-                        Oasis::Real { 2.0 },
-                        Oasis::Log {
-                            Oasis::Real { 2.0 },
-                            Oasis::Real { 8.0 } } } } } }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Punctuator,
+        .lexeme = ")",
+        .charOffset = palm.size() - 1,
+        .tokenIndex = 3,
+        .line = 1,
+        .column = palm.size(),
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingOperandParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( ^ ( real 2 ) ( log ( real 2 ) ( real 8 ) ) ) ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions with Extra Tokens",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real -7 ) extra_token )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = palm.size() - 13,
+        .tokenIndex = 5,
+        .line = 1,
+        .column = palm.size() - 12,
+    };
+
+    requireExtraOperandParsingError(palm, errorToken);
 }
 
-/*
- * Integral Operation
- */
-TEST_CASE("Parse Simple Integral", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions with Number Operand",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
 {
-    const Oasis::Integral expected {
-        Oasis::Variable { "x" },
-        Oasis::Real { 0.0 },
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " 42 )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Number,
+        .lexeme = "42",
+        .charOffset = palm.size() - 3,
+        .tokenIndex = 4,
+        .line = 1,
+        .column = palm.size() - 2,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    return requireInvalidOperandParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( int ( var x ) ( real 0 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions with Identifier Operand",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " x )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "x",
+        .charOffset = palm.size() - 2,
+        .tokenIndex = 4,
+        .line = 1,
+        .column = palm.size() - 1,
+    };
+
+    return requireInvalidOperandParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Nested Integral", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions Missing Opening Parentheses",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
 {
-    const Oasis::Integral expected {
-        Oasis::Variable { "x" },
-        Oasis::Integral {
-            Oasis::Variable { "y" },
-            Oasis::Real { 0.0 } }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = " " + op + " ( real -7 ) )";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = op,
+        .charOffset = 1,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 2,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( int ( var x ) ( int ( var y ) ( real 0 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Unary Expressions Missing Closing Parentheses",
+    "[PALM][Parser][Operator][Template][Unary][Malformed]",
+    Oasis::Negate<>,
+    Oasis::Magnitude<>)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ( real -7 ) ";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = palm.size(),
+        .tokenIndex = 5,
+        .line = 1,
+        .column = palm.size() + 1,
+    };
+
+    requireMissingClosingParenthesisParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Integral Multiple Elements", "[FromPALM][Parsing]")
+// ----------------
+// Leaf Expressions
+// ----------------
+// --- Basic Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Leaf Expressions",
+    "[PALM][Parser][Operator][Template][Leaf]",
+    Oasis::Undefined,
+    Oasis::Imaginary,
+    Oasis::EulerNumber,
+    Oasis::Pi)
 {
-    const Oasis::Integral<> expected {
-        Oasis::Variable { "x" },
-        Oasis::Integral {
-            Oasis::Variable { "y" },
-            Oasis::Integral {
-                Oasis::Variable { "z" },
-                Oasis::Real { 0.0 } } }
+    const TestType expected {};
+
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " )";
+
+    requireSuccessfulParsing(palm, expected);
+}
+
+// --- Malformed Tests ---
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Leaf Expressions with Extra Tokens",
+    "[PALM][Parser][Operator][Template][Leaf][Malformed]",
+    Oasis::Undefined,
+    Oasis::Imaginary,
+    Oasis::EulerNumber,
+    Oasis::Pi)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " extra_token )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = palm.size() - 13,
+        .tokenIndex = 2,
+        .line = 1,
+        .column = palm.size() - 12,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireExtraOperandParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( int ( var x ) ( var y ) ( int ( var z ) ( real 0 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Leaf Expressions with Missing Parentheses",
+    "[PALM][Parser][Operator][Template][Leaf][Malformed]",
+    Oasis::Undefined,
+    Oasis::Imaginary,
+    Oasis::EulerNumber,
+    Oasis::Pi)
+{
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = " " + op + " )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = op,
+        .charOffset = 1,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 2,
+    };
+
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Mixed Integral", "[FromPALM][Parsing]")
+TEMPLATE_TEST_CASE(
+    "PALM Parsing of Leaf Expressions with Missing Closing Parentheses",
+    "[PALM][Parser][Operator][Template][Leaf][Malformed]",
+    Oasis::Undefined,
+    Oasis::Imaginary,
+    Oasis::EulerNumber,
+    Oasis::Pi)
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
-                Oasis::Real { 2.0 },
-                Oasis::Divide {
-                    Oasis::Real { 4.0 },
-                    Oasis::Exponent {
-                        Oasis::Real { 2.0 },
-                        Oasis::Log {
-                            Oasis::Real { 2.0 },
-                            Oasis::Integral {
-                                Oasis::Variable { "x" },
-                                Oasis::Real { 8.0 } } } } } } }
+    const std::string op = OperatorSymbol<TestType>::value;
+    const std::string palm = "( " + op + " ";
+
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = palm.size(),
+        .tokenIndex = 3,
+        .line = 1,
+        .column = palm.size() + 1,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingClosingParenthesisParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( ^ ( real 2 ) ( log ( real 2 ) ( int ( var x ) ( real 8 ) ) ) ) ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+// --------------
+// Real Tests
+// --------------
+
+// --- Basic Tests ---
+TEST_CASE("PALM Parsing of Real Numbers", "[PALM][Parser][Operator][Real]")
+{
+    auto [palm, expected] = GENERATE(
+        std::make_pair("( real 42 )", Oasis::Real { 42.0 }),
+        std::make_pair("( real -7 )", Oasis::Real { -7.0 }),
+        std::make_pair("( real 3.14159 )", Oasis::Real { 3.14159 }),
+        std::make_pair("( real -2.71828 )", Oasis::Real { -2.71828 }),
+        std::make_pair("( real 0.0 )", Oasis::Real { 0.0 }),
+        std::make_pair("( real 1.23e4 )", Oasis::Real { 12300.0 }),
+        std::make_pair("( real NaN )", Oasis::Real { std::numeric_limits<double>::quiet_NaN() }),
+        std::make_pair("( real Infinity )", Oasis::Real { std::numeric_limits<double>::infinity() }),
+        std::make_pair("( real -Infinity )", Oasis::Real { -std::numeric_limits<double>::infinity() }));
+
+    requireSuccessfulParsing(palm, expected);
 }
 
-/*
- * Negate Operation
- */
-TEST_CASE("Parse Simple Negate", "[FromPALM][Parsing]")
+// --- Malformed Tests ---
+TEST_CASE("PALM Parsing of Real with Invalid Number", "[PALM][Parser][Operator][Real]")
 {
-    const Oasis::Negate expected {
-        Oasis::Real { 5.0 }
+    auto [palm, errorLexeme, errorType] = GENERATE(
+        std::make_tuple("( real )", ")", Oasis::PALMTokenType::Punctuator),
+        std::make_tuple("( real ( real 5 ) )", "(", Oasis::PALMTokenType::Punctuator),
+        std::make_tuple("( real x )", "x", Oasis::PALMTokenType::Identifier),
+        std::make_tuple("( real not_a_number )", "not_a_number", Oasis::PALMTokenType::Identifier),
+        std::make_tuple("( real real )", "real", Oasis::PALMTokenType::Operator));
+
+
+    const Oasis::PALMToken errorToken = {
+        .type = errorType,
+        .lexeme = errorLexeme,
+        .charOffset = 7,
+        .tokenIndex = 2,
+        .line = 1,
+        .column = 8,
     };
 
-    const auto expr = Oasis::FromPALM("( neg ( real 5 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireMissingOperandParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Invalid Negate", "[FromPALM][Parsing]")
+TEST_CASE("PALM Parsing of Real with Out of Bounds Number", "[PALM][Parser][Operator][Real]")
 {
-    const auto expr = Oasis::FromPALM("( neg )");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::UnexpectedToken);
+    const std::string palm = "( real 1e4000 )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Number,
+        .lexeme = "1e4000",
+        .charOffset = 12,
+        .tokenIndex = 3,
+        .line = 1,
+        .column = 13,
+    };
+
+    requireNumberOutOfBoundsParsingError(palm, errorToken);
 }
 
-/*
- * Derivative Operation
- */
-TEST_CASE("Parse Simple Derivative", "[FromPALM][Parsing]")
+TEST_CASE("PALM Parsing of Real with Extra Tokens", "[PALM][Parser][Operator][Real]")
 {
-    const Oasis::Derivative expected {
-        Oasis::Variable { "x" },
-        Oasis::Real { 0.0 },
+    const std::string palm = "( real 3.14 extra_token )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = 17,
+        .tokenIndex = 4,
+        .line = 1,
+        .column = 18
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireExtraOperandParsingError(palm, errorToken);
+}
+
+TEST_CASE("PALM Parsing of Real with Missing Opening Parentheses", "[PALM][Parser][Operator][Real]")
+{
+    const std::string palm = " real 3.14 )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "real",
+        .charOffset = 1,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 2,
+    };
 
-    const auto expr = Oasis::FromPALM("( d ( var x ) ( real 0 ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Nested Derivative", "[FromPALM][Parsing]")
+TEST_CASE("PALM Parsing of Real with Missing Closing Parentheses", "[PALM][Parser][Operator][Real]")
 {
-    const Oasis::Derivative expected {
-        Oasis::Variable { "x" },
-        Oasis::Derivative {
-            Oasis::Variable { "y" },
-            Oasis::Real { 0.0 } }
+    const std::string palm = "( real 3.14 ";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = palm.size(),
+        .tokenIndex = 4,
+        .line = 1,
+        .column = palm.size() + 1,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingClosingParenthesisParsingError(palm, errorToken);
+}
+
+// ---------------
+// Imaginary Tests
+// ---------------
+// Testing both 'i' and 'j' representations
+TEST_CASE("PALM Parsing of Imaginary Number", "[PALM][Parser][Operator][Imaginary]")
+{
+    auto [palm, expected] = GENERATE(
+        std::make_pair("( i )", Oasis::Imaginary {}),
+        std::make_pair("( j )", Oasis::Imaginary {}));
 
-    const auto expr = Oasis::FromPALM("( d ( var x ) ( d ( var y ) ( real 0 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireSuccessfulParsing(palm, expected);
 }
 
-TEST_CASE("Parse Derivative Multiple Elements", "[FromPALM][Parsing]")
+// --------------
+// Variable Tests
+// --------------
+// --- Basic Tests ---
+TEST_CASE("PALM Parsing of Variable", "[PALM][Parser][Operator][Variable]")
 {
-    const Oasis::Derivative<> expected {
-        Oasis::Variable { "x" },
-        Oasis::Derivative {
-            Oasis::Variable { "y" },
-            Oasis::Derivative {
-                Oasis::Variable { "z" },
-                Oasis::Real { 0.0 } } }
+    auto [palm, expected] = GENERATE(
+        std::make_pair("( var myVar )", Oasis::Variable { "myVar" }),
+        std::make_pair("( var x )", Oasis::Variable { "x" }),
+        std::make_pair("( var var123 )", Oasis::Variable { "var123" }),
+        std::make_pair("( var var_name )", Oasis::Variable { "var_name" })
+
+    );
+
+    requireSuccessfulParsing(palm, expected);
+}
+
+// --- Malformed Tests ---
+TEST_CASE("PALM Parsing of Variable with Invalid Identifier", "[PALM][Parser][Operator][Variable]")
+{
+    auto [palm, errorLexeme, errorType] = GENERATE(
+        std::make_tuple("( var var-name )", "var-name", Oasis::PALMTokenType::Unknown),
+        std::make_tuple("( var var$name )", "var$name", Oasis::PALMTokenType::Unknown),
+        std::make_tuple("( var real )", "real", Oasis::PALMTokenType::Operator),
+        std::make_tuple("( var log )", "log", Oasis::PALMTokenType::Operator),
+        std::make_tuple("( var 123 )", "123", Oasis::PALMTokenType::Number),
+        std::make_tuple("( var ( real 5 ) )", "(", Oasis::PALMTokenType::Punctuator),
+        std::make_tuple("( var )", ")", Oasis::PALMTokenType::Punctuator));
+
+    const Oasis::PALMToken errorToken = {
+        .type = errorType,
+        .lexeme = errorLexeme,
+        .charOffset = 6,
+        .tokenIndex = 2,
+        .line = 1,
+        .column = 7,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireInvalidVariableNameParsingError(palm, errorToken);
+}
+
+TEST_CASE("PALM Parsing of Variable with Extra Tokens", "[PALM][Parser][Operator][Variable]")
+{
+    const std::string palm = "( var x extra_token )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = 9,
+        .tokenIndex = 3,
+        .line = 1,
+        .column = 10,
+    };
 
-    const auto expr = Oasis::FromPALM("( d ( var x ) ( var y ) ( d ( var z ) ( real 0 ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+    requireExtraOperandParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Mixed Derivative", "[FromPALM][Parsing]")
+TEST_CASE("PALM Parsing of Variable with Missing Opening Parentheses", "[PALM][Parser][Operator][Variable]")
 {
-    const Oasis::Add expected {
-        Oasis::Real { 5.0 },
-        Oasis::Subtract {
-            Oasis::Real { 3.0 },
-            Oasis::Multiply {
-                Oasis::Real { 2.0 },
-                Oasis::Divide {
-                    Oasis::Real { 4.0 },
-                    Oasis::Exponent {
-                        Oasis::Real { 2.0 },
-                        Oasis::Log {
-                            Oasis::Real { 2.0 },
-                            Oasis::Derivative {
-                                Oasis::Variable { "x" },
-                                Oasis::Real { 8.0 } } } } } } }
+    const std::string palm = " var x )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "var",
+        .charOffset = 1,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 2,
     };
 
-    OASIS_CAPTURE_WITH_SERIALIZER(expected);
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
+}
 
-    const auto expr = Oasis::FromPALM("( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( ^ ( real 2 ) ( log ( real 2 ) ( d ( var x ) ( real 8 ) ) ) ) ) ) ) )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Equals(expected));
+TEST_CASE("PALM Parsing of Variable with Missing Closing Parentheses", "[PALM][Parser][Operator][Variable]")
+{
+    const std::string palm = "( var x ";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = palm.size(),
+        .tokenIndex = 3,
+        .line = 1,
+        .column = palm.size() + 1,
+    };
+
+    requireMissingClosingParenthesisParsingError(palm, errorToken);
 }
 
-/*
- * Parse Constants Pi and Euler's Number
- */
-TEST_CASE("Parse Constant Pi (pi)", "[FromPALM][Parsing]")
+// ----------------
+// Expression Tests
+// ----------------
+// --- Malformed Tests ---
+TEST_CASE("PALM Parsing of Real with different spacing and padding", "[PALM][Parser][Real]")
 {
-    const auto expr = Oasis::FromPALM("( pi )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::Pi>());
+    auto [ palm, expected ] = GENERATE(
+        std::make_pair("(   real    7.89   )", Oasis::Real{7.89}),
+        std::make_pair("(\treal\t0.5772\t)", Oasis::Real{0.5772}),
+        std::make_pair("(\nreal\n1.618\n)", Oasis::Real{1.618})
+    );
+
+    requireSuccessfulParsing(palm, expected);
 }
 
-TEST_CASE("Parse Constant Euler's Number", "[FromPALM][Parsing]")
+TEST_CASE("Parse Expression with Unknown Operator", "[PALM][Parsing]")
 {
-    const auto expr = Oasis::FromPALM("( e )");
-    REQUIRE(expr.has_value());
-    REQUIRE((*expr)->Is<Oasis::EulerNumber>());
+    const std::string palm = "( unknown_op ( real 5 ) ( real 3 ) )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "unknown_op",
+        .charOffset = 2,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 3,
+    };
+
+    requireInvalidOperandParsingError(palm, errorToken);
 }
 
-/*
- * Test Invalid Expressions
- */
-TEST_CASE("Parse Invalid Expression", "[FromPALM][Parsing]")
+TEST_CASE("Parse Empty Expression", "[PALM][Parsing]")
 {
-    const auto expr = Oasis::FromPALM("( unknown_op ( real 5 ) ( real 3 ) )");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::UnknownOperator);
+    const std::string palm;
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::EndOfInput,
+        .lexeme = "",
+        .charOffset = 0,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 1,
+    };
+
+    requireUnexpectedEndOfInputParsingError(palm, errorToken);
 }
 
-TEST_CASE("Parse Empty Expression", "[FromPALM][Parsing]")
+TEST_CASE("Parse Expression with Only Parentheses", "[PALM][Parsing]")
 {
-    const auto expr = Oasis::FromPALM("");
-    REQUIRE(!expr);
-    REQUIRE(expr.error() == Oasis::ParseError::UnexpectedEndOfInput);
+    const std::string palm = "( )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Punctuator,
+        .lexeme = ")",
+        .charOffset = 2,
+        .tokenIndex = 1,
+        .line = 1,
+        .column = 3,
+    };
+
+    requireMissingOperatorParsingError(palm, errorToken);
+}
+
+TEST_CASE("Parse Expression with Missing Operator", "[PALM][Parsing]")
+{
+    const std::string palm = "( ( real 5 ) ( real 3 ) )";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Punctuator,
+        .lexeme = "(",
+        .charOffset = 2,
+        .tokenIndex = 1,
+        .line = 1,
+        .column = 3,
+    };
+
+    requireMissingOperatorParsingError(palm, errorToken);
+}
+
+TEST_CASE("Parse Expression with Extra Tokens After Closing Parenthesis", "[PALM][Parsing]")
+{
+    const std::string palm = "( + ( real 5 ) ( real 3 ) ) extra_token";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Identifier,
+        .lexeme = "extra_token",
+        .charOffset = 33,
+        .tokenIndex = 8,
+        .line = 1,
+        .column = 33,
+    };
+
+    requireUnexpectedTokenParsingError(palm, errorToken);
+}
+
+TEST_CASE("Parse Expression Invalid Start of Expression", "[PALM][Parsing]")
+{
+    const std::string palm = "'";
+    const Oasis::PALMToken errorToken = {
+        .type = Oasis::PALMTokenType::Operator,
+        .lexeme = "'",
+        .charOffset = 0,
+        .tokenIndex = 0,
+        .line = 1,
+        .column = 1,
+    };
+
+    requireMissingOpeningParenthesisParsingError(palm, errorToken);
+}
+
+// ------------------------
+// Complex Expression Tests
+// ------------------------
+TEST_CASE("PALM Parsing of Complex Expressions", "[PALM][Parser][Operator]") {
+    using Factory = std::function<std::unique_ptr<Oasis::Expression>()>;
+
+    auto [palm, makeExpected] = GENERATE(
+        std::make_pair(
+            std::string{"( + ( real 5 ) ( * ( real 3 ) ( - ( real 2 ) ( real 1 ) ) ) )"},
+            Factory{[] {
+                return std::unique_ptr<Oasis::Expression>(
+                    new Oasis::Add<
+                        Oasis::Real,
+                        Oasis::Multiply<Oasis::Real, Oasis::Subtract<Oasis::Real>>
+                    >(
+                        Oasis::Real{5.0},
+                        Oasis::Multiply{
+                            Oasis::Real{3.0},
+                            Oasis::Subtract{Oasis::Real{2.0}, Oasis::Real{1.0}}
+                        }
+                    )
+                );
+            }}
+        ),
+        std::make_pair(
+            std::string{"( / ( ^ ( real 2 ) ( real 3 ) ) ( log ( real 10 ) ( real 1000 ) ) )"},
+            Factory{[] {
+                return std::unique_ptr<Oasis::Expression>(
+                    new Oasis::Divide<
+                        Oasis::Exponent<Oasis::Real, Oasis::Real>,
+                        Oasis::Log<Oasis::Real>
+                    >(
+                        Oasis::Exponent{Oasis::Real{2.0}, Oasis::Real{3.0}},
+                        Oasis::Log{Oasis::Real{10.0}, Oasis::Real{1000.0}}
+                    )
+                );
+            }}
+        ),
+        std::make_pair(
+            std::string{"( + ( real 5 ) ( - ( real 3 ) ( * ( real 2 ) ( / ( real 4 ) ( real 2 ) ) ) ) )"},
+            Factory{[] {
+                return std::unique_ptr<Oasis::Expression>(
+                    new Oasis::Add<
+                        Oasis::Real,
+                        Oasis::Subtract<
+                            Oasis::Real,
+                            Oasis::Multiply<Oasis::Real, Oasis::Divide<Oasis::Real>
+                            >
+                        >
+                    >(
+                        Oasis::Real{5.0},
+                        Oasis::Subtract{
+                            Oasis::Real{3.0},
+                            Oasis::Multiply{
+                                Oasis::Real{2.0},
+                                Oasis::Divide{Oasis::Real{4.0}, Oasis::Real{2.0}}
+                            }
+                        }
+                    )
+                );
+            }}
+        )
+    );
+
+    const auto expected = makeExpected();
+    requireSuccessfulParsing(palm, *expected);
 }
\ No newline at end of file