Serde

Kind of a port of Rust's Serde crate.
git clone https://git.philomathiclife.com/repos/Serde
Log | Files | Refs | README
commit 7b07657e4c8d61d75495a20d3cdb994d2e75d33b
Author: Zack Newman <zack@philomathiclife.com>
Date:   Fri, 17 Mar 2023 17:25:04 -0600

initial

Diffstat:

A.editorconfig | 1114+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


A.gitignore | 2++


AAssemblyInfo.cs | 8++++++++


ABinDe.cs | 253+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ABinSer.cs | 182+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ADe.cs | 506+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ALICENSE-APACHE | 177+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ALICENSE-MIT | 20++++++++++++++++++++


AREADME.md | 3+++


ASer.cs | 103+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


ASerde.csproj | 61+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


11 files changed, 2429 insertions(+), 0 deletions(-)

diff --git a/.editorconfig b/.editorconfig
@@ -0,0 +1,1113 @@
+# Remove the line below if you want to inherit .editorconfig settings from higher directories
+root = true
+
+# Don't use tabs for indentation.
+[*]
+indent_style = space
+charset = utf-8
+
+# XML project files
+[*.{csproj,vbproj,vcxproj,vcxproj.filters,proj,projitems,shproj}]
+indent_size = 2
+
+# XML config files
+[*.{props,targets,ruleset,config,nuspec,resx,vsixmanifest,vsct}]
+indent_size = 2
+
+# JSON files
+[*.json]
+indent_size = 2
+
+# Powershell files
+[*.ps1]
+indent_size = 2
+
+# Shell script files
+[*.sh]
+end_of_line = lf
+indent_size = 2
+
+# Code files
+[*.{cs,csx,vb,vbx}]
+# Indentation and spacing
+indent_size = 4
+tab_width = 4
+
+# New line preferences
+end_of_line = lf
+insert_final_newline = false
+dotnet_style_allow_multiple_blank_lines_experimental = false:error
+dotnet_style_allow_statement_immediately_after_block_experimental = true:error
+
+#### .NET Coding Conventions ####
+
+# Organize usings
+dotnet_separate_import_directive_groups = false
+dotnet_sort_system_directives_first = false
+file_header_template = unset
+
+# this. and Me. preferences
+dotnet_style_qualification_for_event = false:error
+dotnet_style_qualification_for_field = false:error
+dotnet_style_qualification_for_method = false:error
+dotnet_style_qualification_for_property = false:error
+
+# Language keywords vs BCL types preferences
+dotnet_style_predefined_type_for_locals_parameters_members = true:error
+dotnet_style_predefined_type_for_member_access = true:error
+
+# Parentheses preferences
+dotnet_style_parentheses_in_arithmetic_binary_operators = always_for_clarity:error
+dotnet_style_parentheses_in_other_binary_operators = always_for_clarity:error
+dotnet_style_parentheses_in_other_operators = never_if_unnecessary:error
+dotnet_style_parentheses_in_relational_binary_operators = always_for_clarity:error
+
+# Modifier preferences
+dotnet_style_require_accessibility_modifiers = omit_if_default:error
+
+# Expression-level preferences
+dotnet_style_coalesce_expression = true:error
+dotnet_style_collection_initializer = true:error
+dotnet_style_explicit_tuple_names = true:error
+dotnet_style_null_propagation = true:error
+dotnet_style_object_initializer = true:error
+dotnet_style_operator_placement_when_wrapping = beginning_of_line
+dotnet_style_prefer_auto_properties = true:error
+dotnet_style_prefer_compound_assignment = true:error
+dotnet_style_prefer_conditional_expression_over_assignment = true:error
+dotnet_style_prefer_conditional_expression_over_return = true:error
+dotnet_style_prefer_inferred_anonymous_type_member_names = true:error
+dotnet_style_prefer_inferred_tuple_names = true:error
+dotnet_style_prefer_is_null_check_over_reference_equality_method = true:error
+dotnet_style_prefer_simplified_boolean_expressions = true:error
+dotnet_style_prefer_simplified_interpolation = true:suggestion
+
+# Field preferences
+dotnet_style_readonly_field = true:error
+
+# Parameter preferences
+dotnet_code_quality_unused_parameters = all:error
+
+# Suppression preferences
+dotnet_remove_unnecessary_suppression_exclusions = error
+
+#### C# Coding Conventions ####
+
+# var preferences
+csharp_style_var_elsewhere = true:error
+csharp_style_var_for_built_in_types = true:error
+csharp_style_var_when_type_is_apparent = true:error
+
+# Expression-bodied members
+csharp_style_expression_bodied_accessors = true:error
+csharp_style_expression_bodied_constructors = true:error
+csharp_style_expression_bodied_indexers = true:error
+csharp_style_expression_bodied_lambdas = true:error
+csharp_style_expression_bodied_local_functions = true:error
+csharp_style_expression_bodied_methods = true:error
+csharp_style_expression_bodied_operators = true:error
+csharp_style_expression_bodied_properties = true:error
+
+# Pattern matching preferences
+csharp_style_pattern_matching_over_as_with_null_check = true:error
+csharp_style_pattern_matching_over_is_with_cast_check = true:error
+csharp_style_prefer_not_pattern = true:error
+csharp_style_prefer_pattern_matching = true:error
+csharp_style_prefer_switch_expression = true:error
+
+# Null-checking preferences
+csharp_style_conditional_delegate_call = true:error
+
+# Modifier preferences
+csharp_prefer_static_local_function = true:error
+csharp_preferred_modifier_order = public,private,protected,internal,static,extern,new,virtual,abstract,sealed,override,readonly,unsafe,volatile,async:error
+
+# Code-block preferences
+csharp_prefer_braces = true:error
+csharp_prefer_simple_using_statement = true:error
+
+# Expression-level preferences
+csharp_prefer_simple_default_expression = true:error
+csharp_style_deconstructed_variable_declaration = true:error
+csharp_style_inlined_variable_declaration = true:error
+csharp_style_pattern_local_over_anonymous_function = true:error
+csharp_style_prefer_index_operator = true:error
+csharp_style_prefer_range_operator = true:error
+csharp_style_throw_expression = true:error
+csharp_style_unused_value_assignment_preference = unused_local_variable:error
+csharp_style_unused_value_expression_statement_preference = unused_local_variable:error
+
+# 'using' directive preferences
+csharp_using_directive_placement = outside_namespace:error
+
+#### C# Formatting Rules ####
+
+# New line preferences
+csharp_new_line_before_catch = false:error
+csharp_new_line_before_else = false:error
+csharp_new_line_before_finally = false:error
+csharp_new_line_before_members_in_anonymous_types = true:error
+csharp_new_line_before_members_in_object_initializers = true:error
+csharp_new_line_before_open_brace = none:error
+csharp_new_line_between_query_expression_clauses = true:error
+
+# Indentation preferences
+csharp_indent_block_contents = true:error
+csharp_indent_braces = false:error
+csharp_indent_case_contents = true:error
+csharp_indent_case_contents_when_block = true:error
+csharp_indent_labels = one_less_than_current:error
+csharp_indent_switch_labels = true:error
+
+# Space preferences
+csharp_space_after_cast = false:error
+csharp_space_after_colon_in_inheritance_clause = true:error
+csharp_space_after_comma = true:error
+csharp_space_after_dot = false:error
+csharp_space_after_keywords_in_control_flow_statements = true:error
+csharp_space_after_semicolon_in_for_statement = true:error
+csharp_space_around_binary_operators = before_and_after:error
+csharp_space_around_declaration_statements = false:error
+csharp_space_before_colon_in_inheritance_clause = false:error
+csharp_space_before_comma = false:error
+csharp_space_before_dot = false:error
+csharp_space_before_open_square_brackets = false:error
+csharp_space_before_semicolon_in_for_statement = false:error
+csharp_space_between_empty_square_brackets = false:error
+csharp_space_between_method_call_empty_parameter_list_parentheses = false:error
+csharp_space_between_method_call_name_and_opening_parenthesis = false:error
+csharp_space_between_method_call_parameter_list_parentheses = false:error
+csharp_space_between_method_declaration_empty_parameter_list_parentheses = false:error
+csharp_space_between_method_declaration_name_and_open_parenthesis = false:error
+csharp_space_between_method_declaration_parameter_list_parentheses = false:error
+csharp_space_between_parentheses = false:error
+csharp_space_between_square_brackets = false:error
+
+# Wrapping preferences
+csharp_preserve_single_line_blocks = true:error
+csharp_preserve_single_line_statements = true:error
+
+#### Naming styles ####
+
+# Naming rules
+
+dotnet_naming_rule.interface_should_be_begins_with_i.severity = error
+dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface
+dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i
+
+dotnet_naming_rule.types_should_be_pascal_case.severity = error
+dotnet_naming_rule.types_should_be_pascal_case.symbols = types
+dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case
+
+dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = error
+dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members
+dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case
+
+# Symbol specifications
+
+dotnet_naming_symbols.interface.applicable_kinds = interface
+dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.interface.required_modifiers = 
+
+dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum
+dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.types.required_modifiers = 
+
+dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method
+dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected
+dotnet_naming_symbols.non_field_members.required_modifiers = 
+
+# Naming styles
+
+dotnet_naming_style.pascal_case.required_prefix = 
+dotnet_naming_style.pascal_case.required_suffix = 
+dotnet_naming_style.pascal_case.word_separator = 
+dotnet_naming_style.pascal_case.capitalization = pascal_case
+
+dotnet_naming_style.begins_with_i.required_prefix = I
+dotnet_naming_style.begins_with_i.required_suffix = 
+dotnet_naming_style.begins_with_i.word_separator = 
+dotnet_naming_style.begins_with_i.capitalization = pascal_case
+
+### Microsoft.CodeAnalysis.Analyzers Rules
+
+# RS1001: Missing diagnostic analyzer attribute
+dotnet_diagnostic.RS1001.severity = error
+
+# RS1002: Missing kind argument when registering an analyzer action
+dotnet_diagnostic.RS1002.severity = error
+
+# RS1003: Unsupported SymbolKind argument when registering a symbol analyzer action
+dotnet_diagnostic.RS1003.severity = error
+
+# RS1004: Recommend adding language support to diagnostic analyzer
+dotnet_diagnostic.RS1004.severity = error
+
+# RS1005: ReportDiagnostic invoked with an unsupported DiagnosticDescriptor
+dotnet_diagnostic.RS1005.severity = error
+
+# RS1006: Invalid type argument for DiagnosticAnalyzer's Register method
+dotnet_diagnostic.RS1006.severity = error
+
+# RS1007: Provide localizable arguments to diagnostic descriptor constructor
+dotnet_diagnostic.RS1007.severity = error
+
+# RS1008: Avoid storing per-compilation data into the fields of a diagnostic analyzer
+dotnet_diagnostic.RS1008.severity = error
+
+# RS1009: Only internal implementations of this interface are allowed
+dotnet_diagnostic.RS1009.severity = error
+
+# RS1010: Create code actions should have a unique EquivalenceKey for FixAll occurrences support
+dotnet_diagnostic.RS1010.severity = error
+
+# RS1011: Use code actions that have a unique EquivalenceKey for FixAll occurrences support
+dotnet_diagnostic.RS1011.severity = error
+
+# RS1012: Start action has no registered actions
+dotnet_diagnostic.RS1012.severity = error
+
+# RS1013: Start action has no registered non-end actions
+dotnet_diagnostic.RS1013.severity = error
+
+# RS1014: Do not ignore values returned by methods on immutable objects.
+dotnet_diagnostic.RS1014.severity = error
+
+# RS1015: Provide non-null 'helpLinkUri' value to diagnostic descriptor constructor
+dotnet_diagnostic.RS1015.severity = error
+
+# RS1016: Code fix providers should provide FixAll support
+dotnet_diagnostic.RS1016.severity = error
+
+# RS1017: DiagnosticId for analyzers must be a non-null constant
+dotnet_diagnostic.RS1017.severity = error
+
+# RS1018: DiagnosticId for analyzers must be in specified format
+dotnet_diagnostic.RS1018.severity = error
+
+# RS1019: DiagnosticId must be unique across analyzers
+dotnet_diagnostic.RS1019.severity = error
+
+# RS1020: Category for analyzers must be from the specified values
+dotnet_diagnostic.RS1020.severity = error
+
+# RS1021: Invalid entry in analyzer category and diagnostic ID range specification file
+dotnet_diagnostic.RS1021.severity = error
+
+# RS1022: Do not use types from Workspaces assembly in an analyzer
+dotnet_diagnostic.RS1022.severity = error
+
+# RS1023: Upgrade MSBuildWorkspace
+dotnet_diagnostic.RS1023.severity = error
+
+# RS1024: Compare symbols correctly
+dotnet_diagnostic.RS1024.severity = error
+
+# RS1025: Configure generated code analysis
+dotnet_diagnostic.RS1025.severity = error
+
+# RS1026: Enable concurrent execution
+dotnet_diagnostic.RS1026.severity = error
+
+# RS1027: Types marked with DiagnosticAnalyzerAttribute(s) should inherit from DiagnosticAnalyzer
+dotnet_diagnostic.RS1027.severity = error
+
+# RS1028: Provide non-null 'customTags' value to diagnostic descriptor constructor
+dotnet_diagnostic.RS1028.severity = error
+
+# RS1029: Do not use reserved diagnostic IDs
+dotnet_diagnostic.RS1029.severity = error
+
+# RS1030: Do not invoke Compilation.GetSemanticModel() method within a diagnostic analyzer
+dotnet_diagnostic.RS1030.severity = error
+
+# RS1031: Define diagnostic title correctly
+dotnet_diagnostic.RS1031.severity = error
+
+# RS1032: Define diagnostic message correctly
+dotnet_diagnostic.RS1032.severity = error
+
+# RS1033: Define diagnostic description correctly
+dotnet_diagnostic.RS1033.severity = error
+
+# RS2000: Add analyzer diagnostic IDs to analyzer release.
+dotnet_diagnostic.RS2000.severity = error
+
+# RS2001: Ensure up-to-date entry for analyzer diagnostic IDs are added to analyzer release.
+dotnet_diagnostic.RS2001.severity = error
+
+# RS2002: Do not add removed analyzer diagnostic IDs to unshipped analyzer release.
+dotnet_diagnostic.RS2002.severity = error
+
+# RS2003: Shipped diagnostic IDs that are no longer reported should have an entry in the 'Removed Rules' table in unshipped file.
+dotnet_diagnostic.RS2003.severity = error
+
+# RS2004: Diagnostic IDs marked as removed in analyzer release file should not be reported by analyzers.
+dotnet_diagnostic.RS2004.severity = error
+
+# RS2005: Remove duplicate entries for diagnostic ID in the same analyzer release.
+dotnet_diagnostic.RS2005.severity = error
+
+# RS2006: Remove duplicate entries for diagnostic ID between analyzer releases.
+dotnet_diagnostic.RS2006.severity = error
+
+# RS2007: Invalid entry in analyzer release file.
+dotnet_diagnostic.RS2007.severity = error
+
+# RS2008: Enable analyzer release tracking
+dotnet_diagnostic.RS2008.severity = error
+
+### Microsoft.CodeAnalysis.FxCopAnalyzers Rules
+
+# CA1058: Types should not extend certain base types
+dotnet_diagnostic.CA1058.severity = error
+
+# CA2153: Do Not Catch Corrupted State Exceptions
+dotnet_diagnostic.CA2153.severity = error
+
+# CA3075: Insecure DTD processing in XML
+dotnet_diagnostic.CA3075.severity = error
+
+# CA3076: Insecure XSLT script processing.
+dotnet_diagnostic.CA3076.severity = error
+
+# CA3077: Insecure Processing in API Design, XmlDocument and XmlTextReader
+dotnet_diagnostic.CA3077.severity = error
+
+# CA3147: Mark Verb Handlers With Validate Antiforgery Token
+dotnet_diagnostic.CA3147.severity = error
+
+### Microsoft.CodeAnalysis.VersionCheckAnalyzer Rules
+
+# CA9999: Analyzer version mismatch
+dotnet_diagnostic.CA9999.severity = error
+
+### Microsoft.CodeQuality.Analyzers Rules
+
+# CA1000: Do not declare static members on generic types
+dotnet_diagnostic.CA1000.severity = none
+
+# CA1001: Types that own disposable fields should be disposable
+dotnet_diagnostic.CA1001.severity = error
+
+# CA1002: Do not expose generic lists
+dotnet_diagnostic.CA1002.severity = error
+
+# CA1003: Use generic event handler instances
+dotnet_diagnostic.CA1003.severity = error
+
+# CA1005: Avoid excessive parameters on generic types
+dotnet_diagnostic.CA1005.severity = error
+
+# CA1008: Enums should have zero value
+dotnet_diagnostic.CA1008.severity = error
+
+# CA1010: Generic interface should also be implemented
+dotnet_diagnostic.CA1010.severity = error
+
+# CA1012: Abstract types should not have public constructors
+dotnet_diagnostic.CA1012.severity = error
+
+# CA1014: Mark assemblies with CLSCompliant
+dotnet_diagnostic.CA1014.severity = error
+
+# CA1016: Mark assemblies with assembly version
+dotnet_diagnostic.CA1016.severity = error
+
+# CA1017: Mark assemblies with ComVisible
+dotnet_diagnostic.CA1017.severity = error
+
+# CA1018: Mark attributes with AttributeUsageAttribute
+dotnet_diagnostic.CA1018.severity = error
+
+# CA1019: Define accessors for attribute arguments
+dotnet_diagnostic.CA1019.severity = error
+
+# CA1021: Avoid out parameters
+dotnet_diagnostic.CA1021.severity = none
+
+# CA1024: Use properties where appropriate
+dotnet_diagnostic.CA1024.severity = error
+
+# CA1027: Mark enums with FlagsAttribute
+dotnet_diagnostic.CA1027.severity = error
+
+# CA1028: Enum Storage should be Int32
+dotnet_diagnostic.CA1028.severity = none
+
+# CA1030: Use events where appropriate
+dotnet_diagnostic.CA1030.severity = error
+
+# CA1031: Do not catch general exception types
+dotnet_diagnostic.CA1031.severity = error
+
+# CA1032: Implement standard exception constructors
+dotnet_diagnostic.CA1032.severity = error
+
+# CA1033: Interface methods should be callable by child types
+dotnet_diagnostic.CA1033.severity = error
+
+# CA1034: Nested types should not be visible
+dotnet_diagnostic.CA1034.severity = none
+
+# CA1036: Override methods on comparable types
+dotnet_diagnostic.CA1036.severity = error
+
+# CA1040: Avoid empty interfaces
+dotnet_diagnostic.CA1040.severity = error
+
+# CA1041: Provide ObsoleteAttribute message
+dotnet_diagnostic.CA1041.severity = error
+
+# CA1043: Use Integral Or String Argument For Indexers
+dotnet_diagnostic.CA1043.severity = error
+
+# CA1044: Properties should not be write only
+dotnet_diagnostic.CA1044.severity = error
+
+# CA1045: Do not pass types by reference
+dotnet_diagnostic.CA1045.severity = none
+
+# CA1046: Do not overload equality operator on reference types
+dotnet_diagnostic.CA1046.severity = error
+
+# CA1047: Do not declare protected member in sealed type
+dotnet_diagnostic.CA1047.severity = error
+
+# CA1050: Declare types in namespaces
+dotnet_diagnostic.CA1050.severity = error
+
+# CA1051: Do not declare visible instance fields
+dotnet_diagnostic.CA1051.severity = none
+
+# CA1052: Static holder types should be Static or NotInheritable
+dotnet_diagnostic.CA1052.severity = error
+
+# CA1054: URI-like parameters should not be strings
+dotnet_diagnostic.CA1054.severity = error
+
+# CA1055: URI-like return values should not be strings
+dotnet_diagnostic.CA1055.severity = error
+
+# CA1056: URI-like properties should not be strings
+dotnet_diagnostic.CA1056.severity = error
+
+# CA1060: Move pinvokes to native methods class
+dotnet_diagnostic.CA1060.severity = error
+
+# CA1061: Do not hide base class methods
+dotnet_diagnostic.CA1061.severity = error
+
+# CA1062: Validate arguments of public methods
+dotnet_diagnostic.CA1062.severity = none
+
+# CA1063: Implement IDisposable Correctly
+dotnet_diagnostic.CA1063.severity = error
+
+# CA1064: Exceptions should be public
+dotnet_diagnostic.CA1064.severity = error
+
+# CA1065: Do not raise exceptions in unexpected locations
+dotnet_diagnostic.CA1065.severity = none
+
+# CA1066: Implement IEquatable when overriding Object.Equals
+dotnet_diagnostic.CA1066.severity = none
+
+# CA1067: Override Object.Equals(object) when implementing IEquatable<T>
+dotnet_diagnostic.CA1067.severity = error
+
+# CA1068: CancellationToken parameters must come last
+dotnet_diagnostic.CA1068.severity = error
+
+# CA1069: Enums values should not be duplicated
+dotnet_diagnostic.CA1069.severity = error
+
+# CA1070: Do not declare event fields as virtual
+dotnet_diagnostic.CA1070.severity = error
+
+# CA1200: Avoid using cref tags with a prefix
+dotnet_diagnostic.CA1200.severity = error
+
+# CA1501: Avoid excessive inheritance
+dotnet_diagnostic.CA1501.severity = error
+
+# CA1502: Avoid excessive complexity
+dotnet_diagnostic.CA1502.severity = error
+
+# CA1505: Avoid unmaintainable code
+dotnet_diagnostic.CA1505.severity = error
+
+# CA1506: Avoid excessive class coupling
+dotnet_diagnostic.CA1506.severity = error
+
+# CA1507: Use nameof to express symbol names
+dotnet_diagnostic.CA1507.severity = error
+
+# CA1508: Avoid dead conditional code
+dotnet_diagnostic.CA1508.severity = error
+
+# CA1509: Invalid entry in code metrics rule specification file
+dotnet_diagnostic.CA1509.severity = error
+
+# CA1700: Do not name enum values 'Reserved'
+dotnet_diagnostic.CA1700.severity = error
+
+# CA1707: Identifiers should not contain underscores
+dotnet_diagnostic.CA1707.severity = error
+
+# CA1708: Identifiers should differ by more than case
+dotnet_diagnostic.CA1708.severity = error
+
+# CA1710: Identifiers should have correct suffix
+dotnet_diagnostic.CA1710.severity = error
+
+# CA1711: Identifiers should not have incorrect suffix
+dotnet_diagnostic.CA1711.severity = error
+
+# CA1712: Do not prefix enum values with type name
+dotnet_diagnostic.CA1712.severity = error
+
+# CA1713: Events should not have 'Before' or 'After' prefix
+dotnet_diagnostic.CA1713.severity = error
+
+# CA1714: Flags enums should have plural names
+dotnet_diagnostic.CA1714.severity = error
+
+# CA1715: Identifiers should have correct prefix
+dotnet_diagnostic.CA1715.severity = error
+
+# CA1716: Identifiers should not match keywords
+dotnet_diagnostic.CA1716.severity = none
+
+# CA1717: Only FlagsAttribute enums should have plural names
+dotnet_diagnostic.CA1717.severity = error
+
+# CA1720: Identifier contains type name
+dotnet_diagnostic.CA1720.severity = none
+
+# CA1721: Property names should not match get methods
+dotnet_diagnostic.CA1721.severity = error
+
+# CA1724: Type names should not match namespaces
+dotnet_diagnostic.CA1724.severity = none
+
+# CA1725: Parameter names should match base declaration
+dotnet_diagnostic.CA1725.severity = none
+
+# CA1801: Review unused parameters
+dotnet_diagnostic.CA1801.severity = error
+
+# CA1802: Use literals where appropriate
+dotnet_diagnostic.CA1802.severity = error
+
+# CA1805: Do not initialize unnecessarily
+dotnet_diagnostic.CA1805.severity = none
+
+# CA1806: Do not ignore method results
+dotnet_diagnostic.CA1806.severity = error
+
+# CA1812: Avoid uninstantiated internal classes
+dotnet_diagnostic.CA1812.severity = error
+
+# CA1814: Prefer jagged arrays over multidimensional
+dotnet_diagnostic.CA1814.severity = error
+
+# CA1815: Override equals and operator equals on value types
+dotnet_diagnostic.CA1815.severity = none
+
+# CA1819: Properties should not return arrays
+dotnet_diagnostic.CA1819.severity = none
+
+# CA1821: Remove empty Finalizers
+dotnet_diagnostic.CA1821.severity = error
+
+# CA1822: Mark members as static
+dotnet_diagnostic.CA1822.severity = none
+
+# CA1823: Avoid unused private fields
+dotnet_diagnostic.CA1823.severity = error
+
+# CA2007: Consider calling ConfigureAwait on the awaited task
+dotnet_diagnostic.CA2007.severity = error
+
+# CA2011: Avoid infinite recursion
+dotnet_diagnostic.CA2011.severity = error
+
+# CA2109: Review visible event handlers
+dotnet_diagnostic.CA2109.severity = error
+
+# CA2119: Seal methods that satisfy private interfaces
+dotnet_diagnostic.CA2119.severity = error
+
+# CA2200: Rethrow to preserve stack details
+dotnet_diagnostic.CA2200.severity = error
+
+# CA2211: Non-constant fields should not be visible
+dotnet_diagnostic.CA2211.severity = error
+
+# CA2214: Do not call overridable methods in constructors
+dotnet_diagnostic.CA2214.severity = error
+
+# CA2217: Do not mark enums with FlagsAttribute
+dotnet_diagnostic.CA2217.severity = error
+
+# CA2218: Override GetHashCode on overriding Equals
+dotnet_diagnostic.CA2218.severity = error
+
+# CA2219: Do not raise exceptions in finally clauses
+dotnet_diagnostic.CA2219.severity = error
+
+# CA2224: Override Equals on overloading operator equals
+dotnet_diagnostic.CA2224.severity = error
+
+# CA2225: Operator overloads have named alternates
+dotnet_diagnostic.CA2225.severity = error
+
+# CA2226: Operators should have symmetrical overloads
+dotnet_diagnostic.CA2226.severity = error
+
+# CA2227: Collection properties should be read only
+dotnet_diagnostic.CA2227.severity = error
+
+# CA2231: Overload operator equals on overriding value type Equals
+dotnet_diagnostic.CA2231.severity = none
+
+# CA2234: Pass system uri objects instead of strings
+dotnet_diagnostic.CA2234.severity = error
+
+# CA2244: Do not duplicate indexed element initializations
+dotnet_diagnostic.CA2244.severity = error
+
+# CA2245: Do not assign a property to itself
+dotnet_diagnostic.CA2245.severity = error
+
+# CA2246: Assigning symbol and its member in the same statement
+dotnet_diagnostic.CA2246.severity = error
+
+### Microsoft.NetCore.Analyzers Rules
+
+# CA1303: Do not pass literals as localized parameters
+dotnet_diagnostic.CA1303.severity = error
+
+# CA1304: Specify CultureInfo
+dotnet_diagnostic.CA1304.severity = error
+
+# CA1305: Specify IFormatProvider
+dotnet_diagnostic.CA1305.severity = none
+
+# CA1307: Specify StringComparison
+dotnet_diagnostic.CA1307.severity = error
+
+# CA1308: Normalize strings to uppercase
+dotnet_diagnostic.CA1308.severity = error
+
+# CA1309: Use ordinal stringcomparison
+dotnet_diagnostic.CA1309.severity = error
+
+# CA1401: P/Invokes should not be visible
+dotnet_diagnostic.CA1401.severity = error
+
+# CA1417: Do not use 'OutAttribute' on string parameters for P/Invokes
+dotnet_diagnostic.CA1417.severity = error
+
+# CA1810: Initialize reference type static fields inline
+dotnet_diagnostic.CA1810.severity = error
+
+# CA1813: Avoid unsealed attributes
+dotnet_diagnostic.CA1813.severity = error
+
+# CA1816: Dispose methods should call SuppressFinalize
+dotnet_diagnostic.CA1816.severity = error
+
+# CA1820: Test for empty strings using string length
+dotnet_diagnostic.CA1820.severity = error
+
+# CA1824: Mark assemblies with NeutralResourcesLanguageAttribute
+dotnet_diagnostic.CA1824.severity = error
+
+# CA1825: Avoid zero-length array allocations
+dotnet_diagnostic.CA1825.severity = error
+
+# CA1826: Do not use Enumerable methods on indexable collections
+dotnet_diagnostic.CA1826.severity = error
+
+# CA1827: Do not use Count() or LongCount() when Any() can be used
+dotnet_diagnostic.CA1827.severity = error
+
+# CA1828: Do not use CountAsync() or LongCountAsync() when AnyAsync() can be used
+dotnet_diagnostic.CA1828.severity = error
+
+# CA1829: Use Length/Count property instead of Count() when available
+dotnet_diagnostic.CA1829.severity = error
+
+# CA1830: Prefer strongly-typed Append and Insert method overloads on StringBuilder
+dotnet_diagnostic.CA1830.severity = error
+
+# CA1831: Use AsSpan or AsMemory instead of Range-based indexers when appropriate
+dotnet_diagnostic.CA1831.severity = error
+
+# CA1832: Use AsSpan or AsMemory instead of Range-based indexers when appropriate
+dotnet_diagnostic.CA1832.severity = error
+
+# CA1833: Use AsSpan or AsMemory instead of Range-based indexers when appropriate
+dotnet_diagnostic.CA1833.severity = error
+
+# CA1834: Consider using 'StringBuilder.Append(char)' when applicable
+dotnet_diagnostic.CA1834.severity = error
+
+# CA1835: Prefer the 'Memory'-based overloads for 'ReadAsync' and 'WriteAsync'
+dotnet_diagnostic.CA1835.severity = error
+
+# CA1836: Prefer IsEmpty over Count
+dotnet_diagnostic.CA1836.severity = error
+
+# CA1837: Use 'Environment.ProcessId'
+dotnet_diagnostic.CA1837.severity = error
+
+# CA1838: Avoid 'StringBuilder' parameters for P/Invokes
+dotnet_diagnostic.CA1838.severity = error
+
+# CA2000: Dispose objects before losing scope
+dotnet_diagnostic.CA2000.severity = error
+
+# CA2002: Do not lock on objects with weak identity
+dotnet_diagnostic.CA2002.severity = error
+
+# CA2008: Do not create tasks without passing a TaskScheduler
+dotnet_diagnostic.CA2008.severity = error
+
+# CA2009: Do not call ToImmutableCollection on an ImmutableCollection value
+dotnet_diagnostic.CA2009.severity = error
+
+# CA2012: Use ValueTasks correctly
+dotnet_diagnostic.CA2012.severity = error
+
+# CA2013: Do not use ReferenceEquals with value types
+dotnet_diagnostic.CA2013.severity = error
+
+# CA2014: Do not use stackalloc in loops
+dotnet_diagnostic.CA2014.severity = error
+
+# CA2015: Do not define finalizers for types derived from MemoryManager<T>
+dotnet_diagnostic.CA2015.severity = error
+
+# CA2016: Forward the 'CancellationToken' parameter to methods that take one
+dotnet_diagnostic.CA2016.severity = error
+
+# CA2100: Review SQL queries for security vulnerabilities
+dotnet_diagnostic.CA2100.severity = error
+
+# CA2101: Specify marshaling for P/Invoke string arguments
+dotnet_diagnostic.CA2101.severity = error
+
+# CA2201: Do not raise reserved exception types
+dotnet_diagnostic.CA2201.severity = error
+
+# CA2207: Initialize value type static fields inline
+dotnet_diagnostic.CA2207.severity = error
+
+# CA2208: Instantiate argument exceptions correctly
+dotnet_diagnostic.CA2208.severity = error
+
+# CA2213: Disposable fields should be disposed
+dotnet_diagnostic.CA2213.severity = error
+
+# CA2215: Dispose methods should call base class dispose
+dotnet_diagnostic.CA2215.severity = error
+
+# CA2216: Disposable types should declare finalizer
+dotnet_diagnostic.CA2216.severity = error
+
+# CA2229: Implement serialization constructors
+dotnet_diagnostic.CA2229.severity = error
+
+# CA2235: Mark all non-serializable fields
+dotnet_diagnostic.CA2235.severity = error
+
+# CA2237: Mark ISerializable types with serializable
+dotnet_diagnostic.CA2237.severity = error
+
+# CA2241: Provide correct arguments to formatting methods
+dotnet_diagnostic.CA2241.severity = error
+
+# CA2242: Test for NaN correctly
+dotnet_diagnostic.CA2242.severity = error
+
+# CA2243: Attribute string literals should parse correctly
+dotnet_diagnostic.CA2243.severity = error
+
+# CA2247: Argument passed to TaskCompletionSource constructor should be TaskCreationOptions enum instead of TaskContinuationOptions enum
+dotnet_diagnostic.CA2247.severity = error
+
+# CA2248: Provide correct 'enum' argument to 'Enum.HasFlag'
+dotnet_diagnostic.CA2248.severity = error
+
+# CA2249: Consider using 'string.Contains' instead of 'string.IndexOf'
+dotnet_diagnostic.CA2249.severity = error
+
+# CA2300: Do not use insecure deserializer BinaryFormatter
+dotnet_diagnostic.CA2300.severity = error
+
+# CA2301: Do not call BinaryFormatter.Deserialize without first setting BinaryFormatter.Binder
+dotnet_diagnostic.CA2301.severity = error
+
+# CA2302: Ensure BinaryFormatter.Binder is set before calling BinaryFormatter.Deserialize
+dotnet_diagnostic.CA2302.severity = error
+
+# CA2305: Do not use insecure deserializer LosFormatter
+dotnet_diagnostic.CA2305.severity = error
+
+# CA2310: Do not use insecure deserializer NetDataContractSerializer
+dotnet_diagnostic.CA2310.severity = error
+
+# CA2311: Do not deserialize without first setting NetDataContractSerializer.Binder
+dotnet_diagnostic.CA2311.severity = error
+
+# CA2312: Ensure NetDataContractSerializer.Binder is set before deserializing
+dotnet_diagnostic.CA2312.severity = error
+
+# CA2315: Do not use insecure deserializer ObjectStateFormatter
+dotnet_diagnostic.CA2315.severity = error
+
+# CA2321: Do not deserialize with JavaScriptSerializer using a SimpleTypeResolver
+dotnet_diagnostic.CA2321.severity = error
+
+# CA2322: Ensure JavaScriptSerializer is not initialized with SimpleTypeResolver before deserializing
+dotnet_diagnostic.CA2322.severity = error
+
+# CA2326: Do not use TypeNameHandling values other than None
+dotnet_diagnostic.CA2326.severity = error
+
+# CA2327: Do not use insecure JsonSerializerSettings
+dotnet_diagnostic.CA2327.severity = error
+
+# CA2328: Ensure that JsonSerializerSettings are secure
+dotnet_diagnostic.CA2328.severity = error
+
+# CA2329: Do not deserialize with JsonSerializer using an insecure configuration
+dotnet_diagnostic.CA2329.severity = error
+
+# CA2330: Ensure that JsonSerializer has a secure configuration when deserializing
+dotnet_diagnostic.CA2330.severity = error
+
+# CA2350: Do not use DataTable.ReadXml() with untrusted data
+dotnet_diagnostic.CA2350.severity = error
+
+# CA2351: Do not use DataSet.ReadXml() with untrusted data
+dotnet_diagnostic.CA2351.severity = error
+
+# CA2352: Unsafe DataSet or DataTable in serializable type can be vulnerable to remote code execution attacks
+dotnet_diagnostic.CA2352.severity = error
+
+# CA2353: Unsafe DataSet or DataTable in serializable type
+dotnet_diagnostic.CA2353.severity = error
+
+# CA2354: Unsafe DataSet or DataTable in deserialized object graph can be vulnerable to remote code execution attacks
+dotnet_diagnostic.CA2354.severity = error
+
+# CA2355: Unsafe DataSet or DataTable type found in deserializable object graph
+dotnet_diagnostic.CA2355.severity = error
+
+# CA2356: Unsafe DataSet or DataTable type in web deserializable object graph
+dotnet_diagnostic.CA2356.severity = error
+
+# CA2361: Ensure autogenerated class containing DataSet.ReadXml() is not used with untrusted data
+dotnet_diagnostic.CA2361.severity = error
+
+# CA2362: Unsafe DataSet or DataTable in autogenerated serializable type can be vulnerable to remote code execution attacks
+dotnet_diagnostic.CA2362.severity = error
+
+# CA3001: Review code for SQL injection vulnerabilities
+dotnet_diagnostic.CA3001.severity = error
+
+# CA3002: Review code for XSS vulnerabilities
+dotnet_diagnostic.CA3002.severity = error
+
+# CA3003: Review code for file path injection vulnerabilities
+dotnet_diagnostic.CA3003.severity = error
+
+# CA3004: Review code for information disclosure vulnerabilities
+dotnet_diagnostic.CA3004.severity = error
+
+# CA3005: Review code for LDAP injection vulnerabilities
+dotnet_diagnostic.CA3005.severity = error
+
+# CA3006: Review code for process command injection vulnerabilities
+dotnet_diagnostic.CA3006.severity = error
+
+# CA3007: Review code for open redirect vulnerabilities
+dotnet_diagnostic.CA3007.severity = error
+
+# CA3008: Review code for XPath injection vulnerabilities
+dotnet_diagnostic.CA3008.severity = error
+
+# CA3009: Review code for XML injection vulnerabilities
+dotnet_diagnostic.CA3009.severity = error
+
+# CA3010: Review code for XAML injection vulnerabilities
+dotnet_diagnostic.CA3010.severity = error
+
+# CA3011: Review code for DLL injection vulnerabilities
+dotnet_diagnostic.CA3011.severity = error
+
+# CA3012: Review code for regex injection vulnerabilities
+dotnet_diagnostic.CA3012.severity = error
+
+# CA3061: Do Not Add Schema By URL
+dotnet_diagnostic.CA3061.severity = error
+
+# CA5350: Do Not Use Weak Cryptographic Algorithms
+dotnet_diagnostic.CA5350.severity = error
+
+# CA5351: Do Not Use Broken Cryptographic Algorithms
+dotnet_diagnostic.CA5351.severity = error
+
+# CA5358: Review cipher mode usage with cryptography experts
+dotnet_diagnostic.CA5358.severity = error
+
+# CA5359: Do Not Disable Certificate Validation
+dotnet_diagnostic.CA5359.severity = error
+
+# CA5360: Do Not Call Dangerous Methods In Deserialization
+dotnet_diagnostic.CA5360.severity = error
+
+# CA5361: Do Not Disable SChannel Use of Strong Crypto
+dotnet_diagnostic.CA5361.severity = error
+
+# CA5362: Potential reference cycle in deserialized object graph
+dotnet_diagnostic.CA5362.severity = error
+
+# CA5363: Do Not Disable Request Validation
+dotnet_diagnostic.CA5363.severity = error
+
+# CA5364: Do Not Use Deprecated Security Protocols
+dotnet_diagnostic.CA5364.severity = error
+
+# CA5365: Do Not Disable HTTP Header Checking
+dotnet_diagnostic.CA5365.severity = error
+
+# CA5366: Use XmlReader For DataSet Read Xml
+dotnet_diagnostic.CA5366.severity = error
+
+# CA5367: Do Not Serialize Types With Pointer Fields
+dotnet_diagnostic.CA5367.severity = error
+
+# CA5368: Set ViewStateUserKey For Classes Derived From Page
+dotnet_diagnostic.CA5368.severity = error
+
+# CA5369: Use XmlReader For Deserialize
+dotnet_diagnostic.CA5369.severity = error
+
+# CA5370: Use XmlReader For Validating Reader
+dotnet_diagnostic.CA5370.severity = error
+
+# CA5371: Use XmlReader For Schema Read
+dotnet_diagnostic.CA5371.severity = error
+
+# CA5372: Use XmlReader For XPathDocument
+dotnet_diagnostic.CA5372.severity = error
+
+# CA5373: Do not use obsolete key derivation function
+dotnet_diagnostic.CA5373.severity = error
+
+# CA5374: Do Not Use XslTransform
+dotnet_diagnostic.CA5374.severity = error
+
+# CA5375: Do Not Use Account Shared Access Signature
+dotnet_diagnostic.CA5375.severity = error
+
+# CA5376: Use SharedAccessProtocol HttpsOnly
+dotnet_diagnostic.CA5376.severity = error
+
+# CA5377: Use Container Level Access Policy
+dotnet_diagnostic.CA5377.severity = error
+
+# CA5378: Do not disable ServicePointManagerSecurityProtocols
+dotnet_diagnostic.CA5378.severity = error
+
+# CA5379: Do Not Use Weak Key Derivation Function Algorithm
+dotnet_diagnostic.CA5379.severity = error
+
+# CA5380: Do Not Add Certificates To Root Store
+dotnet_diagnostic.CA5380.severity = error
+
+# CA5381: Ensure Certificates Are Not Added To Root Store
+dotnet_diagnostic.CA5381.severity = error
+
+# CA5382: Use Secure Cookies In ASP.Net Core
+dotnet_diagnostic.CA5382.severity = error
+
+# CA5383: Ensure Use Secure Cookies In ASP.Net Core
+dotnet_diagnostic.CA5383.severity = error
+
+# CA5384: Do Not Use Digital Signature Algorithm (DSA)
+dotnet_diagnostic.CA5384.severity = error
+
+# CA5385: Use Rivest–Shamir–Adleman (RSA) Algorithm With Sufficient Key Size
+dotnet_diagnostic.CA5385.severity = error
+
+# CA5386: Avoid hardcoding SecurityProtocolType value
+dotnet_diagnostic.CA5386.severity = error
+
+# CA5387: Do Not Use Weak Key Derivation Function With Insufficient Iteration Count
+dotnet_diagnostic.CA5387.severity = error
+
+# CA5388: Ensure Sufficient Iteration Count When Using Weak Key Derivation Function
+dotnet_diagnostic.CA5388.severity = error
+
+# CA5389: Do Not Add Archive Item's Path To The Target File System Path
+dotnet_diagnostic.CA5389.severity = error
+
+# CA5390: Do not hard-code encryption key
+dotnet_diagnostic.CA5390.severity = error
+
+# CA5391: Use antiforgery tokens in ASP.NET Core MVC controllers
+dotnet_diagnostic.CA5391.severity = error
+
+# CA5392: Use DefaultDllImportSearchPaths attribute for P/Invokes
+dotnet_diagnostic.CA5392.severity = error
+
+# CA5393: Do not use unsafe DllImportSearchPath value
+dotnet_diagnostic.CA5393.severity = error
+
+# CA5394: Do not use insecure randomness
+dotnet_diagnostic.CA5394.severity = error
+
+# CA5395: Miss HttpVerb attribute for action methods
+dotnet_diagnostic.CA5395.severity = error
+
+# CA5396: Set HttpOnly to true for HttpCookie
+dotnet_diagnostic.CA5396.severity = error
+
+# CA5397: Do not use deprecated SslProtocols values
+dotnet_diagnostic.CA5397.severity = error
+
+# CA5398: Avoid hardcoded SslProtocols values
+dotnet_diagnostic.CA5398.severity = error
+
+# CA5399: HttpClients should enable certificate revocation list checks
+dotnet_diagnostic.CA5399.severity = error
+
+# CA5400: Ensure HttpClient certificate revocation list check is not disabled
+dotnet_diagnostic.CA5400.severity = error
+
+# CA5401: Do not use CreateEncryptor with non-default IV
+dotnet_diagnostic.CA5401.severity = error
+
+# CA5402: Use CreateEncryptor with the default IV 
+dotnet_diagnostic.CA5402.severity = error
+
+# CA5403: Do not hard-code certificate
+dotnet_diagnostic.CA5403.severity = error
+
+# IL3000: Avoid using accessing Assembly file path when publishing as a single-file
+dotnet_diagnostic.IL3000.severity = error
+
+# IL3001: Avoid using accessing Assembly file path when publishing as a single-file
+dotnet_diagnostic.IL3001.severity = error
+
+# IDE0071: String interpolation can be simplified
+dotnet_diagnostic.IDE0071.severity = none
+
+# IDE0064: Make readonly fields writable
+dotnet_diagnostic.IDE0064.severity = error
+\ No newline at end of file
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,2 @@
+bin/**
+obj/**
diff --git a/AssemblyInfo.cs b/AssemblyInfo.cs
@@ -0,0 +1,7 @@
+using System;
+using System.Reflection;
+
+[assembly: AssemblyCulture("")]
+[assembly: AssemblyDefaultAlias("Serde")]
+[assembly: AssemblyTrademark("")]
+[assembly: CLSCompliant(false)]
+\ No newline at end of file
diff --git a/BinDe.cs b/BinDe.cs
@@ -0,0 +1,253 @@
+using Serde.De;
+using Std;
+using Std.Maybe;
+using Std.Num;
+using Std.Result;
+using Std.Wrappers;
+using System;
+#region Namespaces
+namespace Serde.Bin.De {
+    #region Types
+    public interface IBinDeserializableAdapter<T>: IDeserializableAdapter<T> where T: notnull {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract Result<T, Error> De(ref Deserializer des);
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    // Ensure the API mimics Serde.De.IDeserializer as much as possible.
+    // If a function returns an Error, make sure the position is not moved.
+    public ref struct Deserializer {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        public Deserializer() => throw new InvalidOperationException("Parameterless constructor is not allowed to be called!");
+        public Deserializer(ReadOnlySpan<byte> data) => _data = data;
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        ReadOnlySpan<byte> _data;
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        public readonly bool IsEndOfData => _data.IsEmpty;
+        #endregion
+
+        #region Type-level Functions
+        public static Deserializer New(ReadOnlySpan<byte> data) => new(data);
+        #endregion
+
+        #region Instance Functions
+        public Result<T, Error> DeserializeUnsafe<T>() where T: unmanaged {
+            
+            unsafe {
+                var size = sizeof(T);
+                var res = Peek((uint)size);
+
+                if (res.Length != size) {
+                    return new(Error.InvalidLength((ulong)res.Length, (@string)$"{size.ToString()} bytes."));
+                } else {
+                    _data = _data[res.Length..];
+                    fixed (byte* ptr = res) { return new(*(T*)ptr); }
+                }
+            }
+        }
+        public Result<bool, Error> DeserializeBool() {
+
+            var copy = this;
+            var val = copy.DeserializeByte();
+
+            if (val.IsOK) {
+                var v = val.Unwrap();
+
+                if (v == byte.MinValue) {
+                    this = copy;
+                    return new(false);
+                } else if (v == byte.MaxValue) {
+                    this = copy;
+                    return new(true);
+                } else {
+                    return new(Error.InvalidValue(Unexpected.Byte(v), (@string)"0 or 255."));
+                }
+            } else {
+                return new(val.UnwrapErr());
+            }
+        }
+        public Result<byte, Error> DeserializeByte() => DeserializeUnsafe<byte>();
+        public Result<char, Error> DeserializeChar() => DeserializeUnsafe<char>();
+        public ReadOnlySpan<char> DeserializeChars(uint len) => DeserializeSliceUnsafe<char>(len);
+        public Result<System.DateTime, Error> DeserializeDateTime() {
+
+            var copy = this;
+            var val = copy.DeserializeLong();
+
+            if (val.IsOK) {
+                var v = val.Unwrap();
+                try {
+                    var date =  System.DateTime.FromBinary(v);
+                    this = copy;
+                    return new(date);
+                } catch (ArgumentException) {
+                    return new(Error.InvalidValue(Unexpected.Long(v), (@string)"A long whose binary layout is the same as the binary layout of a valid System.DateTime."));
+                }
+            } else {
+                return new(val.UnwrapErr());
+            }
+        }
+        public Result<System.DateTimeOffset, Error> DeserializeDateTimeOffset() {
+
+            var copy = this;
+            var date = copy.DeserializeDateTime();
+
+            if (date.IsOK) {
+                var time = copy.DeserializeTimeSpan();
+                
+                if (time.IsOK) {
+                    try {
+                        var offset = new System.DateTimeOffset(date.Unwrap(), time.Unwrap());
+                        this = copy;
+                        return new(offset);
+                    } catch (ArgumentException) {
+                        return new(Error.InvalidValue(Unexpected.TimeSpan(time.Unwrap()), (@string)"A valid System.DateTime and System.TimeSpan combination corresponding to a valid System.DateTimeOffset."));
+                    }
+                } else {
+                    return new(time.UnwrapErr());
+                }
+            } else {
+                return new(date.UnwrapErr());
+            }
+        }
+        public Result<decimal, Error> DeserializeDecimal() {
+
+            var copy = this;
+            var val = copy.DeserializeSliceUnsafe<int>(4);
+
+            if (val.Length == 4) {
+                try {
+                    var dec = new decimal(val);
+                    this = copy;
+                    return new(dec);
+                } catch (ArgumentException) {
+                    unsafe {
+                        fixed (int* ptr = val) {
+                            var bytes = new byte[16];
+                            new ReadOnlySpan<byte>((byte*)ptr, 16).CopyTo(bytes.AsSpan());
+                            return new(Error.InvalidValue(Unexpected.Bytes(bytes), (@string)"A sequence of 4 ints returned from decimal.GetBits."));
+                        }
+                    }
+                }
+            } else {
+                return new(Error.InvalidLength((ulong)val.Length * 4ul, (@string)"16 bytes."));
+            }
+        }
+        public Result<double, Error> DeserializeDouble() => DeserializeUnsafe<double>();
+        public Result<float, Error> DeserializeFloat() => DeserializeUnsafe<float>();
+        public Result<System.Guid, Error> DeserializeGuid() => DeserializeUnsafe<System.Guid>();
+        public Result<I128, Error> DeserializeI128() => DeserializeUnsafe<I128>();
+        public Result<int, Error> DeserializeInt() => DeserializeUnsafe<int>();
+        public Result<long, Error> DeserializeLong() => DeserializeUnsafe<long>();
+        public Result<Maybe<TSome>, Error> DeserializeMaybe<TSome, TAdapter>() where TSome: notnull where TAdapter: IBinDeserializableAdapter<TSome>, new() {
+
+            var copy = this;
+            var val = copy.DeserializeByte();
+
+            if (val.IsOK) {
+                var v = val.Unwrap();
+
+                if (v == byte.MinValue) {
+                    this = copy;
+                    return new(Maybe<TSome>.None());
+                } else if (v == byte.MaxValue) {
+                    var res = new TAdapter().De(ref copy);
+
+                    if (res.IsOK) {
+                        this = copy;
+                        return new(new Maybe<TSome>(res.Unwrap()));
+                    } else {
+                        return new(res.UnwrapErr());
+                    }
+                } else {
+                    return new(Error.InvalidValue(Unexpected.Byte(v), (@string)"0 or 255."));
+                }
+            } else {
+                return new(val.UnwrapErr());
+            }
+
+        }
+        public Result<sbyte, Error> DeserializeSbyte() => DeserializeUnsafe<sbyte>();
+        public Result<short, Error> DeserializeShort() => DeserializeUnsafe<short>();
+        // We deserialize the largest quantity of Ts possible less than or equal to len.
+        // Partial Ts are not deserialized.
+        public ReadOnlySpan<T> DeserializeSliceUnsafe<T>(uint len) where T: unmanaged {
+
+            unsafe {
+                var size = sizeof(T);
+                var bytes = Read((uint)Math.Min(len * (uint)size, _data.Length - (_data.Length % size)));
+                fixed (byte* ptr = bytes) { return new ReadOnlySpan<T>(ptr, bytes.Length / size); }
+            }
+        }
+        public Result<System.TimeSpan, Error> DeserializeTimeSpan() => DeserializeUnsafe<System.TimeSpan>();
+        public Result<U128, Error> DeserializeU128() => DeserializeUnsafe<U128>();
+        public Result<uint, Error> DeserializeUint() => DeserializeUnsafe<uint>();
+        public Result<ulong, Error> DeserializeUlong() => DeserializeUnsafe<ulong>();
+        public Result<Unit, Error> DeserializeUnit() => new(new Unit());
+        public Result<ushort, Error> DeserializeUshort() => DeserializeUnsafe<ushort>();
+        public override readonly bool Equals(object? _) => false;
+        public override readonly int GetHashCode() => 0;
+        public ReadOnlySpan<byte> Peek(uint len) => _data[..(int)Math.Min(len, _data.Length)];
+        public ReadOnlySpan<byte> Read(uint len) {
+
+            var l = (int)Math.Min(len, _data.Length);
+            var bytes = _data[..l];
+            _data = _data[l..];
+            return bytes;
+        }
+        public override readonly string ToString() => string.Empty;
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    #endregion
+
+    #region Namespaces
+    #endregion
+}
+#endregion
diff --git a/BinSer.cs b/BinSer.cs
@@ -0,0 +1,182 @@
+using Serde.Ser;
+using Std;
+using Std.Maybe;
+using Std.Num;
+using Std.Result;
+using Std.Vec;
+using System;
+using System.Runtime.InteropServices;
+#region Namespaces
+namespace Serde.Bin.Ser {
+    #region Types
+    public interface IBinSerializable: ISerializable {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract Unit Ser(ref Serializer ser);
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode, Pack = 0)]
+    public struct Serializer: ISerializer<Unit, Bottom> {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        public Serializer() => _buffer = new Vec<byte>();
+        public Serializer(Vec<byte> buffer) => _buffer = buffer;
+        public Serializer(uint bufferSize) => _buffer = Vec<byte>.WithCapacity(bufferSize);
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        [FieldOffset(0)] Vec<byte> _buffer;
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        public readonly uint Len => _buffer.Len;
+        public readonly Vec<byte> RawBuffer => _buffer;
+        public readonly ReadOnlySpan<byte> SerializedData => _buffer.AsSlice();
+        #endregion
+
+        #region Type-level Functions
+        public static Serializer New() => new();
+        public static Serializer NewWithBuffer(Vec<byte> buffer) => new(buffer);
+        public static Serializer NewWithCapacity(uint bufferSize) => new (bufferSize);
+        #endregion
+
+        #region Instance Functions
+        // This exists to avoid copying of data. Instead of one feeding the Serializer bytes to copy internally,
+        // a Span<byte> of its own buffer is handed to downstream code to write into.
+        // This Span<byte> starts at the current position and is of the passed length.
+        // The Serializer assumes every byte is written to and changes its position accordingly.
+        // This means downstream code MUST know exactly how many bytes they want to write as any byte
+        // that is not written to in the Span<byte> will not be detected.
+        public Span<byte> AsMutSlice(uint len) {
+            _ = _buffer.Reserve(len);
+            var origLen = _buffer.Len;
+            // This is safe since we first reserve enough additional space to handle this writing.
+            checked { _ = _buffer.SetLenUnsafe(origLen + len); }
+            return _buffer.AsMutSlice()[(int)origLen..];
+        }
+        public override readonly bool Equals(object? _) => false;
+        public override readonly int GetHashCode() => 0;
+        public Unit Reset() => _buffer.Clear();
+        public Unit SerUnsafe<T>(T val) where T: unmanaged { unsafe { return SerSliceUnsafe(new ReadOnlySpan<T>(&val, 1)); } }
+        public Unit Ser(ReadOnlySpan<byte> bytes) => _buffer.ExtendFromSlice(bytes);
+        public Result<Unit, Bottom> Serialize(ReadOnlySpan<byte> bytes) => new(Ser(bytes));
+        public Unit SerBool(bool val) => _buffer.Push(val ? byte.MaxValue : byte.MinValue);
+        public Result<Unit, Bottom> SerializeBool(bool val) => new(SerBool(val));
+        public Unit SerByte(byte val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeByte(byte val) => new(SerByte(val));
+        public Unit SerChar(char val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeChar(char val) => new(SerChar(val));
+        public Unit SerChars(ReadOnlySpan<char> val) => SerSliceUnsafe(val);
+        public Result<Unit, Bottom> SerializeChars(ReadOnlySpan<char> val) => new(SerChars(val));
+        public Unit SerDateTime(DateTime val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeDateTime(DateTime val) => new(SerDateTime(val));
+        public Unit SerDateTimeOffset(DateTimeOffset val) {
+
+            _ = SerDateTime(new DateTime(val.Ticks, DateTimeKind.Unspecified));
+            return SerTimeSpan(val.Offset);
+        }
+        public Result<Unit, Bottom> SerializeDateTimeOffset(DateTimeOffset val) => new(SerDateTimeOffset(val));
+        public Unit SerDecimal(decimal val) {
+
+            Span<int> bits = stackalloc int[4];
+            _ = decimal.GetBits(val, bits);
+            return SerSliceUnsafe<int>(bits);
+        }
+        public Result<Unit, Bottom> SerializeDecimal(decimal val) => new(SerDecimal(val));
+        public Unit SerDouble(double val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeDouble(double val) => new(SerDouble(val));
+        public Unit SerFloat(float val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeFloat(float val) => new(SerFloat(val));
+        public Unit SerGuid(Guid val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeGuid(Guid val) => new(SerGuid(val));
+        public Unit SerI128(I128 val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeI128(I128 val) => new(SerI128(val));
+        public Unit SerInt(int val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeInt(int val) => new(SerInt(val));
+        public Unit SerLong(long val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeLong(long val) => new(SerLong(val));
+        public Unit SerMaybe<TSome>(Maybe<TSome> val) where TSome: notnull, IBinSerializable {
+
+            if (val.IsNone) {
+                return SerUnsafe(byte.MinValue);
+            } else {
+                _ = SerUnsafe(byte.MaxValue);
+                return val.Unwrap().Ser(ref this);
+            }
+        }
+        public Result<Unit, Bottom> SerializeMaybe<TSome>(Maybe<TSome> val) where TSome : notnull, ISerializable {
+
+            if (val.IsNone) {
+                return new(SerUnsafe(byte.MinValue));
+            } else {
+                _ = SerUnsafe(byte.MaxValue);
+                return val.Unwrap().Serialize<Serializer, Unit, Bottom>(ref this);
+            }
+        }
+        public Unit SerSbyte(sbyte val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeSbyte(sbyte val) => new(SerSbyte(val));
+        public Unit SerShort(short val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeShort(short val) => new(SerShort(val));
+        public Unit SerSliceUnsafe<T>(ReadOnlySpan<T> val) where T: unmanaged { unsafe { fixed (T* ptr = val) { return _buffer.ExtendFromSlice(new(ptr, val.Length * sizeof(T))); } } }
+        public Unit SerTimeSpan(TimeSpan val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeTimeSpan(TimeSpan val) => new(SerTimeSpan(val));
+        public Unit SerU128(U128 val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeU128(U128 val) => new(SerU128(val));
+        public Unit SerUint(uint val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeUint(uint val) => new(SerUint(val));
+        public Unit SerUlong(ulong val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeUlong(ulong val) => new(SerUlong(val));
+        public Result<Unit, Bottom> SerializeUnit(Unit _) => new(new Unit());
+        public Unit SerUshort(ushort val) => SerUnsafe(val);
+        public Result<Unit, Bottom> SerializeUshort(ushort val) => new(SerUshort(val));
+        public override readonly string ToString() => string.Empty;
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    #endregion
+
+    #region Namespaces
+    #endregion
+}
+#endregion
diff --git a/De.cs b/De.cs
@@ -0,0 +1,506 @@
+using Std;
+using Std.Clone;
+using Std.Cmp;
+using Std.Convert;
+using Std.Error;
+using Std.Maybe;
+using Std.Num;
+using Std.Result;
+using System;
+using System.Diagnostics;
+using System.Runtime.InteropServices;
+using System.Text;
+#region Namespaces
+namespace Serde.De {
+    #region Types
+    [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode, Pack = 8, Size = 32)]
+    public readonly struct Unexpected: ISum<bool, byte, byte[], char, string, DateTime, DateTimeOffset, decimal, double, float, Guid, I128, int, long, Unit, sbyte, short, TimeSpan, U128, uint, ulong, Unit, ushort, string>, IClone<Unexpected>, IPartialEq<Unexpected, Unexpected>, IInto<Unexpected>, IInto<string> {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        public Unexpected() => throw new InvalidOperationException("Parameterless constructor is not allowed to be called!");
+        Unexpected(Unit _) => (Var, _bool, _byte, _bytes, _char, _chars, _dateTime, _dateTimeOffset, _decimal, _double, _float, _guid, _i128, _int, _long, _other, _sbyte, _short, _timeSpan, _u128, _uint, _ulong, _ushort) = (default, default, default, default!, default, default!, default, default, default, default, default, default, default, default, default, default!, default, default, default, default, default, default, default);
+        Unexpected(Tag kind) : this(new Std.Unit()) => Var = kind;
+        Unexpected(bool val) : this(new Std.Unit()) => (Var, _bool) = (Tag.Bool, val);
+        Unexpected(byte val) : this(new Std.Unit()) => (Var, _byte) = (Tag.Byte, val);
+        Unexpected(byte[] val) : this(new Std.Unit()) => (Var, _bytes) = (Tag.Bytes, val);
+        Unexpected(char val) : this(new Std.Unit()) => (Var, _char) = (Tag.Char, val);
+        Unexpected(string val) : this(new Std.Unit()) => (Var, _chars) = (Tag.Chars, val);
+        Unexpected(DateTime val) : this(new Std.Unit()) => (Var, _dateTime) = (Tag.DateTime, val);
+        Unexpected(DateTimeOffset val) : this(new Std.Unit()) => (Var, _dateTimeOffset) = (Tag.DateTimeOffset, val);
+        Unexpected(decimal val) : this(new Std.Unit()) => (Var, _decimal) = (Tag.Decimal, val);
+        Unexpected(double val) : this(new Std.Unit()) => (Var, _double) = (Tag.Double, val);
+        Unexpected(float val) : this(new Std.Unit()) => (Var, _float) = (Tag.Float, val);
+        Unexpected(Guid val) : this(new Std.Unit()) => (Var, _guid) = (Tag.Guid, val);
+        Unexpected(I128 val) : this(new Std.Unit()) => (Var, _i128) = (Tag.I128, val);
+        Unexpected(int val) : this(new Std.Unit()) => (Var, _int) = (Tag.Int, val);
+        Unexpected(long val) : this(new Std.Unit()) => (Var, _long) = (Tag.Long, val);
+        Unexpected(sbyte val) : this(new Std.Unit()) => (Var, _sbyte) = (Tag.Sbyte, val);
+        Unexpected(short val) : this(new Std.Unit()) => (Var, _short) = (Tag.Short, val);
+        Unexpected(TimeSpan val) : this(new Std.Unit()) => (Var, _timeSpan) = (Tag.TimeSpan, val);
+        Unexpected(U128 val) : this(new Std.Unit()) => (Var, _u128) = (Tag.U128, val);
+        Unexpected(uint val) : this(new Std.Unit()) => (Var, _uint) = (Tag.Uint, val);
+        Unexpected(ulong val) : this(new Std.Unit()) => (Var, _ulong) = (Tag.Ulong, val);
+        Unexpected(ushort val) : this(new Std.Unit()) => (Var, _ushort) = (Tag.Ushort, val);
+        Unexpected(string val, Unit _) : this(new Std.Unit()) => (Var, _other) = (Tag.Other, val);
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        [FieldOffset(0)] readonly bool _bool;
+        [FieldOffset(0)] readonly byte _byte;
+        [FieldOffset(0)] readonly char _char;
+        [FieldOffset(0)] readonly DateTime _dateTime;
+        [FieldOffset(0)] readonly DateTimeOffset _dateTimeOffset;
+        [FieldOffset(0)] readonly decimal _decimal;
+        [FieldOffset(0)] readonly double _double;
+        [FieldOffset(0)] readonly float _float;
+        [FieldOffset(0)] readonly Guid _guid;
+        [FieldOffset(0)] readonly I128 _i128;
+        [FieldOffset(0)] readonly int _int;
+        [FieldOffset(0)] readonly long _long;
+        [FieldOffset(0)] readonly sbyte _sbyte;
+        [FieldOffset(0)] readonly short _short;
+        [FieldOffset(0)] readonly TimeSpan _timeSpan;
+        [FieldOffset(0)] readonly U128 _u128;
+        [FieldOffset(0)] readonly uint _uint;
+        [FieldOffset(0)] readonly ulong _ulong;
+        [FieldOffset(0)] readonly ushort _ushort;
+        [FieldOffset(16)] readonly byte[] _bytes;
+        [FieldOffset(16)] readonly string _chars;
+        [FieldOffset(16)] readonly string _other;
+        [FieldOffset(24)] public readonly Tag Var;
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        public readonly Var24 Variant => (Var24)Var;
+        public readonly bool Variant0 => IntoBool();
+        public readonly byte Variant1 => IntoByte();
+        public readonly byte[] Variant2 => IntoBytes();
+        public readonly char Variant3 => IntoChar();
+        public readonly string Variant4 => IntoChars();
+        public readonly DateTime Variant5 => IntoDateTime();
+        public readonly DateTimeOffset Variant6 => IntoDateTimeOffset();
+        public readonly decimal Variant7 => IntoDecimal();
+        public readonly double Variant8 => IntoDouble();
+        public readonly float Variant9 => IntoFloat();
+        public readonly Guid Variant10 => IntoGuid();
+        public readonly I128 Variant11 => IntoI128();
+        public readonly int Variant12 => IntoInt();
+        public readonly long Variant13 => IntoLong();
+        public readonly Unit Variant14 => IntoMaybe();
+        public readonly sbyte Variant15 => IntoSbyte();
+        public readonly short Variant16 => IntoShort();
+        public readonly TimeSpan Variant17 => IntoTimeSpan();
+        public readonly U128 Variant18 => IntoU128();
+        public readonly uint Variant19 => IntoUint();
+        public readonly ulong Variant20 => IntoUlong();
+        public readonly Unit Variant21 => IntoUnit();
+        public readonly ushort Variant22 => IntoUshort();
+        public readonly string Variant23 => IntoOther();
+        #endregion
+
+        #region Type-level Functions
+        public static Unexpected Bool(bool val) => new(val);
+        public static Unexpected Byte(byte val) => new(val);
+        public static Unexpected Bytes(byte[] val) => new(val);
+        public static Unexpected Char(char val) => new(val);
+        public static Unexpected Chars(string val) => new(val);
+        public static Unexpected DateTime(DateTime val) => new(val);
+        public static Unexpected DateTimeOffset(DateTimeOffset val) => new(val);
+        public static Unexpected Decimal(decimal val) => new(val);
+        public static Unexpected Double(double val) => new(val);
+        public static Unexpected Float(float val) => new(val);
+        public static Unexpected Guid(Guid val) => new(val);
+        public static Unexpected I128(I128 val) => new(val);
+        public static Unexpected Int(int val) => new(val);
+        public static Unexpected Long(long val) => new(val);
+        public static Unexpected Maybe() => new(Tag.Maybe);
+        public static Unexpected Sbyte(sbyte val) => new(val);
+        public static Unexpected Short(short val) => new(val);
+        public static Unexpected TimeSpan(TimeSpan val) => new(val);
+        public static Unexpected U128(U128 val) => new(val);
+        public static Unexpected Uint(uint val) => new(val);
+        public static Unexpected Ulong(ulong val) => new(val);
+        public static Unexpected Unit() => new(Tag.Unit);
+        public static Unexpected Ushort(ushort val) => new(val);
+        public static Unexpected Other(string val) => new(val, new Std.Unit());
+        #endregion
+
+        #region Instance Functions
+        public readonly Unexpected Clone() {
+
+            if (Var == Tag.Bytes) {
+                var bytes = new byte[_bytes.Length];
+                Array.Copy(_bytes, 0, bytes, 0, bytes.Length);
+                return new(bytes);
+            } else {
+                return this;
+            }
+        }
+        public override readonly bool Equals(object? _) => false;
+        public override readonly int GetHashCode() => 0;
+        public readonly Unexpected Into() => this;
+        public readonly string IntoString() => ToString();
+        readonly string IInto<string>.Into() => IntoString();
+        public readonly bool IntoBool() => Var == Tag.Bool ? _bool : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Bool!");
+        public readonly byte IntoByte() => Var == Tag.Byte ? _byte : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Byte!");
+        public readonly byte[] IntoBytes() => Var == Tag.Bytes ? _bytes : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Bytes!");
+        public readonly char IntoChar() => Var == Tag.Char ? _char : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Char!");
+        public readonly string IntoChars() => Var == Tag.Chars ? _chars : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Chars!");
+        public readonly DateTime IntoDateTime() => Var == Tag.DateTime ? _dateTime : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not DateTime!");
+        public readonly DateTimeOffset IntoDateTimeOffset() => Var == Tag.DateTimeOffset ? _dateTimeOffset : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not DateTimeOffset!");
+        public readonly decimal IntoDecimal() => Var == Tag.Decimal ? _decimal : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Decimal!");
+        public readonly double IntoDouble() => Var == Tag.Double ? _double : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Double!");
+        public readonly float IntoFloat() => Var == Tag.Float ? _float : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Float!");
+        public readonly Guid IntoGuid() => Var == Tag.Guid ? _guid : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Guid!");
+        public readonly I128 IntoI128() => Var == Tag.I128 ? _i128 : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not I128!");
+        public readonly int IntoInt() => Var == Tag.Int ? _int : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Int!");
+        public readonly long IntoLong() => Var == Tag.Long ? _long : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Long!");
+        public readonly Unit IntoMaybe() => Var == Tag.Maybe ? new Std.Unit() : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Maybe!");
+        public readonly sbyte IntoSbyte() => Var == Tag.Sbyte ? _sbyte : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Sbyte!");
+        public readonly short IntoShort() => Var == Tag.Short ? _short : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Short!");
+        public readonly TimeSpan IntoTimeSpan() => Var == Tag.TimeSpan ? _timeSpan : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not TimeSpan!");
+        public readonly U128 IntoU128() => Var == Tag.U128 ? _u128 : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not U128!");
+        public readonly uint IntoUint() => Var == Tag.Uint ? _uint : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Uint!");
+        public readonly ulong IntoUlong() => Var == Tag.Ulong ? _ulong : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Ulong!");
+        public readonly Unit IntoUnit() => Var == Tag.Unit ? new Std.Unit() : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Unit!");
+        public readonly ushort IntoUshort() => Var == Tag.Ushort ? _ushort : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Ushort!");
+        public readonly string IntoOther() => Var == Tag.Other ? _other : throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is not Other!");
+        public override readonly string ToString() => $@"{Var.ToString()}({Var switch {
+            Tag.Bool =>_bool.ToString(),
+            Tag.Byte => _byte.ToString(),
+            Tag.Bytes => _bytes.AsSpan().UpperHex(),
+            Tag.Char => _char.ToString(),
+            Tag.Chars => _chars,
+            Tag.DateTime => _dateTime.ToString(),
+            Tag.DateTimeOffset => _dateTimeOffset.ToString(),
+            Tag.Decimal => _decimal.ToString(),
+            Tag.Double => _double.ToString(),
+            Tag.Float => _float.ToString(),
+            Tag.Guid => _guid.ToString(),
+            Tag.I128 => _i128.IntoString(),
+            Tag.Int => _int.ToString(),
+            Tag.Long => _long.ToString(),
+            Tag.Maybe => string.Empty,
+            Tag.Sbyte => _sbyte.ToString(),
+            Tag.Short => _short.ToString(),
+            Tag.TimeSpan => _timeSpan.ToString(),
+            Tag.U128 => _u128.IntoString(),
+            Tag.Uint => _uint.ToString(),
+            Tag.Ulong => _ulong.ToString(),
+            Tag.Unit => "()",
+            Tag.Ushort => _ushort.ToString(),
+            Tag.Other => _other,
+            _ => throw new InvalidOperationException($"The Unexpected variant {Var.ToString()} is invalid!"),
+        }
+})";
+        readonly Result<Unexpected, Bottom> ITryInto<Unexpected, Bottom>.TryInto() => new(this);
+        readonly Result<string, Bottom> ITryInto<string, Bottom>.TryInto() => new(ToString());
+        #endregion
+
+        #region Operators
+        public static bool operator !=(Unexpected val0, Unexpected val1) => !(val0 == val1);
+        public static bool operator ==(Unexpected val0, Unexpected val1) => val0.Var == val1.Var && val0.Var switch {
+            Tag.Bool => val0._bool == val1._bool,
+            Tag.Byte => val0._byte == val1._byte,
+            Tag.Bytes => val0._bytes.AsSpan().EqualsEquatable(val1._bytes.AsSpan()),
+            Tag.Char => val0._char == val1._char,
+            Tag.Chars => val0._chars == val1._chars,
+            Tag.DateTime => val0._dateTime == val1._dateTime,
+            Tag.DateTimeOffset => val0._dateTimeOffset == val1._dateTimeOffset,
+            Tag.Decimal => val0._decimal == val1._decimal,
+            Tag.Double => val0._double == val1._double,
+            Tag.Float => val0._float == val1._float,
+            Tag.Guid => val0._guid == val1._guid,
+            Tag.I128 => val0._i128 == val1._i128,
+            Tag.Int => val0._int == val1._int,
+            Tag.Long => val0._long == val1._long,
+            Tag.Maybe => true,
+            Tag.Sbyte => val0._sbyte == val1._sbyte,
+            Tag.Short => val0._short == val1._short,
+            Tag.TimeSpan => val0._timeSpan == val1._timeSpan,
+            Tag.U128 => val0._u128 == val1._u128,
+            Tag.Uint => val0._uint == val1._uint,
+            Tag.Ulong => val0._ulong == val1._ulong,
+            Tag.Unit => true,
+            Tag.Ushort => val0._ushort == val1._ushort,
+            Tag.Other=> val0._other== val1._other,
+            _ => throw new InvalidOperationException($"The Unexpected type {val0.Var.ToString()} is invalid."),
+        };
+        #endregion
+
+        #region Types
+        public enum Tag: ulong {
+            Bool = ulong.MinValue,
+            Byte = 1ul,
+            Bytes = 2ul,
+            Char = 3ul,
+            Chars = 4ul,
+            DateTime = 5ul,
+            DateTimeOffset = 6ul,
+            Decimal = 7ul,
+            Double = 8ul,
+            Float = 9ul,
+            Guid = 10ul,
+            I128 = 11ul,
+            Int = 12ul,
+            Long = 13ul,
+            Maybe = 14ul,
+            Sbyte = 15ul,
+            Short = 16ul,
+            TimeSpan = 17ul,
+            U128 = 18ul,
+            Uint = 19ul,
+            Ulong = 20ul,
+            Unit = 21ul,
+            Ushort = 22ul,
+            Other = 23ul,
+        }
+        #endregion
+    }
+    // This is a fairly large type and it will likely be used frequently as the error in a Result.
+    // If this were a struct, the Result would be large. If it were the case the Result
+    // would be local only, then it would be better if this were a struct; however it's likely that the Result will simply
+    // be passed down the call stack making it important the copies are small so we make it a sealed class instead.
+    [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode, Pack = 8, Size = 48)]
+    public sealed class Error: ISum<IInto<string>, Prod<Unexpected, IInto<string>>, Prod<Unexpected, IInto<string>>, Prod<ulong, IInto<string>>, Prod<string, string[]>, Prod<string, string[]>, string, string>, IInto<Error>, IError {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        Error() => (_unexp, _len, _variant_or_field, _expected, _msg_or_exp, Var) = (default, default, default!, default!, default!, default);
+        Error(IInto<string> msg) : this() => (Var, _msg_or_exp) = (Tag.Custom, msg);
+        Error(Tag kind, Unexpected unexp, IInto<string> exp) : this() => (Var, _msg_or_exp, _unexp) = (kind, exp, unexp);
+        Error(ulong len, IInto<string> exp) : this() => (Var, _len, _msg_or_exp) = (Tag.InvalidLength, len, exp);
+        Error(Tag kind, string variant_or_field, string[] expected) : this() => (Var, _variant_or_field, _expected) = (kind, variant_or_field, expected);
+        Error(Tag kind, string field) : this() => (Var, _variant_or_field) = (kind, field);
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        [FieldOffset(0)] readonly Unexpected _unexp;
+        [FieldOffset(0)] readonly ulong _len;
+        [FieldOffset(16)] readonly string _variant_or_field;
+		[FieldOffset(32)] readonly string[] _expected;
+        [FieldOffset(32)] readonly IInto<string> _msg_or_exp;
+        [FieldOffset(40)] public readonly Tag Var;
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        public Var8 Variant => (Var8)Var;
+        public IInto<string> Variant0 => IntoCustom();
+        public Prod<Unexpected, IInto<string>> Variant1 => IntoInvalidType();
+        public Prod<Unexpected, IInto<string>> Variant2 => IntoInvalidValue();
+        public Prod<ulong, IInto<string>> Variant3 => IntoInvalidLength();
+        public Prod<string, string[]> Variant4 => IntoUnknownVariant();
+        public Prod<string, string[]> Variant5 => IntoUnknownField();
+        public string Variant6 => IntoMissingField();
+        public string Variant7 => IntoDuplicateField();
+        #endregion
+
+        #region Type-level Functions
+        public static Error Custom<T>(T msg) where T: notnull, IInto<string> => new(msg);
+        public static Error InvalidType(Unexpected unexp, IInto<string> exp) => new(Tag.InvalidType, unexp, exp);
+        public static Error InvalidValue(Unexpected unexp, IInto<string> exp) => new(Tag.InvalidValue, unexp, exp);
+        public static Error InvalidLength(ulong len, IInto<string> exp) => new(len, exp);
+        public static Error UnknownVariant(string variant, string[] expected) => new(Tag.UnknownVariant, variant, expected);
+        public static Error UnknownField(string field, string[] expected) => new(Tag.UnknownField, field, expected);
+        public static Error MissingField(string field) => new(Tag.MissingField, field);
+        public static Error DuplicateField(string field) => new(Tag.DuplicateField, field);
+        #endregion
+
+        #region Instance Functions
+        public sealed override bool Equals(object? _) => false;
+        public sealed override int GetHashCode() => 0;
+        public Error Into() => this;
+        public string IntoString() => ToString();
+        string IInto<string>.Into() => IntoString();
+        public IInto<string> IntoCustom() => Var == Tag.Custom ? _msg_or_exp : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not a Custom!");
+        public Prod<Unexpected, IInto<string>> IntoInvalidType() => Var == Tag.InvalidType ? new(_unexp, _msg_or_exp) : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not an InvalidType!");
+        public Prod<Unexpected, IInto<string>> IntoInvalidValue() => Var == Tag.InvalidValue ? new(_unexp, _msg_or_exp) : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not an InvalidValue!");
+        public Prod<ulong, IInto<string>> IntoInvalidLength() => Var == Tag.InvalidLength ? new(_len, _msg_or_exp) : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not an InvalidLength!");
+        public Prod<string, string[]> IntoUnknownVariant() => Var == Tag.UnknownVariant ? new(_variant_or_field, _expected) : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not an UnknownVariant!");
+        public Prod<string, string[]> IntoUnknownField() => Var == Tag.UnknownField ? new(_variant_or_field, _expected) : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not an UnknownField!");
+        public string IntoMissingField() => Var == Tag.MissingField ? _variant_or_field : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not a MissingField!");
+        public string IntoDuplicateField() => Var == Tag.DuplicateField ? _variant_or_field : throw new InvalidOperationException($"The Error variant {Var.ToString()} is not a DuplicateField!");
+        public Maybe<IError> Source() => Maybe<IError>.None();
+        public Maybe<StackTrace> StackTrace() => Maybe<StackTrace>.None();
+        public sealed override string ToString() => $@"{Var.ToString()}({Var switch {
+            Tag.Custom => $"{_msg_or_exp.Into()}",
+            Tag.InvalidType => $"{_unexp.IntoString()}, Expected({_msg_or_exp.Into()})",
+            Tag.InvalidValue => $"{_unexp.IntoString()}, Expected({_msg_or_exp.Into()})",
+            Tag.InvalidLength => $"Length: {_len.ToString()}, Expected({_msg_or_exp.Into()})",
+            Tag.UnknownVariant => $"Variant: {_variant_or_field}, Expected([ {_expected.IntoString()} ])",
+            Tag.UnknownField => $"Field: {_variant_or_field}, Expected([ {_expected.IntoString()} ])",
+            Tag.MissingField => $"Field: {_variant_or_field}",
+            Tag.DuplicateField => $"Field: {_variant_or_field}",
+            _ => throw new InvalidOperationException($"The Error variant {Var.ToString()} is invalid!"),
+        }
+})";
+        Result<Error, Bottom> ITryInto<Error, Bottom>.TryInto() => new(this);
+        Result<string, Bottom> ITryInto<string, Bottom>.TryInto() => new(ToString());
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        public enum Tag: ulong {
+            Custom = ulong.MinValue,
+            InvalidType = 1ul,
+            InvalidValue = 2ul,
+            InvalidLength = 3ul,
+            UnknownVariant = 4ul,
+            UnknownField = 5ul,
+            MissingField = 6ul,
+            DuplicateField = 7ul,
+        }
+        #endregion
+    }
+    public interface IDeserializableAdapter<T> where T: notnull {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract Result<T, Error> Deserialize<TDes>(ref TDes des) where TDes: notnull, IDeserializer;
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    public interface IDeserializer {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract uint Deserialize(Span<byte> bytes);
+        public abstract Result<bool, Error> DeserializeBool();
+        public abstract Result<byte, Error> DeserializeByte();
+        public abstract Result<char, Error> DeserializeChar();
+        public abstract uint DeserializeChars(Span<char> chars);
+        public abstract Result<DateTime, Error> DeserializeDateTime();
+        public abstract Result<DateTimeOffset, Error> DeserializeDateTimeOffset();
+        public abstract Result<decimal, Error> DeserializeDecimal();
+        public abstract Result<double, Error> DeserializeDouble();
+        public abstract Result<float, Error> DeserializeFloat();
+        public abstract Result<Guid, Error> DeserializeGuid();
+        public abstract Result<I128, Error> DeserializeI128();
+        public abstract Result<int, Error> DeserializeInt();
+        public abstract Result<long, Error> DeserializeLong();
+        public abstract Result<Maybe<TSome>, Error> DeserializeMaybe<TSome, TAdapter>() where TSome: notnull where TAdapter: IDeserializableAdapter<TSome>, new();
+        public abstract Result<sbyte, Error> DeserializeSbyte();
+        public abstract Result<short, Error> DeserializeShort();
+        public abstract Result<TimeSpan, Error> DeserializeTimeSpan();
+        public abstract Result<U128, Error> DeserializeU128();
+        public abstract Result<uint, Error> DeserializeUint();
+        public abstract Result<ulong, Error> DeserializeUlong();
+        public abstract Result<Unit, Error> DeserializeUnit();
+        public abstract Result<ushort, Error> DeserializeUshort();
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    public static class Functions {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        internal static string IntoString(this string[] self) {
+
+            if (self.Length == 0) { return string.Empty; };
+            var sb = new StringBuilder(self.Length * 32);
+            for (var i = 0; i < self.Length; i++) { sb = sb.Append($"{self[i]}, "); }
+            return sb.Remove(sb.Length - 2, 2).ToString();
+        }
+        #endregion
+
+        #region Instance Functions
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    #endregion
+
+    #region Namespaces
+    #endregion
+}
+#endregion
diff --git a/LICENSE-APACHE b/LICENSE-APACHE
@@ -0,0 +1,177 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
diff --git a/LICENSE-MIT b/LICENSE-MIT
@@ -0,0 +1,20 @@
+Copyright © 2023 Zack Newman
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and associated documentation files (the
+“Software”), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/README.md b/README.md
@@ -0,0 +1,3 @@
+Serde
+--------
+Kind of a port of Rust's Serde crate.
diff --git a/Ser.cs b/Ser.cs
@@ -0,0 +1,103 @@
+using Std;
+using Std.Error;
+using Std.Maybe;
+using Std.Num;
+using Std.Result;
+using System;
+#region Namespaces
+namespace Serde.Ser {
+    #region Types
+    public interface ISerializable {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract Result<TOK, TErr> Serialize<TSer, TOK, TErr>(ref TSer ser) where TOK: notnull where TErr: notnull, IError where TSer: ISerializer<TOK, TErr>;
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    public interface ISerializer<TOK, TErr> where TOK: notnull where TErr: notnull, IError {
+
+        #region Type-level Constructors
+        #endregion
+
+        #region Instance Constructors
+        #endregion
+
+        #region Type-level Fields
+        #endregion
+
+        #region Instance Fields
+        #endregion
+
+        #region Type-level Properties
+        #endregion
+
+        #region Instance Properties
+        #endregion
+
+        #region Type-level Functions
+        #endregion
+
+        #region Instance Functions
+        public abstract Result<TOK, TErr> Serialize(ReadOnlySpan<byte> bytes);
+        public abstract Result<TOK, TErr> SerializeBool(bool val);
+        public abstract Result<TOK, TErr> SerializeByte(byte val);
+        public abstract Result<TOK, TErr> SerializeChar(char val);
+        public abstract Result<TOK, TErr> SerializeChars(ReadOnlySpan<char> val);
+        public abstract Result<TOK, TErr> SerializeDateTime(DateTime val);
+        public abstract Result<TOK, TErr> SerializeDateTimeOffset(DateTimeOffset val);
+        public abstract Result<TOK, TErr> SerializeDecimal(decimal val);
+        public abstract Result<TOK, TErr> SerializeDouble(double val);
+        public abstract Result<TOK, TErr> SerializeFloat(float val);
+        public abstract Result<TOK, TErr> SerializeGuid(Guid val);
+        public abstract Result<TOK, TErr> SerializeI128(I128 val);
+        public abstract Result<TOK, TErr> SerializeInt(int val);
+        public abstract Result<TOK, TErr> SerializeLong(long val);
+        public abstract Result<TOK, TErr> SerializeMaybe<TSome>(Maybe<TSome> val) where TSome: notnull, ISerializable;
+        public abstract Result<TOK, TErr> SerializeSbyte(sbyte val);
+        public abstract Result<TOK, TErr> SerializeShort(short val);
+        public abstract Result<TOK, TErr> SerializeTimeSpan(TimeSpan val);
+        public abstract Result<TOK, TErr> SerializeU128(U128 val);
+        public abstract Result<TOK, TErr> SerializeUint(uint val);
+        public abstract Result<TOK, TErr> SerializeUlong(ulong val);
+        public abstract Result<TOK, TErr> SerializeUnit(Unit _);
+        public abstract Result<TOK, TErr> SerializeUshort(ushort val);
+        #endregion
+
+        #region Operators
+        #endregion
+
+        #region Types
+        #endregion
+    }
+    #endregion
+
+    #region Namespaces
+    #endregion
+}
+#endregion
diff --git a/Serde.csproj b/Serde.csproj
@@ -0,0 +1,61 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+    <AnalysisLevel>latest</AnalysisLevel>
+    <AnalysisMode>All</AnalysisMode>
+    <AppendRuntimeIdentifierToOutputPath>false</AppendRuntimeIdentifierToOutputPath>
+    <AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
+    <AssemblyName>Serde</AssemblyName>
+    <AssemblyTitle>Serde</AssemblyTitle>
+    <AssemblyVersion>1.0.0.0</AssemblyVersion>
+    <Authors>Zack Newman</Authors>
+    <CheckForOverflowUnderflow>false</CheckForOverflowUnderflow>
+    <CodeAnalysisTreatWarningsAsErrors>true</CodeAnalysisTreatWarningsAsErrors>
+    <Company>Philomathic Life</Company>
+    <Configuration>Release</Configuration>
+    <Copyright>2023</Copyright>
+    <DebugSymbols>false</DebugSymbols>
+    <DebugType>none</DebugType>
+    <DefineConstants></DefineConstants>
+    <Description>(de)serialization library.</Description>
+    <Deterministic>true</Deterministic>
+    <DocumentationFile></DocumentationFile>
+    <EnableComHosting>false</EnableComHosting>
+    <EnableDynamicLoading>false</EnableDynamicLoading>
+    <EnableNETAnalyzers>true</EnableNETAnalyzers>
+    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
+    <ErrorReport>prompt</ErrorReport>
+    <FileAlignment>512</FileAlignment>
+    <FileVersion>1.0.0.0</FileVersion>
+    <HighEntropyVA>true</HighEntropyVA>
+    <InformationalVersion>1.0.0.0</InformationalVersion>
+    <IsTrimmable>true</IsTrimmable>
+    <LangVersion>latest</LangVersion>
+    <NeutralLanguage>en-US</NeutralLanguage>
+    <NoWarn></NoWarn>
+    <Nullable>enable</Nullable>
+    <Optimize>true</Optimize>
+    <OutputPath>bin/Release</OutputPath>
+    <OutputType>Library</OutputType>
+    <Platform>x64</Platform>
+    <Product>Serde</Product>
+    <PublishTrimmed>true</PublishTrimmed>
+    <RuntimeIdentifier>linux-x64</RuntimeIdentifier>
+    <TargetFramework>net7.0</TargetFramework>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <TrimMode>link</TrimMode>
+    <TrimmerDefaultAction>link</TrimmerDefaultAction>
+    <Utf8Output>true</Utf8Output>
+    <WarningsAsErrors>true</WarningsAsErrors>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Reference Include="Std">
+      <Name>Std</Name>
+      <HintPath>../Std/bin/Release/Std.dll</HintPath>
+      <Private>false</Private>
+    </Reference>
+  </ItemGroup>
+
+</Project>