diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fd9fac7..cd02584 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -30,8 +30,8 @@ jobs:
         # thumbv6m-none-eabi supports atomic, but not atomic CAS.
         # riscv32i-unknown-none-elf does not support atomic at all.
         target:
-          - thumbv6m-none-eabi
           - thumbv7m-none-eabi
+          - thumbv6m-none-eabi
           - riscv32i-unknown-none-elf
     runs-on: ubuntu-latest
     steps:
@@ -45,6 +45,9 @@ jobs:
         working-directory: valuable
       - run: cargo hack build --target ${{ matrix.target }} --feature-powerset --skip std,default
         working-directory: valuable-serde
+      # TODO: support no-std in valuable-json
+      # - run: cargo hack build --target ${{ matrix.target }} --feature-powerset --skip std,default
+      #   working-directory: valuable-json
 
   features:
     runs-on: ubuntu-latest
diff --git a/Cargo.toml b/Cargo.toml
index 92cffaf..a72d83c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "valuable",
     "valuable-derive",
+    "valuable-json",
     "valuable-serde",
     "tests",
 ]
diff --git a/valuable-json/Cargo.toml b/valuable-json/Cargo.toml
new file mode 100644
index 0000000..abd7e9c
--- /dev/null
+++ b/valuable-json/Cargo.toml
@@ -0,0 +1,20 @@
+[package]
+name = "valuable-json"
+version = "0.1.0"
+authors = ["Taiki Endo <te316e89@gmail.com>"]
+edition = "2018"
+license = "MIT"
+description = "JSON support for Valuable."
+
+[features]
+default = ["std"]
+
+# NOTE: Disabling `std` feature is not supported yet.
+std = ["valuable/std"]
+
+[dependencies]
+valuable = { version = "0.1", path = "../valuable", default-features = false }
+ryu = "1"
+
+[dev-dependencies]
+valuable = { version = "0.1", path = "../valuable", features = ["derive"] }
diff --git a/valuable-json/src/lib.rs b/valuable-json/src/lib.rs
new file mode 100644
index 0000000..8827c26
--- /dev/null
+++ b/valuable-json/src/lib.rs
@@ -0,0 +1,766 @@
+#![warn(
+    missing_debug_implementations,
+    missing_docs,
+    rust_2018_idioms,
+    unreachable_pub
+)]
+#![cfg(feature = "std")]
+
+//! JSON support for Valuable.
+//!
+//! # Examples
+//!
+//! ```
+//! use valuable::Valuable;
+//!
+//! #[derive(Valuable)]
+//! struct Point {
+//!     x: i32,
+//!     y: i32,
+//! }
+//!
+//! let point = Point { x: 1, y: 2 };
+//!
+//! assert_eq!(
+//!     valuable_json::to_string(&point).unwrap(),
+//!     r#"{"x":1,"y":2}"#,
+//! );
+//! ```
+
+use std::io;
+
+use valuable::*;
+
+macro_rules! try_block {
+    ($expr:expr) => {
+        (|| -> io::Result<_> {
+            $expr;
+            Ok(())
+        })()
+    };
+}
+
+// TODO: should we define our own error type?
+#[cold]
+fn invalid_data(msg: &str) -> io::Error {
+    io::Error::new(io::ErrorKind::InvalidData, msg)
+}
+
+/// Serialize the given value JSON into the IO stream.
+pub fn to_writer<W, V>(writer: W, value: &V) -> io::Result<()>
+where
+    W: io::Write,
+    V: ?Sized + Valuable,
+{
+    Serializer::new(writer).serialize(value)
+}
+
+/// Serialize the given value as pretty-printed JSON into the IO stream.
+pub fn to_writer_pretty<W, V>(writer: W, value: &V) -> io::Result<()>
+where
+    W: io::Write,
+    V: ?Sized + Valuable,
+{
+    Serializer::pretty(writer).serialize(value)
+}
+
+/// Serialize the given value as a byte vector of JSON.
+pub fn to_vec<V>(value: &V) -> io::Result<Vec<u8>>
+where
+    V: ?Sized + Valuable,
+{
+    let mut out = Vec::with_capacity(128);
+    to_writer(&mut out, value)?;
+    Ok(out)
+}
+
+/// Serialize the given value as a pretty-printed byte vector of JSON.
+pub fn to_vec_pretty<V>(value: &V) -> io::Result<Vec<u8>>
+where
+    V: ?Sized + Valuable,
+{
+    let mut out = Vec::with_capacity(128);
+    to_writer_pretty(&mut out, value)?;
+    Ok(out)
+}
+
+/// Serialize the given value as a string of JSON.
+pub fn to_string<V>(value: &V) -> io::Result<String>
+where
+    V: ?Sized + Valuable,
+{
+    let vec = to_vec(value)?;
+    if cfg!(debug_assertions) {
+        Ok(String::from_utf8(vec).unwrap())
+    } else {
+        // SAFETY: We do not emit invalid UTF-8.
+        Ok(unsafe { String::from_utf8_unchecked(vec) })
+    }
+}
+
+/// Serialize the given value as a pretty-printed string of JSON.
+pub fn to_string_pretty<V>(value: &V) -> io::Result<String>
+where
+    V: ?Sized + Valuable,
+{
+    let vec = to_vec_pretty(value)?;
+    if cfg!(debug_assertions) {
+        Ok(String::from_utf8(vec).unwrap())
+    } else {
+        // SAFETY: We do not emit invalid UTF-8.
+        Ok(unsafe { String::from_utf8_unchecked(vec) })
+    }
+}
+
+/// A JSON serializer.
+#[derive(Debug)]
+pub struct Serializer<W> {
+    out: W,
+    option: SerializerOption,
+    error: Option<io::Error>,
+}
+
+// TODO: Investigate what the better way to set these options is.
+#[derive(Debug)]
+struct SerializerOption {
+    reject_nan: bool,
+    escape_solidus: bool,
+    style: Option<Style>,
+}
+
+#[derive(Debug, Clone, Copy)]
+struct Style {
+    current_indent: usize,
+    indent_size: usize,
+}
+
+impl SerializerOption {
+    fn new(style: Option<Style>) -> Self {
+        Self {
+            style,
+            // Default behavior match serde_json.
+            reject_nan: false,
+            escape_solidus: false,
+        }
+    }
+}
+
+impl<W: io::Write> Serializer<W> {
+    /// Creates a new JSON serializer.
+    pub fn new(out: W) -> Self {
+        Self {
+            out,
+            option: SerializerOption::new(None),
+            error: None,
+        }
+    }
+
+    /// Creates a new JSON pretty print serializer.
+    pub fn pretty(out: W) -> Self {
+        Self {
+            out,
+            option: SerializerOption::new(Some(Style {
+                indent_size: 2,
+                current_indent: 0,
+            })),
+            error: None,
+        }
+    }
+
+    /// Return an error when encountered to NaN or infinity.
+    /// By default, valuable-json, serializes NaN and infinity as null.
+    pub fn reject_nan(&mut self) -> &mut Self {
+        self.option.reject_nan = true;
+        self
+    }
+
+    /// Escape solidus (aka slashes, `/`).
+    /// By default, valuable-json serializes solidus without escape.
+    pub fn escape_solidus(&mut self) -> &mut Self {
+        self.option.escape_solidus = true;
+        self
+    }
+
+    /// Serializes the given value as a JSON.
+    pub fn serialize<V>(&mut self, value: &V) -> io::Result<()>
+    where
+        V: ?Sized + Valuable,
+    {
+        valuable::visit(value, self);
+        if let Some(e) = self.error.take() {
+            return Err(e);
+        }
+        Ok(())
+    }
+
+    fn increment_ident(&mut self) {
+        if let Some(style) = &mut self.option.style {
+            style.current_indent += 1;
+        }
+    }
+
+    fn decrement_ident(&mut self) {
+        if let Some(style) = &mut self.option.style {
+            style.current_indent -= 1;
+        }
+    }
+
+    fn push_indent(&mut self) -> io::Result<()> {
+        if let Some(style) = self.option.style {
+            for _ in 0..style.current_indent * style.indent_size {
+                self.push_u8(b' ')?;
+            }
+        }
+        Ok(())
+    }
+
+    fn push_newline(&mut self) -> io::Result<()> {
+        if self.option.style.is_some() {
+            self.push_u8(b'\n')?;
+        }
+        Ok(())
+    }
+
+    fn push_space(&mut self) -> io::Result<()> {
+        if self.option.style.is_some() {
+            self.push_u8(b' ')?;
+        }
+        Ok(())
+    }
+
+    fn push_u8(&mut self, byte: u8) -> io::Result<()> {
+        self.push_bytes(&[byte])
+    }
+
+    fn push_bytes(&mut self, bytes: &[u8]) -> io::Result<()> {
+        self.out.write_all(bytes)
+    }
+
+    fn push_finite_float(&mut self, n: impl ryu::Float) -> io::Result<()> {
+        let mut buffer = ryu::Buffer::new();
+        let s = buffer.format_finite(n);
+        self.push_bytes(s.as_bytes())
+    }
+
+    fn push_null(&mut self) -> io::Result<()> {
+        self.push_bytes(b"null")
+    }
+
+    fn push_escaped_string(&mut self, s: &str) -> io::Result<()> {
+        self.start_string()?;
+
+        let bytes = s.as_bytes();
+
+        let mut start = 0;
+
+        for (i, &byte) in bytes.iter().enumerate() {
+            let escape = escape(byte, self.option.escape_solidus);
+
+            if matches!(escape, Escape::None) {
+                continue;
+            }
+
+            if start < i {
+                self.push_bytes(&bytes[start..i])?;
+            }
+
+            match escape {
+                Escape::Char(bytes) => self.push_bytes(&bytes)?,
+                Escape::Control(bytes) => self.push_bytes(&bytes)?,
+                Escape::None => unreachable!(),
+            }
+
+            start = i + 1;
+        }
+
+        if start != bytes.len() {
+            self.push_bytes(&bytes[start..])?;
+        }
+
+        self.end_string()
+    }
+
+    fn start_string(&mut self) -> io::Result<()> {
+        self.push_u8(b'"')
+    }
+
+    fn end_string(&mut self) -> io::Result<()> {
+        self.push_u8(b'"')
+    }
+
+    /// Starts serializing a JSON array.
+    fn start_array(&mut self) -> io::Result<()> {
+        self.push_u8(b'[')?;
+        self.push_newline()?;
+        self.increment_ident();
+        Ok(())
+    }
+
+    /// Finishes serializing a JSON array.
+    fn end_array(&mut self, is_empty: bool) -> io::Result<()> {
+        if let Some(e) = self.error.take() {
+            return Err(e);
+        }
+        if is_empty {
+            self.push_u8(b'[')?;
+        } else {
+            self.push_newline()?;
+            self.decrement_ident();
+            self.push_indent()?;
+        }
+        self.push_u8(b']')
+    }
+
+    /// Starts serializing a JSON object.
+    fn start_object(&mut self) -> io::Result<()> {
+        self.push_u8(b'{')?;
+        self.push_newline()?;
+        self.increment_ident();
+        Ok(())
+    }
+
+    /// Finishes serializing a JSON object.
+    fn end_object(&mut self, is_empty: bool) -> io::Result<()> {
+        if let Some(e) = self.error.take() {
+            return Err(e);
+        }
+        if is_empty {
+            self.push_u8(b'{')?;
+        } else {
+            self.push_newline()?;
+            self.decrement_ident();
+            self.push_indent()?;
+        }
+        self.push_u8(b'}')
+    }
+
+    fn visit_value_inner(&mut self, value: Value<'_>, is_field: bool) -> io::Result<()> {
+        macro_rules! visit_num {
+            ($n:expr) => {
+                if is_field {
+                    self.start_string()?;
+                    write!(self.out, "{}", $n)?;
+                    self.end_string()?;
+                } else {
+                    write!(self.out, "{}", $n)?;
+                }
+            };
+        }
+        match value {
+            Value::Listable(l) => {
+                if is_field {
+                    return Err(invalid_data("list cannot be a key"));
+                }
+                let mut v = VisitStructure {
+                    first: true,
+                    inner: self,
+                    kind: ValueKind::List,
+                };
+                l.visit(&mut v);
+                v.inner.end_array(v.first)?;
+            }
+            Value::Mappable(m) => {
+                if is_field {
+                    return Err(invalid_data("map cannot be a key"));
+                }
+                let mut v = VisitStructure {
+                    first: true,
+                    inner: self,
+                    kind: ValueKind::Map,
+                };
+                m.visit(&mut v);
+                v.inner.end_object(v.first)?;
+            }
+            Value::Structable(s) => {
+                if is_field {
+                    return Err(invalid_data("struct cannot be a key"));
+                }
+                if s.definition().fields().is_named() {
+                    let mut v = VisitStructure {
+                        first: true,
+                        inner: self,
+                        kind: ValueKind::Named,
+                    };
+                    s.visit(&mut v);
+                    v.inner.end_object(v.first)?;
+                } else {
+                    let mut v = VisitStructure {
+                        first: true,
+                        inner: self,
+                        kind: ValueKind::Unnamed,
+                    };
+                    s.visit(&mut v);
+                    v.inner.end_array(v.first)?;
+                }
+            }
+            Value::Enumerable(e) => {
+                if is_field {
+                    return Err(invalid_data("enum cannot be a key"));
+                }
+
+                self.visit_key(&mut true, Value::String(e.variant().name()))?;
+
+                if e.variant().is_named_fields() {
+                    let mut v = VisitStructure {
+                        first: true,
+                        inner: self,
+                        kind: ValueKind::Named,
+                    };
+                    e.visit(&mut v);
+                    v.inner.end_object(v.first)?;
+                } else {
+                    let mut v = VisitStructure {
+                        first: true,
+                        inner: self,
+                        kind: ValueKind::Unnamed,
+                    };
+                    e.visit(&mut v);
+                    v.inner.end_array(v.first)?;
+                }
+
+                self.end_object(false)?;
+            }
+            Value::Tuplable(t) => {
+                if is_field {
+                    let msg = if t.definition().is_unit() {
+                        "unit cannot be a key"
+                    } else {
+                        "tuple cannot be a key"
+                    };
+                    return Err(invalid_data(msg));
+                }
+                if t.definition().is_unit() {
+                    self.push_null()?;
+                } else {
+                    let mut v = VisitStructure {
+                        first: true,
+                        inner: self,
+                        kind: ValueKind::Unnamed,
+                    };
+                    t.visit(&mut v);
+                    v.inner.end_array(v.first)?;
+                }
+            }
+            Value::String(s) => {
+                self.push_escaped_string(s)?;
+            }
+            Value::Char(c) => {
+                self.push_escaped_string(&c.to_string())?;
+            }
+            Value::Path(p) => {
+                self.push_escaped_string(&p.display().to_string())?;
+            }
+            Value::Bool(b) => {
+                if is_field {
+                    return Err(invalid_data("bool cannot be a key"));
+                }
+                write!(self.out, "{}", b)?;
+            }
+            Value::I8(n) => {
+                visit_num!(n);
+            }
+            Value::I16(n) => {
+                visit_num!(n);
+            }
+            Value::I32(n) => {
+                visit_num!(n);
+            }
+            Value::I64(n) => {
+                visit_num!(n);
+            }
+            Value::I128(n) => {
+                visit_num!(n);
+            }
+            Value::Isize(n) => {
+                visit_num!(n);
+            }
+            Value::U8(n) => {
+                visit_num!(n);
+            }
+            Value::U16(n) => {
+                visit_num!(n);
+            }
+            Value::U32(n) => {
+                visit_num!(n);
+            }
+            Value::U64(n) => {
+                visit_num!(n);
+            }
+            Value::U128(n) => {
+                visit_num!(n);
+            }
+            Value::Usize(n) => {
+                visit_num!(n);
+            }
+            Value::F32(n) => {
+                if is_field {
+                    return Err(invalid_data("float cannot be a key"));
+                }
+                if n.is_finite() {
+                    self.push_finite_float(n)?;
+                } else if self.option.reject_nan {
+                    let msg = if n.is_nan() {
+                        "NaN cannot be a JSON value"
+                    } else {
+                        "infinity cannot be a JSON value"
+                    };
+                    return Err(invalid_data(msg));
+                } else {
+                    self.push_null()?;
+                }
+            }
+            Value::F64(n) => {
+                if is_field {
+                    return Err(invalid_data("float cannot be a key"));
+                }
+                if n.is_finite() {
+                    self.push_finite_float(n)?;
+                } else if self.option.reject_nan {
+                    let msg = if n.is_nan() {
+                        "NaN cannot be a JSON value"
+                    } else {
+                        "infinity cannot be a JSON value"
+                    };
+                    return Err(invalid_data(msg));
+                } else {
+                    self.push_null()?;
+                }
+            }
+            Value::Unit => {
+                self.push_null()?;
+            }
+            v => {
+                return Err(invalid_data(&format!("unsupported value kind: {:?}", v)));
+            }
+        }
+        Ok(())
+    }
+
+    fn visit_key(&mut self, first: &mut bool, key: Value<'_>) -> io::Result<()> {
+        if *first {
+            self.start_object()?;
+            *first = false;
+        } else {
+            self.push_u8(b',')?;
+            self.push_newline()?;
+        }
+        self.push_indent()?;
+        self.visit_value_inner(key, true)?;
+        self.push_u8(b':')?;
+        self.push_space()
+    }
+}
+
+impl<W: io::Write> Visit for Serializer<W> {
+    fn visit_value(&mut self, value: Value<'_>) {
+        if self.error.is_some() {
+            return;
+        }
+        if let Err(e) = self.visit_value_inner(value, false) {
+            self.error = Some(e);
+        }
+    }
+
+    fn visit_named_fields(&mut self, _: &NamedValues<'_>) {
+        if self.error.is_none() {
+            self.error = Some(invalid_data("value needs to call visit_value first"));
+        }
+    }
+
+    fn visit_unnamed_fields(&mut self, _: &[Value<'_>]) {
+        if self.error.is_none() {
+            self.error = Some(invalid_data("value needs to call visit_value first"));
+        }
+    }
+
+    fn visit_entry(&mut self, _: Value<'_>, _: Value<'_>) {
+        if self.error.is_none() {
+            self.error = Some(invalid_data("value needs to call visit_value first"));
+        }
+    }
+
+    fn visit_primitive_slice(&mut self, _: Slice<'_>) {
+        if self.error.is_none() {
+            self.error = Some(invalid_data("value needs to call visit_value first"));
+        }
+    }
+}
+
+struct VisitStructure<'a, W> {
+    first: bool,
+    inner: &'a mut Serializer<W>,
+    kind: ValueKind,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum ValueKind {
+    // `Value::Mappable`.
+    // Serialized as JSON object.
+    Map,
+    // `Value::Listable`.
+    // Serialized as JSON array.
+    List,
+    // `Structable` or `Enumerable` with named fields.
+    // Serialized as JSON object.
+    Named,
+    // `Structable` or `Enumerable` with unnamed fields, or `Tuplable`.
+    // Serialized as JSON array.
+    Unnamed,
+}
+
+impl ValueKind {
+    #[cold]
+    fn as_str(&self) -> &'static str {
+        match self {
+            Self::Map => "map",
+            Self::List => "list",
+            Self::Named => "named struct/variant",
+            Self::Unnamed => "unnamed struct/variant",
+        }
+    }
+}
+
+impl<W: io::Write> Visit for VisitStructure<'_, W> {
+    fn visit_value(&mut self, value: Value<'_>) {
+        if self.inner.error.is_some() {
+            return;
+        }
+        if self.kind != ValueKind::List {
+            self.inner.error = Some(invalid_data(&format!(
+                "visit_value in {}",
+                self.kind.as_str()
+            )));
+            return;
+        }
+        if let Err(e) = try_block!({
+            if self.first {
+                self.inner.start_array()?;
+                self.first = false;
+            } else {
+                self.inner.push_u8(b',')?;
+                self.inner.push_newline()?;
+            }
+            self.inner.push_indent()?;
+            self.inner.visit_value_inner(value, false)?;
+        }) {
+            self.inner.error = Some(e);
+        }
+    }
+
+    fn visit_entry(&mut self, key: Value<'_>, value: Value<'_>) {
+        if self.inner.error.is_some() {
+            return;
+        }
+        if self.kind != ValueKind::Map {
+            self.inner.error = Some(invalid_data(&format!(
+                "visit_entry in {}",
+                self.kind.as_str()
+            )));
+            return;
+        }
+
+        if let Err(e) = try_block!({
+            self.inner.visit_key(&mut self.first, key)?;
+            self.inner.visit_value_inner(value, false)?;
+        }) {
+            self.inner.error = Some(e);
+        }
+    }
+
+    fn visit_named_fields(&mut self, named_values: &NamedValues<'_>) {
+        if self.inner.error.is_some() {
+            return;
+        }
+        if self.kind != ValueKind::Named {
+            self.inner.error = Some(invalid_data(&format!(
+                "visit_named_fields in {}",
+                self.kind.as_str()
+            )));
+            return;
+        }
+        if let Err(e) = try_block!({
+            for (f, &v) in named_values {
+                self.inner
+                    .visit_key(&mut self.first, Value::String(f.name()))?;
+                self.inner.visit_value_inner(v, false)?;
+            }
+        }) {
+            self.inner.error = Some(e);
+        }
+    }
+
+    fn visit_unnamed_fields(&mut self, values: &[Value<'_>]) {
+        if self.inner.error.is_some() {
+            return;
+        }
+        if self.kind != ValueKind::Unnamed {
+            self.inner.error = Some(invalid_data(&format!(
+                "visit_unnamed_fields in {}",
+                self.kind.as_str()
+            )));
+            return;
+        }
+        if let Err(e) = try_block!({
+            for &v in values {
+                if self.first {
+                    self.inner.start_array()?;
+                    self.first = false;
+                } else {
+                    self.inner.push_u8(b',')?;
+                    self.inner.push_newline()?;
+                }
+                self.inner.push_indent()?;
+                self.inner.visit_value_inner(v, false)?;
+            }
+        }) {
+            self.inner.error = Some(e);
+        }
+    }
+}
+
+enum Escape {
+    Char([u8; 2]),
+    Control([u8; 6]),
+    None,
+}
+
+#[inline]
+fn escape(byte: u8, escape_solidus: bool) -> Escape {
+    Escape::Char(*match byte {
+        // quote (`"`)
+        b'"' => b"\\\"",
+        // reverse solidus (`\`)
+        b'\\' => b"\\\\",
+        // solidus (`/`)
+        b'/' => {
+            if !escape_solidus {
+                return Escape::None;
+            }
+            b"\\/"
+        }
+        // line feed character (`\n`)
+        b'\n' => b"\\n",
+        // carriage return character (`\r`)
+        b'\r' => b"\\r",
+        // tab character (`\t`)
+        b'\t' => b"\\t",
+        // backspace character (`\b`)
+        0x08 => b"\\b",
+        // form feed character (`\f`)
+        0x0C => b"\\f",
+        // control character (`\u00XX`).
+        // Based on https://github.com/serde-rs/json/blob/v1.0.64/src/ser.rs#L1790-L1801
+        0x00..=0x1F => {
+            static HEX: [u8; 16] = *b"0123456789abcdef";
+            return Escape::Control([
+                b'\\',
+                b'u',
+                b'0',
+                b'0',
+                HEX[(byte >> 4) as usize],
+                HEX[(byte & 0xF) as usize],
+            ]);
+        }
+        _ => return Escape::None,
+    })
+}
diff --git a/valuable-json/tests/test.rs b/valuable-json/tests/test.rs
new file mode 100644
index 0000000..3a110d2
--- /dev/null
+++ b/valuable-json/tests/test.rs
@@ -0,0 +1,604 @@
+use std::{collections::BTreeMap, path::Path};
+
+use valuable::*;
+use valuable_json::*;
+
+macro_rules! map {
+    ($($key:expr => $val:expr),* $(,)?) => {{
+        let mut _map = BTreeMap::new();
+        $(
+            _map.insert($key, $val);
+        )*
+        _map
+    }};
+}
+
+#[track_caller]
+fn assert_ser_compact<V>(value: V, expected: impl AsRef<str>)
+where
+    V: Valuable,
+{
+    let s = to_string(&value).unwrap();
+    assert_eq!(s, expected.as_ref());
+}
+
+#[track_caller]
+fn assert_ser_pretty<V>(value: V, expected: impl AsRef<str>)
+where
+    V: Valuable,
+{
+    let s = to_string_pretty(&value).unwrap();
+    assert_eq!(s, expected.as_ref());
+}
+
+#[track_caller]
+fn assert_ser_both<V>(value: V, expected: impl AsRef<str>)
+where
+    V: Valuable,
+{
+    assert_ser_compact(&value, expected.as_ref());
+    assert_ser_pretty(&value, expected);
+}
+
+#[test]
+fn test_bool() {
+    assert_ser_both(false, "false");
+    assert_ser_both(true, "true");
+}
+
+#[test]
+fn test_bool_key() {
+    let map = map!(
+        true => 1,
+        false => 0
+    );
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "bool cannot be a key"
+    );
+}
+
+#[test]
+fn test_int() {
+    macro_rules! assert_int {
+        ($($ty:ty),*) => {{
+            $(
+                assert_ser_both(<$ty>::MIN, <$ty>::MIN.to_string());
+                assert_ser_both(<$ty>::MAX, <$ty>::MAX.to_string());
+            )*
+        }};
+    }
+
+    assert_int!(i8, i16, i32, i64, i128, isize);
+    assert_int!(u8, u16, u32, u64, u128, usize);
+}
+
+#[test]
+fn test_int_key() {
+    macro_rules! assert_int_key {
+        ($($ty:ty),*) => {{
+            $(
+                assert_ser_compact(
+                    map!(
+                        <$ty>::MAX => (),
+                        <$ty>::MIN => (),
+                    ),
+                    to_string(&map!(
+                        <$ty>::MAX.to_string() => (),
+                        <$ty>::MIN.to_string() => (),
+                    ))
+                    .unwrap(),
+                );
+                assert_ser_pretty(
+                    map!(
+                        <$ty>::MAX => (),
+                        <$ty>::MIN => (),
+                    ),
+                    to_string_pretty(&map!(
+                        <$ty>::MAX.to_string() => (),
+                        <$ty>::MIN.to_string() => (),
+                    ))
+                    .unwrap(),
+                );
+            )*
+        }};
+    }
+
+    assert_int_key!(i8, i16, i32, i64, i128, isize);
+    assert_int_key!(u8, u16, u32, u64, u128, usize);
+}
+
+#[test]
+fn test_float() {
+    assert_ser_both(f32::MIN, "-3.4028235e38");
+    assert_ser_both(f32::MAX, "3.4028235e38");
+    assert_ser_both(f32::EPSILON, "1.1920929e-7");
+    assert_ser_both(f64::MIN, "-1.7976931348623157e308");
+    assert_ser_both(f64::MAX, "1.7976931348623157e308");
+    assert_ser_both(f64::EPSILON, "2.220446049250313e-16");
+}
+
+#[test]
+fn test_float_key() {
+    #[derive(PartialEq, Eq, PartialOrd, Ord)]
+    struct F32;
+    impl Valuable for F32 {
+        fn as_value(&self) -> Value<'_> {
+            Value::F32(1.0)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_value(self.as_value())
+        }
+    }
+
+    #[derive(PartialEq, Eq, PartialOrd, Ord)]
+    struct F64;
+    impl Valuable for F64 {
+        fn as_value(&self) -> Value<'_> {
+            Value::F64(1.0)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_value(self.as_value())
+        }
+    }
+
+    let map = map!(F32 => ());
+    assert_eq!(
+        to_string(&map).unwrap_err().to_string(),
+        "float cannot be a key"
+    );
+    let map = map!(F64 => ());
+    assert_eq!(
+        to_string(&map).unwrap_err().to_string(),
+        "float cannot be a key"
+    );
+}
+
+#[test]
+fn test_nonfinite_float_null() {
+    assert_ser_both(f32::NAN, "null");
+    assert_ser_both(f32::INFINITY, "null");
+    assert_ser_both(f32::NEG_INFINITY, "null");
+    assert_ser_both(f64::NAN, "null");
+    assert_ser_both(f64::INFINITY, "null");
+    assert_ser_both(f64::NEG_INFINITY, "null");
+}
+
+#[test]
+fn test_nonfinite_float_error() {
+    let mut out = vec![];
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f32::NAN)
+            .unwrap_err()
+            .to_string(),
+        "NaN cannot be a JSON value"
+    );
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f32::INFINITY)
+            .unwrap_err()
+            .to_string(),
+        "infinity cannot be a JSON value"
+    );
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f32::NEG_INFINITY)
+            .unwrap_err()
+            .to_string(),
+        "infinity cannot be a JSON value"
+    );
+
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f64::NAN)
+            .unwrap_err()
+            .to_string(),
+        "NaN cannot be a JSON value"
+    );
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f64::INFINITY)
+            .unwrap_err()
+            .to_string(),
+        "infinity cannot be a JSON value"
+    );
+    assert_eq!(
+        Serializer::new(&mut out)
+            .reject_nan()
+            .serialize(&f64::NEG_INFINITY)
+            .unwrap_err()
+            .to_string(),
+        "infinity cannot be a JSON value"
+    );
+}
+
+#[test]
+fn test_char() {
+    assert_ser_both('a', "\"a\"");
+    assert_ser_both('"', "\"\\\"\"");
+    assert_ser_both('\\', "\"\\\\\"");
+    assert_ser_both('/', "\"/\"");
+    assert_ser_both('\n', "\"\\n\"");
+    assert_ser_both('\r', "\"\\r\"");
+    assert_ser_both('\t', "\"\\t\"");
+    assert_ser_both('\x08', "\"\\b\"");
+    assert_ser_both('\x0C', "\"\\f\"");
+    assert_ser_both('\x00', "\"\\u0000\"");
+    assert_ser_both('\x1F', "\"\\u001f\"");
+    assert_ser_both('\u{3A3}', "\"\u{3A3}\"");
+}
+
+#[test]
+fn test_char_key() {
+    assert_ser_compact(map!('a' => ()), to_string(&map!("a" => ())).unwrap());
+    assert_ser_pretty(map!('a' => ()), to_string_pretty(&map!("a" => ())).unwrap());
+}
+
+#[test]
+fn test_escape_solidus() {
+    let mut out = vec![];
+    Serializer::new(&mut out)
+        .escape_solidus()
+        .serialize(&"/")
+        .unwrap();
+    assert_eq!(String::from_utf8(out).unwrap(), "\"\\/\"");
+}
+
+#[test]
+fn test_str() {
+    assert_ser_both("", "\"\"");
+    assert_ser_both("a", "\"a\"");
+}
+
+#[test]
+fn test_path() {
+    assert_ser_both(Path::new("a/b/c.txt"), "\"a/b/c.txt\"");
+}
+
+#[test]
+fn test_path_key() {
+    assert_ser_compact(
+        map!(Path::new("a.txt") => ()),
+        to_string(&map!("a.txt" => ())).unwrap(),
+    );
+    assert_ser_pretty(
+        map!(Path::new("a.txt") => ()),
+        to_string_pretty(&map!("a.txt" => ())).unwrap(),
+    );
+}
+
+#[test]
+fn test_option() {
+    assert_ser_both(None::<u8>, "null");
+    assert_ser_both(Some(1), "1");
+    assert_ser_both(Some(()), "null");
+    assert_ser_compact(Some(vec![0, 1]), "[0,1]");
+    assert_ser_pretty(Some(vec![0, 1]), "[\n  0,\n  1\n]");
+}
+
+#[test]
+fn test_unit() {
+    assert_ser_both((), "null");
+}
+
+#[test]
+fn test_unit_key() {
+    let map = map!(
+        () => (),
+    );
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "unit cannot be a key"
+    );
+}
+
+#[test]
+fn test_tuple() {
+    assert_ser_compact((1,), r#"[1]"#);
+    assert_ser_pretty((1,), "[\n  1\n]");
+    assert_ser_compact(("a", 'b'), r#"["a","b"]"#);
+    assert_ser_pretty(("a", 'b'), "[\n  \"a\",\n  \"b\"\n]");
+}
+
+#[test]
+fn test_tuple_key() {
+    let map = map!(
+        ("a",) => (),
+    );
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "tuple cannot be a key"
+    );
+}
+
+#[test]
+fn test_list() {
+    assert_ser_both(Vec::<u8>::new(), r#"[]"#);
+    assert_ser_compact(vec![1, 2, 3], r#"[1,2,3]"#);
+    assert_ser_pretty(vec![1, 2, 3], "[\n  1,\n  2,\n  3\n]");
+
+    assert_ser_compact(vec![1, 2], r#"[1,2]"#);
+    assert_ser_pretty(vec![1, 2], "[\n  1,\n  2\n]");
+    assert_ser_compact(vec![vec![1, 2]], r#"[[1,2]]"#);
+    assert_ser_pretty(vec![vec![1, 2]], "[\n  [\n    1,\n    2\n  ]\n]");
+    assert_ser_compact(vec![Vec::<()>::new()], r#"[[]]"#);
+    assert_ser_pretty(vec![Vec::<()>::new()], "[\n  []\n]");
+}
+
+#[test]
+fn test_list_key() {
+    let map = map!(
+        vec!["a"] => (),
+    );
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "list cannot be a key"
+    );
+}
+
+#[test]
+fn test_unit_struct() {
+    #[derive(Valuable)]
+    struct S;
+
+    assert_ser_both(S, "[]");
+}
+
+#[test]
+fn test_tuple_struct() {
+    #[derive(Valuable)]
+    struct S0();
+    #[derive(Valuable)]
+    struct S1(u8);
+    #[derive(Valuable)]
+    struct S2(i8, u8);
+
+    assert_ser_both(S0(), "[]");
+    assert_ser_compact(S1(0), "[0]");
+    assert_ser_pretty(S1(0), "[\n  0\n]");
+    assert_ser_compact(S2(-1, 1), "[-1,1]");
+    assert_ser_pretty(S2(-1, 1), "[\n  -1,\n  1\n]");
+}
+
+#[test]
+fn test_map() {
+    let mut m = BTreeMap::new();
+    assert_ser_both(&m, r#"{}"#);
+    m.insert("a", 10);
+    assert_ser_compact(&m, r#"{"a":10}"#);
+    assert_ser_pretty(&m, "{\n  \"a\": 10\n}");
+    m.insert("b", 20);
+    assert_ser_compact(&m, r#"{"a":10,"b":20}"#);
+    assert_ser_pretty(&m, "{\n  \"a\": 10,\n  \"b\": 20\n}");
+}
+
+#[test]
+fn test_map_key() {
+    let map = map!(
+        map!["a" => ()] => (),
+    );
+    assert_eq!(to_vec(&map).unwrap_err().to_string(), "map cannot be a key");
+}
+
+#[test]
+fn test_struct() {
+    #[derive(Valuable)]
+    struct S0 {}
+    #[derive(Valuable)]
+    struct S1 {
+        f: u8,
+    }
+    #[derive(Valuable)]
+    struct S2 {
+        f: u8,
+        g: char,
+    }
+
+    assert_ser_both(S0 {}, r#"{}"#);
+    assert_ser_compact(S1 { f: 1 }, r#"{"f":1}"#);
+    assert_ser_pretty(S1 { f: 1 }, "{\n  \"f\": 1\n}");
+    assert_ser_compact(S2 { f: 1, g: 'a' }, r#"{"f":1,"g":"a"}"#);
+    assert_ser_pretty(S2 { f: 1, g: 'a' }, "{\n  \"f\": 1,\n  \"g\": \"a\"\n}");
+}
+
+#[test]
+fn test_struct_key() {
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Valuable)]
+    struct Unit;
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Valuable)]
+    struct Newtype(u8);
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Valuable)]
+    struct Tuple(i8, u8);
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Valuable)]
+    struct Struct {
+        f: u8,
+    }
+
+    let map = map!(Unit => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "struct cannot be a key"
+    );
+    let map = map!(Newtype(0) => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "struct cannot be a key"
+    );
+    let map = map!(Tuple(-1, 1) => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "struct cannot be a key"
+    );
+    let map = map!(Struct { f: 0 } => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "struct cannot be a key"
+    );
+}
+
+#[test]
+fn test_enum() {
+    #[derive(Valuable)]
+    enum E {
+        Unit,
+        Newtype(u8),
+        Tuple(i8, u8),
+        Struct { f: u8 },
+    }
+
+    assert_ser_compact(E::Unit, r#"{"Unit":[]}"#);
+    assert_ser_pretty(E::Unit, "{\n  \"Unit\": []\n}");
+    assert_ser_compact(E::Newtype(0), r#"{"Newtype":[0]}"#);
+    assert_ser_pretty(E::Newtype(0), "{\n  \"Newtype\": [\n    0\n  ]\n}");
+    assert_ser_compact(E::Tuple(-1, 1), r#"{"Tuple":[-1,1]}"#);
+    assert_ser_pretty(E::Tuple(-1, 1), "{\n  \"Tuple\": [\n    -1,\n    1\n  ]\n}");
+    assert_ser_compact(E::Struct { f: 1 }, r#"{"Struct":{"f":1}}"#);
+    assert_ser_pretty(
+        E::Struct { f: 1 },
+        "{\n  \"Struct\": {\n    \"f\": 1\n  }\n}",
+    );
+}
+
+#[test]
+fn test_enum_key() {
+    #[derive(PartialEq, Eq, PartialOrd, Ord, Valuable)]
+    enum E {
+        Unit,
+        Newtype(u8),
+        Tuple(i8, u8),
+        Struct { f: u8 },
+    }
+
+    let map = map!(E::Unit => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "enum cannot be a key"
+    );
+    let map = map!(E::Newtype(0) => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "enum cannot be a key"
+    );
+    let map = map!(E::Tuple(-1, 1) => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "enum cannot be a key"
+    );
+    let map = map!(E::Struct { f: 0 } => ());
+    assert_eq!(
+        to_vec(&map).unwrap_err().to_string(),
+        "enum cannot be a key"
+    );
+}
+
+#[test]
+fn test_dyn_struct() {
+    struct Named;
+
+    impl Valuable for Named {
+        fn as_value(&self) -> Value<'_> {
+            Value::Structable(self)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_named_fields(&NamedValues::new(&[NamedField::new("a")], &[Value::U32(1)]));
+            visit.visit_named_fields(&NamedValues::new(
+                &[NamedField::new("b")],
+                &[Value::I32(-1)],
+            ));
+        }
+    }
+
+    impl Structable for Named {
+        fn definition(&self) -> StructDef<'_> {
+            StructDef::new_dynamic("Named", Fields::Named(&[]))
+        }
+    }
+
+    struct Unnamed;
+
+    impl Valuable for Unnamed {
+        fn as_value(&self) -> Value<'_> {
+            Value::Structable(self)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            visit.visit_unnamed_fields(&[Value::U32(1)]);
+            visit.visit_unnamed_fields(&[Value::I32(-1)]);
+        }
+    }
+
+    impl Structable for Unnamed {
+        fn definition(&self) -> StructDef<'_> {
+            StructDef::new_dynamic("Unnamed", Fields::Unnamed)
+        }
+    }
+
+    assert_ser_compact(Named, r#"{"a":1,"b":-1}"#);
+    assert_ser_pretty(Named, "{\n  \"a\": 1,\n  \"b\": -1\n}");
+
+    assert_ser_compact(Unnamed, "[1,-1]");
+    assert_ser_pretty(Unnamed, "[\n  1,\n  -1\n]");
+}
+
+#[test]
+fn test_dyn_enum() {
+    enum E {
+        Named,
+        Unnamed,
+    }
+
+    impl Valuable for E {
+        fn as_value(&self) -> Value<'_> {
+            Value::Enumerable(self)
+        }
+
+        fn visit(&self, visit: &mut dyn Visit) {
+            match self {
+                Self::Named => {
+                    visit.visit_named_fields(&NamedValues::new(
+                        &[NamedField::new("a")],
+                        &[Value::U32(1)],
+                    ));
+                    visit.visit_named_fields(&NamedValues::new(
+                        &[NamedField::new("b")],
+                        &[Value::I32(-1)],
+                    ));
+                }
+                Self::Unnamed => {
+                    visit.visit_unnamed_fields(&[Value::U32(1)]);
+                    visit.visit_unnamed_fields(&[Value::I32(-1)]);
+                }
+            }
+        }
+    }
+
+    impl Enumerable for E {
+        fn definition(&self) -> EnumDef<'_> {
+            EnumDef::new_dynamic("E", &[])
+        }
+
+        fn variant(&self) -> Variant<'_> {
+            match self {
+                Self::Named => Variant::Dynamic(VariantDef::new("Named", Fields::Named(&[]))),
+                Self::Unnamed => Variant::Dynamic(VariantDef::new("Unnamed", Fields::Unnamed)),
+            }
+        }
+    }
+
+    assert_ser_compact(E::Named, r#"{"Named":{"a":1,"b":-1}}"#);
+    assert_ser_pretty(
+        E::Named,
+        "{\n  \"Named\": {\n    \"a\": 1,\n    \"b\": -1\n  }\n}",
+    );
+    assert_ser_compact(E::Unnamed, r#"{"Unnamed":[1,-1]}"#);
+    assert_ser_pretty(E::Unnamed, "{\n  \"Unnamed\": [\n    1,\n    -1\n  ]\n}");
+}
diff --git a/valuable-serde/tests/test.rs b/valuable-serde/tests/test.rs
index 332ad32..38bb833 100644
--- a/valuable-serde/tests/test.rs
+++ b/valuable-serde/tests/test.rs
@@ -491,7 +491,7 @@ fn test_dyn_enum() {
         fn variant(&self) -> Variant<'_> {
             match self {
                 Self::Named => Variant::Dynamic(VariantDef::new("Named", Fields::Named(&[]))),
-                Self::Unnamed => Variant::Dynamic(VariantDef::new("Named", Fields::Unnamed)),
+                Self::Unnamed => Variant::Dynamic(VariantDef::new("Unnamed", Fields::Unnamed)),
             }
         }
     }
diff --git a/valuable/src/visit.rs b/valuable/src/visit.rs
index 2d22199..e7e85f6 100644
--- a/valuable/src/visit.rs
+++ b/valuable/src/visit.rs
@@ -414,6 +414,9 @@ pub trait Visit {
 /// ```
 ///
 /// [`Visit`]: Visit [`NamedField`]: crate::NamedField
-pub fn visit(value: &impl Valuable, visit: &mut dyn Visit) {
+pub fn visit<V>(value: &V, visit: &mut dyn Visit)
+where
+    V: ?Sized + Valuable,
+{
     visit.visit_value(value.as_value());
 }