Convert the floats of json_view from the digit layout

The parser records where the integer digits, the fraction digits, and the exponent of a float token are. For floats and doubles with at most 19 digits, the value is now read from that layout: the digits eight at a time, without scanning the token, and rounded by the library's conversion core (detail::decimal_to_float(): Clinger's fast path where both operands are exact, else the Eisel-Lemire algorithm, which needs no fallback for up to 19 digits). It rounds correctly, so the values are those of parse(); other tokens and types keep the library's conversion of the whole token. get<double>(), materialize(), dump(), and comparisons use it. Traversing canada.json (111,000 floats, every number converted): 0.95 -> 1.29 GB/s. Tests add tokens around the limits (19 and 20 digits, 2^53, 10^22, and those of float) to the bit-for-bit comparison with parse(). Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Format the comparison examples with the pinned astyle
2026-09-30 19:50:34 +00:00 · 2026-09-30 21:01:51 +02:00 · 2026-09-30 21:01:50 +02:00 · 2026-09-30 21:01:49 +02:00 · 2026-09-30 21:01:49 +02:00 · 2026-09-30 21:01:48 +02:00
123 changed files with 8238 additions and 64 deletions
@@ -67,16 +67,22 @@ cc_library(
        "include/nlohmann/detail/string_utils.hpp",
        "include/nlohmann/detail/value_t.hpp",
        "include/nlohmann/detail/view/builder.hpp",
+        "include/nlohmann/detail/view/compare.hpp",
        "include/nlohmann/detail/view/document_data.hpp",
        "include/nlohmann/detail/view/errors.hpp",
        "include/nlohmann/detail/view/input.hpp",
+        "include/nlohmann/detail/view/iterator.hpp",
+        "include/nlohmann/detail/view/lookup.hpp",
        "include/nlohmann/detail/view/macro_scope.hpp",
        "include/nlohmann/detail/view/macro_unscope.hpp",
        "include/nlohmann/detail/view/materialize.hpp",
        "include/nlohmann/detail/view/node.hpp",
        "include/nlohmann/detail/view/number.hpp",
+        "include/nlohmann/detail/view/pointer.hpp",
        "include/nlohmann/detail/view/scan.hpp",
+        "include/nlohmann/detail/view/serializer.hpp",
        "include/nlohmann/detail/view/string_ref.hpp",
+        "include/nlohmann/detail/view/value.hpp",
        "include/nlohmann/json.hpp",
        "include/nlohmann/json_fwd.hpp",
        "include/nlohmann/json_literals.hpp",
@@ -143,7 +143,21 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::shrink_t
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::source', 'Method', 'api/basic_json_document/source/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view', 'Class', 'api/basic_json_view/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::basic_json_view', 'Constructor', 'api/basic_json_view/basic_json_view/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::at', 'Method', 'api/basic_json_view/at/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::back', 'Method', 'api/basic_json_view/back/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::begin', 'Method', 'api/basic_json_view/begin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cbegin', 'Method', 'api/basic_json_view/cbegin/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::cend', 'Method', 'api/basic_json_view/cend/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::contains', 'Method', 'api/basic_json_view/contains/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::count', 'Method', 'api/basic_json_view/count/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::dump', 'Method', 'api/basic_json_view/dump/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::empty', 'Method', 'api/basic_json_view/empty/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::end', 'Method', 'api/basic_json_view/end/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::find', 'Method', 'api/basic_json_view/find/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::front', 'Method', 'api/basic_json_view/front/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get', 'Method', 'api/basic_json_view/get/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_string', 'Method', 'api/basic_json_view/get_string/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::get_to', 'Method', 'api/basic_json_view/get_to/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_array', 'Method', 'api/basic_json_view/is_array/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_binary', 'Method', 'api/basic_json_view/is_binary/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_boolean', 'Method', 'api/basic_json_view/is_boolean/index.html');
@@ -157,11 +171,20 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_object',
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_primitive', 'Method', 'api/basic_json_view/is_primitive/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_string', 'Method', 'api/basic_json_view/is_string/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::is_structured', 'Method', 'api/basic_json_view/is_structured/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::items', 'Method', 'api/basic_json_view/items/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::materialize', 'Method', 'api/basic_json_view/materialize/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_format', 'Enum', 'api/basic_json_view/number_format/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::number_token', 'Method', 'api/basic_json_view/number_token/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator bool', 'Method', 'api/basic_json_view/operator_bool/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator<<', 'Operator', 'api/basic_json_view/operator_ltlt/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator[]', 'Operator', 'api/basic_json_view/operator[]/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator==', 'Operator', 'api/basic_json_view/operator_eq/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::operator!=', 'Operator', 'api/basic_json_view/operator_ne/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::size', 'Method', 'api/basic_json_view/size/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::source_offset', 'Method', 'api/basic_json_view/source_offset/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type', 'Method', 'api/basic_json_view/type/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::type_name', 'Method', 'api/basic_json_view/type_name/index.html');
+INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_view::value', 'Method', 'api/basic_json_view/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json', 'Class', 'api/json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_document', 'Class', 'api/json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('json_view', 'Class', 'api/json_view/index.html');
@@ -219,6 +219,7 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [checked access](../../features/element_access/checked_access.md)
 - [`operator[]`](operator%5B%5D.md) for unchecked access by reference
 - [`value`](value.md) for access with default value
+- [basic_json_view::at](../basic_json_view/at.md) - the same access on a zero-copy view

 ## Version history

@@ -58,6 +58,7 @@ Constant.
 ## See also

 - [front](front.md) to access the first element
+- [basic_json_view::back](../basic_json_view/back.md) - the same access on a zero-copy view

 ## Version history

@@ -37,6 +37,12 @@ Constant.
    --8<-- "examples/begin.output"
    ```

+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [basic_json_view::begin](../basic_json_view/begin.md) - the same iteration on a zero-copy view (in document order,
+  not sorted by key)
+
 ## Version history

 - Added in version 1.0.0.
@@ -36,6 +36,11 @@ Constant.
    --8<-- "examples/cbegin.output"
    ```

+## See also
+
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [basic_json_view::cbegin](../basic_json_view/cbegin.md) - the same iteration on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -36,6 +36,11 @@ Constant.
    --8<-- "examples/cend.output"
    ```

+## See also
+
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [basic_json_view::cend](../basic_json_view/cend.md) - the same iteration on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -115,6 +115,7 @@ Logarithmic in the size of the JSON object.

 - [find](find.md) find a value in an object
 - [count](count.md) returns the number of occurrences of a key
+- [basic_json_view::contains](../basic_json_view/contains.md) - the same check on a zero-copy view

 ## Version history

@@ -80,6 +80,7 @@ Logarithmic in the size of the JSON object.

 - [find](find.md) find a value in an object
 - [contains](contains.md) checks whether a key exists
+- [basic_json_view::count](../basic_json_view/count.md) - the same check on a zero-copy view

 ## Version history

@@ -86,6 +86,8 @@ Binary values are serialized as an object containing two keys:

 - [to_string](to_string.md) returns a string representation of a JSON value
 - [operator<<](../operator_ltlt.md) serialize to stream
+- [`basic_json_view::dump`](../basic_json_view/dump.md) the corresponding function of `basic_json_view`, serializing
+  directly from a flat index without building a `basic_json` value
 - [Serialization](../../features/serialization.md) - the serialization article

 ## Version history
@@ -37,6 +37,11 @@ Constant.
    --8<-- "examples/end.output"
    ```

+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [basic_json_view::end](../basic_json_view/end.md) - the same iteration on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -84,6 +84,7 @@ Logarithmic in the size of the JSON object.

 - [count](count.md) returns the number of occurrences of a key
 - [contains](contains.md) checks whether a key exists
+- [basic_json_view::find](../basic_json_view/find.md) - the same lookup on a zero-copy view

 ## Version history

@@ -51,6 +51,7 @@ Constant.
 ## See also

 - [back](back.md) to access the last element
+- [basic_json_view::front](../basic_json_view/front.md) - the same access on a zero-copy view

 ## Version history

@@ -163,6 +163,8 @@ overload (3).
 - [get_ref](get_ref.md) get a reference to the stored value
 - [operator ValueType](operator_ValueType.md) get a value via implicit conversion
 - [Converting values](../../features/conversions.md) - the type conversions article
+- [basic_json_view::get](../basic_json_view/get.md) - the same conversion on a zero-copy view (many types are
+  converted without ever building a `basic_json` value)

 ## Version history

@@ -61,6 +61,8 @@ Constant.
 ## See also

 - [get_ptr()](get_ptr.md) get a pointer value
+- [basic_json_view::get_string](../basic_json_view/get_string.md) - the closest counterpart on a zero-copy view: a
+  string without a copy, but as a view rather than a reference to a value that must already exist

 ## Version history

@@ -67,6 +67,7 @@ Depends on the `json_serializer<ValueType>::from_json()` implementation.
 - [get_ref](get_ref.md) get a reference to the stored value
 - [get_ptr](get_ptr.md) get a pointer to the stored value
 - [Converting values](../../features/conversions.md) - the type conversions article
+- [basic_json_view::get_to](../basic_json_view/get_to.md) - the same conversion on a zero-copy view

 ## Version history

@@ -99,6 +99,8 @@ When iterating over an array, `key()` will return the index of the element as st

 - [begin](begin.md) returns an iterator to the first element
 - [end](end.md) returns an iterator to one past the last element
+- [basic_json_view::items](../basic_json_view/items.md) - the same range on a zero-copy view (`#!cpp const auto`,
+  not `#!cpp const auto&`: items are produced on the fly)

 ## Version history

@@ -257,6 +257,8 @@ Strong exception safety: if an exception occurs, the original value stays intact
 - documentation on [runtime assertions](../../features/assertions.md)
 - see [`at`](at.md) for access by reference with range checking
 - see [`value`](value.md) for access with default value
+- [basic_json_view::operator[]](../basic_json_view/operator%5B%5D.md) - the same access on a zero-copy view (always
+  returns a discarded view instead of assuming undefined behavior)

 ## Version history

@@ -166,6 +166,8 @@ Linear.

 - [operator!=](operator_ne.md) compare for inequality
 - [operator<=>](operator_spaceship.md) comparison: 3-way (C++20)
+- [basic_json_view::operator==](../basic_json_view/operator_eq.md) - the same comparison on a zero-copy view, without
+  building a `basic_json` value for it

 ## Version history

@@ -89,6 +89,12 @@ Linear.
    --8<-- "examples/operator__notequal__nullptr_t.output"
    ```

+## See also
+
+- [operator==](operator_eq.md) compare for equality
+- [basic_json_view::operator!=](../basic_json_view/operator_ne.md) - the same comparison on a zero-copy view, without
+  building a `basic_json` value for it
+
 ## Version history

 1. Added in version 1.0.0. Added C++20 member functions in version 3.11.0. Changed in version 3.13.0 to remove 
@@ -52,6 +52,11 @@ Constant.
    --8<-- "examples/type_name.output"
    ```

+## See also
+
+- [type](type.md) - return the type of the JSON value
+- [basic_json_view::type_name](../basic_json_view/type_name.md) - the same function on a zero-copy view
+
 ## Version history

 - Added in version 1.0.0.
@@ -189,6 +189,7 @@ changes to any JSON value.

 - see [`at`](at.md) for access by reference with range checking
 - see [`operator[]`](operator%5B%5D.md) for unchecked access by reference
+- [basic_json_view::value](../basic_json_view/value.md) - the same access on a zero-copy view

 ## Version history

@@ -0,0 +1,132 @@
+# <small>nlohmann::basic_json_view::</small>at
+
+```cpp
+// (1)
+basic_json_view at(string_view_t key) const;
+basic_json_view at(const char* key) const;
+basic_json_view at(const string_t& key) const;
+
+// (2)
+basic_json_view at(size_type idx) const;
+basic_json_view at(int idx) const;
+
+// (3)
+basic_json_view at(const json_pointer& ptr) const;
+```
+
+1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
+   [Notes on duplicate keys](operator[].md#notes)).
+2. Returns the array element at index `idx`.
+3. Returns the value a JSON pointer `ptr` refers to, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`idx` (in)
+:   index of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+## Return value
+
+1. the value of the first member with key `key`
+2. the element at index `idx`
+3. the value `ptr` resolves to, starting at this value
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+1. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an object.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if no member has key `key`.
+2. The function can throw the following exceptions, both with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`type_error.304`](../../home/exceptions.md#jsonexceptiontype_error304) if the value is not an array.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if `#!cpp idx >= size()`.
+3. The function can throw the following exceptions, all with the same message as the corresponding call to
+   [`BasicJsonType::at`](../basic_json/at.md):
+    - Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr`
+      begins with `#!cpp '0'`.
+    - Throws [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is
+      not a number.
+    - Throws [`out_of_range.401`](../../home/exceptions.md#jsonexceptionout_of_range401) if an array index in `ptr`
+      is out of range.
+    - Throws [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is
+      `#!cpp "-"` at an array -- `at` never inserts an element, so `#!cpp "-"` is always invalid.
+    - Throws [`out_of_range.403`](../../home/exceptions.md#jsonexceptionout_of_range403) if a reference token names
+      an object member that does not exist.
+    - Throws [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if `ptr` cannot be resolved
+      because a reference token is used on a primitive value.
+
+None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length --
+   already known from the index, without reading the key bytes -- before comparing its content.
+2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
+   index (unlike `BasicJsonType`'s array, which is random-access).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level (as 1.) or the index into the array (as 2.).
+
+## Notes
+
+Unlike [`operator[]`](operator[].md), which returns a [discarded](is_discarded.md) view for a missing key or an
+out-of-range index, `at` always throws -- exactly as `BasicJsonType::at` does, and with the same messages, so
+existing error handling written against `BasicJsonType::at` keeps working unchanged when switched to a view. This
+also holds for overload 3: unlike [`operator[]`](operator[].md) with a JSON pointer, which returns a discarded view
+for a missing key or an out-of-range index, `at` throws for those too (`out_of_range.403`/`out_of_range.401`).
+
+## Examples
+
+??? example "Example: (1)/(2) access specified element with bounds checking"
+
+    The example below reads required fields out of a service configuration with `at`, and shows that the exceptions
+    it throws -- for a wrong type and for a missing key -- carry the same messages
+    [`BasicJsonType::at`](../basic_json/at.md) would produce for the same JSON text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at.output"
+    ```
+
+??? example "Example: (3) access specified element via JSON pointer with bounds checking"
+
+    The example below shows that `at` with a JSON pointer throws exactly the exceptions, with exactly the messages,
+    that [`BasicJsonType::at`](../basic_json/at.md) throws for the same pointer and the same document.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__at_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__at_json_pointer.output"
+    ```
+
+## See also
+
+- [operator[]](operator[].md) - access specified element (returns a discarded view instead of throwing)
+- [front](front.md), [back](back.md) - access the first or last element
+- [`BasicJsonType::at`](../basic_json/at.md) - the corresponding function of `basic_json`
+- [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,64 @@
+# <small>nlohmann::basic_json_view::</small>back
+
+```cpp
+basic_json_view back() const;
+```
+
+Returns the last element of an array, the last member value of an object, or the value itself if it is primitive
+(as for [`BasicJsonType::back()`](../basic_json/back.md), a primitive value is a range of one element).
+
+## Return value
+
+The last element or member value. For a primitive value (number, string, boolean), the value itself.
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
+[null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Linear in the size of the array or object: unlike [`front()`](front.md), which only ever looks at the first
+element, `back()` has to walk every element to find where they end, since elements are not a fixed size in the
+index.
+
+## Notes
+
+Unlike [`BasicJsonType::back()`](../basic_json/back.md), which has undefined behavior for an empty array or object,
+`back()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and for a
+discarded view, where `BasicJsonType::back()` also throws.
+
+## Examples
+
+??? example
+
+    The example below reads only the final status of a build log with `back()`. Even though `back()` is linear in
+    the number of events (unlike [`front()`](front.md), which is constant), it still avoids building a
+    `BasicJsonType` value for the events that are not needed.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__back.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__back.output"
+    ```
+
+## See also
+
+- [front](front.md) - access the first element
+- [`BasicJsonType::back`](../basic_json/back.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -8,8 +8,9 @@ Creates an invalid (discarded) view: [`type()`](type.md) is `#!cpp value_t::disc
 [`is_discarded()`](is_discarded.md) is `#!cpp true`, and `#!cpp explicit operator bool()` is `#!cpp false`.

 This is the only constructor a caller can use directly. Every other view is obtained from a
-[`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or (once
-element access is added) from navigating into a container.
+[`basic_json_document`](../basic_json_document/index.md), via [`root()`](../basic_json_document/root.md) or by
+navigating into a container with [`operator[]`](operator[].md), [`at`](at.md), [`front`](front.md), [`back`](back.md),
+[`find`](find.md), or iteration.

 ## Exception safety

@@ -0,0 +1,61 @@
+# <small>nlohmann::basic_json_view::</small>begin
+
+```cpp
+iterator begin() const noexcept;
+```
+
+Returns an iterator to the first element of an array, or the first member value of an object, in **document order**
+-- the order the values appear in the source text, not sorted by key. A primitive value iterates as a range of one
+element (itself); `#!json null` and a [discarded](is_discarded.md) view iterate as an empty range.
+
+## Return value
+
+Iterator to the first element.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+For an object, iteration visits **every** member, including all occurrences of a duplicate key -- unlike
+[`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md), [`contains`](contains.md), and [`count`](count.md),
+which all resolve to the *first* member with a given key. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]`.
+
+Because objects are iterated in document order rather than sorted by key, the order seen here can differ from what
+iterating the [`materialize()`](materialize.md)d `BasicJsonType` value would produce: a `#!cpp basic_json` object
+(`std::map`-backed by default) sorts its keys, while a view does not.
+
+## Examples
+
+??? example
+
+    The example below iterates a log record's members with `begin()`/[`end()`](end.md) and prints them in the order
+    they were written. Materializing the record into a `BasicJsonType` object and iterating that would instead print
+    the members sorted by key.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__begin.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__begin.output"
+    ```
+
+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [items](items.md) - access iterator member functions in range-based for
+- [`BasicJsonType::begin`](../basic_json/begin.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,49 @@
+# <small>nlohmann::basic_json_view::</small>cbegin
+
+```cpp
+iterator cbegin() const noexcept;
+```
+
+Returns an iterator to the first element, in [document order](begin.md). Equivalent to [`begin()`](begin.md): a view
+is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cbegin()` exists only so
+that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
+
+## Return value
+
+Iterator to the first element; identical to what [`begin()`](begin.md) returns.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below sums many measurements with `std::accumulate`, using `cbegin()`/[`cend()`](cend.md) as the
+    range -- the same way it would for any standard container -- without ever materializing the whole array into a
+    `BasicJsonType` value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__cbegin.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__cbegin.output"
+    ```
+
+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [`BasicJsonType::cbegin`](../basic_json/cbegin.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,49 @@
+# <small>nlohmann::basic_json_view::</small>cend
+
+```cpp
+iterator cend() const noexcept;
+```
+
+Returns an iterator to one past the last element, in [document order](begin.md). Equivalent to [`end()`](end.md): a
+view is always read-only, so `#!cpp const_iterator` and `#!cpp iterator` are the same type, and `cend()` exists only
+so that generic code that expects a `cbegin()`/`cend()` pair works with a view too.
+
+## Return value
+
+Iterator one past the last element; identical to what [`end()`](end.md) returns.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below checks that every record of a batch is an object with `std::all_of`, using
+    [`cbegin()`](cbegin.md)/`cend()` as the range -- the same way it would for any standard container -- before
+    materializing any record of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__cend.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__cend.output"
+    ```
+
+## See also
+
+- [end](end.md) - returns an iterator to one past the last element
+- [cbegin](cbegin.md) - returns a const iterator to the first element
+- [`BasicJsonType::cend`](../basic_json/cend.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,101 @@
+# <small>nlohmann::basic_json_view::</small>contains
+
+```cpp
+// (1)
+bool contains(string_view_t key) const;
+bool contains(const char* key) const;
+bool contains(const string_t& key) const;
+
+// (2)
+bool contains(const json_pointer& ptr) const;
+```
+
+1. Checks whether the value is an object with a member with key `key`.
+2. Checks whether a JSON pointer `ptr` can be resolved, starting at this value.
+
+## Parameters
+
+`key` (in)
+:   key value to check its existence
+
+`ptr` (in)
+:   JSON pointer to check its existence
+
+## Return value
+
+1. `#!cpp true` if the value is an object and has a member with key `key`, `#!cpp false` otherwise
+2. `#!cpp true` if `ptr` can be resolved to a value starting at this view, `#!cpp false` otherwise
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+   known from the index, without reading the key bytes -- before comparing its content.
+2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array -- as for [`operator[]`](operator[].md#complexity) and
+   [`at`](at.md#complexity) with a JSON pointer.
+
+## Notes
+
+Overload 1 always returns `#!cpp false` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+!!! info "Postconditions"
+
+    If `#!cpp v.contains(key)` returns `#!cpp true`, then `#!cpp v[key]` is not [discarded](is_discarded.md). If
+    `#!cpp v.contains(ptr)` returns `#!cpp true`, then `#!cpp v[ptr]` is not discarded and `#!cpp v.at(ptr)` does not
+    throw.
+
+!!! info "Overload 2 never throws"
+
+    Unlike [`BasicJsonType::contains(const json_pointer&)`](../basic_json/contains.md), which can throw for certain
+    malformed pointers (for instance an empty array-index reference token), overload 2 never throws: a missing key,
+    an out-of-range or malformed array index, a `#!cpp "-"` index, or a reference token used on a primitive all
+    simply make it return `#!cpp false`.
+
+## Examples
+
+??? example "Example: (1) check with key"
+
+    The example below counts how many of a batch of records carry an optional `retry_of` field, using `contains()`
+    to check without ever materializing a single record of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains.output"
+    ```
+
+??? example "Example: (2) check with JSON pointer"
+
+    The example below checks an optional, nested field with a JSON pointer, and shows two pointers that
+    `#!cpp contains()` resolves to `#!cpp false` without throwing.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__contains_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__contains_json_pointer.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [count](count.md) - returns the number of occurrences of a key
+- [at](at.md), [operator[]](operator[].md) - resolve a JSON pointer and throw, or return a discarded view
+- [`BasicJsonType::contains`](../basic_json/contains.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,66 @@
+# <small>nlohmann::basic_json_view::</small>count
+
+```cpp
+size_type count(string_view_t key) const;
+size_type count(const char* key) const;
+size_type count(const string_t& key) const;
+```
+
+Returns `#!cpp 1` if the value is an object with a member with key `key`, `#!cpp 0` otherwise.
+
+## Parameters
+
+`key` (in)
+:   key value of the element to count
+
+## Return value
+
+`#!cpp 1` if the value is an object and has a member with key `key`, `#!cpp 0` otherwise.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+known from the index, without reading the key bytes -- before comparing its content.
+
+## Notes
+
+This method always returns `#!cpp 0` when the value is not an object -- including a [discarded](is_discarded.md)
+view.
+
+Unlike [`BasicJsonType::count()`](../basic_json/count.md), whose return value can in principle exceed `#!cpp 1` for
+an `ObjectType` that allows multiple entries per key, `count()` here never does: it is exactly
+[`contains()`](contains.md) as `#!cpp 0`/`#!cpp 1`. This holds even if the source text has a duplicate key -- see the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]` -- because a `#!cpp count() > 1` result would require
+counting every member with a matching key, not just finding the first one.
+
+## Examples
+
+??? example
+
+    The example below validates that every transaction of a batch carries a mandatory `amount` field, using
+    `count()` before deciding whether to materialize a transaction at all.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__count.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__count.output"
+    ```
+
+## See also
+
+- [find](find.md) - find a value in an object
+- [contains](contains.md) - checks whether a key exists
+- [`BasicJsonType::count`](../basic_json/count.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,102 @@
+# <small>nlohmann::basic_json_view::</small>dump
+
+```cpp
+string_t dump(const int indent = -1,
+              const char indent_char = ' ',
+              const bool ensure_ascii = false,
+              const number_format numbers = number_format::shortest) const;
+```
+
+Serializes this value (and its subtree) directly from the flat index, without ever building a `BasicJsonType` value
+first. With the default `#!cpp numbers == number_format::shortest`, the result is the same string
+[`BasicJsonType::dump`](../basic_json/dump.md) would produce for the value
+[`BasicJsonType::parse()`](../basic_json/parse.md) builds from the same source text, called with the same `indent`,
+`indent_char`, and `ensure_ascii` -- except that members of an object appear in document order rather than sorted by
+key, and *every* occurrence of a repeated key is written rather than only the last one (see
+[Notes on duplicate keys](operator[].md#notes)). For a `json_view` (whose `BasicJsonType` is not ordered), this means
+`dump()` can print an object's members in a different order than [`materialize()`](materialize.md)`.dump()` of the
+same subtree.
+
+## Parameters
+
+`indent` (in)
+:   If `indent` is nonnegative, array elements and object members are pretty-printed with that indent level. An
+    indent level of `0` only inserts newlines. `-1` (the default) selects the most compact representation.
+
+`indent_char` (in)
+:   The character used for indentation if `indent` is greater than `0`. The default is ` ` (space).
+
+`ensure_ascii` (in)
+:   If `ensure_ascii` is `#!cpp true`, all non-ASCII characters in the output are escaped with `\uXXXX` sequences, and
+    the result consists of ASCII characters only.
+
+`numbers` (in)
+:   how to write numbers, see [`number_format`](number_format.md): `shortest` (the default) writes them the way
+    [`BasicJsonType::dump`](../basic_json/dump.md) would; `source` copies every number exactly as it appears in the
+    source text.
+
+## Return value
+
+string containing the serialization of this value, or `#!cpp "<discarded>"` if the view is
+[discarded](is_discarded.md).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc` if allocating the output string fails. Unlike
+[`BasicJsonType::dump`](../basic_json/dump.md), there is no `error_handler` parameter and no
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316): the view only ever holds text the parser
+already validated as UTF-8, so there is nothing to replace or ignore.
+
+## Complexity
+
+Linear in the size of the output text.
+
+## Notes
+
+The walk over the subtree is iterative, so the nesting depth it can write is limited by available memory only, not by
+the call stack -- as for [`materialize()`](materialize.md).
+
+Strings are escaped by the same rules as [`BasicJsonType::dump`](../basic_json/dump.md). With
+`#!cpp numbers == number_format::shortest`, floats are written with the library's shortest round-trip conversion,
+exactly as [`BasicJsonType::dump`](../basic_json/dump.md) would (e.g. `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`), and
+integers are copied from the source text -- already canonical in JSON, so this matches their shortest form too --
+except that `#!cpp -0` is written as `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it.
+`#!cpp number_format::source` copies every number exactly as written in the source text instead, with no exception
+for `#!cpp -0` -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0.0`, `#!cpp -0`, or all digits of an integer literal with more
+digits than any number type holds (such a literal is itself classified as a float, see
+[What is different](../../features/json_view.md#what-is-different)) -- something `BasicJsonType` cannot do, since
+parsing already reduces every number to its parsed value.
+
+## Examples
+
+??? example
+
+    The example below forwards a single record out of a larger batch, and re-serializes a configuration file, both
+    without ever building a `BasicJsonType` value for the surrounding array or for the parts of it that were not
+    needed. It also shows that [`materialize()`](materialize.md)`.dump()` of the configuration sorts its keys, where
+    `dump()` on the view keeps the order they appear in the source text.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__dump.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__dump.output"
+    ```
+
+## See also
+
+- [`number_format`](number_format.md) - how `dump()` writes numbers
+- [operator<<](operator_ltlt.md) - serialize this value to a stream
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to use `BasicJsonType::dump`'s `error_handler`
+- [`BasicJsonType::dump`](../basic_json/dump.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,54 @@
+# <small>nlohmann::basic_json_view::</small>end
+
+```cpp
+iterator end() const noexcept;
+```
+
+Returns an iterator to one past the last element of an array, one past the last member value of an object, in
+**document order** -- see [`begin()`](begin.md). A primitive value iterates as a range of one element (itself);
+`#!json null` and a [discarded](is_discarded.md) view iterate as an empty range, so `#!cpp begin() == end()` for
+them.
+
+## Return value
+
+Iterator one past the last element.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`#!cpp iterator` is a forward iterator: unlike `BasicJsonType::iterator`, it cannot be decremented, so there is no
+way to reach the last element by stepping back from `end()`. Use [`back()`](back.md) instead.
+
+## Examples
+
+??? example
+
+    The example below scans a (possibly large) array of readings for the first one over a threshold, stopping the
+    loop at `end()` as soon as one is found. Only the matching reading, if any, is ever materialized.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__end.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__end.output"
+    ```
+
+## See also
+
+- [begin](begin.md) - returns an iterator to the first element
+- [cend](cend.md) - returns a const iterator to one past the last element
+- [`BasicJsonType::end`](../basic_json/end.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,63 @@
+# <small>nlohmann::basic_json_view::</small>find
+
+```cpp
+iterator find(string_view_t key) const;
+iterator find(const char* key) const;
+iterator find(const string_t& key) const;
+```
+
+Finds a member with key `key` -- the first one, should the key occur more than once (see
+[Notes on duplicate keys](operator[].md#notes)). If the value is not an object, or no member has this key,
+[`end()`](end.md) is returned.
+
+## Parameters
+
+`key` (in)
+:   key value of the element to search for
+
+## Return value
+
+An iterator to the member with key `key`, or [`end()`](end.md) if there is none or the value is not an object.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+another, in document order, stopping at the first match. Each comparison first checks the key's length -- already
+known from the index, without reading the key bytes -- before comparing its content.
+
+## Notes
+
+Unlike [`BasicJsonType::find`](../basic_json/find.md), which always returns `#!cpp end()` for a non-object type, this
+also does so for a [discarded](is_discarded.md) view -- there is no separate "invalid" iterator to return.
+
+## Examples
+
+??? example
+
+    The example below scans a batch of events for those that carry an optional `user_id` field, using `find()`
+    instead of [`operator[]`](operator[].md) (which would throw for the events that are not objects at all) or
+    [`contains()`](contains.md) followed by a second lookup. Events without a match are never materialized.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__find.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__find.output"
+    ```
+
+## See also
+
+- [count](count.md) - returns the number of occurrences of a key
+- [contains](contains.md) - checks whether a key exists
+- [`BasicJsonType::find`](../basic_json/find.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,61 @@
+# <small>nlohmann::basic_json_view::</small>front
+
+```cpp
+basic_json_view front() const;
+```
+
+Returns the first element of an array, the first member value of an object, or the value itself if it is primitive
+(as for [`BasicJsonType::front()`](../basic_json/front.md), a primitive value is a range of one element).
+
+## Return value
+
+The first element or member value. For a primitive value (number, string, boolean), the value itself.
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`invalid_iterator.214`](../../home/exceptions.md#jsonexceptioninvalid_iterator214) if the view is
+[null](is_null.md) or [discarded](is_discarded.md), or if it is an empty array or object.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+Unlike [`BasicJsonType::front()`](../basic_json/front.md), which has undefined behavior for an empty array or
+object, `front()` throws `invalid_iterator.214` in that case -- the same way it already does for `#!json null` and
+for a discarded view, where `BasicJsonType::front()` also throws.
+
+## Examples
+
+??? example
+
+    The example below reads only the earliest entry of a build log with `front()`, without materializing the rest
+    of the (possibly long) log.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__front.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__front.output"
+    ```
+
+## See also
+
+- [back](back.md) - access the last element
+- [`BasicJsonType::front`](../basic_json/front.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,130 @@
+# <small>nlohmann::basic_json_view::</small>get
+
+```cpp
+template<typename T>
+T get() const;
+```
+
+Converts the value to `T`.
+
+For the types below, the conversion works directly on the flat index -- no `BasicJsonType` value is built for it:
+
+- `#!cpp bool`
+- arithmetic types other than `#!cpp bool` (from a number; from a boolean, as `#!cpp 0`/`#!cpp 1`, exactly as
+  [`BasicJsonType::get<T>()`](../basic_json/get.md) converts a boolean)
+- `#!cpp std::nullptr_t`
+- `#!cpp std::basic_string<char, Traits, Alloc>` (including `string_t`) -- a copy of the string
+- [`string_view_t`](index.md#member-types) -- **no copy**: the returned view points into the document's
+  [`source()`](../basic_json_document/source.md) text, or, for a string that contains escape sequences, into the
+  document's own buffer of decoded strings (see [`get_string()`](get_string.md))
+- `BasicJsonType` -- equivalent to [`materialize()`](materialize.md)
+- `basic_json_view` -- returns `#!cpp *this`
+- `#!cpp std::vector<U, A>` -- element by element, each converted with `#!cpp get<U>()`; `#!cpp
+  std::vector<basic_json_view>` keeps a view of every element instead of a value
+- `#!cpp std::map<K, V, C, A>` and `#!cpp std::unordered_map<K, V, H, E, A>`, if `K` is constructible from a `#!cpp
+  (const char*, std::size_t)` pair -- member by member, each value converted with `#!cpp get<V>()`; with a repeated
+  key, the *last* value is kept, as [`BasicJsonType::parse()`](../basic_json/parse.md) (and
+  [`materialize()`](materialize.md)) does; `#!cpp std::map<std::string, basic_json_view>` keeps views of the members
+  instead of values
+
+Every other `T` -- `#!cpp std::list`, `#!cpp std::pair`, `#!cpp std::array`, enumerations, user types with a
+`from_json()`, ... -- is converted by `#!cpp materialize().get<T>()`: the subtree is built into a real `BasicJsonType`
+value first (as [`BasicJsonType::parse()`](../basic_json/parse.md) would), and converted from there exactly as
+[`BasicJsonType::get<T>()`](../basic_json/get.md) would convert it.
+
+## Template parameters
+
+`T`
+:   the type to convert the value to
+
+## Return value
+
+the value, converted to `T`
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+- For the directly-converted types listed above (other than `BasicJsonType` and `basic_json_view`, which never
+  throw): throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value's type does not
+  match `T` -- the same exception, with the same message, that [`BasicJsonType::get<T>()`](../basic_json/get.md)
+  throws for the same JSON type and `T`.
+- For `#!cpp std::vector<U, A>`: throws `type_error.302` if the value is not an array; otherwise, whatever converting
+  an element to `U` throws.
+- For `#!cpp std::map`/`#!cpp std::unordered_map`: throws `type_error.302` if the value is not an object; otherwise,
+  whatever converting a member to the mapped type throws.
+- For every other `T`: whatever [`materialize().get<T>()`](../basic_json/get.md) throws -- typically `type_error.302`,
+  or whatever a user-provided `from_json()` throws.
+
+None of the exceptions thrown directly by this function (the first three bullets above) carry a
+[`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no `BasicJsonType` value to point at. An
+exception thrown while converting through `materialize()` (the last bullet) is different: it is thrown by a real
+`BasicJsonType` value, so it **does** carry a `JSON_DIAGNOSTICS` path if `BasicJsonType` was built with it enabled.
+
+## Complexity
+
+- `#!cpp bool`, arithmetic types, `#!cpp std::nullptr_t`, [`string_view_t`](index.md#member-types), `basic_json_view`:
+  constant.
+- `#!cpp std::basic_string<char, Traits, Alloc>`: constant, plus one allocation and a copy of the string's bytes.
+- `BasicJsonType`: linear in the size of the subtree, see [`materialize()`](materialize.md).
+- `#!cpp std::vector<U, A>`: linear in the number of elements, times the complexity of converting one element to `U`.
+- `#!cpp std::map`/`#!cpp std::unordered_map`: linear in the number of members for walking them, plus the container's
+  own insertion cost per member (logarithmic for `#!cpp std::map`, amortized constant for `#!cpp
+  std::unordered_map`), times the complexity of converting one member to the mapped type.
+- every other `T`: linear in the size of the subtree (building the `BasicJsonType` value), plus the complexity of
+  [`BasicJsonType::get<T>()`](../basic_json/get.md) on it.
+
+## Notes
+
+!!! info "Floating-point values"
+
+    A floating-point `T` is converted from the same digits the lexer would see during `#!cpp BasicJsonType::parse()`,
+    using the same conversion, so the result is bit-for-bit identical to `#!cpp BasicJsonType::parse(text).get<T>()`
+    for the same source text.
+
+!!! info "Duplicate keys"
+
+    `#!cpp std::map`/`#!cpp std::unordered_map` conversions keep the *last* value of a repeated key, like
+    [`materialize()`](materialize.md) and [`BasicJsonType::parse()`](../basic_json/parse.md) do. This is the opposite
+    of [`operator[]`](operator[].md)/[`at`](at.md)/[`find`](find.md)/[`contains`](contains.md), which resolve to the
+    *first* occurrence (see the [Notes on duplicate keys](operator[].md#notes)).
+
+!!! info "No pointers, references, or implicit conversion"
+
+    Unlike `BasicJsonType`, `basic_json_view` has no stored value anywhere to hand out a pointer or a reference to, so
+    it provides neither `#!cpp get_ptr()`, `#!cpp get_ref()`, nor `#!cpp operator ValueType()`.
+    [`get_string()`](get_string.md) (equivalently, `#!cpp get<string_view_t>()`) is the zero-copy alternative for
+    strings.
+
+## Examples
+
+??? example
+
+    The example below reads typed fields straight into C++ variables, collects a view of every array element with
+    `#!cpp get<std::vector<basic_json_view>>()` instead of a value, and converts a nested object into a user type
+    through its `from_json()` -- which runs on a `BasicJsonType` value `materialize()` builds for just that one
+    member.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get.output"
+    ```
+
+## See also
+
+- [get_to](get_to.md) - convert and write into a passed value
+- [get_string](get_string.md) - the string, without a copy
+- [number_token](number_token.md) - a number's token text, without a copy
+- [materialize](materialize.md) - build the `BasicJsonType` value of this subtree
+- [`BasicJsonType::get`](../basic_json/get.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,71 @@
+# <small>nlohmann::basic_json_view::</small>get_string
+
+```cpp
+string_view_t get_string() const;
+```
+
+Returns the string value as a [`string_view_t`](index.md#member-types), without copying it.
+
+## Return value
+
+The string, as a [`string_view_t`](index.md#member-types) that points either into the document's
+[`source()`](../basic_json_document/source.md) text (a string with no escape sequences), or into the document's own
+buffer of decoded strings (a string that contains escape sequences, such as `#!json "\n"` or `#!json "\u00e9"`, which
+had to be decoded once when the document was parsed).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a string; example:
+`"type must be string, but is array"`.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`basic_json_view` has no `BasicJsonType` value stored anywhere, so unlike `BasicJsonType`, it has no `get_ref()` to
+hand out a reference to a stored `string_t`. `get_string()` (equivalently, [`get<string_view_t>()`](get.md)) is the
+zero-copy alternative: [`BasicJsonType::get_ref<const string_t&>()`](../basic_json/get_ref.md) is its closest
+counterpart, except that it returns a view instead of a reference to a value that must already exist.
+
+The returned [`string_view_t`](index.md#member-types) is valid exactly as long as the view that produced it -- see the
+[validity rules](index.md) of `basic_json_view` -- and, for a string with no escapes, for as long as the document's
+source text.
+
+## Examples
+
+??? example
+
+    The example below pulls one field out of a JSON text that stands in for a large API response, and shows that no
+    `#!cpp std::string` was allocated for it: the returned view still points inside the original buffer. A field that
+    contains an escape sequence cannot point into the original text -- it was decoded once into the document's own
+    buffer instead -- but still avoids a per-field allocation.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get_string.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get_string.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type (`#!cpp get<string_view_t>()` is equivalent to this function)
+- [number_token](number_token.md) - a number's token text, without a copy
+- [`BasicJsonType::get_ref`](../basic_json/get_ref.md) - the closest counterpart of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,65 @@
+# <small>nlohmann::basic_json_view::</small>get_to
+
+```cpp
+template<typename T>
+T& get_to(T& v) const;
+```
+
+Converts the value to `T` and assigns it to `v`. Equivalent to
+
+```cpp
+v = get<T>();
+return v;
+```
+
+## Template parameters
+
+`T`
+:   the type to convert the value to
+
+## Parameters
+
+`v` (out)
+:   the variable to store the converted value in
+
+## Return value
+
+`v`, allowing calls to chain
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, `v` is not modified.
+
+## Exceptions
+
+Whatever [`get<T>()`](get.md) throws for the same value and `T`.
+
+## Complexity
+
+Whatever [`get<T>()`](get.md) has for the same `T`.
+
+## Examples
+
+??? example
+
+    The example below reads several fields of a service configuration directly into existing variables, then uses
+    the returned reference to fold the `#!cpp host`/`#!cpp port` pair into a single string in the same expression.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__get_to.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__get_to.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type
+- [`BasicJsonType::get_to`](../basic_json/get_to.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -19,9 +19,13 @@ to the document and a pointer into its index), trivially copyable. A view is val
 Moving the document itself does not invalidate its views: the index is heap-allocated independently of the
 `basic_json_document` object.

-`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, and
-[`materialize()`](materialize.md) to build the `BasicJsonType` value of a subtree on demand. It does not (yet) provide
-element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or comparison.
+`basic_json_view` provides the read-only part of the `BasicJsonType` interface: the type-inspection functions, element
+access, lookup, iteration, conversion, and comparison -- [`get<T>()`](get.md), [`get_string()`](get_string.md),
+[`number_token()`](number_token.md), and [`materialize()`](materialize.md) to build the `BasicJsonType` value of a
+subtree on demand. [`operator[]`](operator%5B%5D.md), [`at`](at.md), [`contains`](contains.md), and
+[`value`](value.md) also accept a [`json_pointer`](../json_pointer/index.md). [`operator==`](operator_eq.md) and
+[`operator!=`](operator_ne.md) compare two views, or a view and a `BasicJsonType` value, without ever building a
+`BasicJsonType` value for a view; no ordering comparison (`#!cpp operator<`) is provided.

 ## Template parameters

@@ -41,6 +45,10 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
  member types of `BasicJsonType`
 - **size_type** - `#!cpp std::size_t`
 - **string_view_t** - `#!cpp std::string_view` on C++17 and newer, a minimal internal substitute otherwise
+- **iterator**, **const_iterator** - a forward iterator over the elements of an array or the member values of an
+  object, in document order; both names refer to the same type, since a view is always read-only
+- **item** - a (key, value) pair produced by [`items()`](items.md)
+- [**number_format**](number_format.md) - how [`dump()`](dump.md) writes numbers

 ## Member functions

@@ -49,6 +57,7 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
 ### Object inspection

 - [**type**](type.md) - return the type of the value
+- [**type_name**](type_name.md) - return the type as string
 - [**is_null**](is_null.md) - return whether the value is null
 - [**is_boolean**](is_boolean.md) - return whether the value is a boolean
 - [**is_number**](is_number.md) - return whether the value is a number
@@ -64,6 +73,28 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar
 - [**is_discarded**](is_discarded.md) - return whether the view is invalid
 - [**operator bool**](operator_bool.md) - return whether the view refers to a value

+### Element access
+
+- [**at**](at.md) - access specified element with bounds checking
+- [**operator[]**](operator[].md) - access specified element
+- [**value**](value.md) - access specified element with default value
+- [**front**](front.md) - access the first element
+- [**back**](back.md) - access the last element
+
+### Lookup
+
+- [**find**](find.md) - find an element in an object
+- [**count**](count.md) - returns the number of occurrences of a key in an object
+- [**contains**](contains.md) - check the existence of an element in an object
+
+### Iterators
+
+- [**begin**](begin.md) - returns an iterator to the first element
+- [**cbegin**](cbegin.md) - returns a const iterator to the first element
+- [**end**](end.md) - returns an iterator to one past the last element
+- [**cend**](cend.md) - returns a const iterator to one past the last element
+- [**items**](items.md) - wrapper to access iterator member functions in range-based for
+
 ### Capacity

 - [**size**](size.md) - return the number of elements
@@ -71,8 +102,22 @@ element access, iteration, `get<T>()`, JSON Pointer support, `dump()`, or compar

 ### Conversion

+- [**get**](get.md) - get a value
+- [**get_to**](get_to.md) - get a value and write it to a destination
+- [**get_string**](get_string.md) - get a string value without a copy
+- [**number_token**](number_token.md) - get a number's token text without a copy
 - [**materialize**](materialize.md) - build the `BasicJsonType` value of this subtree

+### Comparison
+
+- [**operator==**](operator_eq.md) - comparison: equal
+- [**operator!=**](operator_ne.md) - comparison: not equal
+
+### Serialization
+
+- [**dump**](dump.md) - serialize to a JSON-formatted string
+- [**operator<<**](operator_ltlt.md) - serialize to stream
+
 ### Source access

 - [**source_offset**](source_offset.md) - byte offset of this value in the document's source text
@@ -0,0 +1,86 @@
+# <small>nlohmann::basic_json_view::</small>items
+
+```cpp
+/* unspecified */ items() const noexcept;
+```
+
+Returns a range of [`item`](index.md#member-types) values -- (key, value) pairs -- for use in range-based for loops.
+The key of an array element is its index, converted to a string, as for
+[`BasicJsonType::items()`](../basic_json/items.md).
+
+The returned type is not part of the public API and may change between versions; use a range-based for loop (see the
+example), or `#!cpp decltype(v.items())` if you need to name it.
+
+```cpp
+for (const auto& item : v.items())
+{
+    std::cout << "key: " << item.key() << ", value: " << item.value() << '\n';
+}
+```
+
+On C++17, `item` also supports [structured bindings](https://en.cppreference.com/w/cpp/language/structured_binding):
+
+```cpp
+for (const auto [key, value] : v.items())
+{
+    std::cout << "key: " << key << ", value: " << value << '\n';
+}
+```
+
+Note the `#!cpp const auto` (by value), not `#!cpp const auto&`: unlike `BasicJsonType::items()`, whose elements are
+references into an existing object, a view's `item` is produced on the fly for each step of the iteration, so there
+is nothing for a reference to bind to.
+
+## Return value
+
+A range whose iterators dereference to [`item`](index.md#member-types) and whose `#!cpp begin()`/`#!cpp end()` are
+equivalent to [`basic_json_view::begin()`](begin.md)/[`end()`](end.md), in document order.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+As for [`begin()`](begin.md)/[`end()`](end.md), `items()` visits **every** member of an object, including all
+occurrences of a duplicate key -- unlike [`operator[]`](operator[].md), [`at`](at.md), [`find`](find.md),
+[`contains`](contains.md), and [`count`](count.md), which resolve to the *first* member with a given key. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]`.
+
+!!! danger "Lifetime issues"
+
+    As for `BasicJsonType::items()`, calling `items()` on a temporary view (or a temporary document) is dangerous:
+    the range refers back to the document, so the document must outlive the loop. See
+    [#2040](https://github.com/nlohmann/json/issues/2040) for the `BasicJsonType` background.
+
+## Examples
+
+??? example
+
+    The example below shows a settings object whose source text records every update to a key as a duplicate
+    member, in the order they happened. `items()` walks all of them, so the update history is visible, while
+    [`operator[]`](operator[].md) only ever sees the *first* one and [`materialize()`](materialize.md) -- like
+    [`BasicJsonType::parse()`](../basic_json/parse.md) -- keeps only the *last*.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__items.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__items.output"
+    ```
+
+## See also
+
+- [begin](begin.md), [end](end.md) - the iterators `items()` is built on
+- [`BasicJsonType::items`](../basic_json/items.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,51 @@
+# <small>nlohmann::basic_json_view::</small>number_format
+
+```cpp
+enum class number_format {
+    shortest,
+    source
+};
+```
+
+This enumeration is used in [`dump`](dump.md) to choose how numbers are written. Two values are differentiated:
+
+shortest
+:   integers are copied from the source text -- already canonical in JSON -- except that `#!cpp -0` becomes
+    `#!cpp 0`, the way [`BasicJsonType::parse()`](../basic_json/parse.md) reads it; floats are written with the
+    library's shortest round-trip conversion, exactly as [`BasicJsonType::dump()`](../basic_json/dump.md) would (e.g.
+    `#!cpp 1.5`, `#!cpp 100.0`, `#!cpp 1e+100`)
+
+source
+:   every number is copied exactly as it appears in the source text -- `#!cpp 1.50`, `#!cpp 1E2`, `#!cpp -0`, all
+    digits of an integer literal with more digits than any number type holds -- something `BasicJsonType` cannot do,
+    since parsing already reduces every number to its parsed value
+
+## Examples
+
+??? example
+
+    The example below writes back a price list received from a supplier: with `number_format::shortest` (the
+    default), a trailing zero and scientific notation are normalized away and a long account number that overflows
+    every number type is rounded, the same way `#!cpp materialize().dump()` (or `basic_json::dump()`) would;
+    `number_format::source` keeps every number exactly as it was written in the source text instead.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__number_format.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__number_format.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [number_token](number_token.md) - get a single number's token text without dumping the whole value
+- [`BasicJsonType::error_handler_t`](../basic_json/error_handler_t.md) - the analogous enumeration for
+  `BasicJsonType::dump`'s decoding-error behavior
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,74 @@
+# <small>nlohmann::basic_json_view::</small>number_token
+
+```cpp
+string_view_t number_token() const;
+```
+
+Returns the number exactly as it appears in the source text, without parsing or rounding it.
+
+## Return value
+
+The number's token text, as a [`string_view_t`](index.md#member-types) into the document's
+[`source()`](../basic_json_document/source.md) text -- for example `#!cpp "1.50"`, `#!cpp "1E2"`, `#!cpp "-0"`, or an
+integer literal with more digits than any number type holds (such as a 30-digit integer, which [`get<T>()`](get.md)
+and [`materialize()`](materialize.md) can only represent approximately, as a `number_float_t`).
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+Throws [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) if the value is not a number; example:
+`"type must be number, but is string"`.
+
+This exception does not carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+Constant.
+
+## Notes
+
+`BasicJsonType` has no counterpart to this function: once a number is parsed into `number_integer_t`,
+`number_unsigned_t`, or `number_float_t`, its original textual form (leading zeros aside, which are already rejected
+by the grammar; trailing zeros in the fraction; the case and sign of the exponent; ...) is gone. `number_token()` is
+useful precisely where that form must survive -- a price or an identifier that must be reproduced exactly, or a
+number too large for any of `BasicJsonType`'s number types to hold without loss.
+
+The returned [`string_view_t`](index.md#member-types) always points into the document's
+[`source()`](../basic_json_document/source.md) text -- numbers are never decoded into the document's separate string
+buffer -- and is valid exactly as long as that text is, see the [validity rules](index.md) of `basic_json_view`.
+
+## Examples
+
+??? example
+
+    The example below keeps a price and an order ID exactly as they were written in an incoming order, where
+    converting them with [`get<T>()`](get.md) would lose information: the price picks up floating-point rounding, and
+    the order ID -- more digits than a 64-bit integer holds -- can only be approximated as a `#!cpp double` once
+    `#!cpp materialize()`d.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__number_token.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__number_token.output"
+    ```
+
+## See also
+
+- [get](get.md) - convert the value to a given type
+- [get_string](get_string.md) - the string, without a copy
+- [`BasicJsonType::number_integer_t`](../basic_json/number_integer_t.md),
+  [`number_unsigned_t`](../basic_json/number_unsigned_t.md), [`number_float_t`](../basic_json/number_float_t.md) - the
+  number types `#!cpp get<T>()` and `materialize()` convert into
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,156 @@
+# <small>nlohmann::basic_json_view::</small>operator[]
+
+```cpp
+// (1)
+basic_json_view operator[](string_view_t key) const;
+basic_json_view operator[](const char* key) const;
+basic_json_view operator[](const string_t& key) const;
+
+// (2)
+basic_json_view operator[](size_type idx) const;
+basic_json_view operator[](int idx) const;
+
+// (3)
+basic_json_view operator[](const json_pointer& ptr) const;
+```
+
+1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
+   the [Notes](#notes) below) -- or a [discarded](is_discarded.md) view if there is no such member.
+2. Returns the array element at index `idx`, or a [discarded](is_discarded.md) view if `idx` is out of range. (The
+   `#!cpp int` overload only exists so that an integer literal is not ambiguous between this overload and 1.)
+3. Returns the value a JSON pointer `ptr` refers to, starting at this value, or a [discarded](is_discarded.md) view
+   wherever resolving it further is not possible without inserting into or extending the document (see
+   [Return value](#return-value) and [Exceptions](#exceptions) below).
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`idx` (in)
+:   index of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+## Return value
+
+1. the value of the first member with key `key`, or a discarded view if `#!cpp is_object()` is `#!cpp false` or no
+   member has this key
+2. the element at index `idx`, or a discarded view if `#!cpp is_array()` is `#!cpp false` or `#!cpp idx >= size()`
+3. the value `ptr` resolves to, starting at this value, or a discarded view for exactly the reference tokens where the
+   **const** overload of [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) invokes undefined behavior for
+   the same pointer and the same document: an object member that does not exist, or an array index that is out of
+   range
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+1. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an object --
+   the same exception, with the same message, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a string argument on a non-object value.
+2. Throws [`type_error.305`](../../home/exceptions.md#jsonexceptiontype_error305) if the value is not an array --
+   the same exception, with the same message, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for a numeric argument on a non-array value.
+3. Throws the same exceptions, with the same messages, that the **const** overload of
+   [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) throws for the same pointer and the same document:
+    - [`out_of_range.402`](../../home/exceptions.md#jsonexceptionout_of_range402) if a reference token is `#!cpp "-"`
+      at an array.
+    - [`out_of_range.404`](../../home/exceptions.md#jsonexceptionout_of_range404) if a reference token cannot be
+      resolved because it is used on a primitive value.
+    - [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106) if an array index in `ptr` begins
+      with `#!cpp '0'`.
+    - [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if an array index in `ptr` is not a
+      number.
+
+None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+1. Linear in the number of members: as for [`ordered_json`](../ordered_json.md), members are compared one after
+   another, in document order, stopping at the first match. Each comparison first checks the key's length --
+   already known from the index, without reading the key bytes -- before comparing its content, so a key of a
+   different length than `key` is rejected without touching the source text.
+2. Linear in `idx`: elements are skipped one at a time from the first one, since they are not a fixed size in the
+   index (unlike `BasicJsonType`'s array, which is random-access).
+3. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level (as 1.) or the index into the array (as 2.).
+
+## Notes
+
+Unlike `BasicJsonType::operator[]`, which is undefined behavior (guarded by a
+[runtime assertion](../../features/assertions.md)) for a missing key on a **const** value, this operator always
+returns a safe, testable result: a [discarded](is_discarded.md) view, which is `#!cpp false` in a boolean context.
+There is also no non-const overload that inserts a missing key or extends an array -- a view never modifies the
+document.
+
+!!! info "Duplicate keys"
+
+    If the source text has an object with a duplicate key, `#!cpp operator[]` (and [`at`](at.md), [`find`](find.md),
+    [`contains`](contains.md), [`count`](count.md)) all resolve to the *first* member with that key, because a
+    lookup can stop as soon as it finds a match. This is different from
+    [`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which replay every
+    member in order and so end up keeping the *last* value for a repeated key -- there is no reason for them to stop
+    early. [`begin()`](begin.md)/[`end()`](end.md) and [`items()`](items.md) iterate over *all* members, including
+    duplicates, in document order. See the example below and [`size()`](size.md#notes).
+
+!!! info "JSON pointer resolution"
+
+    Overload 3 walks `ptr` one reference token at a time, starting at this value, the same way [`at`](at.md) and
+    [`contains`](contains.md) do. It only ever returns a discarded view where the **const** overload of
+    `BasicJsonType::operator[]` would be undefined behavior for the same pointer -- a missing object member or an
+    out-of-range array index -- and still throws for every other way `ptr` can fail to resolve. See
+    [`at`](at.md#exceptions) for the checked version, which throws in every case instead, and
+    [`contains`](contains.md) for a version that never throws.
+
+## Examples
+
+??? example "Example: (1)/(2) access specified element"
+
+    The example below reads a couple of fields out of a batch of user records without ever materializing a full
+    `BasicJsonType` value for the batch. `operator[]` is used both to look up an optional object member and to index
+    into an array -- in both cases, a missing value comes back as a discarded view that can be tested with a plain
+    `#!cpp if`, instead of relying on undefined behavior.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator[].cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator[].output"
+    ```
+
+??? example "Example: (3) access specified element via JSON pointer"
+
+    The example below reaches straight into one deeply nested field of a large document with a single JSON pointer,
+    without ever building a tree for the rest of it, and shows the discarded-view and throwing outcomes of a pointer
+    that cannot be fully resolved.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator[]_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator[]_json_pointer.output"
+    ```
+
+## See also
+
+- [at](at.md) - access specified element with bounds checking (throws instead of returning a discarded view)
+- [front](front.md), [back](back.md) - access the first or last element
+- [find](find.md), [contains](contains.md) - look up a member without throwing
+- [`BasicJsonType::operator[]`](../basic_json/operator%5B%5D.md) - the corresponding function of `basic_json`
+- [`json_pointer`](../json_pointer/index.md) - JSON pointer type used by overload 3
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,107 @@
+# <small>nlohmann::basic_json_view::</small>operator==
+
+```cpp
+// (1)
+bool operator==(const basic_json_view& lhs, const basic_json_view& rhs);
+
+// (2)
+bool operator==(const basic_json_view& lhs, const BasicJsonType& rhs);
+bool operator==(const BasicJsonType& lhs, const basic_json_view& rhs);
+```
+
+1. Compares two views for equality: whether the values [`BasicJsonType::parse()`](../basic_json/parse.md) would
+   produce for `lhs` and `rhs` are equal, according to `BasicJsonType`'s [`operator==`](../basic_json/operator_eq.md).
+2. Compares a view and a `BasicJsonType` value for equality, in either order: whether the value `parse()` would
+   produce for the view and the other operand are equal, according to `BasicJsonType`'s
+   [`operator==`](../basic_json/operator_eq.md).
+
+Neither overload builds a `BasicJsonType` value for a view to do the comparison (see [Notes](#notes) below). Numbers
+compare by value across their types (`#!cpp 1 == 1.0`), and an object compares by its members, with duplicate keys
+resolved exactly as `parse()` resolves them -- the last value, at the position of the first occurrence of the key.
+
+## Parameters
+
+`lhs` (in)
+:   first value to consider
+
+`rhs` (in)
+:   second value to consider
+
+## Return value
+
+whether the values `lhs` and `rhs` are equal
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
+view refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`. Unlike the other comparison and most other `basic_json_view` functions,
+`operator==` is not `#!cpp noexcept`: resolving an object's members needs a temporary array to sort them by key (see
+[Complexity](#complexity) below), and that allocation can fail.
+
+## Complexity
+
+Linear in the size of the compared values: every number, string, array element, and object member is visited at most
+once, and the walk is iterative, so the nesting depth it can compare is limited by available memory only, not by the
+call stack (as for [`materialize()`](materialize.md)). Resolving an object's members takes an additional O(n log n)
+in the number of members at that level, since they are sorted by key to detect and resolve duplicates before being
+compared. Two arrays of different [`size()`](size.md) are rejected without visiting either one's elements.
+
+## Notes
+
+Only a single number, boolean, or `#!cpp null` value is ever materialized into a `BasicJsonType`, to reuse its
+`operator==` -- for numbers, so that values written differently in the source text but equal in value (e.g. an
+integer and a floating-point literal) still compare equal, following the same rules `BasicJsonType` does for special
+values such as `#!cpp NaN`. Constructing one of these scalars never allocates. Strings are compared directly, without
+allocating, either from the source text on both sides or, for overload 2, against `BasicJsonType`'s own string.
+Arrays and objects are never materialized at all; only their elements or members are visited, one pair at a time.
+
+!!! info "How objects are compared"
+
+    For a [`json_view`](../json_view.md) (`BasicJsonType::object_t` is `#!cpp std::map`), members are compared by
+    key, regardless of the order they appear in the source text. For an
+    [`ordered_json_view`](../ordered_json_view.md) (`object_t` is `ordered_map`), they are compared in the order
+    they occur, so the very same two objects with their members reordered can compare equal as `json_view`s but not
+    as `ordered_json_view`s. This is exactly how [`json`](../json.md) and [`ordered_json`](../ordered_json.md)
+    compare, see ["Comparing different `basic_json` specializations"](../basic_json/operator_eq.md#notes).
+
+!!! info "Discarded views"
+
+    A [discarded](is_discarded.md) view compares the same way a discarded `BasicJsonType` value does, which is
+    governed by
+    [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../macros/json_use_legacy_discarded_value_comparison.md): by
+    default, a discarded view is never equal to anything, not even another discarded view.
+
+No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
+the way to get a `BasicJsonType` value that supports it.
+
+## Examples
+
+??? example
+
+    The example below checks whether a newly received configuration differs from the previous one, and whether a
+    received document matches what a test expects -- directly on views, without ever materializing a `BasicJsonType`
+    value for either side.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_eq.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_eq.output"
+    ```
+
+## See also
+
+- [operator!=](operator_ne.md) - compare for inequality
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
+- [`BasicJsonType::operator==`](../basic_json/operator_eq.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,74 @@
+# <small>nlohmann::basic_json_view::</small>operator<<
+
+```cpp
+std::ostream& operator<<(std::ostream& o, const basic_json_view& v);
+```
+
+Not available when [`JSON_NO_IO`](../macros/json_no_io.md) is defined.
+
+Serializes the given view `v` to the output stream `o`, using [`dump`](dump.md) -- exactly as
+`#!cpp operator<<(std::ostream&, const basic_json&)` does for a `basic_json` value.
+
+- The indentation of the output can be controlled with the member variable `width` of the output stream `o`. For
+  instance, using the manipulator `std::setw(4)` on `o` sets the indentation level to `4`, and the serialization
+  result is the same as calling `#!cpp v.dump(4)`. A `width` of `0` or less (the default) selects the most compact
+  representation, as `#!cpp v.dump(-1)` does.
+- The indentation character can be controlled with the member variable `fill` of the output stream `o`. For instance,
+  the manipulator `std::setfill('\t')` sets indentation to use a tab character rather than the default space
+  character.
+- As for `basic_json`, `o`'s `width` is reset to `0` after this call, whether or not it was greater than `0` before.
+
+Numbers are always written as `#!cpp v.dump()` writes them by default, i.e. as with
+[`number_format::shortest`](number_format.md); there is no way to select `#!cpp number_format::source` through the
+stream.
+
+## Parameters
+
+`o` (in, out)
+:   stream to write to
+
+`v` (in)
+:   view to serialize
+
+## Return value
+
+the stream `o`
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`, propagated from [`dump`](dump.md#exceptions). Unlike
+`#!cpp operator<<(std::ostream&, const basic_json&)`, there is no UTF-8 decoding step that could throw
+[`type_error.316`](../../home/exceptions.md#jsonexceptiontype_error316), and no `error_handler` to choose between --
+see the [Exceptions](dump.md#exceptions) of `dump`.
+
+## Complexity
+
+Linear, as [`dump`](dump.md#complexity).
+
+## Examples
+
+??? example
+
+    The example below writes one record out of a larger batch straight to a log stream -- compact for a one-line
+    entry, and pretty-printed with `std::setw`/`std::setfill` for a readable dump -- without ever building a
+    `BasicJsonType` value for the record, or for the rest of the batch.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_ltlt.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_ltlt.output"
+    ```
+
+## See also
+
+- [dump](dump.md) - serialize to a JSON-formatted string
+- [`operator<<(std::ostream&)`](../operator_ltlt.md) - the corresponding operator for `basic_json`
+- [`JSON_NO_IO`](../macros/json_no_io.md) - switch off functions relying on certain C++ I/O headers
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,82 @@
+# <small>nlohmann::basic_json_view::</small>operator!=
+
+```cpp
+// (1)
+bool operator!=(const basic_json_view& lhs, const basic_json_view& rhs);
+
+// (2)
+bool operator!=(const basic_json_view& lhs, const BasicJsonType& rhs);
+bool operator!=(const BasicJsonType& lhs, const basic_json_view& rhs);
+```
+
+1. Compares two views for inequality. Returns `#!cpp !(lhs == rhs)`, see [operator==](operator_eq.md).
+2. Compares a view and a `BasicJsonType` value for inequality, in either order. Returns `#!cpp !(lhs == rhs)` (or,
+   for the reversed order, `#!cpp !(rhs == lhs)`), see [operator==](operator_eq.md).
+
+Since `operator!=` is defined as the negation of [`operator==`](operator_eq.md), it follows the same rules for
+special cases: for instance, since a [discarded](is_discarded.md) view is never equal to anything by default (see
+[operator=='s Notes](operator_eq.md#notes)), it is never *unequal* to anything either -- `#!cpp discarded != discarded`
+is also `#!cpp false`, exactly as for a discarded `BasicJsonType` value.
+
+## Parameters
+
+`lhs` (in)
+:   first value to consider
+
+`rhs` (in)
+:   second value to consider
+
+## Return value
+
+whether the values `lhs` and `rhs` are not equal
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to either operand, or to the document(s) a
+view refers to.
+
+## Exceptions
+
+May throw `#!cpp std::bad_alloc`, propagated from [`operator==`](operator_eq.md#exceptions). Unlike most other
+`basic_json_view` functions, `operator!=` is not `#!cpp noexcept`.
+
+## Complexity
+
+Linear, as [`operator==`](operator_eq.md#complexity).
+
+## Notes
+
+See the [Notes](operator_eq.md#notes) of `operator==` -- in particular for how an object's members are compared
+(order matters for [`ordered_json_view`](../ordered_json_view.md) but not for [`json_view`](../json_view.md)) and
+for how discarded views compare.
+
+No ordering comparison (`#!cpp operator<`) is provided for `basic_json_view`; [`materialize()`](materialize.md) is
+the way to get a `BasicJsonType` value that supports it.
+
+## Examples
+
+??? example
+
+    The example below asserts, as a test would, that a received document differs from an unwanted value, and shows
+    that -- as for [`json`](../json.md)/[`ordered_json`](../ordered_json.md) -- reordering an object's members is
+    detected as a difference for an `ordered_json_view` but not for a `json_view`.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__operator_ne.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__operator_ne.output"
+    ```
+
+## See also
+
+- [operator==](operator_eq.md) - compare for equality
+- [materialize](materialize.md) - build a `BasicJsonType` value, e.g. to keep comparing after the document is gone
+- [`BasicJsonType::operator!=`](../basic_json/operator_ne.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -33,6 +33,12 @@ Constant: for an object or array, the element count is stored in the index, not
 As for [`BasicJsonType::size()`](../basic_json/size.md), this does not return the length of a string value -- it is
 `1` for a string, regardless of its length.

+If the source text has an object with a duplicate key, every occurrence counts towards its `size()` -- unlike
+[`materialize()`](materialize.md) (and [`BasicJsonType::parse()`](../basic_json/parse.md)), which keeps only the last
+value for a repeated key. This means `#!cpp v.size()` can be larger than `#!cpp v.materialize().size()`. See the
+[Notes on duplicate keys](operator[].md#notes) of `operator[]` for why lookups and iteration disagree on how many
+members there are.
+
 ## Examples

 ??? example
@@ -0,0 +1,63 @@
+# <small>nlohmann::basic_json_view::</small>type_name
+
+```cpp
+const char* type_name() const noexcept;
+```
+
+Returns the type name as string to be used in error messages -- usually to indicate that a function was called on a
+wrong JSON type. Identical to [`BasicJsonType::type_name()`](../basic_json/type_name.md), including the extra
+`#!cpp "discarded"` return value for a [discarded](is_discarded.md) view (`BasicJsonType::type_name()` produces the
+same string for a discarded `BasicJsonType` value).
+
+## Return value
+
+a string representation of the type ([`value_t`](../basic_json/value_t.md)):
+
+| Value type                                         | return value  |
+|-----------------------------------------------------|---------------|
+| `#!json null`                                        | `"null"`      |
+| boolean                                              | `"boolean"`   |
+| string                                               | `"string"`    |
+| number (integer, unsigned integer, floating-point)   | `"number"`    |
+| object                                               | `"object"`    |
+| array                                                | `"array"`     |
+| discarded                                            | `"discarded"` |
+
+`type_name()` never returns `#!cpp "binary"`, since a JSON text has no binary values (see
+[`is_binary()`](is_binary.md)); it also never returns `#!cpp "invalid"`, since a view's `#!cpp kind` always comes
+from a value the parser actually produced.
+
+## Exception safety
+
+No-throw guarantee: this function never throws exceptions.
+
+## Complexity
+
+Constant.
+
+## Examples
+
+??? example
+
+    The example below reports why some parsed messages were rejected, using only `type_name()` -- no
+    `BasicJsonType` value is ever built for the ones that are wrong, and the message text matches what
+    [`BasicJsonType::type_name()`](../basic_json/type_name.md) would produce for the same value.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__type_name.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__type_name.output"
+    ```
+
+## See also
+
+- [type](type.md) - return the type of the value
+- [`BasicJsonType::type_name`](../basic_json/type_name.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -0,0 +1,131 @@
+# <small>nlohmann::basic_json_view::</small>value
+
+```cpp
+// (1)
+template<typename T>
+T value(string_view_t key, const T& default_value) const;
+string_t value(string_view_t key, const char* default_value) const;
+
+// (2)
+template<typename T>
+T value(const json_pointer& ptr, const T& default_value) const;
+string_t value(const json_pointer& ptr, const char* default_value) const;
+```
+
+1. Returns the value of the object member with key `key` -- the first one, should the key occur more than once (see
+   [Notes on duplicate keys](operator[].md#notes)) -- converted to `T`, or `default_value` if there is no such member.
+2. Returns the value a JSON pointer `ptr` refers to, starting at this value, converted to `T`, or `default_value` if
+   `ptr` cannot be resolved.
+
+Both overloads have a dedicated `#!cpp const char*` overload, so `#!cpp v.value(key, "default")` (and the JSON pointer
+equivalent) deduce `string_t`, not `const char*`, for their return type and for the comparison used to pick between
+`key` and `default_value`.
+
+## Template parameters
+
+`T`
+:   the type to convert the found value to; also the type of `default_value`
+
+## Parameters
+
+`key` (in)
+:   object key of the element to access
+
+`ptr` (in)
+:   JSON pointer to the element to access
+
+`default_value` (in)
+:   the value to return if `key`/`ptr` resolves to no value
+
+## Return value
+
+1. the first member with key `key`, converted to `T`, or `default_value`
+2. the value `ptr` resolves to, converted to `T`, or `default_value`
+
+## Exception safety
+
+Strong exception safety: if an exception is thrown, there are no changes to the view or the document it refers to.
+
+## Exceptions
+
+1. Throws [`type_error.306`](../../home/exceptions.md#jsonexceptiontype_error306) if the value is not an object --
+   the same exception, with the same message, that [`BasicJsonType::value`](../basic_json/value.md) throws for the
+   same call. If a member with key `key` is found, throws whatever converting it to `T` throws (typically
+   [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302), with the same message
+   [`BasicJsonType::value`](../basic_json/value.md) throws for the same mismatch); a missing member never throws.
+2. Throws [`type_error.306`](../../home/exceptions.md#jsonexceptiontype_error306) if this value -- not the value `ptr`
+   resolves to -- is neither an object nor an array. Throws [`parse_error.106`](../../home/exceptions.md#jsonexceptionparse_error106)
+   or [`parse_error.109`](../../home/exceptions.md#jsonexceptionparse_error109) if `ptr` contains a malformed array
+   index. If `ptr` resolves to a value, throws whatever converting it to `T` throws. Every other way `ptr` can fail to
+   resolve -- a missing key, an out-of-range or "`-`" array index, an unresolvable token on a primitive -- yields
+   `default_value` instead of throwing, exactly as [`BasicJsonType::value`](../basic_json/value.md) catches
+   `out_of_range` and returns `default_value`.
+
+None of these exceptions carry a [`JSON_DIAGNOSTICS`](../macros/json_diagnostics.md) path: the view has no
+`BasicJsonType` value to point at, so the exception is created without one, even if `BasicJsonType` was built with
+`JSON_DIAGNOSTICS` enabled.
+
+## Complexity
+
+1. Linear in the number of members: as for [`operator[]`](operator[].md#complexity), members are compared one after
+   another, in document order, stopping at the first match. Plus the complexity of converting the found member to
+   `T` (see [`get`](get.md)).
+2. Linear in the number of reference tokens of `ptr` and, for each token, in the number of members of the object at
+   that level or the index into the array -- as for the [`operator[]`](operator[].md#complexity) and
+   [`at`](at.md#complexity) overloads that take a JSON pointer. Plus the complexity of converting the resolved value
+   to `T`.
+
+## Notes
+
+!!! info "Differences to `at` and `operator[]`"
+
+    Unlike [`at`](at.md), this function does not throw if `key`/`ptr` resolves to no value. Unlike
+    [`operator[]`](operator[].md), it never returns a [discarded](is_discarded.md) view -- it always returns a `T` --
+    and it is available on any view, since it never needs to insert a missing element the way the non-const
+    `BasicJsonType::operator[]` would.
+
+!!! info "Which values can be asked"
+
+    As for [`BasicJsonType::value`](../basic_json/value.md), the key overload (1) requires an object, and the JSON
+    pointer overload (2) an object or an array.
+
+## Examples
+
+??? example "Example: (1) access specified object element with default value"
+
+    The example below reads a couple of optional configuration fields with a default, so that a missing key never
+    needs a `#!cpp try`/`#!cpp catch` of its own.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__value.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__value.output"
+    ```
+
+??? example "Example: (2) access specified element via JSON pointer with default value"
+
+    The example below reads an optional, nested configuration value with a default, given as a JSON pointer.
+
+    ```cpp
+    --8<-- "examples/basic_json_view__value_json_pointer.cpp"
+    ```
+
+    Output:
+
+    ```json
+    --8<-- "examples/basic_json_view__value_json_pointer.output"
+    ```
+
+## See also
+
+- [at](at.md) - access specified element with bounds checking (throws instead of returning a default value)
+- [operator[]](operator[].md) - access specified element (returns a discarded view instead of a default value)
+- [`BasicJsonType::value`](../basic_json/value.md) - the corresponding function of `basic_json`
+
+## Version history
+
+- Added in version 3.13.0.
@@ -84,6 +84,8 @@ Linear.
 ## See also

 - [dump](basic_json/dump.md) - serialize to a JSON-formatted string
+- [`basic_json_view::operator<<`](basic_json_view/operator_ltlt.md) - the corresponding operator for
+  `basic_json_view`
 - [Serialization](../features/serialization.md) - the serialization article

 ## Version history
@@ -0,0 +1,36 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // required fields of a service configuration -- at() reports a missing
+    // or wrong-typed field with the very same exception basic_json::at()
+    // would throw for the equivalent nlohmann::json value, so error
+    // handling written against basic_json::at() keeps working unchanged
+    json_document config = json_document::parse(R"({"name": "cache", "port": "6379"})");
+    const json_view service = config.root();
+
+    std::cout << service.at("port").materialize().dump() << '\n';
+
+    try
+    {
+        // "port" is a string, not an array
+        static_cast<void>(service.at("port").at(0));
+    }
+    catch (const nlohmann::json::type_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(service.at("timeout"));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+"6379"
+[json.exception.type_error.304] cannot use at() with string
+[json.exception.out_of_range.403] key 'timeout' not found
@@ -0,0 +1,34 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"region": "eu", "servers": ["eu-1", "eu-2"]})");
+    const auto root = doc.root();
+
+    std::cout << root.at(json_pointer("/servers/1")).materialize().dump() << '\n';
+
+    // at() throws for every resolution failure -- with the very same
+    // message json::at(ptr) would throw for the same pointer and the same
+    // document
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/servers/5")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        static_cast<void>(root.at(json_pointer("/missing")));
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+"eu-2"
+[json.exception.out_of_range.401] array index 5 is out of range
+[json.exception.out_of_range.403] key 'missing' not found
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // the same build log; back() reads only the final status. It is linear
+    // in the number of events (unlike front(), which is constant), but
+    // still far less work than materializing the whole array
+    json_document log = json_document::parse(R"(["queued", "started", "compiling", "linking", "done"])");
+    std::cout << log.root().back().materialize().dump() << '\n';
+
+    // an empty log -- back() throws instead of the undefined behavior
+    // basic_json::back() has for an empty array
+    json_document empty_log = json_document::parse("[]");
+    try
+    {
+        static_cast<void>(empty_log.root().back());
+    }
+    catch (const nlohmann::json::invalid_iterator& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+"done"
+[json.exception.invalid_iterator.214] cannot get value
@@ -0,0 +1,18 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a log record: the fields matter in the order they were written, e.g.
+    // to reproduce the record as it was logged. A nlohmann::json object
+    // sorts its keys, so materializing and iterating it would instead print
+    // them alphabetically ("level", "message", "time")
+    json_document record = json_document::parse(R"({"time": "10:00:01", "level": "info", "message": "started"})");
+
+    for (auto it = record.root().begin(); it != record.root().end(); ++it)
+    {
+        std::cout << it.key() << '=' << it->materialize().dump() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+time="10:00:01"
+level="info"
+message="started"
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <numeric>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // sum many measurements with std::accumulate; cbegin()/cend() (identical
+    // to begin()/end() here -- the view is always read-only) let the view be
+    // used with standard algorithms without ever materializing the whole
+    // array into a nlohmann::json value
+    json_document measurements = json_document::parse("[3, 1, 4, 1, 5, 9, 2, 6]");
+    const auto values = measurements.root();
+
+    const int sum = std::accumulate(values.cbegin(), values.cend(), 0,
+                                    [](int total, const json_view & v)
+    {
+        return total + v.materialize().get<int>();
+    });
+
+    std::cout << sum << '\n';
+}
@@ -0,0 +1 @@
+31
@@ -0,0 +1,24 @@
+#include <algorithm>
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // check that every element of a (possibly large) batch is an object,
+    // before materializing any of them -- cbegin()/cend() (identical to
+    // begin()/end() here) work as the range for std::all_of like they would
+    // for any standard container
+    json_document batch = json_document::parse(R"([{"id": 1}, {"id": 2}, {"id": 3}])");
+    const auto records = batch.root();
+
+    const bool all_objects = std::all_of(records.cbegin(), records.cend(),
+                                         [](const json_view & v)
+    {
+        return v.is_object();
+    });
+
+    std::cout << std::boolalpha << all_objects << '\n';
+}
@@ -0,0 +1 @@
+true
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // count how many of many incoming records carry an optional "retry_of"
+    // field -- contains() only walks the flat index, so scanning a large
+    // batch like this never builds a single nlohmann::json value
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1},
+        {"id": 2, "retry_of": 1},
+        {"id": 3},
+        {"id": 4, "retry_of": 3}
+      ]
+    )");
+
+    const auto records = batch.root();
+    std::size_t retries = 0;
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        if (records[i].contains("retry_of"))
+        {
+            ++retries;
+        }
+    }
+    std::cout << retries << " of " << records.size() << " records are retries\n";
+}
@@ -0,0 +1 @@
+2 of 4 records are retries
@@ -0,0 +1,39 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    // "retry_of" is only present on some records, nested a level down
+    // inside "meta"
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "meta": {}},
+        {"id": 2, "meta": {"retry_of": 1}}
+      ]
+    )");
+
+    const auto records = batch.root();
+    const json_pointer retry_of("/meta/retry_of");
+    for (std::size_t i = 0; i < records.size(); ++i)
+    {
+        const auto record = records[i];
+        if (record.contains(retry_of))
+        {
+            std::cout << "record " << i << " is a retry of " << record[retry_of].get<int>() << '\n';
+        }
+        else
+        {
+            std::cout << "record " << i << " is original\n";
+        }
+    }
+
+    // contains() with a JSON pointer never throws -- not even for a
+    // pointer that indexes into a primitive ("/0/id/x") or uses a
+    // malformed array index ("/01"), either of which would need a
+    // try/catch with json::contains(ptr)
+    std::cout << std::boolalpha << records.contains(json_pointer("/0/id/x")) << '\n';
+    std::cout << std::boolalpha << records.contains(json_pointer("/01")) << '\n';
+}
@@ -0,0 +1,4 @@
+record 0 is original
+record 1 is a retry of 1
+false
+false
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // validate that every transaction of a batch carries a mandatory
+    // "amount" field before materializing any of them into a nlohmann::json
+    // value -- count() returns 0 or 1 for an object
+    json_document batch = json_document::parse(R"(
+      [
+        {"id": 1, "amount": 9.99},
+        {"id": 2}
+      ]
+    )");
+
+    const auto transactions = batch.root();
+    for (std::size_t i = 0; i < transactions.size(); ++i)
+    {
+        const auto transaction = transactions[i];
+        if (transaction.count("amount") == 0)
+        {
+            std::cout << "transaction " << i << " is missing \"amount\"\n";
+            continue;
+        }
+        std::cout << "transaction " << i << ": " << transaction["amount"].materialize().dump() << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+transaction 0: 9.99
+transaction 1 is missing "amount"
@@ -0,0 +1,25 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a large batch of sensor readings -- forward just the one that changed,
+    // without ever building a basic_json value for the batch or for the
+    // readings that are not needed
+    const json_document batch = json_document::parse(R"(
+      [{"id": 1, "temp": 21.5}, {"id": 2, "temp": 87.3}, {"id": 3, "temp": 21.7}]
+    )");
+    const json_view readings = batch.root();
+    std::cout << readings[1].dump() << '\n';
+
+    // a configuration file -- dump() on the view keeps the member order of
+    // the source text; a json value's object_t is std::map, so
+    // materialize().dump() of the very same view sorts the keys instead
+    const json_document config = json_document::parse(
+                                     R"({"name": "cache", "host": "db1", "port": 6379, "timeout": 30})");
+    std::cout << config.root().dump(2) << "\n\n";
+    std::cout << config.root().materialize().dump(2) << '\n';
+}
@@ -0,0 +1,14 @@
+{"id":2,"temp":87.3}
+{
+  "name": "cache",
+  "host": "db1",
+  "port": 6379,
+  "timeout": 30
+}
+
+{
+  "host": "db1",
+  "name": "cache",
+  "port": 6379,
+  "timeout": 30
+}
@@ -0,0 +1,27 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // scan a (possibly large) array of readings for the first one over a
+    // threshold; the loop stops at end() as soon as one is found, and only
+    // the matching reading is ever materialized
+    json_document readings = json_document::parse("[12, 18, 25, 31, 9]");
+    const auto values = readings.root();
+
+    auto it = values.begin();
+    for (; it != values.end(); ++it)
+    {
+        if (it->materialize().get<int>() > 20)
+        {
+            break;
+        }
+    }
+
+    if (it != values.end())
+    {
+        std::cout << "first reading over 20: " << it->materialize().dump() << '\n';
+    }
+}
@@ -0,0 +1 @@
+first reading over 20: 25
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a batch of incoming events; only some carry a "user_id" -- find()
+    // locates it without throwing for the events that turn out to not be
+    // objects, and without materializing an event that does not match
+    json_document batch = json_document::parse(R"(
+      [
+        {"type": "click", "user_id": 42},
+        {"type": "ping"},
+        {"type": "click", "user_id": 7}
+      ]
+    )");
+
+    const auto events = batch.root();
+    for (std::size_t i = 0; i < events.size(); ++i)
+    {
+        const auto event = events[i];
+        const auto it = event.find("user_id");
+        if (it != event.end())
+        {
+            std::cout << "user " << it->materialize().dump() << '\n';
+        }
+    }
+}
@@ -0,0 +1,2 @@
+user 42
+user 7
@@ -0,0 +1,24 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // the build log of a running job; front() reads just the earliest event
+    // without materializing the (possibly long) rest of the log
+    json_document log = json_document::parse(R"(["queued", "started", "compiling", "linking", "done"])");
+    std::cout << log.root().front().materialize().dump() << '\n';
+
+    // an empty log -- front() throws instead of the undefined behavior
+    // basic_json::front() has for an empty array
+    json_document empty_log = json_document::parse("[]");
+    try
+    {
+        static_cast<void>(empty_log.root().front());
+    }
+    catch (const nlohmann::json::invalid_iterator& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+"queued"
+[json.exception.invalid_iterator.214] cannot get value
@@ -0,0 +1,55 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+#include <vector>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+// address has no direct conversion in get<T>(), so get<address>() falls back
+// to materialize().get<address>() -- a real nlohmann::json value is built
+// for just this one member, and its own from_json() runs on that
+struct address
+{
+    std::string city;
+    int zip = 0;
+};
+
+void from_json(const nlohmann::json& j, address& a)
+{
+    j.at("city").get_to(a.city);
+    j.at("zip").get_to(a.zip);
+}
+
+int main()
+{
+    json_document doc = json_document::parse(R"(
+      {
+        "name": "Alice",
+        "active": true,
+        "orders": [1, 2, 3],
+        "address": {"city": "Berlin", "zip": 10115}
+      }
+    )");
+    const json_view customer = doc.root();
+
+    // read typed fields straight into C++ variables -- none of these build
+    // a nlohmann::json value
+    const std::string name = customer["name"].get<std::string>();
+    const bool active = customer["active"].get<bool>();
+    std::cout << name << (active ? " (active)" : " (inactive)") << '\n';
+
+    // std::vector<json_view> keeps views of the array elements instead of
+    // copies of their values
+    bool first = true;
+    for (const json_view order : customer["orders"].get<std::vector<json_view>>())
+    {
+        std::cout << (first ? "" : " ") << order.get<int>();
+        first = false;
+    }
+    std::cout << '\n';
+
+    // everything else goes through materialize()
+    const address a = customer["address"].get<address>();
+    std::cout << a.city << ' ' << a.zip << '\n';
+}
@@ -0,0 +1,3 @@
+Alice (active)
+1 2 3
+Berlin 10115
@@ -0,0 +1,31 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a "large response" stand-in: only the "id" field is ever read out of it
+    const std::string text =
+        R"({"id": "8f14e45f-ceea-467e-bb92-963f5e3c7a08", "note": "created via API\n", "payload": "..."})";
+    const json_document doc = json_document::parse(text);
+    const json_view response = doc.root();
+
+    const json_view::string_view_t id = response["id"].get_string();
+    std::cout << id << '\n';
+
+    // no std::string was allocated for "id": its bytes still live inside
+    // the original buffer, so id's data lies inside [text.data(),
+    // text.data() + text.size())
+    const bool id_in_source = id.data() >= text.data() && id.data() + id.size() <= text.data() + text.size();
+    std::cout << std::boolalpha << id_in_source << '\n';
+
+    // "note" contains an escape sequence ('\n'), so it was decoded once
+    // into the document's own buffer -- get_string() still avoids a copy
+    // into a new std::string, but the bytes no longer live inside "text"
+    const json_view::string_view_t note = response["note"].get_string();
+    const bool note_in_source = note.data() >= text.data() && note.data() + note.size() <= text.data() + text.size();
+    std::cout << std::boolalpha << note_in_source << '\n';
+}
@@ -0,0 +1,3 @@
+8f14e45f-ceea-467e-bb92-963f5e3c7a08
+true
+false
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"host": "db.example.com", "port": 5432, "ssl": true})");
+    const json_view config = doc.root();
+
+    // get_to() writes directly into existing variables -- handy for filling
+    // in the members of a struct one field at a time, without an
+    // intermediate value from get<T>() for each one
+    std::string host;
+    int port = 0;
+    bool ssl = false;
+    config["host"].get_to(host);
+    config["port"].get_to(port);
+    config["ssl"].get_to(ssl);
+    std::cout << host << ':' << port << (ssl ? " (tls)" : "") << '\n';
+
+    // the return value is a reference to the argument, so a call can be
+    // used directly in a larger expression
+    std::string other_host;
+    std::cout << config["host"].get_to(other_host).size() << '\n';
+}
@@ -0,0 +1,2 @@
+db.example.com:5432 (tls)
+14
@@ -0,0 +1,22 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // a settings object whose source text records every update to a key as
+    // a duplicate member. items() visits all of them, in document order, so
+    // the update history is visible; operator[] only ever sees the first
+    // one, and materialize() -- like basic_json::parse() -- keeps the last
+    json_document updates = json_document::parse(R"({"retries": 1, "timeout": 30, "retries": 5})");
+    const auto settings = updates.root();
+
+    for (const auto& item : settings.items())
+    {
+        std::cout << item.key() << '=' << item.value().materialize().dump() << '\n';
+    }
+
+    std::cout << "first \"retries\" seen by operator[]: " << settings["retries"].materialize().dump() << '\n';
+    std::cout << "last \"retries\" kept by materialize(): " << settings.materialize()["retries"].dump() << '\n';
+}
@@ -0,0 +1,5 @@
+retries=1
+timeout=30
+retries=5
+first "retries" seen by operator[]: 1
+last "retries" kept by materialize(): 5
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a price list received from a supplier feed -- prices and account
+    // numbers must be forwarded exactly, e.g. into an invoice
+    const json_document doc = json_document::parse(R"(
+      [{"sku": "A1", "price": 19.90, "account_id": 12345678901234567890123456},
+       {"sku": "A2", "price": 1E2, "account_id": 98765432109876543210987654}]
+    )");
+    const json_view list = doc.root();
+
+    // number_format::shortest (the default) writes numbers the way
+    // basic_json::dump() would: "19.90" becomes "19.9", "1E2" becomes
+    // "100.0", and each account number -- far beyond any 64-bit integer --
+    // is rounded to the nearest double, exactly as materialize().dump()
+    // (or a plain nlohmann::json) would round it
+    std::cout << list.dump() << '\n';
+
+    // number_format::source copies every number exactly as it was written
+    // in the source text instead -- something basic_json cannot do at all,
+    // since parsing already reduces every number to its parsed value
+    std::cout << list.dump(-1, ' ', false, json_view::number_format::source) << '\n';
+}
@@ -0,0 +1,2 @@
+[{"sku":"A1","price":19.9,"account_id":1.2345678901234568e+25},{"sku":"A2","price":100.0,"account_id":9.876543210987655e+25}]
+[{"sku":"A1","price":19.90,"account_id":12345678901234567890123456},{"sku":"A2","price":1E2,"account_id":98765432109876543210987654}]
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // a price and an order id from an incoming order -- both need to be
+    // reproduced exactly, e.g. for an invoice or an audit log
+    json_document doc = json_document::parse(R"(
+      {"price": 19.90, "order_id": 1234567890123456789012345, "quantity": 3}
+    )");
+    const json_view order = doc.root();
+
+    // number_token() returns the number exactly as written in the source
+    std::cout << order["price"].number_token() << '\n';
+    std::cout << order["order_id"].number_token() << '\n';
+
+    // get<double>() converts it instead -- the exact source text is gone:
+    // "19.90" becomes the double closest to 19.9, printed without the
+    // trailing zero, and the 25-digit order id -- far beyond any 64-bit
+    // integer -- can only be approximated as a double
+    std::cout << order["price"].get<double>() << '\n';
+    std::cout << order.materialize()["order_id"].dump() << '\n';
+
+    // an ordinary quantity has nothing to lose either way
+    std::cout << order["quantity"].number_token() << " == " << order["quantity"].get<int>() << '\n';
+}
@@ -0,0 +1,5 @@
+19.90
+1234567890123456789012345
+19.9
+1.2345678901234568e+24
+3 == 3
@@ -0,0 +1,42 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+
+int main()
+{
+    // two user records from a large API response; only the fields that are
+    // actually read are ever touched, and no nlohmann::json tree is built
+    // for the batch
+    json_document batch = json_document::parse(R"(
+      [
+        {"name": "Alice", "email": "alice@example.com", "tags": ["admin", "ops"]},
+        {"name": "Bob", "tags": []}
+      ]
+    )");
+
+    const auto users = batch.root();
+    for (std::size_t i = 0; i < users.size(); ++i)
+    {
+        const auto user = users[i];
+        std::cout << user["name"].materialize().dump();
+
+        // operator[] on a missing object key gives a discarded view -- test
+        // it with a plain "if". The const overload of json::operator[]
+        // would instead be undefined behavior (guarded by an assertion) for
+        // a missing key
+        if (const auto email = user["email"])
+        {
+            std::cout << " <" << email.materialize().dump() << ">";
+        }
+
+        // the same holds for an array index past the end: a discarded view,
+        // not undefined behavior
+        if (const auto first_tag = user["tags"][0])
+        {
+            std::cout << " #" << first_tag.materialize().dump();
+        }
+
+        std::cout << '\n';
+    }
+}
@@ -0,0 +1,2 @@
+"Alice" <"alice@example.com"> #"admin"
+"Bob"
@@ -0,0 +1,47 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_pointer = nlohmann::json::json_pointer;
+
+int main()
+{
+    // a larger document; operator[] with a JSON pointer reaches straight to
+    // one deeply nested field, without ever building a tree for the rest
+    json_document doc = json_document::parse(R"(
+      {
+        "region": {
+          "servers": [
+            {"name": "eu-1", "metrics": {"cpu": 0.42}},
+            {"name": "eu-2", "metrics": {"cpu": 0.71}}
+          ]
+        }
+      }
+    )");
+
+    const auto root = doc.root();
+    std::cout << root[json_pointer("/region/servers/1/metrics/cpu")].materialize().dump() << '\n';
+
+    // a missing key or an out-of-range index along the path gives a
+    // discarded view, exactly where const json::operator[] would be
+    // undefined behavior for the same pointer
+    if (const auto missing = root[json_pointer("/region/servers/5/metrics/cpu")])
+    {
+        std::cout << missing.materialize().dump() << '\n';
+    }
+    else
+    {
+        std::cout << "no such server\n";
+    }
+
+    // indexing into a primitive still throws, as basic_json::operator[]
+    // does for the same pointer
+    try
+    {
+        static_cast<void>(root[json_pointer("/region/servers/0/name/x")]);
+    }
+    catch (const nlohmann::json::out_of_range& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
@@ -0,0 +1,3 @@
+0.71
+no such server
+[json.exception.out_of_range.404] unresolved reference token 'x'
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json = nlohmann::json;
+
+int main()
+{
+    // two snapshots of a polled configuration endpoint -- compare them
+    // directly as views, without ever building a nlohmann::json value for
+    // either one
+    const json_document previous = json_document::parse(
+                                       R"({"name": "cache", "port": 6379, "timeout": 30})");
+    const json_document current = json_document::parse(
+                                      R"({"port": 6379.0, "timeout": 30, "name": "cache"})");
+
+    // same members, reordered, and 6379 written as a float -- operator==
+    // treats them the same way BasicJsonType::operator== would
+    std::cout << std::boolalpha << (previous.root() == current.root()) << '\n';
+
+    // an actually changed value is detected the same way
+    const json_document changed = json_document::parse(
+                                      R"({"name": "cache", "port": 6380, "timeout": 30})");
+    std::cout << (previous.root() == changed.root()) << '\n';
+
+    // comparing a view directly against an expected json value -- handy in a
+    // test, without materializing the received document at all
+    const json expected = {{"name", "cache"}, {"port", 6379}, {"timeout", 30}};
+    std::cout << (previous.root() == expected) << '\n';
+}
@@ -0,0 +1,3 @@
+true
+false
+true
@@ -0,0 +1,26 @@
+#include <iostream>
+#include <iomanip>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // one order out of a large incoming batch -- write it straight to a log
+    // stream without ever building a basic_json value for it, or for the
+    // rest of the batch
+    const json_document doc = json_document::parse(R"(
+      [{"id": 1, "item": "cable"}, {"id": 2, "item": "adapter"}]
+    )");
+    const json_view orders = doc.root();
+
+    // compact, for a one-line log entry
+    std::cout << orders[1] << '\n';
+
+    // std::setw sets the indentation level, exactly as for basic_json
+    std::cout << std::setw(2) << orders[1] << "\n\n";
+
+    // std::setfill changes the indentation character
+    std::cout << std::setw(1) << std::setfill('\t') << orders[1] << '\n';
+}
@@ -0,0 +1,10 @@
+{"id":2,"item":"adapter"}
+{
+  "id": 2,
+  "item": "adapter"
+}
+
+{
+	"id": 2,
+	"item": "adapter"
+}
@@ -0,0 +1,28 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using ordered_json_document = nlohmann::ordered_json_document;
+using json = nlohmann::json;
+
+int main()
+{
+    // assert, as a test would, that a received document differs from an
+    // unwanted shape -- without ever materializing it into a json value just
+    // to compare
+    const json_document received = json_document::parse(
+                                       R"({"status": "ok", "code": 200})");
+    const json unwanted = {{"status", "error"}, {"code", 500}};
+    std::cout << std::boolalpha << (received.root() != unwanted) << '\n';
+
+    // json (std::map) compares object members regardless of order ...
+    const json_document a = json_document::parse(R"({"a": 1, "b": 2})");
+    const json_document b = json_document::parse(R"({"b": 2, "a": 1})");
+    std::cout << (a.root() != b.root()) << '\n';
+
+    // ... but ordered_json (ordered_map) compares them in the order they
+    // appear, so the very same reordering is detected as a difference
+    const ordered_json_document oa = ordered_json_document::parse(R"({"a": 1, "b": 2})");
+    const ordered_json_document ob = ordered_json_document::parse(R"({"b": 2, "a": 1})");
+    std::cout << (oa.root() != ob.root()) << '\n';
+}
@@ -0,0 +1,3 @@
+true
+false
+true
@@ -0,0 +1,30 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    // report why some parsed messages were rejected, using only
+    // type_name() -- no nlohmann::json value is built for the ones that
+    // are wrong
+    json_document good = json_document::parse(R"({"id": 1})");
+    json_document bad = json_document::parse("[1, 2, 3]");
+    json_document failed = json_document::parse("not json", /* allow_exceptions */ false);
+
+    for (const json_view v :
+            {
+                good.root(), bad.root(), failed.root()
+            })
+    {
+        if (v.is_object())
+        {
+            std::cout << "ok\n";
+        }
+        else
+        {
+            std::cout << "expected an object, got " << v.type_name() << '\n';
+        }
+    }
+}
@@ -0,0 +1,3 @@
+ok
+expected an object, got array
+expected an object, got discarded
@@ -0,0 +1,29 @@
+#include <iostream>
+#include <nlohmann/json_view.hpp>
+#include <string>
+
+using json_document = nlohmann::json_document;
+using json_view = nlohmann::json_view;
+
+int main()
+{
+    json_document doc = json_document::parse(R"({"server": {"host": "localhost"}})");
+    const json_view server = doc.root()["server"];
+
+    // "port" is missing -- value() returns the default instead of
+    // throwing, so optional configuration fields never need their own
+    // try/catch
+    std::cout << server.value("host", std::string("0.0.0.0")) << '\n';
+    std::cout << server.value("port", 8080) << '\n';
+
+    // a present but wrong-typed default still throws -- value() only
+    // replaces "not found", not "wrong type", exactly as basic_json::value
+    try
+    {
+        static_cast<void>(server.value("host", 0));
+    }
+    catch (const nlohmann::json::type_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+}
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Niels Lohmann	ecf9df7c45	Convert the floats of json_view from the digit layout The parser records where the integer digits, the fraction digits, and the exponent of a float token are. For floats and doubles with at most 19 digits, the value is now read from that layout: the digits eight at a time, without scanning the token, and rounded by the library's conversion core (detail::decimal_to_float(): Clinger's fast path where both operands are exact, else the Eisel-Lemire algorithm, which needs no fallback for up to 19 digits). It rounds correctly, so the values are those of parse(); other tokens and types keep the library's conversion of the whole token. get<double>(), materialize(), dump(), and comparisons use it. Traversing canada.json (111,000 floats, every number converted): 0.95 -> 1.29 GB/s. Tests add tokens around the limits (19 and 20 digits, 2^53, 10^22, and those of float) to the bit-for-bit comparison with parse(). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:51 +02:00
Niels Lohmann	b992e1f76a	Format the comparison examples with the pinned astyle The "check" job runs astyle over the documentation examples once it gets past the amalgamation step. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:50 +02:00
Niels Lohmann	a7fa8d04e8	Address the cpplint findings of json_view's comparisons compare.hpp includes <string> (build/include_what_you_use). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:49 +02:00
Niels Lohmann	677507137b	Address the clang-tidy findings of the comparisons Separate the comparison of discarded values from the other types, so that the conditional chain has no repeated branch bodies, and mark the deliberate comparisons of views with empty containers in the tests. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:49 +02:00
Niels Lohmann	21d90fac1c	Document the comparisons of json_view - API pages for operator== and operator!= of basic_json_view, linked both ways with the basic_json pages - the feature page and the class overview list the comparisons - the examples show when the view helps: detecting a changed document without building json values Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:48 +02:00
Niels Lohmann	e842f3a68f	Add comparisons to json_view basic_json_view gains operator== and operator!= with other views and with basic_json values. Two views are equal if the values parse() would produce for them are equal by basic_json's operator==: numbers compare by value across their types, and objects by their members, with duplicate keys resolved as parse() resolves them (the last value, at the position of the first key). Objects are compared in member order if the object type keeps an order (ordered_json), by key otherwise, as basic_json does. Discarded views compare as discarded basic_json values do, which follows JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON. Nothing is materialized except single numbers, and the walk is iterative. Tests compare the results for pairs of 1,200 generated documents (also written differently: sorted keys, canonical numbers) with those of basic_json, for json and ordered_json, plus numbers, duplicate keys, member order, discarded values, and 100,000 levels of nesting. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:47 +02:00
Niels Lohmann	bc56ac6d9a	Format the dump() example with the pinned astyle The "check" job runs astyle over the documentation examples once it gets past the amalgamation step. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:46 +02:00
Niels Lohmann	bfb2b0cb48	Mark the cases of the view's serializer that tests cannot reach Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:45 +02:00
Niels Lohmann	8cccae029b	Address the clang-tidy findings of dump() The output buffer initializes its members in the initializer list, and the escaping has no nested conditional operators; the test marks a fixed seed. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:44 +02:00
Niels Lohmann	c7e534d41e	Document dump() of json_view - API pages for dump, number_format, and operator<< of basic_json_view, linked both ways with the basic_json pages - the feature page describes document order and number_format::source - the examples show when the view helps: forwarding part of a message and writing numbers exactly as they were read Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:43 +02:00
Niels Lohmann	83d72fd7a7	Add dump() to json_view basic_json_view::dump(indent, indent_char, ensure_ascii, number_format) writes the text of a value as ordered_json::parse(text).dump() writes it for the same arguments: members in document order (all of them, should a key occur more than once), strings escaped by the same rules and with the library's scanning kernels, floats with the library's conversion, and integers copied from the source, where they are canonical except "-0". With number_format::source, numbers are copied as they appear in the source ("1.50", "1E2", "-0", all digits of long integers). operator<< takes the indentation from the stream width, as for basic_json. The writer (detail/view/serializer.hpp) writes through a raw pointer into a string sized from the source extent of the value, and walks the index iteratively, so the nesting depth is limited by memory only. Tests compare the output of 2,000 generated documents with ordered_json::dump() for several indentations and ensure_ascii, strings with every kind of escape, numbers (5,000 random doubles, float as number_float_t), duplicate keys, 100,000 levels of nesting, and streams. ViewDump joins the benchmarks. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:42 +02:00
Niels Lohmann	da971a52c8	Fix CI: useless cast in the array index check of the view's JSON pointers GCC -Werror=useless-cast on Linux x86-64 rejected static_cast<std::uint64_t>((std::numeric_limits<std::size_t>::max)()), as both are the same type there. Compare without the cast: std::size_t converts to std::uint64_t implicitly on every platform. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:41 +02:00
Niels Lohmann	4c6a64507b	Fix CI: value-initialize a const json_view for clang 3.6 clang 3.6 rejects `const json_view invalid;` (no user-provided default constructor, CWG 253), as fixed in json-view/10-view-document. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:40 +02:00
Niels Lohmann	c62aa8ac67	Fix CI: json_view value tests without exceptions and with GCC - ci_test_noexceptions: exception_of() and without_path() exist only with exceptions (they catch outside a CHECK_THROWS, which aborts with JSON_NOEXCEPTION); compile the comparisons of the conversion, value(), and JSON pointer errors only with exceptions as well. - ci_test_gcc: -Werror=unused-result for static_cast<void>(j.contains(p)) (GCC's warn_unused_result ignores a cast to void); store the result. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:40 +02:00
Niels Lohmann	a7256deba3	Inline get() of arithmetic values of json_view get<T>() of arithmetic types is inlined down to the conversion, so that its checks of the node kind merge with those of the caller, and reading an integer needs no call. Traversing every value: citm_catalog -6%, marine_ik -5%, numbers and twitter -3%, mesh -2.5%, canada -1% (and more above the float conversion from the digit layout: citm_catalog -14%, marine_ik -11%). Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:39 +02:00
Niels Lohmann	3a4eddf4ac	Address the clang-tidy findings of values and JSON pointers get_string() and number_token() return braced lists; the test compares floats by their bit patterns instead of with memcmp, uses std::any_of, and marks a fixed seed, a default member initializer (needed by GCC's -Weffc++), and a string search. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:38 +02:00
Niels Lohmann	43e2d9c525	Document values and JSON pointers of json_view - API pages for get, get_to, get_string, number_token, and value of basic_json_view; JSON pointer overloads of operator[], at, and contains; links both ways with the basic_json pages - the feature page describes which conversions copy nothing - the examples show when the view helps: strings without copies, numbers exactly as written, and paths into a large text Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:37 +02:00
Niels Lohmann	0650a48659	Add values and JSON pointers to json_view basic_json_view gains get<T>(), get_to(), value() with keys and JSON pointers, and operator[], at(), and contains() with JSON pointers, plus two functions basic_json has no counterpart for: - get_string(): the string without a copy (a string_view into the source, or into the decoded strings for strings with escapes) - number_token(): the text of a number as it appears in the source get<T>() converts arithmetic types, strings (also string_view_t), std::nullptr_t, std::vector, maps with string keys, and views directly; floats are converted from the digit layout recorded by the parser with the library's conversion chain, so the values are bit-identical to parse(). Other types, including user types with from_json(), go through materialize(). The exceptions are those of basic_json, message included. Where const basic_json has undefined behavior (a missing key or an index out of range with operator[] and a JSON pointer), the result is a discarded view; value() returns the default wherever basic_json catches out_of_range, and contains() never throws. Array indices of JSON pointers follow json_pointer's rules (parse_error.106/109, out_of_range.404/410). Tests compare the conversions of 2,000 generated documents, 20,000 float tokens (double and float, bit for bit), and every JSON pointer of 1,000 documents with basic_json, and the exceptions for malformed pointers. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:36 +02:00
Niels Lohmann	29bb5c48b8	Give code outside basic_json the reference tokens of a json_pointer detail::json_pointer_access returns the reference tokens of a pointer, so that code resolving pointers without a basic_json value (such as the zero-copy view) does not have to parse to_string() again. No change in behavior. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:35 +02:00
Niels Lohmann	e17e23a2b1	Fix CI: json_view access tests without exceptions and on clang 3.6 - ci_test_noexceptions: the element access tests compare the exceptions of json_view and basic_json through exception_of(), which catches them outside a CHECK_THROWS; with JSON_NOEXCEPTION the first one aborted the test. Compile those comparisons only with exceptions. - clang 3.6: value-initialize a const json_view, as in the tests of json-view/10-view-document. - Format three new documentation examples with the pinned astyle, which the "check" job runs once it gets past the amalgamation step. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:34 +02:00
Niels Lohmann	c2d7177d30	Address the clang-tidy findings of element access and iteration Marks the default initializer of the item's index string (needed by GCC's -Weffc++) and, in the test, an escaped literal and a comparison of find() with end(), which is what the test is about. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:33 +02:00
Niels Lohmann	08dcdaf9b8	Document element access, lookup, and iteration of json_view - API pages for operator[], at, front, back, find, contains, count, begin, end, cbegin, cend, items, and type_name of basic_json_view, linked both ways with the basic_json pages - the feature page and size() describe document order and duplicate keys - the examples show when the view helps: reading a few fields of a large text, probing optional members, and members in source order Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:33 +02:00
Niels Lohmann	7dae258350	Add element access, lookup, and iteration to json_view basic_json_view gains the read-only access functions of basic_json: operator[] and at() with keys and indices, front(), back(), find(), contains(), count(), begin()/end(), items() (with structured bindings from C++17 on), and type_name(). They throw the exceptions (ids and messages) that the const functions of basic_json throw; where basic_json has undefined behavior (operator[] with a missing key or an index out of range, front()/back() of an empty container), the view returns a discarded view or throws invalid_iterator.214. Objects are iterated in document order, and all members are visited. With duplicate keys, lookups find the first member, so that a lookup can stop at the first match; parse() keeps the last value. Keys of up to 16 bytes are compared with two overlapping loads instead of memcmp, and most keys are rejected by their length alone, from the index. The iterators and items live in detail/view/iterator.hpp, the lookups in detail/view/lookup.hpp. Tests compare every element and member of 2,000 generated documents with ordered_json, keys of every length around the load sizes, the exceptions against const basic_json, and the iterators. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:32 +02:00
Niels Lohmann	7da943c5c4	Name JSON types without a basic_json value basic_json::type_name() now calls detail::value_type_name(value_t), so that code which reports types without a basic_json value at hand, such as the zero-copy view, uses the same names in its exception messages. No change in behavior. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 21:01:31 +02:00