Consolidate number support into a single "value" API

10 files changed, 685 insertions, 422 deletions

diff --git a/doc/conf.py.in b/doc/conf.py.in
index 39d9568f..8760bbd9 100644
--- a/doc/conf.py.in
+++ b/doc/conf.py.in
@@ -35,9 +35,14 @@ _opaque = [
     "SerdStatementImpl",
     "SerdWorldImpl",
     "SerdWriterImpl",
+    "int16_t",
+    "int32_t",
     "int64_t",
+    "int8_t",
     "size_t",
+    "uint16_t",
     "uint32_t",
+    "uint64_t",
     "uint8_t",
     "uintptr_t",
     "va_list",
diff --git a/include/serd/serd.h b/include/serd/serd.h
index 49046054..c09494bc 100644
--- a/include/serd/serd.h
+++ b/include/serd/serd.h
@@ -741,6 +741,116 @@ typedef enum {
 } SerdNodeType;
 
 /**
+   @defgroup serd_node_value Values
+
+   Serd supports reading and writing machine-native numbers, called "values",
+   in a standards-conformant and portable way.  The value structure is used in
+   the API to allow passing and returning a primitive value of any supported
+   type.  Note that this is just an API convenience, literal nodes themselves
+   always store their values as strings.
+
+   @{
+*/
+
+/// The type of a #SerdValue
+typedef enum {
+  SERD_NOTHING, ///< Sentinel for unknown datatypes or errors
+  SERD_BOOL,    ///< xsd:boolean (bool)
+  SERD_DOUBLE,  ///< xsd:double (double)
+  SERD_FLOAT,   ///< xsd:float (float)
+  SERD_LONG,    ///< xsd:long (int64_t)
+  SERD_INT,     ///< xsd:integer (int32_t)
+  SERD_SHORT,   ///< xsd:short (int16_t)
+  SERD_BYTE,    ///< xsd:byte (int8_t)
+  SERD_ULONG,   ///< xsd:unsignedLong (uint64_t)
+  SERD_UINT,    ///< xsd:unsignedInt (uint32_t)
+  SERD_USHORT,  ///< xsd:unsignedShort (uint16_t)
+  SERD_UBYTE,   ///< xsd:unsignedByte (uint8_t)
+} SerdValueType;
+
+/// The data of a #SerdValue (the actual machine-native primitive)
+typedef union {
+  bool     as_bool;
+  double   as_double;
+  float    as_float;
+  int64_t  as_long;
+  int32_t  as_int;
+  int16_t  as_short;
+  int8_t   as_byte;
+  uint64_t as_ulong;
+  uint32_t as_uint;
+  uint16_t as_ushort;
+  uint8_t  as_ubyte;
+} SerdValueData;
+
+/// A primitive value with a type tag
+typedef struct {
+  SerdValueType type;
+  SerdValueData data;
+} SerdValue;
+
+/// Convenience constructor to make a #SERD_NOTHING (non-)value
+SERD_CONST_API
+SerdValue
+serd_nothing(void);
+
+/// Convenience constructor to make a #SERD_BOOL value
+SERD_CONST_API
+SerdValue
+serd_bool(bool v);
+
+/// Convenience constructor to make a #SERD_DOUBLE value
+SERD_CONST_API
+SerdValue
+serd_double(double v);
+
+/// Convenience constructor to make a #SERD_FLOAT value
+SERD_CONST_API
+SerdValue
+serd_float(float v);
+
+/// Convenience constructor to make a #SERD_LONG value
+SERD_CONST_API
+SerdValue
+serd_long(int64_t v);
+
+/// Convenience constructor to make a #SERD_INT value
+SERD_CONST_API
+SerdValue
+serd_int(int32_t v);
+
+/// Convenience constructor to make a #SERD_SHORT value
+SERD_CONST_API
+SerdValue
+serd_short(int16_t v);
+
+/// Convenience constructor to make a #SERD_BYTE value
+SERD_CONST_API
+SerdValue
+serd_byte(int8_t v);
+
+/// Convenience constructor to make a #SERD_ULONG value
+SERD_CONST_API
+SerdValue
+serd_ulong(uint64_t v);
+
+/// Convenience constructor to make a #SERD_UINT value
+SERD_CONST_API
+SerdValue
+serd_uint(uint32_t v);
+
+/// Convenience constructor to make a #SERD_USHORT value
+SERD_CONST_API
+SerdValue
+serd_ushort(uint16_t v);
+
+/// Convenience constructor to make a #SERD_UBYTE value
+SERD_CONST_API
+SerdValue
+serd_ubyte(uint8_t v);
+
+/**
+   @}
    @defgroup serd_node_construction Construction
 
    This is the low-level node construction API, which can be used to construct
@@ -864,18 +974,15 @@ serd_node_construct_literal(size_t              buf_size,
                             SerdStringView      meta);
 
 /**
-   Construct a canonical xsd:boolean literal.
-
-   The constructed node will be either "true" or "false", with datatype
-   xsd:boolean.
+   Construct a canonical literal for a primitive value.
 
-   This is a convenience wrapper for serd_node_construct_literal() that
-   constructs a node directly from a `bool`.
+   The constructed node will be a typed literal in canonical form for the xsd
+   datatype corresponding to the value.
 */
 SerdWriteResult
-serd_node_construct_boolean(size_t              buf_size,
-                            void* SERD_NULLABLE buf,
-                            bool                value);
+serd_node_construct_value(size_t              buf_size,
+                          void* SERD_NULLABLE buf,
+                          SerdValue           value);
 
 /**
    Construct a canonical xsd:decimal literal.
@@ -896,38 +1003,6 @@ serd_node_construct_decimal(size_t              buf_size,
                             double              value);
 
 /**
-   Construct a canonical xsd:double literal.
-
-   The constructed node will be an xsd:double literal, like "1.23E45", with
-   datatype xsd:double.  A canonical xsd:double is always in scientific
-   notation.
-
-   This is a convenience wrapper for serd_node_construct_literal() that
-   constructs a node directly from a `double`.
-*/
-SerdWriteResult
-serd_node_construct_double(size_t              buf_size,
-                           void* SERD_NULLABLE buf,
-                           double              value);
-
-/**
-   Construct a canonical xsd:float literal.
-
-   The constructed node will be an xsd:float literal, like "1.23E45", with
-   datatype xsd:float.  A canonical xsd:float is always in scientific notation.
-
-   Uses identical formatting to serd_node_construct_double(), except with at
-   most 9 significant digits (under 14 characters total).
-
-   This is a convenience wrapper for serd_node_construct_literal() that
-   constructs a node directly from a `float`.
-*/
-SerdWriteResult
-serd_node_construct_float(size_t              buf_size,
-                          void* SERD_NULLABLE buf,
-                          float               value);
-
-/**
    Construct a canonical xsd:integer literal.
 
    The constructed node will be an xsd:integer literal like "1234", with the
@@ -1069,17 +1144,17 @@ serd_new_literal(SerdAllocator* SERD_NULLABLE allocator,
                  SerdStringView               meta);
 
 /**
-   Create a new canonical xsd:boolean node.
+   Create a new canonical value node.
 
-   This is a wrapper for serd_node_construct_boolean() that allocates a new
-   node on the heap.
+   This is a wrapper for serd_node_construct_value() that allocates a new node
+   on the heap.
 
    @return A newly allocated node that must be freed with serd_node_free(), or
    null.
 */
 SERD_API
 SerdNode* SERD_ALLOCATED
-serd_new_boolean(SerdAllocator* SERD_NULLABLE allocator, bool b);
+serd_new_value(SerdAllocator* SERD_NULLABLE allocator, SerdValue value);
 
 /**
    Create a new canonical xsd:decimal literal.
@@ -1095,32 +1170,6 @@ SerdNode* SERD_ALLOCATED
 serd_new_decimal(SerdAllocator* SERD_NULLABLE allocator, double d);
 
 /**
-   Create a new canonical xsd:double literal.
-
-   This is a wrapper for serd_node_construct_double() that allocates a new
-   node on the heap.
-
-   @return A newly allocated node that must be freed with serd_node_free(), or
-   null.
-*/
-SERD_API
-SerdNode* SERD_ALLOCATED
-serd_new_double(SerdAllocator* SERD_NULLABLE allocator, double d);
-
-/**
-   Create a new canonical xsd:float literal.
-
-   This is a wrapper for serd_node_construct_float() that allocates a new
-   node on the heap.
-
-   @return A newly allocated node that must be freed with serd_node_free(), or
-   null.
-*/
-SERD_API
-SerdNode* SERD_ALLOCATED
-serd_new_float(SerdAllocator* SERD_NULLABLE allocator, float f);
-
-/**
    Create a new canonical xsd:integer literal.
 
    This is a wrapper for serd_node_construct_integer() that allocates a new
@@ -1153,49 +1202,39 @@ serd_new_base64(SerdAllocator* SERD_NULLABLE allocator,
 */
 
 /**
-   Return the value of `node` as a boolean.
+   Return the primitive value of `node`.
 
-   This will work for booleans, and numbers of any datatype if they are 0 or
-   1.
+   This will return a typed value if the node can be read as one, or a value
+   with type #SERD_NOTHING otherwise.
 
-   @return The value of `node` as a `bool`, or `false` on error.
+   @return The value of `node` as a #SerdValue, if possible.
 */
 SERD_API
-bool
-serd_get_boolean(const SerdNode* SERD_NONNULL node);
+SerdValue
+serd_get_value(const SerdNode* SERD_NONNULL node);
 
 /**
-   Return the value of `node` as a double.
+   Return the value of `node` as a specific type of number.
 
-   This will coerce numbers of any datatype to double, if the value fits.
+   This is like serd_get_number(), but will coerce the value of the node to the
+   requrested type if possible.
 
-   @return The value of `node` as a `double`, or NaN on error.
-*/
-SERD_API
-double
-serd_get_double(const SerdNode* SERD_NONNULL node);
+   @param node The node to interpret as a number.
 
-/**
-   Return the value of `node` as a float.
+   @param type The desired numeric datatype of the result.
 
-   This will coerce numbers of any datatype to float, if the value fits.
+   @param lossy Whether lossy conversions can be used.  If this is false, then
+   this function only succeeds if the value could be converted back to the
+   original datatype of the node without loss.  Otherwise, precision may be
+   reduced or values may be truncated to fit the result.
 
-   @return The value of `node` as a `float`, or NaN on error.
+   @return The value of `node` as a #SerdValue, or nothing.
 */
 SERD_API
-float
-serd_get_float(const SerdNode* SERD_NONNULL node);
-
-/**
-   Return the value of `node` as a long (signed 64-bit integer).
-
-   This will coerce numbers of any datatype to long, if the value fits.
-
-   @return The value of `node` as a `int64_t`, or 0 on error.
-*/
-SERD_API
-int64_t
-serd_get_integer(const SerdNode* SERD_NONNULL node);
+SerdValue
+serd_get_value_as(const SerdNode* SERD_NONNULL node,
+                  SerdValueType                type,
+                  bool                         lossy);
 
 /**
    Return the maximum size of a decoded base64 node in bytes.
@@ -1426,14 +1465,14 @@ serd_nodes_literal(SerdNodes* SERD_NONNULL nodes,
                    SerdStringView          meta);
 
 /**
-   Make a canonical xsd:boolean node.
+   Make a canonical value node.
 
-   A new node will be constructed with serd_node_construct_boolean() if an
+   A new node will be constructed with serd_node_construct_value() if an
    equivalent one is not already in the set.
 */
 SERD_API
 const SerdNode* SERD_ALLOCATED
-serd_nodes_boolean(SerdNodes* SERD_NONNULL nodes, bool value);
+serd_nodes_value(SerdNodes* SERD_NONNULL nodes, SerdValue value);
 
 /**
    Make a canonical xsd:decimal node.
@@ -1446,26 +1485,6 @@ const SerdNode* SERD_ALLOCATED
 serd_nodes_decimal(SerdNodes* SERD_NONNULL nodes, double value);
 
 /**
-   Make a canonical xsd:double node.
-
-   A new node will be constructed with serd_node_construct_double() if an
-   equivalent one is not already in the set.
-*/
-SERD_API
-const SerdNode* SERD_ALLOCATED
-serd_nodes_double(SerdNodes* SERD_NONNULL nodes, double value);
-
-/**
-   Make a canonical xsd:float node.
-
-   A new node will be constructed with serd_node_construct_float() if an
-   equivalent one is not already in the set.
-*/
-SERD_API
-const SerdNode* SERD_ALLOCATED
-serd_nodes_float(SerdNodes* SERD_NONNULL nodes, float value);
-
-/**
    Make a canonical xsd:integer node.
 
    A new node will be constructed with serd_node_construct_integer() if an
diff --git a/meson.build b/meson.build
index 57547bfc..f94c9dd1 100644
--- a/meson.build
+++ b/meson.build
@@ -118,6 +118,7 @@ sources = [
   'src/syntax.c',
   'src/system.c',
   'src/uri.c',
+  'src/value.c',
   'src/world.c',
   'src/writer.c',
 ]
diff --git a/src/node.c b/src/node.c
index 2d92e07d..7ccc039f 100644
--- a/src/node.c
+++ b/src/node.c
@@ -24,7 +24,6 @@
 #include "serd/serd.h"
 
 #include <assert.h>
-#include <math.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <string.h>
@@ -37,6 +36,21 @@
 
 static const SerdNodeFlags meta_mask = (SERD_HAS_DATATYPE | SERD_HAS_LANGUAGE);
 
+static const ExessDatatype value_type_datatypes[] = {
+  EXESS_NOTHING,
+  EXESS_BOOLEAN,
+  EXESS_DOUBLE,
+  EXESS_FLOAT,
+  EXESS_LONG,
+  EXESS_INT,
+  EXESS_SHORT,
+  EXESS_BYTE,
+  EXESS_ULONG,
+  EXESS_UINT,
+  EXESS_USHORT,
+  EXESS_UBYTE,
+};
+
 // Round size up to an even multiple of the node alignment
 static size_t
 serd_node_pad_size(const size_t size)
@@ -281,21 +295,122 @@ serd_node_construct(const size_t         buf_size,
             : serd_node_construct_token(buf_size, buf, type, string));
 }
 
+static ExessDatatype
+value_type_datatype(const SerdValueType value_type)
+{
+  return (value_type > SERD_UBYTE) ? EXESS_NOTHING
+                                   : value_type_datatypes[value_type];
+}
+
+static const char*
+value_type_uri(const SerdValueType value_type)
+{
+  return exess_datatype_uri(value_type_datatype(value_type));
+}
+
+static inline SerdValueType
+datatype_value_type(const ExessDatatype datatype)
+{
+  switch (datatype) {
+  case EXESS_NOTHING:
+    return SERD_NOTHING;
+  case EXESS_BOOLEAN:
+    return SERD_BOOL;
+  case EXESS_DECIMAL:
+  case EXESS_DOUBLE:
+    return SERD_DOUBLE;
+  case EXESS_FLOAT:
+    return SERD_FLOAT;
+  case EXESS_INTEGER:
+  case EXESS_NON_POSITIVE_INTEGER:
+  case EXESS_NEGATIVE_INTEGER:
+  case EXESS_LONG:
+    return SERD_LONG;
+  case EXESS_INT:
+    return SERD_INT;
+  case EXESS_SHORT:
+    return SERD_SHORT;
+  case EXESS_BYTE:
+    return SERD_BYTE;
+  case EXESS_NON_NEGATIVE_INTEGER:
+  case EXESS_ULONG:
+    return SERD_ULONG;
+  case EXESS_UINT:
+    return SERD_UINT;
+  case EXESS_USHORT:
+    return SERD_USHORT;
+  case EXESS_UBYTE:
+    return SERD_UBYTE;
+  case EXESS_POSITIVE_INTEGER:
+    return SERD_ULONG;
+
+  case EXESS_DURATION:
+  case EXESS_DATETIME:
+  case EXESS_TIME:
+  case EXESS_DATE:
+  case EXESS_HEX:
+  case EXESS_BASE64:
+    break;
+  }
+
+  return SERD_NOTHING;
+}
+
 SerdWriteResult
-serd_node_construct_boolean(const size_t buf_size,
-                            void* const  buf,
-                            const bool   value)
-{
-  char temp[EXESS_MAX_BOOLEAN_LENGTH + 1] = {0};
+serd_node_construct_value(const size_t    buf_size,
+                          void* const     buf,
+                          const SerdValue value)
+{
+  char        temp[EXESS_MAX_DOUBLE_LENGTH + 1] = {0};
+  ExessResult r                                 = {EXESS_UNSUPPORTED, 0u};
+  switch (value.type) {
+  case SERD_NOTHING:
+    return result(SERD_BAD_ARG, 0u);
+  case SERD_BOOL:
+    r = exess_write_boolean(value.data.as_bool, sizeof(temp), temp);
+    break;
+  case SERD_DOUBLE:
+    r = exess_write_double(value.data.as_double, sizeof(temp), temp);
+    break;
+  case SERD_FLOAT:
+    r = exess_write_float(value.data.as_float, sizeof(temp), temp);
+    break;
+  case SERD_LONG:
+    r = exess_write_long(value.data.as_long, sizeof(temp), temp);
+    break;
+  case SERD_INT:
+    r = exess_write_int(value.data.as_int, sizeof(temp), temp);
+    break;
+  case SERD_SHORT:
+    r = exess_write_short(value.data.as_short, sizeof(temp), temp);
+    break;
+  case SERD_BYTE:
+    r = exess_write_byte(value.data.as_byte, sizeof(temp), temp);
+    break;
+  case SERD_ULONG:
+    r = exess_write_ulong(value.data.as_ulong, sizeof(temp), temp);
+    break;
+  case SERD_UINT:
+    r = exess_write_uint(value.data.as_uint, sizeof(temp), temp);
+    break;
+  case SERD_USHORT:
+    r = exess_write_ushort(value.data.as_ushort, sizeof(temp), temp);
+    break;
+  case SERD_UBYTE:
+    r = exess_write_ubyte(value.data.as_ubyte, sizeof(temp), temp);
+    break;
+  }
 
-  const ExessResult r = exess_write_boolean(value, sizeof(temp), temp);
   MUST_SUCCEED(r.status); // The only error is buffer overrun
 
+  const char* const datatype_uri = value_type_uri(value.type);
+  assert(datatype_uri);
+
   return serd_node_construct_literal(buf_size,
                                      buf,
                                      SERD_SUBSTRING(temp, r.count),
                                      SERD_HAS_DATATYPE,
-                                     SERD_STRING(EXESS_XSD_URI "boolean"));
+                                     SERD_OPTIONAL_STRING(datatype_uri));
 }
 
 SerdWriteResult
@@ -316,40 +431,6 @@ serd_node_construct_decimal(const size_t buf_size,
 }
 
 SerdWriteResult
-serd_node_construct_double(const size_t buf_size,
-                           void* const  buf,
-                           const double value)
-{
-  char temp[EXESS_MAX_DOUBLE_LENGTH + 1] = {0};
-
-  const ExessResult r = exess_write_double(value, sizeof(temp), temp);
-  MUST_SUCCEED(r.status); // The only error is buffer overrun
-
-  return serd_node_construct_literal(buf_size,
-                                     buf,
-                                     SERD_SUBSTRING(temp, r.count),
-                                     SERD_HAS_DATATYPE,
-                                     SERD_STRING(EXESS_XSD_URI "double"));
-}
-
-SerdWriteResult
-serd_node_construct_float(const size_t buf_size,
-                          void* const  buf,
-                          const float  value)
-{
-  char temp[EXESS_MAX_FLOAT_LENGTH + 1] = {0};
-
-  const ExessResult r = exess_write_float(value, sizeof(temp), temp);
-  MUST_SUCCEED(r.status); // The only error is buffer overrun
-
-  return serd_node_construct_literal(buf_size,
-                                     buf,
-                                     SERD_SUBSTRING(temp, r.count),
-                                     SERD_HAS_DATATYPE,
-                                     SERD_STRING(EXESS_XSD_URI "float"));
-}
-
-SerdWriteResult
 serd_node_construct_integer(const size_t  buf_size,
                             void* const   buf,
                             const int64_t value)
@@ -503,91 +584,69 @@ serd_new_literal(SerdAllocator* const allocator,
   return serd_node_new(allocator, SERD_LITERAL, str, flags, meta);
 }
 
-ExessResult
-serd_node_get_value_as(const SerdNode* const node,
-                       const ExessDatatype   value_type,
-                       const size_t          value_size,
-                       void* const           value)
+SerdValue
+serd_get_value(const SerdNode* const node)
 {
+  assert(node);
+
   const SerdNode* const datatype_node = serd_node_datatype(node);
 
-  const ExessDatatype node_type =
+  const ExessDatatype datatype =
     datatype_node ? exess_datatype_from_uri(serd_node_string(datatype_node))
                   : EXESS_NOTHING;
 
-  if (node_type == EXESS_NOTHING ||
-      (node_type == EXESS_HEX && value_type == EXESS_BASE64) ||
-      (node_type == EXESS_BASE64 && value_type == EXESS_HEX)) {
-    // Try to read the large or untyped node string directly into the result
-    const ExessVariableResult vr =
-      exess_read_value(value_type, value_size, value, serd_node_string(node));
-
-    const ExessResult r = {vr.status, vr.write_count};
-    return r;
+  const SerdValueType value_type = datatype_value_type(datatype);
+  if (value_type == SERD_NOTHING) {
+    return serd_nothing();
   }
 
-  // Read the (smallish) value from the node
-  ExessValue                node_value = {false};
-  const ExessVariableResult vr         = exess_read_value(
-    node_type, sizeof(node_value), &node_value, serd_node_string(node));
+  ExessValue                value = {false};
+  const ExessVariableResult vr =
+    exess_read_value(datatype, sizeof(value), &value, serd_node_string(node));
 
   if (vr.status) {
-    const ExessResult r = {vr.status, 0u};
-    return r;
+    return serd_nothing();
   }
 
-  // Coerce value to the desired type if possible
-  return exess_value_coerce(EXESS_REDUCE_PRECISION,
-                            node_type,
-                            vr.write_count,
-                            &node_value,
-                            value_type,
-                            value_size,
-                            value);
-}
-
-bool
-serd_get_boolean(const SerdNode* const node)
-{
-  assert(node);
-
-  bool value = false;
-  serd_node_get_value_as(node, EXESS_BOOLEAN, sizeof(value), &value);
-
-  return value;
-}
-
-double
-serd_get_double(const SerdNode* const node)
-{
-  assert(node);
-
-  double value = (double)NAN; // NOLINT(google-readability-casting)
-  serd_node_get_value_as(node, EXESS_DOUBLE, sizeof(value), &value);
+  SerdValue result = {value_type, {false}};
+  memcpy(&result.data, &value, vr.write_count);
 
-  return value;
+  return result;
 }
 
-float
-serd_get_float(const SerdNode* const node)
+SerdValue
+serd_get_value_as(const SerdNode* const node,
+                  const SerdValueType   type,
+                  const bool            lossy)
 {
-  assert(node);
+  // Get the value as it is
+  const SerdValue value = serd_get_value(node);
+  if (!value.type || value.type == type) {
+    return value;
+  }
 
-  float value = (float)NAN; // NOLINT(google-readability-casting)
-  serd_node_get_value_as(node, EXESS_FLOAT, sizeof(value), &value);
+  const ExessCoercions coercions =
+    lossy ? (EXESS_REDUCE_PRECISION | EXESS_ROUND | EXESS_TRUNCATE)
+          : EXESS_LOSSLESS;
 
-  return value;
-}
+  const ExessDatatype node_datatype = value_type_datatype(value.type);
+  const ExessDatatype datatype      = value_type_datatype(type);
+  SerdValue           result        = {type, {false}};
 
-int64_t
-serd_get_integer(const SerdNode* const node)
-{
-  assert(node);
+  // Coerce to the desired type
+  const ExessResult r = exess_value_coerce(coercions,
+                                           node_datatype,
+                                           exess_value_size(node_datatype),
+                                           &value.data,
+                                           datatype,
+                                           exess_value_size(datatype),
+                                           &result.data);
 
-  int64_t value = 0;
-  serd_node_get_value_as(node, EXESS_LONG, sizeof(value), &value);
+  if (r.status) {
+    result.type = SERD_NOTHING;
+  }
 
-  return value;
+  return result;
 }
 
 size_t
@@ -784,45 +843,13 @@ serd_new_file_uri(SerdAllocator* const allocator,
 }
 
 SerdNode*
-serd_new_double(SerdAllocator* const allocator, const double d)
-{
-  SerdWriteResult r    = serd_node_construct_double(0, NULL, d);
-  SerdNode* const node = serd_node_try_malloc(allocator, r);
-
-  if (node) {
-    r = serd_node_construct_double(r.count, node, d);
-    MUST_SUCCEED(r.status);
-    assert(serd_node_length(node) == strlen(serd_node_string(node)));
-    serd_node_check_padding(node);
-  }
-
-  return node;
-}
-
-SerdNode*
-serd_new_float(SerdAllocator* const allocator, const float f)
-{
-  SerdWriteResult r    = serd_node_construct_float(0, NULL, f);
-  SerdNode* const node = serd_node_try_malloc(allocator, r);
-
-  if (node) {
-    r = serd_node_construct_float(r.count, node, f);
-    MUST_SUCCEED(r.status);
-    assert(serd_node_length(node) == strlen(serd_node_string(node)));
-    serd_node_check_padding(node);
-  }
-
-  return node;
-}
-
-SerdNode*
-serd_new_boolean(SerdAllocator* const allocator, bool b)
+serd_new_value(SerdAllocator* const allocator, const SerdValue value)
 {
-  SerdWriteResult r    = serd_node_construct_boolean(0, NULL, b);
+  SerdWriteResult r    = serd_node_construct_value(0, NULL, value);
   SerdNode* const node = serd_node_try_malloc(allocator, r);
 
   if (node) {
-    r = serd_node_construct_boolean(r.count, node, b);
+    r = serd_node_construct_value(r.count, node, value);
     MUST_SUCCEED(r.status);
     assert(serd_node_length(node) == strlen(serd_node_string(node)));
     serd_node_check_padding(node);
diff --git a/src/node.h b/src/node.h
index 751b827a..4e40c530 100644
--- a/src/node.h
+++ b/src/node.h
@@ -17,7 +17,6 @@
 #ifndef SERD_NODE_H
 #define SERD_NODE_H
 
-#include "exess/exess.h"
 #include "serd/serd.h"
 
 #include <assert.h>
@@ -121,10 +120,4 @@ serd_node_total_size(const SerdNode* SERD_NONNULL node);
 void
 serd_node_zero_pad(SerdNode* SERD_NONNULL node);
 
-ExessResult
-serd_node_get_value_as(const SerdNode* SERD_NONNULL node,
-                       ExessDatatype                value_type,
-                       size_t                       value_size,
-                       void* SERD_NONNULL           value);
-
 #endif // SERD_NODE_H
diff --git a/src/nodes.c b/src/nodes.c
index 90dd4f2c..c048863b 100644
--- a/src/nodes.c
+++ b/src/nodes.c
@@ -415,12 +415,12 @@ try_intern(SerdNodes* const      nodes,
 }
 
 const SerdNode*
-serd_nodes_boolean(SerdNodes* const nodes, bool value)
+serd_nodes_value(SerdNodes* const nodes, const SerdValue value)
 {
   StaticNode key = empty_static_node;
 
   return try_intern(
-    nodes, serd_node_construct_boolean(sizeof(key), &key, value), &key.node);
+    nodes, serd_node_construct_value(sizeof(key), &key, value), &key.node);
 }
 
 const SerdNode*
@@ -433,24 +433,6 @@ serd_nodes_decimal(SerdNodes* const nodes, const double value)
 }
 
 const SerdNode*
-serd_nodes_double(SerdNodes* const nodes, const double value)
-{
-  StaticNode key = empty_static_node;
-
-  return try_intern(
-    nodes, serd_node_construct_double(sizeof(key), &key, value), &key.node);
-}
-
-const SerdNode*
-serd_nodes_float(SerdNodes* const nodes, const float value)
-{
-  StaticNode key = empty_static_node;
-
-  return try_intern(
-    nodes, serd_node_construct_float(sizeof(key), &key, value), &key.node);
-}
-
-const SerdNode*
 serd_nodes_integer(SerdNodes* const nodes, const int64_t value)
 {
   StaticNode key = empty_static_node;
diff --git a/src/value.c b/src/value.c
new file mode 100644
index 00000000..bd6320bf
--- /dev/null
+++ b/src/value.c
@@ -0,0 +1,114 @@
+/*
+  Copyright 2022 David Robillard <d@drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+#include "serd/serd.h"
+
+#include <stdbool.h>
+#include <stdint.h>
+
+SerdValue
+serd_nothing(void)
+{
+  static const SerdValue value = {SERD_NOTHING, {0}};
+  return value;
+}
+
+SerdValue
+serd_bool(const bool v)
+{
+  const SerdValue value = {SERD_BOOL, {v}};
+  return value;
+}
+
+SerdValue
+serd_double(const double v)
+{
+  SerdValue value      = {SERD_DOUBLE, {0}};
+  value.data.as_double = v;
+  return value;
+}
+
+SerdValue
+serd_float(const float v)
+{
+  SerdValue value     = {SERD_FLOAT, {0}};
+  value.data.as_float = v;
+  return value;
+}
+
+SerdValue
+serd_long(const int64_t v)
+{
+  SerdValue value    = {SERD_LONG, {0}};
+  value.data.as_long = v;
+  return value;
+}
+
+SerdValue
+serd_int(const int32_t v)
+{
+  SerdValue value   = {SERD_INT, {0}};
+  value.data.as_int = v;
+  return value;
+}
+
+SerdValue
+serd_short(const int16_t v)
+{
+  SerdValue value     = {SERD_SHORT, {0}};
+  value.data.as_short = v;
+  return value;
+}
+
+SerdValue
+serd_byte(const int8_t v)
+{
+  SerdValue value    = {SERD_BYTE, {0}};
+  value.data.as_byte = v;
+  return value;
+}
+
+SerdValue
+serd_ulong(const uint64_t v)
+{
+  SerdValue value     = {SERD_ULONG, {0}};
+  value.data.as_ulong = v;
+  return value;
+}
+
+SerdValue
+serd_uint(const uint32_t v)
+{
+  SerdValue value    = {SERD_UINT, {0}};
+  value.data.as_uint = v;
+  return value;
+}
+
+SerdValue
+serd_ushort(const uint16_t v)
+{
+  SerdValue value      = {SERD_USHORT, {0}};
+  value.data.as_ushort = v;
+  return value;
+}
+
+SerdValue
+serd_ubyte(const uint8_t v)
+{
+  SerdValue value     = {SERD_UBYTE, {0}};
+  value.data.as_ubyte = v;
+  return value;
+}
diff --git a/test/test_node.c b/test/test_node.c
index c1d39053..5cba7013 100644
--- a/test/test_node.c
+++ b/test/test_node.c
@@ -57,54 +57,156 @@
 #endif
 
 static void
+test_value(void)
+{
+  static const double double_one = 1.0;
+  static const float  float_two  = 2.0f;
+
+  SerdNode* const null_node   = serd_new_value(NULL, serd_nothing());
+  SerdNode* const bool_node   = serd_new_value(NULL, serd_bool(false));
+  SerdNode* const double_node = serd_new_value(NULL, serd_double(1.0));
+  SerdNode* const float_node  = serd_new_value(NULL, serd_float(2.0f));
+  SerdNode* const long_node   = serd_new_value(NULL, serd_long(3));
+  SerdNode* const int_node    = serd_new_value(NULL, serd_int(4));
+  SerdNode* const short_node  = serd_new_value(NULL, serd_short(5));
+  SerdNode* const byte_node   = serd_new_value(NULL, serd_byte(6));
+  SerdNode* const ulong_node  = serd_new_value(NULL, serd_ulong(7u));
+  SerdNode* const uint_node   = serd_new_value(NULL, serd_uint(8u));
+  SerdNode* const ushort_node = serd_new_value(NULL, serd_ushort(9u));
+  SerdNode* const ubyte_node  = serd_new_value(NULL, serd_ubyte(10u));
+
+  assert(!null_node);
+
+  assert(!strcmp(serd_node_string(bool_node), "false"));
+  assert(serd_get_value(bool_node).type == SERD_BOOL);
+  assert(serd_get_value(bool_node).data.as_bool == false);
+
+  assert(!strcmp(serd_node_string(double_node), "1.0E0"));
+  assert(serd_get_value(double_node).type == SERD_DOUBLE);
+  {
+    const double double_value = serd_get_value(double_node).data.as_double;
+    assert(!memcmp(&double_value, &double_one, sizeof(double)));
+  }
+
+  assert(!strcmp(serd_node_string(float_node), "2.0E0"));
+  assert(serd_get_value(float_node).type == SERD_FLOAT);
+  {
+    const float float_value = serd_get_value(float_node).data.as_float;
+    assert(!memcmp(&float_value, &float_two, sizeof(float)));
+  }
+
+  assert(!strcmp(serd_node_string(long_node), "3"));
+  assert(serd_get_value(long_node).type == SERD_LONG);
+  assert(serd_get_value(long_node).data.as_long == 3);
+
+  assert(!strcmp(serd_node_string(int_node), "4"));
+  assert(serd_get_value(int_node).type == SERD_INT);
+  assert(serd_get_value(int_node).data.as_int == 4);
+
+  assert(!strcmp(serd_node_string(short_node), "5"));
+  assert(serd_get_value(short_node).type == SERD_SHORT);
+  assert(serd_get_value(short_node).data.as_short == 5);
+
+  assert(!strcmp(serd_node_string(byte_node), "6"));
+  assert(serd_get_value(byte_node).type == SERD_BYTE);
+  assert(serd_get_value(byte_node).data.as_byte == 6);
+
+  assert(!strcmp(serd_node_string(ulong_node), "7"));
+  assert(serd_get_value(ulong_node).type == SERD_ULONG);
+  assert(serd_get_value(ulong_node).data.as_ulong == 7u);
+
+  assert(!strcmp(serd_node_string(uint_node), "8"));
+  assert(serd_get_value(uint_node).type == SERD_UINT);
+  assert(serd_get_value(uint_node).data.as_uint == 8u);
+
+  assert(!strcmp(serd_node_string(ushort_node), "9"));
+  assert(serd_get_value(ushort_node).type == SERD_USHORT);
+  assert(serd_get_value(ushort_node).data.as_ushort == 9u);
+
+  assert(!strcmp(serd_node_string(ubyte_node), "10"));
+  assert(serd_get_value(ubyte_node).type == SERD_UBYTE);
+  assert(serd_get_value(ubyte_node).data.as_ubyte == 10u);
+
+  serd_node_free(NULL, bool_node);
+  serd_node_free(NULL, double_node);
+  serd_node_free(NULL, float_node);
+  serd_node_free(NULL, long_node);
+  serd_node_free(NULL, int_node);
+  serd_node_free(NULL, short_node);
+  serd_node_free(NULL, byte_node);
+  serd_node_free(NULL, ulong_node);
+  serd_node_free(NULL, uint_node);
+  serd_node_free(NULL, ushort_node);
+  serd_node_free(NULL, ubyte_node);
+}
+
+static void
 test_boolean(void)
 {
-  SerdNode* const true_node = serd_new_boolean(NULL, true);
-  assert(!strcmp(serd_node_string(true_node), "true"));
-  assert(serd_get_boolean(true_node));
-
-  const SerdNode* const true_datatype = serd_node_datatype(true_node);
-  assert(true_datatype);
-  assert(!strcmp(serd_node_string(true_datatype), NS_XSD "boolean"));
-  serd_node_free(NULL, true_node);
-
-  SerdNode* const false_node = serd_new_boolean(NULL, false);
-  assert(!strcmp(serd_node_string(false_node), "false"));
-  assert(!serd_get_boolean(false_node));
-
-  const SerdNode* const false_datatype = serd_node_datatype(false_node);
-  assert(false_datatype);
-  assert(!strcmp(serd_node_string(false_datatype), NS_XSD "boolean"));
-  serd_node_free(NULL, false_node);
+  {
+    SerdNode* const true_node = serd_new_value(NULL, serd_bool(true));
+    assert(true_node);
+    assert(!strcmp(serd_node_string(true_node), "true"));
+    assert(serd_get_value(true_node).data.as_bool);
+
+    const SerdNode* const true_datatype = serd_node_datatype(true_node);
+    assert(true_datatype);
+    assert(!strcmp(serd_node_string(true_datatype), NS_XSD "boolean"));
+    serd_node_free(NULL, true_node);
+  }
+  {
+    SerdNode* const false_node = serd_new_value(NULL, serd_bool(false));
+    assert(false_node);
+    assert(!strcmp(serd_node_string(false_node), "false"));
+    assert(!serd_get_value(false_node).data.as_bool);
+
+    const SerdNode* const false_datatype = serd_node_datatype(false_node);
+    assert(false_datatype);
+    assert(!strcmp(serd_node_string(false_datatype), NS_XSD "boolean"));
+    serd_node_free(NULL, false_node);
+  }
 }
 
 static void
-check_get_boolean(const char* string,
-                  const char* datatype_uri,
-                  const bool  expected)
+check_get_bool(const char*         string,
+               const char*         datatype_uri,
+               const bool          lossy,
+               const SerdValueType value_type,
+               const bool          expected)
 {
   SerdNode* const node = serd_new_literal(
     NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
 
   assert(node);
-  assert(serd_get_boolean(node) == expected);
+
+  const SerdValue value = serd_get_value_as(node, SERD_BOOL, lossy);
+
+  assert(value.type == value_type);
+  assert(value.data.as_bool == expected);
 
   serd_node_free(NULL, node);
 }
 
 static void
-test_get_boolean(void)
+test_get_bool(void)
 {
-  check_get_boolean("false", NS_XSD "boolean", false);
-  check_get_boolean("true", NS_XSD "boolean", true);
-  check_get_boolean("0", NS_XSD "boolean", false);
-  check_get_boolean("1", NS_XSD "boolean", true);
-  check_get_boolean("0", NS_XSD "integer", false);
-  check_get_boolean("1", NS_XSD "integer", true);
-  check_get_boolean("0.0", NS_XSD "double", false);
-  check_get_boolean("1.0", NS_XSD "double", true);
-  check_get_boolean("unknown", NS_XSD "string", false);
-  check_get_boolean("!invalid", NS_XSD "long", false);
+  check_get_bool("false", NS_XSD "boolean", false, SERD_BOOL, false);
+  check_get_bool("true", NS_XSD "boolean", false, SERD_BOOL, true);
+  check_get_bool("0", NS_XSD "boolean", false, SERD_BOOL, false);
+  check_get_bool("1", NS_XSD "boolean", false, SERD_BOOL, true);
+  check_get_bool("0", NS_XSD "integer", false, SERD_BOOL, false);
+  check_get_bool("1", NS_XSD "integer", false, SERD_BOOL, true);
+  check_get_bool("0.0", NS_XSD "double", false, SERD_BOOL, false);
+  check_get_bool("1.0", NS_XSD "double", false, SERD_BOOL, true);
+
+  check_get_bool("2", NS_XSD "integer", false, SERD_NOTHING, false);
+  check_get_bool("1.5", NS_XSD "double", false, SERD_NOTHING, false);
+
+  check_get_bool("2", NS_XSD "integer", true, SERD_BOOL, true);
+  check_get_bool("1.5", NS_XSD "double", true, SERD_BOOL, true);
+
+  check_get_bool("unknown", NS_XSD "string", true, SERD_NOTHING, false);
+  check_get_bool("!invalid", NS_XSD "long", true, SERD_NOTHING, false);
 }
 
 static void
@@ -134,8 +236,8 @@ test_decimal(void)
     assert(datatype);
     assert(!strcmp(serd_node_string(datatype), NS_XSD "decimal"));
 
-    const double value = serd_get_double(node);
-    assert(!memcmp(&value, &test_values[i], sizeof(value)));
+    const SerdValue value = serd_get_value(node);
+    assert(!memcmp(&value.data.as_double, &test_values[i], sizeof(double)));
     serd_node_free(NULL, node);
   }
 }
@@ -148,7 +250,7 @@ test_double(void)
     "0.0E0", "-0.0E0", "1.2E0", "-2.3E0", "4.56789E6"};
 
   for (size_t i = 0; i < sizeof(test_values) / sizeof(double); ++i) {
-    SerdNode*   node     = serd_new_double(NULL, test_values[i]);
+    SerdNode*   node     = serd_new_value(NULL, serd_double(test_values[i]));
     const char* node_str = serd_node_string(node);
     assert(!strcmp(node_str, test_strings[i]));
 
@@ -159,24 +261,35 @@ test_double(void)
     assert(datatype);
     assert(!strcmp(serd_node_string(datatype), NS_XSD "double"));
 
-    const double value = serd_get_double(node);
-    assert(!memcmp(&value, &test_values[i], sizeof(value)));
+    const SerdValue value = serd_get_value(node);
+    assert(!memcmp(&value.data.as_double, &test_values[i], sizeof(double)));
     serd_node_free(NULL, node);
   }
 }
 
 static void
-check_get_double(const char*  string,
-                 const char*  datatype_uri,
-                 const double expected)
+check_get_double(const char*         string,
+                 const char*         datatype_uri,
+                 const bool          lossy,
+                 const SerdValueType value_type,
+                 const double        expected)
 {
   SerdNode* const node = serd_new_literal(
     NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
 
   assert(node);
 
-  const double value = serd_get_double(node);
-  assert(!memcmp(&value, &expected, sizeof(value)));
+  const SerdValue value = serd_get_value_as(node, SERD_DOUBLE, lossy);
+
+  assert(value.type == value_type);
+
+  SERD_DISABLE_CONVERSION_WARNINGS
+
+  assert(value_type == SERD_NOTHING ||
+         ((isnan(value.data.as_double) && isnan(expected)) ||
+          !memcmp(&value.data.as_double, &expected, sizeof(double))));
+
+  SERD_RESTORE_WARNINGS
 
   serd_node_free(NULL, node);
 }
@@ -184,34 +297,19 @@ check_get_double(const char*  string,
 static void
 test_get_double(void)
 {
-  check_get_double("1.2", NS_XSD "double", 1.2);
-  check_get_double("-.5", NS_XSD "float", -0.5);
-  check_get_double("-67", NS_XSD "long", -67.0);
-  check_get_double("8.9", NS_XSD "decimal", 8.9);
-  check_get_double("false", NS_XSD "boolean", 0.0);
-  check_get_double("true", NS_XSD "boolean", 1.0);
-
-  static const uint8_t blob[] = {1u, 2u, 3u, 4u};
+  check_get_double("1.2", NS_XSD "double", false, SERD_DOUBLE, 1.2);
+  check_get_double("-.5", NS_XSD "float", false, SERD_DOUBLE, -0.5);
+  check_get_double("-67", NS_XSD "long", false, SERD_DOUBLE, -67.0);
+  check_get_double("67", NS_XSD "unsignedLong", false, SERD_DOUBLE, 67.0);
+  check_get_double("8.9", NS_XSD "decimal", false, SERD_DOUBLE, 8.9);
+  check_get_double("false", NS_XSD "boolean", false, SERD_DOUBLE, 0.0);
+  check_get_double("true", NS_XSD "boolean", false, SERD_DOUBLE, 1.0);
 
   SERD_DISABLE_CONVERSION_WARNINGS
-
-  SerdNode* const nan = serd_new_string(NULL, SERD_STRING("unknown"));
-  assert(isnan(serd_get_double(nan)));
-  serd_node_free(NULL, nan);
-
-  SerdNode* const invalid = serd_new_literal(NULL,
-                                             SERD_STRING("!invalid"),
-                                             SERD_HAS_DATATYPE,
-                                             SERD_STRING(NS_XSD "long"));
-
-  assert(isnan(serd_get_double(invalid)));
-  serd_node_free(NULL, invalid);
-
-  SerdNode* const base64 = serd_new_base64(NULL, blob, sizeof(blob));
-
-  assert(isnan(serd_get_double(base64)));
-  serd_node_free(NULL, base64);
-
+  check_get_double("str", NS_XSD "string", true, SERD_NOTHING, NAN);
+  check_get_double("!invalid", NS_XSD "long", true, SERD_NOTHING, NAN);
+  check_get_double("D3AD", NS_XSD "hexBinary", true, SERD_NOTHING, NAN);
+  check_get_double("Zm9v", NS_XSD "base64Binary", true, SERD_NOTHING, NAN);
   SERD_RESTORE_WARNINGS
 }
 
@@ -223,7 +321,7 @@ test_float(void)
     "0.0E0", "-0.0E0", "1.5E0", "-2.5E0", "4.56789E6"};
 
   for (size_t i = 0; i < sizeof(test_values) / sizeof(float); ++i) {
-    SerdNode*   node     = serd_new_float(NULL, test_values[i]);
+    SerdNode*   node     = serd_new_value(NULL, serd_float(test_values[i]));
     const char* node_str = serd_node_string(node);
     assert(!strcmp(node_str, test_strings[i]));
 
@@ -234,24 +332,35 @@ test_float(void)
     assert(datatype);
     assert(!strcmp(serd_node_string(datatype), NS_XSD "float"));
 
-    const float value = serd_get_float(node);
-    assert(!memcmp(&value, &test_values[i], sizeof(value)));
+    const SerdValue value = serd_get_value(node);
+    assert(!memcmp(&value.data.as_float, &test_values[i], sizeof(float)));
     serd_node_free(NULL, node);
   }
 }
 
 static void
-check_get_float(const char* string,
-                const char* datatype_uri,
-                const float expected)
+check_get_float(const char*         string,
+                const char*         datatype_uri,
+                const bool          lossy,
+                const SerdValueType value_type,
+                const float         expected)
 {
   SerdNode* const node = serd_new_literal(
     NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
 
   assert(node);
 
-  const float value = serd_get_float(node);
-  assert(!memcmp(&value, &expected, sizeof(value)));
+  const SerdValue value = serd_get_value_as(node, SERD_FLOAT, lossy);
+
+  assert(value.type == value_type);
+
+  SERD_DISABLE_CONVERSION_WARNINGS
+
+  assert(value_type == SERD_NOTHING ||
+         ((isnan(value.data.as_float) && isnan(expected)) ||
+          !memcmp(&value.data.as_float, &expected, sizeof(float))));
+
+  SERD_RESTORE_WARNINGS
 
   serd_node_free(NULL, node);
 }
@@ -259,29 +368,20 @@ check_get_float(const char* string,
 static void
 test_get_float(void)
 {
-  check_get_float("1.2", NS_XSD "float", 1.2f);
-  check_get_float("-.5", NS_XSD "float", -0.5f);
-  check_get_float("-67", NS_XSD "long", -67.0f);
-  check_get_float("1.5", NS_XSD "decimal", 1.5f);
-  check_get_float("false", NS_XSD "boolean", 0.0f);
-  check_get_float("true", NS_XSD "boolean", 1.0f);
-
-  SERD_DISABLE_CONVERSION_WARNINGS
+  check_get_float("1.2", NS_XSD "float", false, SERD_FLOAT, 1.2f);
+  check_get_float("-.5", NS_XSD "float", false, SERD_FLOAT, -0.5f);
+  check_get_float("-67", NS_XSD "long", false, SERD_FLOAT, -67.0f);
+  check_get_float("false", NS_XSD "boolean", false, SERD_FLOAT, 0.0f);
+  check_get_float("true", NS_XSD "boolean", false, SERD_FLOAT, 1.0f);
 
-  SerdNode* const nan = serd_new_string(NULL, SERD_STRING("unknown"));
-  assert(isnan(serd_get_float(nan)));
-  serd_node_free(NULL, nan);
-
-  SerdNode* const invalid = serd_new_literal(NULL,
-                                             SERD_STRING("!invalid"),
-                                             SERD_HAS_DATATYPE,
-                                             SERD_STRING(NS_XSD "long"));
-
-  assert(isnan(serd_get_double(invalid)));
+  check_get_float("1.5", NS_XSD "decimal", true, SERD_FLOAT, 1.5f);
 
+  SERD_DISABLE_CONVERSION_WARNINGS
+  check_get_float("str", NS_XSD "string", true, SERD_NOTHING, NAN);
+  check_get_float("!invalid", NS_XSD "long", true, SERD_NOTHING, NAN);
+  check_get_float("D3AD", NS_XSD "hexBinary", true, SERD_NOTHING, NAN);
+  check_get_float("Zm9v", NS_XSD "base64Binary", true, SERD_NOTHING, NAN);
   SERD_RESTORE_WARNINGS
-
-  serd_node_free(NULL, invalid);
 }
 
 static void
@@ -302,21 +402,27 @@ test_integer(void)
     assert(datatype);
     assert(!strcmp(serd_node_string(datatype), NS_XSD "integer"));
 
-    assert(serd_get_integer(node) == test_values[i]);
+    assert(serd_get_value(node).data.as_long == test_values[i]);
     serd_node_free(NULL, node);
   }
 }
 
 static void
-check_get_integer(const char*   string,
-                  const char*   datatype_uri,
-                  const int64_t expected)
+check_get_integer(const char*         string,
+                  const char*         datatype_uri,
+                  const bool          lossy,
+                  const SerdValueType value_type,
+                  const int64_t       expected)
 {
   SerdNode* const node = serd_new_literal(
     NULL, SERD_STRING(string), SERD_HAS_DATATYPE, SERD_STRING(datatype_uri));
 
   assert(node);
-  assert(serd_get_integer(node) == expected);
+
+  const SerdValue value = serd_get_value_as(node, SERD_LONG, lossy);
+
+  assert(value.type == value_type);
+  assert(value_type == SERD_NOTHING || value.data.as_long == expected);
 
   serd_node_free(NULL, node);
 }
@@ -324,14 +430,23 @@ check_get_integer(const char*   string,
 static void
 test_get_integer(void)
 {
-  check_get_integer("12", NS_XSD "long", 12);
-  check_get_integer("-34", NS_XSD "long", -34);
-  check_get_integer("56", NS_XSD "integer", 56);
-  check_get_integer("false", NS_XSD "boolean", 0);
-  check_get_integer("true", NS_XSD "boolean", 1);
-  check_get_integer("78.0", NS_XSD "decimal", 78);
-  check_get_integer("unknown", NS_XSD "string", 0);
-  check_get_integer("!invalid", NS_XSD "long", 0);
+  check_get_integer("12", NS_XSD "long", false, SERD_LONG, 12);
+  check_get_integer("-34", NS_XSD "long", false, SERD_LONG, -34);
+  check_get_integer("56", NS_XSD "integer", false, SERD_LONG, 56);
+  check_get_integer("false", NS_XSD "boolean", false, SERD_LONG, 0);
+  check_get_integer("true", NS_XSD "boolean", false, SERD_LONG, 1);
+  check_get_integer("78.0", NS_XSD "decimal", false, SERD_LONG, 78);
+
+  check_get_integer("0", NS_XSD "nonPositiveInteger", false, SERD_LONG, 0);
+  check_get_integer("-1", NS_XSD "negativeInteger", false, SERD_LONG, -1);
+  check_get_integer("2", NS_XSD "nonNegativeInteger", false, SERD_LONG, 2);
+  check_get_integer("3", NS_XSD "positiveInteger", false, SERD_LONG, 3);
+
+  check_get_integer("78.5", NS_XSD "decimal", false, SERD_NOTHING, 0);
+  check_get_integer("78.5", NS_XSD "decimal", true, SERD_LONG, 78);
+
+  check_get_integer("unknown", NS_XSD "string", true, SERD_NOTHING, 0);
+  check_get_integer("!invalid", NS_XSD "long", true, SERD_NOTHING, 0);
 }
 
 static void
@@ -592,10 +707,11 @@ test_compare(void)
   SerdNode* hallo = serd_new_literal(
     NULL, SERD_STRING("Hallo"), SERD_HAS_LANGUAGE, SERD_STRING("de"));
 
-  SerdNode* hello    = serd_new_string(NULL, SERD_STRING("Hello"));
-  SerdNode* universe = serd_new_string(NULL, SERD_STRING("Universe"));
-  SerdNode* integer  = serd_new_integer(NULL, 4);
-  SerdNode* blank    = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b1"));
+  SerdNode* hello         = serd_new_string(NULL, SERD_STRING("Hello"));
+  SerdNode* universe      = serd_new_string(NULL, SERD_STRING("Universe"));
+  SerdNode* integer       = serd_new_integer(NULL, 4);
+  SerdNode* short_integer = serd_new_value(NULL, serd_short(4));
+  SerdNode* blank         = serd_new_token(NULL, SERD_BLANK, SERD_STRING("b1"));
 
   SerdNode* uri = serd_new_uri(NULL, SERD_STRING("http://example.org/"));
 
@@ -621,12 +737,14 @@ test_compare(void)
   assert(serd_node_compare(angst, angst_de) < 0);
   assert(serd_node_compare(angst_de, angst_en) < 0);
   assert(serd_node_compare(aardvark, badger) < 0);
+  assert(serd_node_compare(integer, short_integer) < 0);
 
+  serd_node_free(NULL, badger);
+  serd_node_free(NULL, aardvark);
   serd_node_free(NULL, uri);
   serd_node_free(NULL, blank);
+  serd_node_free(NULL, short_integer);
   serd_node_free(NULL, integer);
-  serd_node_free(NULL, badger);
-  serd_node_free(NULL, aardvark);
   serd_node_free(NULL, universe);
   serd_node_free(NULL, hello);
   serd_node_free(NULL, hallo);
@@ -639,8 +757,9 @@ test_compare(void)
 int
 main(void)
 {
+  test_value();
   test_boolean();
-  test_get_boolean();
+  test_get_bool();
   test_decimal();
   test_double();
   test_get_double();
diff --git a/test/test_node_syntax.c b/test/test_node_syntax.c
index 09037363..a8e0a163 100644
--- a/test/test_node_syntax.c
+++ b/test/test_node_syntax.c
@@ -130,12 +130,12 @@ test_common(SerdWorld* const world, const SerdSyntax syntax)
 
   assert(check(world,
                syntax,
-               serd_new_double(NULL, 1.25),
+               serd_new_value(NULL, serd_double(1.25)),
                "\"1.25E0\"^^<http://www.w3.org/2001/XMLSchema#double>"));
 
   assert(check(world,
                syntax,
-               serd_new_float(NULL, 1.25),
+               serd_new_value(NULL, serd_float(1.25f)),
                "\"1.25E0\"^^<http://www.w3.org/2001/XMLSchema#float>"));
 
   assert(
@@ -186,12 +186,12 @@ test_ntriples(void)
 
   assert(check(world,
                SERD_NTRIPLES,
-               serd_new_boolean(NULL, true),
+               serd_new_value(NULL, serd_bool(true)),
                "\"true\"^^<http://www.w3.org/2001/XMLSchema#boolean>"));
 
   assert(check(world,
                SERD_NTRIPLES,
-               serd_new_boolean(NULL, false),
+               serd_new_value(NULL, serd_bool(false)),
                "\"false\"^^<http://www.w3.org/2001/XMLSchema#boolean>"));
 
   serd_world_free(world);
@@ -212,8 +212,11 @@ test_turtle(void)
   assert(check(world, SERD_TURTLE, serd_new_decimal(NULL, 1.25), "1.25"));
   assert(check(world, SERD_TURTLE, serd_new_integer(NULL, 1234), "1234"));
 
-  assert(check(world, SERD_TURTLE, serd_new_boolean(NULL, true), "true"));
-  assert(check(world, SERD_TURTLE, serd_new_boolean(NULL, false), "false"));
+  assert(
+    check(world, SERD_TURTLE, serd_new_value(NULL, serd_bool(true)), "true"));
+
+  assert(
+    check(world, SERD_TURTLE, serd_new_value(NULL, serd_bool(false)), "false"));
 
   serd_world_free(world);
 }
diff --git a/test/test_nodes.c b/test/test_nodes.c
index 19dcee01..482c7727 100644
--- a/test/test_nodes.c
+++ b/test/test_nodes.c
@@ -232,10 +232,10 @@ test_boolean(void)
 
   SerdNodes* const nodes = serd_nodes_new(allocator);
 
-  const SerdNode* const false1 = serd_nodes_boolean(nodes, false);
-  const SerdNode* const false2 = serd_nodes_boolean(nodes, false);
-  const SerdNode* const true1  = serd_nodes_boolean(nodes, true);
-  const SerdNode* const true2  = serd_nodes_boolean(nodes, true);
+  const SerdNode* const false1 = serd_nodes_value(nodes, serd_bool(false));
+  const SerdNode* const false2 = serd_nodes_value(nodes, serd_bool(false));
+  const SerdNode* const true1  = serd_nodes_value(nodes, serd_bool(true));
+  const SerdNode* const true2  = serd_nodes_value(nodes, serd_bool(true));
 
   assert(false1 == false2);
   assert(true1 == true2);
@@ -285,8 +285,8 @@ test_double(void)
 
   SerdNodes* const nodes = serd_nodes_new(allocator);
 
-  const SerdNode* const a = serd_nodes_double(nodes, -1.2E3);
-  const SerdNode* const b = serd_nodes_double(nodes, -1.2E3);
+  const SerdNode* const a = serd_nodes_value(nodes, serd_double(-1.2E3));
+  const SerdNode* const b = serd_nodes_value(nodes, serd_double(-1.2E3));
 
   assert(a == b);
   assert(!strcmp(serd_node_string(a), "-1.2E3"));
@@ -303,8 +303,8 @@ test_float(void)
 
   SerdNodes* const nodes = serd_nodes_new(allocator);
 
-  const SerdNode* const a = serd_nodes_float(nodes, -1.2E3f);
-  const SerdNode* const b = serd_nodes_float(nodes, -1.2E3f);
+  const SerdNode* const a = serd_nodes_value(nodes, serd_float(-1.2E3f));
+  const SerdNode* const b = serd_nodes_value(nodes, serd_float(-1.2E3f));
 
   assert(a == b);
   assert(!strcmp(serd_node_string(a), "-1.2E3"));