This is an automated email from the ASF dual-hosted git repository.
github-bot pushed a commit to branch asf-site
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/asf-site by this push:
new 5761394f update documentation for tag main
5761394f is described below
commit 5761394ffb8d82e23a63aac74667540637f674d0
Author: GitHub Actions <[email protected]>
AuthorDate: Thu Nov 20 17:09:44 2025 +0000
update documentation for tag main
---
main/.doctrees/environment.pickle | Bin 1167642 -> 1167642
bytes
main/r/404.html | 2 +-
main/r/404.md | 3 +
main/r/LICENSE.html | 2 +-
main/r/LICENSE.md | 206 ++++++++++++
main/r/authors.html | 2 +-
main/r/authors.md | 28 ++
main/r/deps/bootstrap-5.3.1/bootstrap.min.css | 2 +-
main/r/index.html | 2 +-
main/r/index.md | 258 +++++++++++++++
main/r/katex-auto.js | 4 +-
main/r/lightswitch.js | 4 +-
main/r/llms.txt | 360 +++++++++++++++++++++
main/r/news/index.html | 2 +-
main/r/news/index.md | 153 +++++++++
main/r/pkgdown.js | 192 +++++------
main/r/pkgdown.yml | 4 +-
main/r/reference/array_stream_set_finalizer.html | 2 +-
main/r/reference/array_stream_set_finalizer.md | 44 +++
main/r/reference/as_nanoarrow_array.html | 2 +-
main/r/reference/as_nanoarrow_array.md | 80 +++++
main/r/reference/as_nanoarrow_array_stream.html | 2 +-
main/r/reference/as_nanoarrow_array_stream.md | 88 +++++
main/r/reference/as_nanoarrow_buffer.html | 2 +-
main/r/reference/as_nanoarrow_buffer.md | 44 +++
main/r/reference/as_nanoarrow_schema.html | 2 +-
main/r/reference/as_nanoarrow_schema.md | 81 +++++
.../as_nanoarrow_schema.python.builtin.object.html | 2 +-
.../as_nanoarrow_schema.python.builtin.object.md | 79 +++++
main/r/reference/as_nanoarrow_vctr.html | 2 +-
main/r/reference/as_nanoarrow_vctr.md | 77 +++++
main/r/reference/basic_array_stream.html | 2 +-
main/r/reference/basic_array_stream.md | 46 +++
main/r/reference/convert_array.html | 2 +-
main/r/reference/convert_array.md | 128 ++++++++
main/r/reference/convert_array_stream.html | 2 +-
main/r/reference/convert_array_stream.md | 94 ++++++
main/r/reference/example_ipc_stream.html | 2 +-
main/r/reference/example_ipc_stream.md | 30 ++
main/r/reference/index.html | 68 ++--
main/r/reference/index.md | 100 ++++++
main/r/reference/infer_nanoarrow_ptype.html | 2 +-
main/r/reference/infer_nanoarrow_ptype.md | 69 ++++
.../reference/infer_nanoarrow_ptype_extension.html | 2 +-
.../r/reference/infer_nanoarrow_ptype_extension.md | 52 +++
main/r/reference/na_type.html | 2 +-
main/r/reference/na_type.md | 240 ++++++++++++++
main/r/reference/na_vctrs.html | 2 +-
main/r/reference/na_vctrs.md | 45 +++
main/r/reference/nanoarrow-package.html | 2 +-
main/r/reference/nanoarrow-package.md | 31 ++
main/r/reference/nanoarrow_array_init.html | 2 +-
main/r/reference/nanoarrow_array_init.md | 86 +++++
main/r/reference/nanoarrow_buffer_init.html | 2 +-
main/r/reference/nanoarrow_buffer_init.md | 49 +++
main/r/reference/nanoarrow_extension_array.html | 2 +-
main/r/reference/nanoarrow_extension_array.md | 49 +++
main/r/reference/nanoarrow_extension_spec.html | 2 +-
main/r/reference/nanoarrow_extension_spec.md | 57 ++++
main/r/reference/nanoarrow_pointer_is_valid.html | 2 +-
main/r/reference/nanoarrow_pointer_is_valid.md | 109 +++++++
main/r/reference/nanoarrow_version.html | 2 +-
main/r/reference/nanoarrow_version.md | 31 ++
main/r/reference/read_nanoarrow.html | 2 +-
main/r/reference/read_nanoarrow.md | 69 ++++
65 files changed, 2962 insertions(+), 154 deletions(-)
diff --git a/main/.doctrees/environment.pickle
b/main/.doctrees/environment.pickle
index a89e8276..93326833 100644
Binary files a/main/.doctrees/environment.pickle and
b/main/.doctrees/environment.pickle differ
diff --git a/main/r/404.html b/main/r/404.html
index 83a77baf..43bf11dc 100644
--- a/main/r/404.html
+++ b/main/r/404.html
@@ -61,7 +61,7 @@ Content not found. Please use links in the navbar.
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer>
diff --git a/main/r/404.md b/main/r/404.md
new file mode 100644
index 00000000..5107f896
--- /dev/null
+++ b/main/r/404.md
@@ -0,0 +1,3 @@
+Content not found. Please use links in the navbar.
+
+# Page not found (404)
diff --git a/main/r/LICENSE.html b/main/r/LICENSE.html
index 11fb98c3..7e294d9f 100644
--- a/main/r/LICENSE.html
+++ b/main/r/LICENSE.html
@@ -121,7 +121,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/LICENSE.md b/main/r/LICENSE.md
new file mode 100644
index 00000000..cdeff298
--- /dev/null
+++ b/main/r/LICENSE.md
@@ -0,0 +1,206 @@
+# Apache License
+
+*Version 2.0, January 2004* *\<<http://www.apache.org/licenses/>\>*
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control
+with that entity. For the purposes of this definition, “control” means
+**(i)** the power, direct or indirect, to cause the direction or
+management of such entity, whether by contract or otherwise, or **(ii)**
+ownership of fifty percent (50%) or more of the outstanding shares, or
+**(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source,
+and configuration files.
+
+“Object” form shall mean any form resulting from mechanical
+transformation or translation of a Source form, including but not
+limited to compiled object code, generated documentation, and
+conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object
+form, made available under the License, as indicated by a copyright
+notice that is included in or attached to the work (an example is
+provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object
+form, that is based on (or derived from) the Work and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship. For the purposes
+of this License, Derivative Works shall not include works that remain
+separable from, or merely link (or bind by name) to the interfaces of,
+the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor
+for inclusion in the Work by the copyright owner or by an individual or
+Legal Entity authorized to submit on behalf of the copyright owner. For
+the purposes of this definition, “submitted” means any form of
+electronic, verbal, or written communication sent to the Licensor or its
+representatives, including but not limited to communication on
+electronic mailing lists, source code control systems, and issue
+tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding
+communication that is conspicuously marked or otherwise designated in
+writing by the copyright owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on
+behalf of whom a Contribution has been received by Licensor and
+subsequently incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor
+hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable copyright license to reproduce, prepare
+Derivative Works of, publicly display, publicly perform, sublicense, and
+distribute the Work and such Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor
+hereby grants to You a perpetual, worldwide, non-exclusive, no-charge,
+royalty-free, irrevocable (except as stated in this section) patent
+license to make, have made, use, offer to sell, sell, import, and
+otherwise transfer the Work, where such license applies only to those
+patent claims licensable by such Contributor that are necessarily
+infringed by their Contribution(s) alone or by combination of their
+Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Work or a Contribution incorporated within the Work constitutes direct
+or contributory patent infringement, then any patent licenses granted to
+You under this License for that Work shall terminate as of the date such
+litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works
+thereof in any medium, with or without modifications, and in Source or
+Object form, provided that You meet the following conditions:
+
+- **(a)** You must give any other recipients of the Work or Derivative
+ Works a copy of this License; and
+- **(b)** You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+- **(c)** You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and attribution
+ notices from the Source form of the Work, excluding those notices that
+ do not pertain to any part of the Derivative Works; and
+- **(d)** If the Work includes a “NOTICE” text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained within
+ such NOTICE file, excluding those notices that do not pertain to any
+ part of the Derivative Works, in at least one of the following places:
+ within a NOTICE text file distributed as part of the Derivative Works;
+ within the Source form or documentation, if provided along with the
+ Derivative Works; or, within a display generated by the Derivative
+ Works, if and wherever such third-party notices normally appear. The
+ contents of the NOTICE file are for informational purposes only and do
+ not modify the License. You may add Your own attribution notices
+ within Derivative Works that You distribute, alongside or as an
+ addendum to the NOTICE text from the Work, provided that such
+ additional attribution notices cannot be construed as modifying the
+ License.
+
+You may add Your own copyright statement to Your modifications and may
+provide additional or different license terms and conditions for use,
+reproduction, or distribution of Your modifications, or for any such
+Derivative Works as a whole, provided Your use, reproduction, and
+distribution of the Work otherwise complies with the conditions stated
+in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally
+submitted for inclusion in the Work by You to the Licensor shall be
+under the terms and conditions of this License, without any additional
+terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may
+have executed with Licensor regarding such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as
+required for reasonable and customary use in describing the origin of
+the Work and reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor
+provides the Work (and each Contributor provides its Contributions) on
+an “AS IS” BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
+express or implied, including, without limitation, any warranties or
+conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+PARTICULAR PURPOSE. You are solely responsible for determining the
+appropriateness of using or redistributing the Work and assume any risks
+associated with Your exercise of permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including
+negligence), contract, or otherwise, unless required by applicable law
+(such as deliberate and grossly negligent acts) or agreed to in writing,
+shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or
+inability to use the Work (including but not limited to damages for loss
+of goodwill, work stoppage, computer failure or malfunction, or any and
+all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may
+choose to offer, and charge a fee for, acceptance of support, warranty,
+indemnity, or other liability obligations and/or rights consistent with
+this License. However, in accepting such obligations, You may act only
+on Your own behalf and on Your sole responsibility, not on behalf of any
+other Contributor, and only if You agree to indemnify, defend, and hold
+each Contributor harmless for any liability incurred by, or claims
+asserted against, such Contributor by reason of your accepting any such
+warranty or additional liability.
+
+*END OF TERMS AND CONDITIONS*
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following
+boilerplate notice, with the fields enclosed by brackets `[]` replaced
+with your own identifying information. (Don’t include the brackets!) The
+text should be enclosed in the appropriate comment syntax for the file
+format. We also recommend that a file or class name and description of
+purpose be included on the same “printed page” as the copyright notice
+for easier identification within third-party archives.
+
+``` R
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
diff --git a/main/r/authors.html b/main/r/authors.html
index 1d2aa9bb..c1821788 100644
--- a/main/r/authors.html
+++ b/main/r/authors.html
@@ -74,7 +74,7 @@ R package version 0.7.0.9000,
https://github.com/apache/arrow-nanoarrow, <a href
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/authors.md b/main/r/authors.md
new file mode 100644
index 00000000..784e9930
--- /dev/null
+++ b/main/r/authors.md
@@ -0,0 +1,28 @@
+# Authors and Citation
+
+## Authors
+
+- **Dewey Dunnington**. Author, maintainer.
+ [](https://orcid.org/0000-0002-9415-4582)
+
+- **Apache Arrow**. Author, copyright holder.
+
+- **Apache Software Foundation**. Copyright holder.
+
+## Citation
+
+Source:
+[`DESCRIPTION`](https://github.com/apache/arrow-nanoarrow/blob/main/r/DESCRIPTION)
+
+Dunnington D, Apache Arrow (2025). *nanoarrow: Interface to the
+'nanoarrow' 'C' Library*. R package version 0.7.0.9000,
+https://github.com/apache/arrow-nanoarrow,
+<https://arrow.apache.org/nanoarrow/latest/r/>.
+
+ @Manual{,
+ title = {nanoarrow: Interface to the 'nanoarrow' 'C' Library},
+ author = {Dewey Dunnington and {Apache Arrow}},
+ year = {2025},
+ note = {R package version 0.7.0.9000,
https://github.com/apache/arrow-nanoarrow},
+ url = {https://arrow.apache.org/nanoarrow/latest/r/},
+ }
diff --git a/main/r/deps/bootstrap-5.3.1/bootstrap.min.css
b/main/r/deps/bootstrap-5.3.1/bootstrap.min.css
index 3363cb22..b8a510c2 100644
--- a/main/r/deps/bootstrap-5.3.1/bootstrap.min.css
+++ b/main/r/deps/bootstrap-5.3.1/bootstrap.min.css
@@ -2,4 +2,4 @@
* Bootstrap v5.3.1 (https://getbootstrap.com/)
* Copyright 2011-2023 The Bootstrap Authors
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
- */:root,[data-bs-theme="light"]{--bs-blue: #0d6efd;--bs-indigo:
#6610f2;--bs-purple: #6f42c1;--bs-pink: #d63384;--bs-red: #dc3545;--bs-orange:
#fd7e14;--bs-yellow: #ffc107;--bs-green: #198754;--bs-teal: #20c997;--bs-cyan:
#0dcaf0;--bs-black: #000;--bs-white: #fff;--bs-gray: #6c757d;--bs-gray-dark:
#343a40;--bs-gray-100: #f8f9fa;--bs-gray-200: #e9ecef;--bs-gray-300:
#dee2e6;--bs-gray-400: #ced4da;--bs-gray-500: #adb5bd;--bs-gray-600:
#6c757d;--bs-gray-700: #495057;--bs-gray-800: #343a4 [...]
+ */:root,[data-bs-theme="light"]{--bs-blue: #0d6efd;--bs-indigo:
#6610f2;--bs-purple: #6f42c1;--bs-pink: #d63384;--bs-red: #dc3545;--bs-orange:
#fd7e14;--bs-yellow: #ffc107;--bs-green: #198754;--bs-teal: #20c997;--bs-cyan:
#0dcaf0;--bs-black: #000;--bs-white: #fff;--bs-gray: #6c757d;--bs-gray-dark:
#343a40;--bs-gray-100: #f8f9fa;--bs-gray-200: #e9ecef;--bs-gray-300:
#dee2e6;--bs-gray-400: #ced4da;--bs-gray-500: #adb5bd;--bs-gray-600:
#6c757d;--bs-gray-700: #495057;--bs-gray-800: #343a4 [...]
diff --git a/main/r/index.html b/main/r/index.html
index ed63e5f4..0ebd76a4 100644
--- a/main/r/index.html
+++ b/main/r/index.html
@@ -285,7 +285,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer>
diff --git a/main/r/index.md b/main/r/index.md
new file mode 100644
index 00000000..ed1070f8
--- /dev/null
+++ b/main/r/index.md
@@ -0,0 +1,258 @@
+# nanoarrow
+
+The goal of nanoarrow is to provide minimal useful bindings to the
+[Arrow C Data](https://arrow.apache.org/docs/format/CDataInterface.html)
+and [Arrow C
+Stream](https://arrow.apache.org/docs/format/CStreamInterface.html)
+interfaces using the [nanoarrow C
+library](https://arrow.apache.org/nanoarrow/).
+
+## Installation
+
+You can install the released version of nanoarrow from
+[CRAN](https://cran.r-project.org/) with:
+
+``` r
+install.packages("nanoarrow")
+```
+
+You can install the development version of nanoarrow from
+[GitHub](https://github.com/) with:
+
+``` r
+# install.packages("remotes")
+remotes::install_github("apache/arrow-nanoarrow/r")
+```
+
+If you can load the package, you’re good to go!
+
+``` r
+library(nanoarrow)
+```
+
+## Example
+
+The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the `ArrowSchema` which represents a data type of an array,
+the `ArrowArray` which represents the values of an array, and an
+`ArrowArrayStream`, which represents zero or more `ArrowArray`s with a
+common `ArrowSchema`. All three can be wrapped by R objects using the
+nanoarrow R package.
+
+### Schemas
+
+Use [`infer_nanoarrow_schema()`](reference/as_nanoarrow_schema.md) to
+get the ArrowSchema object that corresponds to a given R vector type;
+use [`as_nanoarrow_schema()`](reference/as_nanoarrow_schema.md) to
+convert an object from some other data type representation (e.g., an
+arrow R package `DataType` like
+[`arrow::int32()`](https://arrow.apache.org/docs/r/reference/data-type.html));
+or use `na_XXX()` functions to construct them.
+
+``` r
+infer_nanoarrow_schema(1:5)
+#> <nanoarrow_schema int32>
+#> $ format : chr "i"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+as_nanoarrow_schema(arrow::schema(col1 = arrow::float64()))
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_schema double>
+#> .. ..$ format : chr "g"
+#> .. ..$ name : chr "col1"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+na_int64()
+#> <nanoarrow_schema int64>
+#> $ format : chr "l"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+```
+
+### Arrays
+
+Use [`as_nanoarrow_array()`](reference/as_nanoarrow_array.md) to convert
+an object to an ArrowArray object:
+
+``` r
+as_nanoarrow_array(1:5)
+#> <nanoarrow_array int32[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 2
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> $ dictionary: NULL
+#> $ children : list()
+as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+```
+
+You can use [`as.vector()`](https://rdrr.io/r/base/vector.html) or
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) to get
+the R representation of the object back:
+
+``` r
+array <- as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+as.data.frame(array)
+#> col1
+#> 1 1.1
+#> 2 2.2
+```
+
+Even though at the C level the ArrowArray is distinct from the
+ArrowSchema, at the R level we attach a schema wherever possible. You
+can access the attached schema using
+[`infer_nanoarrow_schema()`](reference/as_nanoarrow_schema.md):
+
+``` r
+infer_nanoarrow_schema(array)
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_schema double>
+#> .. ..$ format : chr "g"
+#> .. ..$ name : chr "col1"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+```
+
+### Array Streams
+
+The easiest way to create an ArrowArrayStream is from a list of arrays
+or objects that can be converted to an array using
+[`as_nanoarrow_array()`](reference/as_nanoarrow_array.md):
+
+``` r
+stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+)
+```
+
+You can pull batches from the stream using the `$get_next()` method. The
+last batch will return `NULL`.
+
+``` r
+stream$get_next()
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+stream$get_next()
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `3.3 4.4`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+stream$get_next()
+#> NULL
+```
+
+You can pull all the batches into a
+[`data.frame()`](https://rdrr.io/r/base/data.frame.html) by calling
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) or
+[`as.vector()`](https://rdrr.io/r/base/vector.html):
+
+``` r
+stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+)
+
+as.data.frame(stream)
+#> col1
+#> 1 1.1
+#> 2 2.2
+#> 3 3.3
+#> 4 4.4
+```
+
+After consuming a stream, you should call the release method as soon as
+you can. This lets the implementation of the stream release any
+resources (like open files) it may be holding in a more predictable way
+than waiting for the garbage collector to clean up the object.
+
+## Integration with the arrow package
+
+The nanoarrow package implements
+[`as_nanoarrow_schema()`](reference/as_nanoarrow_schema.md),
+[`as_nanoarrow_array()`](reference/as_nanoarrow_array.md), and
+[`as_nanoarrow_array_stream()`](reference/as_nanoarrow_array_stream.md)
+for most arrow package types. Similarly, it implements
+[`arrow::as_arrow_array()`](https://arrow.apache.org/docs/r/reference/as_arrow_array.html),
+[`arrow::as_record_batch()`](https://arrow.apache.org/docs/r/reference/as_record_batch.html),
+[`arrow::as_arrow_table()`](https://arrow.apache.org/docs/r/reference/as_arrow_table.html),
+[`arrow::as_record_batch_reader()`](https://arrow.apache.org/docs/r/reference/as_record_batch_reader.html),
+[`arrow::infer_type()`](https://arrow.apache.org/docs/r/reference/infer_type.html),
+[`arrow::as_data_type()`](https://arrow.apache.org/docs/r/reference/as_data_type.html),
+and
+[`arrow::as_schema()`](https://arrow.apache.org/docs/r/reference/as_schema.html)
+for nanoarrow objects such that you can pass equivalent nanoarrow
+objects into many arrow functions and vice versa.
diff --git a/main/r/katex-auto.js b/main/r/katex-auto.js
index 20651d9f..2adab3a9 100644
--- a/main/r/katex-auto.js
+++ b/main/r/katex-auto.js
@@ -11,4 +11,6 @@ document.addEventListener("DOMContentLoaded", function () {
macros: macros,
fleqn: false
});
- }}});
+ }
+ }
+});
diff --git a/main/r/lightswitch.js b/main/r/lightswitch.js
index 9467125a..3808ca11 100644
--- a/main/r/lightswitch.js
+++ b/main/r/lightswitch.js
@@ -26,7 +26,7 @@ const setTheme = theme => {
}
}
-function bsSetupThemeToggle () {
+function bsSetupThemeToggle() {
'use strict'
const showActiveTheme = (theme, focus = false) => {
@@ -35,7 +35,7 @@ function bsSetupThemeToggle () {
document.querySelectorAll('[data-bs-theme-value]').forEach(element => {
const buttonTheme = element.getAttribute('data-bs-theme-value')
const isActive = buttonTheme == theme
-
+
element.classList.toggle('active', isActive)
element.setAttribute('aria-pressed', isActive)
diff --git a/main/r/llms.txt b/main/r/llms.txt
new file mode 100644
index 00000000..27848e89
--- /dev/null
+++ b/main/r/llms.txt
@@ -0,0 +1,360 @@
+# nanoarrow
+
+The goal of nanoarrow is to provide minimal useful bindings to the
+[Arrow C Data](https://arrow.apache.org/docs/format/CDataInterface.html)
+and [Arrow C
+Stream](https://arrow.apache.org/docs/format/CStreamInterface.html)
+interfaces using the [nanoarrow C
+library](https://arrow.apache.org/nanoarrow/).
+
+## Installation
+
+You can install the released version of nanoarrow from
+[CRAN](https://cran.r-project.org/) with:
+
+``` r
+install.packages("nanoarrow")
+```
+
+You can install the development version of nanoarrow from
+[GitHub](https://github.com/) with:
+
+``` r
+# install.packages("remotes")
+remotes::install_github("apache/arrow-nanoarrow/r")
+```
+
+If you can load the package, you’re good to go!
+
+``` r
+library(nanoarrow)
+```
+
+## Example
+
+The Arrow C Data and Arrow C Stream interfaces are comprised of three
+structures: the `ArrowSchema` which represents a data type of an array,
+the `ArrowArray` which represents the values of an array, and an
+`ArrowArrayStream`, which represents zero or more `ArrowArray`s with a
+common `ArrowSchema`. All three can be wrapped by R objects using the
+nanoarrow R package.
+
+### Schemas
+
+Use [`infer_nanoarrow_schema()`](reference/as_nanoarrow_schema.md) to
+get the ArrowSchema object that corresponds to a given R vector type;
+use [`as_nanoarrow_schema()`](reference/as_nanoarrow_schema.md) to
+convert an object from some other data type representation (e.g., an
+arrow R package `DataType` like
+[`arrow::int32()`](https://arrow.apache.org/docs/r/reference/data-type.html));
+or use `na_XXX()` functions to construct them.
+
+``` r
+infer_nanoarrow_schema(1:5)
+#> <nanoarrow_schema int32>
+#> $ format : chr "i"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+as_nanoarrow_schema(arrow::schema(col1 = arrow::float64()))
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_schema double>
+#> .. ..$ format : chr "g"
+#> .. ..$ name : chr "col1"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+na_int64()
+#> <nanoarrow_schema int64>
+#> $ format : chr "l"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+```
+
+### Arrays
+
+Use [`as_nanoarrow_array()`](reference/as_nanoarrow_array.md) to convert
+an object to an ArrowArray object:
+
+``` r
+as_nanoarrow_array(1:5)
+#> <nanoarrow_array int32[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 2
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> $ dictionary: NULL
+#> $ children : list()
+as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+```
+
+You can use [`as.vector()`](https://rdrr.io/r/base/vector.html) or
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) to get
+the R representation of the object back:
+
+``` r
+array <- as_nanoarrow_array(data.frame(col1 = c(1.1, 2.2)))
+as.data.frame(array)
+#> col1
+#> 1 1.1
+#> 2 2.2
+```
+
+Even though at the C level the ArrowArray is distinct from the
+ArrowSchema, at the R level we attach a schema wherever possible. You
+can access the attached schema using
+[`infer_nanoarrow_schema()`](reference/as_nanoarrow_schema.md):
+
+``` r
+infer_nanoarrow_schema(array)
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_schema double>
+#> .. ..$ format : chr "g"
+#> .. ..$ name : chr "col1"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+```
+
+### Array Streams
+
+The easiest way to create an ArrowArrayStream is from a list of arrays
+or objects that can be converted to an array using
+[`as_nanoarrow_array()`](reference/as_nanoarrow_array.md):
+
+``` r
+stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+)
+```
+
+You can pull batches from the stream using the `$get_next()` method. The
+last batch will return `NULL`.
+
+``` r
+stream$get_next()
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `1.1 2.2`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+stream$get_next()
+#> <nanoarrow_array struct[2]>
+#> $ length : int 2
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_array double[2]>
+#> .. ..$ length : int 2
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[0][0 b]> ``
+#> .. .. ..$ :<nanoarrow_buffer data<double>[2][16 b]> `3.3 4.4`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+stream$get_next()
+#> NULL
+```
+
+You can pull all the batches into a
+[`data.frame()`](https://rdrr.io/r/base/data.frame.html) by calling
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) or
+[`as.vector()`](https://rdrr.io/r/base/vector.html):
+
+``` r
+stream <- basic_array_stream(
+ list(
+ data.frame(col1 = c(1.1, 2.2)),
+ data.frame(col1 = c(3.3, 4.4))
+ )
+)
+
+as.data.frame(stream)
+#> col1
+#> 1 1.1
+#> 2 2.2
+#> 3 3.3
+#> 4 4.4
+```
+
+After consuming a stream, you should call the release method as soon as
+you can. This lets the implementation of the stream release any
+resources (like open files) it may be holding in a more predictable way
+than waiting for the garbage collector to clean up the object.
+
+## Integration with the arrow package
+
+The nanoarrow package implements
+[`as_nanoarrow_schema()`](reference/as_nanoarrow_schema.md),
+[`as_nanoarrow_array()`](reference/as_nanoarrow_array.md), and
+[`as_nanoarrow_array_stream()`](reference/as_nanoarrow_array_stream.md)
+for most arrow package types. Similarly, it implements
+[`arrow::as_arrow_array()`](https://arrow.apache.org/docs/r/reference/as_arrow_array.html),
+[`arrow::as_record_batch()`](https://arrow.apache.org/docs/r/reference/as_record_batch.html),
+[`arrow::as_arrow_table()`](https://arrow.apache.org/docs/r/reference/as_arrow_table.html),
+[`arrow::as_record_batch_reader()`](https://arrow.apache.org/docs/r/reference/as_record_batch_reader.html),
+[`arrow::infer_type()`](https://arrow.apache.org/docs/r/reference/infer_type.html),
+[`arrow::as_data_type()`](https://arrow.apache.org/docs/r/reference/as_data_type.html),
+and
+[`arrow::as_schema()`](https://arrow.apache.org/docs/r/reference/as_schema.html)
+for nanoarrow objects such that you can pass equivalent nanoarrow
+objects into many arrow functions and vice versa.
+
+# Package index
+
+## All functions
+
+- [`array_stream_set_finalizer()`](array_stream_set_finalizer.md) :
+ Register an array stream finalizer
+- [`as_nanoarrow_array()`](as_nanoarrow_array.md) : Convert an object to
+ a nanoarrow array
+- [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md) :
+ Convert an object to a nanoarrow array_stream
+- [`as_nanoarrow_buffer()`](as_nanoarrow_buffer.md) : Convert an object
+ to a nanoarrow buffer
+- [`as_nanoarrow_schema()`](as_nanoarrow_schema.md)
+ [`infer_nanoarrow_schema()`](as_nanoarrow_schema.md)
+ [`nanoarrow_schema_parse()`](as_nanoarrow_schema.md)
+ [`nanoarrow_schema_modify()`](as_nanoarrow_schema.md) : Convert an
+ object to a nanoarrow schema
+-
[`as_nanoarrow_schema(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`as_nanoarrow_array(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`as_nanoarrow_array_stream(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`test_reticulate_with_nanoarrow()`](as_nanoarrow_schema.python.builtin.object.md)
+ : Python integration via reticulate
+- [`as_nanoarrow_vctr()`](as_nanoarrow_vctr.md)
+ [`nanoarrow_vctr()`](as_nanoarrow_vctr.md) : Experimental Arrow
+ encoded arrays as R vectors
+- [`basic_array_stream()`](basic_array_stream.md) : Create ArrayStreams
+ from batches
+- [`convert_array()`](convert_array.md) : Convert an Array into an R
+ vector
+- [`convert_array_stream()`](convert_array_stream.md)
+ [`collect_array_stream()`](convert_array_stream.md) : Convert an Array
+ Stream into an R vector
+- [`example_ipc_stream()`](example_ipc_stream.md) : Example Arrow IPC
+ Data
+- [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md) : Infer an R
+ vector prototype
+- [`infer_nanoarrow_ptype_extension()`](infer_nanoarrow_ptype_extension.md)
+ [`convert_array_extension()`](infer_nanoarrow_ptype_extension.md)
+ [`as_nanoarrow_array_extension()`](infer_nanoarrow_ptype_extension.md)
+ : Implement Arrow extension types
+- [`na_type()`](na_type.md) [`na_na()`](na_type.md)
+ [`na_bool()`](na_type.md) [`na_int8()`](na_type.md)
+ [`na_uint8()`](na_type.md) [`na_int16()`](na_type.md)
+ [`na_uint16()`](na_type.md) [`na_int32()`](na_type.md)
+ [`na_uint32()`](na_type.md) [`na_int64()`](na_type.md)
+ [`na_uint64()`](na_type.md) [`na_half_float()`](na_type.md)
+ [`na_float()`](na_type.md) [`na_double()`](na_type.md)
+ [`na_string()`](na_type.md) [`na_large_string()`](na_type.md)
+ [`na_string_view()`](na_type.md) [`na_binary()`](na_type.md)
+ [`na_large_binary()`](na_type.md)
+ [`na_fixed_size_binary()`](na_type.md)
+ [`na_binary_view()`](na_type.md) [`na_date32()`](na_type.md)
+ [`na_date64()`](na_type.md) [`na_time32()`](na_type.md)
+ [`na_time64()`](na_type.md) [`na_duration()`](na_type.md)
+ [`na_interval_months()`](na_type.md)
+ [`na_interval_day_time()`](na_type.md)
+ [`na_interval_month_day_nano()`](na_type.md)
+ [`na_timestamp()`](na_type.md) [`na_decimal32()`](na_type.md)
+ [`na_decimal64()`](na_type.md) [`na_decimal128()`](na_type.md)
+ [`na_decimal256()`](na_type.md) [`na_struct()`](na_type.md)
+ [`na_sparse_union()`](na_type.md) [`na_dense_union()`](na_type.md)
+ [`na_list()`](na_type.md) [`na_large_list()`](na_type.md)
+ [`na_list_view()`](na_type.md) [`na_large_list_view()`](na_type.md)
+ [`na_fixed_size_list()`](na_type.md) [`na_map()`](na_type.md)
+ [`na_dictionary()`](na_type.md) [`na_extension()`](na_type.md) :
+ Create type objects
+- [`na_vctrs()`](na_vctrs.md) : Vctrs extension type
+- [`nanoarrow_array_init()`](nanoarrow_array_init.md)
+ [`nanoarrow_array_set_schema()`](nanoarrow_array_init.md)
+ [`nanoarrow_array_modify()`](nanoarrow_array_init.md) : Modify
+ nanoarrow arrays
+- [`nanoarrow_buffer_init()`](nanoarrow_buffer_init.md)
+ [`nanoarrow_buffer_append()`](nanoarrow_buffer_init.md)
+ [`convert_buffer()`](nanoarrow_buffer_init.md) : Create and modify
+ nanoarrow buffers
+- [`nanoarrow_extension_array()`](nanoarrow_extension_array.md) : Create
+ Arrow extension arrays
+- [`nanoarrow_extension_spec()`](nanoarrow_extension_spec.md)
+ [`register_nanoarrow_extension()`](nanoarrow_extension_spec.md)
+ [`unregister_nanoarrow_extension()`](nanoarrow_extension_spec.md)
+ [`resolve_nanoarrow_extension()`](nanoarrow_extension_spec.md) :
+ Register Arrow extension types
+- [`nanoarrow_pointer_is_valid()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_dbl()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_chr()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_pretty()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_release()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_move()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_export()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_schema()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_array()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_array_stream()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_set_protected()`](nanoarrow_pointer_is_valid.md) :
+ Danger zone: low-level pointer operations
+- [`nanoarrow_version()`](nanoarrow_version.md)
+ [`nanoarrow_with_zstd()`](nanoarrow_version.md) : Underlying
+ 'nanoarrow' C library build
+- [`read_nanoarrow()`](read_nanoarrow.md)
+ [`write_nanoarrow()`](read_nanoarrow.md) : Read/write serialized
+ streams of Arrow data
+
diff --git a/main/r/news/index.html b/main/r/news/index.html
index 7ecc5c6e..8acdcd6f 100644
--- a/main/r/news/index.html
+++ b/main/r/news/index.html
@@ -119,7 +119,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/news/index.md b/main/r/news/index.md
new file mode 100644
index 00000000..bc5d8193
--- /dev/null
+++ b/main/r/news/index.md
@@ -0,0 +1,153 @@
+# Changelog
+
+## nanoarrow 0.7.0
+
+CRAN release: 2025-07-03
+
+- Add zstd decompression support to R package
+ ([\#733](https://github.com/apache/arrow-nanoarrow/issues/733))
+- Support native creation of more numeric Arrow arrays from integer
+ vectors
+ ([\#697](https://github.com/apache/arrow-nanoarrow/issues/697))
+- Support matrix objects as fixed-size-list arrays
+ ([\#692](https://github.com/apache/arrow-nanoarrow/issues/692))
+- Ensure that `python` is used on Windows when running bootstrap.R
+ ([\#792](https://github.com/apache/arrow-nanoarrow/issues/792))
+- Update vctrs extension name to reflect implementation change
+ ([\#752](https://github.com/apache/arrow-nanoarrow/issues/752))
+- sub-day precision Date should be floored when treated as integer
+ ([\#674](https://github.com/apache/arrow-nanoarrow/issues/674))
+
+## nanoarrow 0.6.0
+
+CRAN release: 2024-10-13
+
+- Add float16 support for R bindings
+ ([\#650](https://github.com/apache/arrow-nanoarrow/issues/650))
+- Implement string view support in R bindings
+ ([\#636](https://github.com/apache/arrow-nanoarrow/issues/636))
+- Allow opt-out of warning for unregistered extension types
+ ([\#632](https://github.com/apache/arrow-nanoarrow/issues/632))
+- Add bindings to IPC writer
+ ([\#608](https://github.com/apache/arrow-nanoarrow/issues/608))
+- Avoid flatcc aligned_alloc() call when compiling R package
+ ([\#494](https://github.com/apache/arrow-nanoarrow/issues/494))
+- Use JSON in experimental R vctrs extension type
+ ([\#533](https://github.com/apache/arrow-nanoarrow/issues/533))
+
+## nanoarrow 0.5.0
+
+CRAN release: 2024-05-26
+
+- Add experimental `nanoarrow_vctr` to wrap a list of arrays
+ ([\#461](https://github.com/apache/arrow-nanoarrow/issues/461))
+- Add bindings for IPC reader
+ ([\#390](https://github.com/apache/arrow-nanoarrow/issues/390))
+- Fix tests for platforms where arrow dataset and/or zip is not
+ available
+ ([\#415](https://github.com/apache/arrow-nanoarrow/issues/415))
+- Remove unnecessary package name call
+ ([\#381](https://github.com/apache/arrow-nanoarrow/issues/381))
+
+## nanoarrow 0.4.0
+
+CRAN release: 2024-02-01
+
+- Fix source links from pkgdown site
+ ([\#315](https://github.com/apache/arrow-nanoarrow/issues/315)).
+- Provide LinkingTo headers for extension packages
+ ([\#332](https://github.com/apache/arrow-nanoarrow/issues/332)).
+- Add more `nanoarrow_array_stream` generics
+ ([\#349](https://github.com/apache/arrow-nanoarrow/issues/349)).
+- Add conversion from integer type to
+ [`character()`](https://rdrr.io/r/base/character.html)
+ ([\#345](https://github.com/apache/arrow-nanoarrow/issues/345)).
+- Ensure simple [`list()`](https://rdrr.io/r/base/list.html)s can be
+ converted without arrow installed
+ ([\#344](https://github.com/apache/arrow-nanoarrow/issues/344)).
+
+## nanoarrow 0.3.0.1
+
+CRAN release: 2023-12-08
+
+- Ensure wrapper array stream eagerly releases the wrapped array stream
+ ([\#333](https://github.com/apache/arrow-nanoarrow/issues/333)).
+
+## nanoarrow 0.3.0
+
+CRAN release: 2023-09-29
+
+- Use classed warnings to signal that a lossy conversion occurred
+ ([\#298](https://github.com/apache/arrow-nanoarrow/issues/298))
+- Add support for
+ [`bit64::integer64()`](https://rdrr.io/pkg/bit64/man/bit64-package.html)
+ conversions
+ ([\#293](https://github.com/apache/arrow-nanoarrow/issues/293))
+- Implement extension type registration/conversion
+ ([\#288](https://github.com/apache/arrow-nanoarrow/issues/288))
+- Implement dictionary conversion
+ ([\#285](https://github.com/apache/arrow-nanoarrow/issues/285))
+- Ensure `ordered` is reflected in
+ [`na_dictionary()`](../reference/na_type.md)
+ ([\#299](https://github.com/apache/arrow-nanoarrow/issues/299))
+- Warn for possibly out of range int64 -\> double conversions
+ ([\#294](https://github.com/apache/arrow-nanoarrow/issues/294))
+- Support map conversion to R vector
+ ([\#282](https://github.com/apache/arrow-nanoarrow/issues/282))
+- Don’t link to arrow package R6 class pages
+ ([\#269](https://github.com/apache/arrow-nanoarrow/issues/269))
+- Use [`basic_array_stream()`](../reference/basic_array_stream.md) to
+ improve array stream to data.frame conversion
+ ([\#279](https://github.com/apache/arrow-nanoarrow/issues/279))
+
+## nanoarrow 0.2.0-1
+
+- Don’t link to arrow package R6 class pages
+ ([\#269](https://github.com/apache/arrow-nanoarrow/issues/269))
+
+## nanoarrow 0.2.0
+
+### New features
+
+- Improve printing and conversion of buffers
+ ([\#208](https://github.com/apache/arrow-nanoarrow/issues/208))
+- Add `enum ArrowType buffer_data_type` member to `struct ArrowLayout`
+ ([\#207](https://github.com/apache/arrow-nanoarrow/issues/207))
+- Implement ListChildOffset function
+ ([\#197](https://github.com/apache/arrow-nanoarrow/issues/197))
+- Add ability to deterministically run a finalizer on an array stream
+ ([\#196](https://github.com/apache/arrow-nanoarrow/issues/196))
+- Union array support
+ ([\#195](https://github.com/apache/arrow-nanoarrow/issues/195))
+- Add ArrowArrayStream implementation to support keeping a dependent
+ object in scope
+ ([\#194](https://github.com/apache/arrow-nanoarrow/issues/194))
+- Add [`as_nanoarrow_array()`](../reference/as_nanoarrow_array.md)
+ implementation that does not fall back on
+
[`arrow::as_arrow_array()`](https://arrow.apache.org/docs/r/reference/as_arrow_array.html)
+ everywhere
+ ([\#108](https://github.com/apache/arrow-nanoarrow/issues/108))
+- Create nanoarrow_array objects from buffers
+ ([\#105](https://github.com/apache/arrow-nanoarrow/issues/105))
+- Implement infer schema methods
+ ([\#104](https://github.com/apache/arrow-nanoarrow/issues/104))
+- Create and modify nanoarrow_schema objects
+ ([\#101](https://github.com/apache/arrow-nanoarrow/issues/101))
+
+### Bugfixes
+
+- Fix [`convert_array_stream()`](../reference/convert_array_stream.md)
+ for non-record batch stream with zero batches
+ ([\#212](https://github.com/apache/arrow-nanoarrow/issues/212))
+- clear `release` in `EmptyArrayStream::release_wrapper`
+ ([\#204](https://github.com/apache/arrow-nanoarrow/issues/204))
+- Release streams when calling
+ [`as.vector()`](https://rdrr.io/r/base/vector.html) or
+ [`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html)
+ ([\#202](https://github.com/apache/arrow-nanoarrow/issues/202))
+- Don’t invoke undefined behaviour in conversions to/from Arrow
+ ([\#167](https://github.com/apache/arrow-nanoarrow/issues/167))
+- Use strict prototypes in all internal C functions
+ ([\#151](https://github.com/apache/arrow-nanoarrow/issues/151))
+- Don’t memcpy NULL when converting buffer to raw
+ ([\#149](https://github.com/apache/arrow-nanoarrow/issues/149))
diff --git a/main/r/pkgdown.js b/main/r/pkgdown.js
index 1a99c65f..0a5573ae 100644
--- a/main/r/pkgdown.js
+++ b/main/r/pkgdown.js
@@ -1,6 +1,6 @@
/* http://gregfranko.com/blog/jquery-best-practices/ */
-(function($) {
- $(function() {
+(function ($) {
+ $(function () {
$('nav.navbar').headroom();
@@ -27,45 +27,45 @@
$('[data-bs-toggle="tooltip"]').tooltip();
- /* Clipboard --------------------------*/
+ /* Clipboard --------------------------*/
- function changeTooltipMessage(element, msg) {
- var tooltipOriginalTitle=element.getAttribute('data-bs-original-title');
- element.setAttribute('data-bs-original-title', msg);
- $(element).tooltip('show');
- element.setAttribute('data-bs-original-title', tooltipOriginalTitle);
- }
+ function changeTooltipMessage(element, msg) {
+ var tooltipOriginalTitle =
element.getAttribute('data-bs-original-title');
+ element.setAttribute('data-bs-original-title', msg);
+ $(element).tooltip('show');
+ element.setAttribute('data-bs-original-title', tooltipOriginalTitle);
+ }
- if(ClipboardJS.isSupported()) {
- $(document).ready(function() {
- var copyButton = "<button type='button' class='btn btn-primary
btn-copy-ex' title='Copy to clipboard' aria-label='Copy to clipboard'
data-toggle='tooltip' data-placement='left' data-trigger='hover'
data-clipboard-copy><i class='fa fa-copy'></i></button>";
+ if (ClipboardJS.isSupported()) {
+ $(document).ready(function () {
+ var copyButton = "<button type='button' class='btn btn-primary
btn-copy-ex' title='Copy to clipboard' aria-label='Copy to clipboard'
data-toggle='tooltip' data-placement='left' data-trigger='hover'
data-clipboard-copy><i class='fa fa-copy'></i></button>";
- $("div.sourceCode").addClass("hasCopyButton");
+ $("div.sourceCode").addClass("hasCopyButton");
- // Insert copy buttons:
- $(copyButton).prependTo(".hasCopyButton");
+ // Insert copy buttons:
+ $(copyButton).prependTo(".hasCopyButton");
- // Initialize tooltips:
- $('.btn-copy-ex').tooltip({container: 'body'});
+ // Initialize tooltips:
+ $('.btn-copy-ex').tooltip({ container: 'body' });
- // Initialize clipboard:
- var clipboard = new ClipboardJS('[data-clipboard-copy]', {
- text: function(trigger) {
- return trigger.parentNode.textContent.replace(/\n#>[^\n]*/g, "");
- }
- });
+ // Initialize clipboard:
+ var clipboard = new ClipboardJS('[data-clipboard-copy]', {
+ text: function (trigger) {
+ return trigger.parentNode.textContent.replace(/\n#>[^\n]*/g, "");
+ }
+ });
- clipboard.on('success', function(e) {
- changeTooltipMessage(e.trigger, 'Copied!');
- e.clearSelection();
- });
+ clipboard.on('success', function (e) {
+ changeTooltipMessage(e.trigger, 'Copied!');
+ e.clearSelection();
+ });
- clipboard.on('error', function(e) {
- changeTooltipMessage(e.trigger,'Press Ctrl+C or Command+C to copy');
- });
+ clipboard.on('error', function (e) {
+ changeTooltipMessage(e.trigger, 'Press Ctrl+C or Command+C to copy');
+ });
- });
- }
+ });
+ }
/* Search marking --------------------------*/
var url = new URL(window.location.href);
@@ -80,80 +80,80 @@
});
}
- /* Search --------------------------*/
- /* Adapted from
https://github.com/rstudio/bookdown/blob/2d692ba4b61f1e466c92e78fd712b0ab08c11d31/inst/resources/bs4_book/bs4_book.js#L25
*/
+ /* Search --------------------------*/
+ /* Adapted from
https://github.com/rstudio/bookdown/blob/2d692ba4b61f1e466c92e78fd712b0ab08c11d31/inst/resources/bs4_book/bs4_book.js#L25
*/
// Initialise search index on focus
- var fuse;
- $("#search-input").focus(async function(e) {
- if (fuse) {
- return;
- }
-
- $(e.target).addClass("loading");
- var response = await fetch($("#search-input").data("search-index"));
- var data = await response.json();
+ var fuse;
+ $("#search-input").focus(async function (e) {
+ if (fuse) {
+ return;
+ }
+
+ $(e.target).addClass("loading");
+ var response = await fetch($("#search-input").data("search-index"));
+ var data = await response.json();
+
+ var options = {
+ keys: ["what", "text", "code"],
+ ignoreLocation: true,
+ threshold: 0.1,
+ includeMatches: true,
+ includeScore: true,
+ };
+ fuse = new Fuse(data, options);
+
+ $(e.target).removeClass("loading");
+ });
+ // Use algolia autocomplete
var options = {
- keys: ["what", "text", "code"],
- ignoreLocation: true,
- threshold: 0.1,
- includeMatches: true,
- includeScore: true,
+ autoselect: true,
+ debug: true,
+ hint: false,
+ minLength: 2,
};
- fuse = new Fuse(data, options);
-
- $(e.target).removeClass("loading");
- });
-
- // Use algolia autocomplete
- var options = {
- autoselect: true,
- debug: true,
- hint: false,
- minLength: 2,
- };
- var q;
-async function searchFuse(query, callback) {
- await fuse;
-
- var items;
- if (!fuse) {
- items = [];
- } else {
- q = query;
- var results = fuse.search(query, { limit: 20 });
- items = results
- .filter((x) => x.score <= 0.75)
- .map((x) => x.item);
- if (items.length === 0) {
- items = [{dir:"Sorry 😿",previous_headings:"",title:"No results
found.",what:"No results found.",path:window.location.href}];
+ var q;
+ async function searchFuse(query, callback) {
+ await fuse;
+
+ var items;
+ if (!fuse) {
+ items = [];
+ } else {
+ q = query;
+ var results = fuse.search(query, { limit: 20 });
+ items = results
+ .filter((x) => x.score <= 0.75)
+ .map((x) => x.item);
+ if (items.length === 0) {
+ items = [{ dir: "Sorry 😿", previous_headings: "", title: "No results
found.", what: "No results found.", path: window.location.href }];
+ }
+ }
+ callback(items);
}
- }
- callback(items);
-}
- $("#search-input").autocomplete(options, [
- {
- name: "content",
- source: searchFuse,
- templates: {
- suggestion: (s) => {
- if (s.title == s.what) {
- return `${s.dir} > <div class="search-details"> ${s.title}</div>`;
- } else if (s.previous_headings == "") {
- return `${s.dir} > <div class="search-details"> ${s.title}</div> >
${s.what}`;
- } else {
- return `${s.dir} > <div class="search-details"> ${s.title}</div> >
${s.previous_headings} > ${s.what}`;
- }
+ $("#search-input").autocomplete(options, [
+ {
+ name: "content",
+ source: searchFuse,
+ templates: {
+ suggestion: (s) => {
+ if (s.title == s.what) {
+ return `${s.dir} > <div class="search-details">
${s.title}</div>`;
+ } else if (s.previous_headings == "") {
+ return `${s.dir} > <div class="search-details">
${s.title}</div> > ${s.what}`;
+ } else {
+ return `${s.dir} > <div class="search-details">
${s.title}</div> > ${s.previous_headings} > ${s.what}`;
+ }
+ },
},
},
- },
- ]).on('autocomplete:selected', function(event, s) {
- window.location.href = s.path + "?q=" + q + "#" + s.id;
- });
+ ]).on('autocomplete:selected', function (event, s) {
+ window.location.href = s.path + "?q=" + q + "#" + s.id;
+ });
});
})(window.jQuery || window.$)
-document.addEventListener('keydown', function(event) {
+document.addEventListener('keydown', function (event) {
// Check if the pressed key is '/'
if (event.key === '/') {
event.preventDefault(); // Prevent any default action associated with the
'/' key
diff --git a/main/r/pkgdown.yml b/main/r/pkgdown.yml
index 4913097c..5b95644c 100644
--- a/main/r/pkgdown.yml
+++ b/main/r/pkgdown.yml
@@ -1,5 +1,5 @@
pandoc: 3.1.3
-pkgdown: 2.1.3
+pkgdown: 2.2.0
pkgdown_sha: ~
articles: {}
-last_built: 2025-10-29T21:47Z
+last_built: 2025-11-20T17:09Z
diff --git a/main/r/reference/array_stream_set_finalizer.html
b/main/r/reference/array_stream_set_finalizer.html
index 171759ba..ed9e3f10 100644
--- a/main/r/reference/array_stream_set_finalizer.html
+++ b/main/r/reference/array_stream_set_finalizer.html
@@ -104,7 +104,7 @@ the supplied finalizer.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/array_stream_set_finalizer.md
b/main/r/reference/array_stream_set_finalizer.md
new file mode 100644
index 00000000..c4a9467f
--- /dev/null
+++ b/main/r/reference/array_stream_set_finalizer.md
@@ -0,0 +1,44 @@
+# Register an array stream finalizer
+
+In some cases, R functions that return a
+[nanoarrow_array_stream](as_nanoarrow_array_stream.md) may require that
+the scope of some other object outlive that of the array stream. If
+there is a need for that object to be released deterministically (e.g.,
+to close open files), you can register a function to run after the
+stream's release callback is invoked from the R thread. Note that this
+finalizer will **not** be run if the stream's release callback is
+invoked from a **non**-R thread. In this case, the finalizer and its
+chain of environments will be garbage-collected when
+`nanoarrow:::preserved_empty()` is run.
+
+## Usage
+
+``` r
+array_stream_set_finalizer(array_stream, finalizer)
+```
+
+## Arguments
+
+- array_stream:
+
+ A [nanoarrow_array_stream](as_nanoarrow_array_stream.md)
+
+- finalizer:
+
+ A function that will be called with zero arguments.
+
+## Value
+
+A newly allocated `array_stream` whose release callback will call the
+supplied finalizer.
+
+## Examples
+
+``` r
+stream <- array_stream_set_finalizer(
+ basic_array_stream(list(1:5)),
+ function() message("All done!")
+)
+stream$release()
+#> All done!
+```
diff --git a/main/r/reference/as_nanoarrow_array.html
b/main/r/reference/as_nanoarrow_array.html
index c49f6734..028c3c9e 100644
--- a/main/r/reference/as_nanoarrow_array.html
+++ b/main/r/reference/as_nanoarrow_array.html
@@ -131,7 +131,7 @@ type. Defaults to <code><a
href="as_nanoarrow_schema.html">infer_nanoarrow_schem
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_array.md
b/main/r/reference/as_nanoarrow_array.md
new file mode 100644
index 00000000..d41584f7
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_array.md
@@ -0,0 +1,80 @@
+# Convert an object to a nanoarrow array
+
+In nanoarrow an 'array' refers to the `struct ArrowArray` definition in
+the Arrow C data interface. At the R level, we attach a
+[schema](as_nanoarrow_schema.md) such that functionally the
+nanoarrow_array class can be used in a similar way as an
+[`arrow::Array`](https://arrow.apache.org/docs/r/reference/array-class.html).
+Note that in nanoarrow an
+[`arrow::RecordBatch`](https://arrow.apache.org/docs/r/reference/RecordBatch-class.html)
+and a non-nullable
+[`arrow::StructArray`](https://arrow.apache.org/docs/r/reference/array-class.html)
+are represented identically.
+
+## Usage
+
+``` r
+as_nanoarrow_array(x, ..., schema = NULL)
+```
+
+## Arguments
+
+- x:
+
+ An object to convert to a array
+
+- ...:
+
+ Passed to S3 methods
+
+- schema:
+
+ An optional schema used to enforce conversion to a particular type.
+ Defaults to [`infer_nanoarrow_schema()`](as_nanoarrow_schema.md).
+
+## Value
+
+An object of class 'nanoarrow_array'
+
+## Examples
+
+``` r
+(array <- as_nanoarrow_array(1:5))
+#> <nanoarrow_array int32[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 2
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> $ dictionary: NULL
+#> $ children : list()
+as.vector(array)
+#> [1] 1 2 3 4 5
+
+(array <- as_nanoarrow_array(data.frame(x = 1:5)))
+#> <nanoarrow_array struct[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> $ children :List of 1
+#> ..$ x:<nanoarrow_array int32[5]>
+#> .. ..$ length : int 5
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> .. .. ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+as.data.frame(array)
+#> x
+#> 1 1
+#> 2 2
+#> 3 3
+#> 4 4
+#> 5 5
+```
diff --git a/main/r/reference/as_nanoarrow_array_stream.html
b/main/r/reference/as_nanoarrow_array_stream.html
index 82b4fbb0..af1f137b 100644
--- a/main/r/reference/as_nanoarrow_array_stream.html
+++ b/main/r/reference/as_nanoarrow_array_stream.html
@@ -147,7 +147,7 @@ type. Defaults to <code><a
href="as_nanoarrow_schema.html">infer_nanoarrow_schem
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_array_stream.md
b/main/r/reference/as_nanoarrow_array_stream.md
new file mode 100644
index 00000000..1753da9c
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_array_stream.md
@@ -0,0 +1,88 @@
+# Convert an object to a nanoarrow array_stream
+
+In nanoarrow, an 'array stream' corresponds to the
+`struct ArrowArrayStream` as defined in the Arrow C Stream interface.
+This object is used to represent a stream of
+[arrays](as_nanoarrow_array.md) with a common
+[schema](as_nanoarrow_schema.md). This is similar to an
+[arrow::RecordBatchReader](https://arrow.apache.org/docs/r/reference/RecordBatchReader.html)
+except it can be used to represent a stream of any type (not just record
+batches). Note that a stream of record batches and a stream of
+non-nullable struct arrays are represented identically. Also note that
+array streams are mutable objects and are passed by reference and not by
+value.
+
+## Usage
+
+``` r
+as_nanoarrow_array_stream(x, ..., schema = NULL)
+```
+
+## Arguments
+
+- x:
+
+ An object to convert to a array_stream
+
+- ...:
+
+ Passed to S3 methods
+
+- schema:
+
+ An optional schema used to enforce conversion to a particular type.
+ Defaults to [`infer_nanoarrow_schema()`](as_nanoarrow_schema.md).
+
+## Value
+
+An object of class 'nanoarrow_array_stream'
+
+## Examples
+
+``` r
+(stream <- as_nanoarrow_array_stream(data.frame(x = 1:5)))
+#> <nanoarrow_array_stream struct<x: int32>>
+#> $ get_schema:function ()
+#> $ get_next :function (schema = x$get_schema(), validate = TRUE)
+#> $ release :function ()
+stream$get_schema()
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ x:<nanoarrow_schema int32>
+#> .. ..$ format : chr "i"
+#> .. ..$ name : chr "x"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+stream$get_next()
+#> <nanoarrow_array struct[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> $ children :List of 1
+#> ..$ x:<nanoarrow_array int32[5]>
+#> .. ..$ length : int 5
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> .. .. ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+
+# The last batch is returned as NULL
+stream$get_next()
+#> NULL
+
+# Release the stream
+stream$release()
+```
diff --git a/main/r/reference/as_nanoarrow_buffer.html
b/main/r/reference/as_nanoarrow_buffer.html
index 4ae7ddac..9614a7f3 100644
--- a/main/r/reference/as_nanoarrow_buffer.html
+++ b/main/r/reference/as_nanoarrow_buffer.html
@@ -89,7 +89,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_buffer.md
b/main/r/reference/as_nanoarrow_buffer.md
new file mode 100644
index 00000000..041000b0
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_buffer.md
@@ -0,0 +1,44 @@
+# Convert an object to a nanoarrow buffer
+
+Convert an object to a nanoarrow buffer
+
+## Usage
+
+``` r
+as_nanoarrow_buffer(x, ...)
+```
+
+## Arguments
+
+- x:
+
+ An object to convert to a buffer
+
+- ...:
+
+ Passed to S3 methods
+
+## Value
+
+An object of class 'nanoarrow_buffer'
+
+## Examples
+
+``` r
+array <- as_nanoarrow_array(c(NA, 1:4))
+array$buffers
+#> [[1]]
+#> <nanoarrow_buffer validity<bool>[8][1 b]> `FALSE TRUE TRUE TRUE TRUE FALSE
F...`
+#>
+#> [[2]]
+#> <nanoarrow_buffer data<int32>[5][20 b]> `NA 1 2 3 4`
+#>
+as.raw(array$buffers[[1]])
+#> [1] 1e
+as.raw(array$buffers[[2]])
+#> [1] 00 00 00 80 01 00 00 00 02 00 00 00 03 00 00 00 04 00 00 00
+convert_buffer(array$buffers[[1]])
+#> [1] FALSE TRUE TRUE TRUE TRUE FALSE FALSE FALSE
+convert_buffer(array$buffers[[2]])
+#> [1] NA 1 2 3 4
+```
diff --git a/main/r/reference/as_nanoarrow_schema.html
b/main/r/reference/as_nanoarrow_schema.html
index 62ab93d9..4282686e 100644
--- a/main/r/reference/as_nanoarrow_schema.html
+++ b/main/r/reference/as_nanoarrow_schema.html
@@ -127,7 +127,7 @@ schemas.</p></dd>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_schema.md
b/main/r/reference/as_nanoarrow_schema.md
new file mode 100644
index 00000000..f06ce760
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_schema.md
@@ -0,0 +1,81 @@
+# Convert an object to a nanoarrow schema
+
+In nanoarrow a 'schema' refers to a `struct ArrowSchema` as defined in
+the Arrow C Data interface. This data structure can be used to represent
+an
+[`arrow::schema()`](https://arrow.apache.org/docs/r/reference/schema.html),
+an
+[`arrow::field()`](https://arrow.apache.org/docs/r/reference/Field-class.html),
+or an
+[`arrow::DataType`](https://arrow.apache.org/docs/r/reference/DataType-class.html).
+Note that in nanoarrow, an
+[`arrow::schema()`](https://arrow.apache.org/docs/r/reference/schema.html)
+and a non-nullable
+[`arrow::struct()`](https://arrow.apache.org/docs/r/reference/data-type.html)
+are represented identically.
+
+## Usage
+
+``` r
+as_nanoarrow_schema(x, ...)
+
+infer_nanoarrow_schema(x, ...)
+
+nanoarrow_schema_parse(x, recursive = FALSE)
+
+nanoarrow_schema_modify(x, new_values, validate = TRUE)
+```
+
+## Arguments
+
+- x:
+
+ An object to convert to a schema
+
+- ...:
+
+ Passed to S3 methods
+
+- recursive:
+
+ Use `TRUE` to include a `children` member when parsing schemas.
+
+- new_values:
+
+ New schema component to assign
+
+- validate:
+
+ Use `FALSE` to skip schema validation
+
+## Value
+
+An object of class 'nanoarrow_schema'
+
+## Examples
+
+``` r
+infer_nanoarrow_schema(integer())
+#> <nanoarrow_schema int32>
+#> $ format : chr "i"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+infer_nanoarrow_schema(data.frame(x = integer()))
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ x:<nanoarrow_schema int32>
+#> .. ..$ format : chr "i"
+#> .. ..$ name : chr "x"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+```
diff --git a/main/r/reference/as_nanoarrow_schema.python.builtin.object.html
b/main/r/reference/as_nanoarrow_schema.python.builtin.object.html
index 86dacff5..685c2dfe 100644
--- a/main/r/reference/as_nanoarrow_schema.python.builtin.object.html
+++ b/main/r/reference/as_nanoarrow_schema.python.builtin.object.html
@@ -128,7 +128,7 @@ primitives for facilitating interchange in Python.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_schema.python.builtin.object.md
b/main/r/reference/as_nanoarrow_schema.python.builtin.object.md
new file mode 100644
index 00000000..ae1e6eb3
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_schema.python.builtin.object.md
@@ -0,0 +1,79 @@
+# Python integration via reticulate
+
+These functions enable Python wrapper objects created via reticulate to
+be used with any function that uses
+[`as_nanoarrow_array()`](as_nanoarrow_array.md) or
+[`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md) to accept
+generic "arrowable" input. Implementations for
+[`reticulate::py_to_r()`](https://rstudio.github.io/reticulate/reference/r-py-conversion.html)
+and
+[`reticulate::r_to_py()`](https://rstudio.github.io/reticulate/reference/r-py-conversion.html)
+are also included such that nanoarrow's array/schema/array stream
+objects can be passed as arguments to Python functions that would
+otherwise accept an object implementing the Arrow PyCapsule protocol.
+
+## Usage
+
+``` r
+# S3 method for class 'python.builtin.object'
+as_nanoarrow_schema(x, ...)
+
+# S3 method for class 'python.builtin.object'
+as_nanoarrow_array(x, ..., schema = NULL)
+
+# S3 method for class 'python.builtin.object'
+as_nanoarrow_array_stream(x, ..., schema = NULL)
+
+test_reticulate_with_nanoarrow()
+```
+
+## Arguments
+
+- x:
+
+ An Python object to convert
+
+- ...:
+
+ Unused
+
+- schema:
+
+ A requested schema, which may or may not be honoured depending on the
+ capabilities of the producer
+
+## Value
+
+- [`as_nanoarrow_schema()`](as_nanoarrow_schema.md) returns an object of
+ class nanoarrow_schema
+
+- [`as_nanoarrow_array()`](as_nanoarrow_array.md) returns an object of
+ class nanoarrow_array
+
+- [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md) returns
+ an object of class nanoarrow_array_stream.
+
+## Details
+
+This implementation uses the [Arrow PyCapsule
+protocol](https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html)
+to interpret an arbitrary Python object as an Arrow array/schema/array
+stream and produces Python objects that implement this protocol. This is
+currently implemented using the nanoarrow Python package which provides
+similar primitives for facilitating interchange in Python.
+
+## Examples
+
+``` r
+if (FALSE) { # test_reticulate_with_nanoarrow()
+library(reticulate)
+
+py_require("nanoarrow")
+
+na <- import("nanoarrow", convert = FALSE)
+python_arrayish_thing <- na$Array(1:3, na_int32())
+as_nanoarrow_array(python_arrayish_thing)
+
+r_to_py(as_nanoarrow_array(1:3))
+}
+```
diff --git a/main/r/reference/as_nanoarrow_vctr.html
b/main/r/reference/as_nanoarrow_vctr.html
index 79d3406b..71e7566e 100644
--- a/main/r/reference/as_nanoarrow_vctr.html
+++ b/main/r/reference/as_nanoarrow_vctr.html
@@ -121,7 +121,7 @@ to be resolved from a logical index with
<code>log(n)</code> complexity.</p></li
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/as_nanoarrow_vctr.md
b/main/r/reference/as_nanoarrow_vctr.md
new file mode 100644
index 00000000..b3114226
--- /dev/null
+++ b/main/r/reference/as_nanoarrow_vctr.md
@@ -0,0 +1,77 @@
+# Experimental Arrow encoded arrays as R vectors
+
+This experimental vctr class allows zero or more Arrow arrays to present
+as an R vector without converting them. This is useful for arrays with
+types that do not have a non-lossy R equivalent, and helps provide an
+intermediary object type where the default conversion is prohibitively
+expensive (e.g., a nested list of data frames). These objects will not
+survive many vctr transformations; however, they can be sliced without
+copying the underlying arrays.
+
+## Usage
+
+``` r
+as_nanoarrow_vctr(x, ..., schema = NULL, subclass = character())
+
+nanoarrow_vctr(schema = NULL, subclass = character())
+```
+
+## Arguments
+
+- x:
+
+ An object that works with
+ [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md).
+
+- ...:
+
+ Passed to
+ [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md)
+
+- schema:
+
+ An optional `schema`
+
+- subclass:
+
+ An optional subclass of nanoarrow_vctr to prepend to the final class
+ name.
+
+## Value
+
+A vctr of class 'nanoarrow_vctr'
+
+## Details
+
+The nanoarrow_vctr is currently implemented similarly to
+[`factor()`](https://rdrr.io/r/base/factor.html): its storage type is an
+[`integer()`](https://rdrr.io/r/base/integer.html) that is a sequence
+along the total length of the vctr and there are attributes that are
+required to resolve these indices to an array + offset. Sequences
+typically have a very compact representation in recent versions of R
+such that this has a cheap storage footprint even for large arrays. The
+attributes are currently:
+
+- `schema`: The [nanoarrow_schema](as_nanoarrow_schema.md) shared by
+ each chunk.
+
+- `chunks`: A [`list()`](https://rdrr.io/r/base/list.html) of
+ `nanoarrow_array`.
+
+- `offsets`: An [`integer()`](https://rdrr.io/r/base/integer.html)
+ vector beginning with `0` and followed by the cumulative length of
+ each chunk. This allows the chunk index + offset to be resolved from a
+ logical index with `log(n)` complexity.
+
+This implementation is preliminary and may change; however, the result
+of `as_nanoarrow_array_stream(some_vctr[begin:end])` should remain
+stable.
+
+## Examples
+
+``` r
+array <- as_nanoarrow_array(1:5)
+as_nanoarrow_vctr(array)
+#> <nanoarrow_vctr int32[5]>
+#> [1] 1 2 3 4 5
+```
diff --git a/main/r/reference/basic_array_stream.html
b/main/r/reference/basic_array_stream.html
index 485bd89b..8467186e 100644
--- a/main/r/reference/basic_array_stream.html
+++ b/main/r/reference/basic_array_stream.html
@@ -90,7 +90,7 @@ know that the arrays are valid).</p></dd>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/basic_array_stream.md
b/main/r/reference/basic_array_stream.md
new file mode 100644
index 00000000..186d172a
--- /dev/null
+++ b/main/r/reference/basic_array_stream.md
@@ -0,0 +1,46 @@
+# Create ArrayStreams from batches
+
+Create ArrayStreams from batches
+
+## Usage
+
+``` r
+basic_array_stream(batches, schema = NULL, validate = TRUE)
+```
+
+## Arguments
+
+- batches:
+
+ A [`list()`](https://rdrr.io/r/base/list.html) of
+ [nanoarrow_array](as_nanoarrow_array.md) objects or objects that can
+ be coerced via [`as_nanoarrow_array()`](as_nanoarrow_array.md).
+
+- schema:
+
+ A [nanoarrow_schema](as_nanoarrow_schema.md) or `NULL` to guess based
+ on the first schema.
+
+- validate:
+
+ Use `FALSE` to skip the validation step (i.e., if you know that the
+ arrays are valid).
+
+## Value
+
+An [nanoarrow_array_stream](as_nanoarrow_array_stream.md)
+
+## Examples
+
+``` r
+(stream <- basic_array_stream(list(data.frame(a = 1, b = 2))))
+#> <nanoarrow_array_stream struct<a: double, b: double>>
+#> $ get_schema:function ()
+#> $ get_next :function (schema = x$get_schema(), validate = TRUE)
+#> $ release :function ()
+as.data.frame(stream$get_next())
+#> a b
+#> 1 1 2
+stream$get_next()
+#> NULL
+```
diff --git a/main/r/reference/convert_array.html
b/main/r/reference/convert_array.html
index 93b7d280..54eeb457 100644
--- a/main/r/reference/convert_array.html
+++ b/main/r/reference/convert_array.html
@@ -140,7 +140,7 @@ converted as their storage type.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/convert_array.md
b/main/r/reference/convert_array.md
new file mode 100644
index 00000000..4f3bb81a
--- /dev/null
+++ b/main/r/reference/convert_array.md
@@ -0,0 +1,128 @@
+# Convert an Array into an R vector
+
+Converts `array` to the type specified by `to`. This is a low-level
+interface; most users should use
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) or
+[`as.vector()`](https://rdrr.io/r/base/vector.html) unless finer-grained
+control is needed over the conversion. This function is an S3 generic
+dispatching on `to`: developers may implement their own S3 methods for
+custom vector types.
+
+## Usage
+
+``` r
+convert_array(array, to = NULL, ...)
+```
+
+## Arguments
+
+- array:
+
+ A [nanoarrow_array](as_nanoarrow_array.md).
+
+- to:
+
+ A target prototype object describing the type to which `array` should
+ be converted, or `NULL` to use the default conversion as returned by
+ [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md). Alternatively,
+ a function can be passed to perform an alternative calculation of the
+ default ptype as a function of `array` and the default inference of
+ the prototype.
+
+- ...:
+
+ Passed to S3 methods
+
+## Value
+
+An R vector of type `to`.
+
+## Details
+
+Note that unregistered extension types will by default issue a warning.
+Use `options(nanoarrow.warn_unregistered_extension = FALSE)` to disable
+this behaviour.
+
+Conversions are implemented for the following R vector types:
+
+- [`logical()`](https://rdrr.io/r/base/logical.html): Any numeric type
+ can be converted to [`logical()`](https://rdrr.io/r/base/logical.html)
+ in addition to the bool type. For numeric types, any non-zero value is
+ considered `TRUE`.
+
+- [`integer()`](https://rdrr.io/r/base/integer.html): Any numeric type
+ can be converted to
+ [`integer()`](https://rdrr.io/r/base/integer.html); however, a warning
+ will be signaled if the any value is outside the range of the 32-bit
+ integer.
+
+- [`double()`](https://rdrr.io/r/base/double.html): Any numeric type can
+ be converted to [`double()`](https://rdrr.io/r/base/double.html). This
+ conversion currently does not warn for values that may not roundtrip
+ through a floating-point double (e.g., very large uint64 and int64
+ values).
+
+- [`character()`](https://rdrr.io/r/base/character.html): String and
+ large string types can be converted to
+ [`character()`](https://rdrr.io/r/base/character.html). The conversion
+ does not check for valid UTF-8: if you need finer-grained control over
+ encodings, use `to = blob::blob()`.
+
+- [`factor()`](https://rdrr.io/r/base/factor.html): Dictionary-encoded
+ arrays of strings can be converted to
+ [`factor()`](https://rdrr.io/r/base/factor.html); however, this must
+ be specified explicitly (i.e., `convert_array(array, factor())`)
+ because arrays arriving in chunks can have dictionaries that contain
+ different levels. Use `convert_array(array, factor(levels = c(...)))`
+ to materialize an array into a vector with known levels.
+
+- [Date](https://rdrr.io/r/base/as.Date.html): Only the date32 type can
+ be converted to an R Date vector.
+
+- [`hms::hms()`](https://hms.tidyverse.org/reference/hms.html): Time32
+ and time64 types can be converted to
+ [`hms::hms()`](https://hms.tidyverse.org/reference/hms.html).
+
+- [`difftime()`](https://rdrr.io/r/base/difftime.html): Time32, time64,
+ and duration types can be converted to R
+ [`difftime()`](https://rdrr.io/r/base/difftime.html) vectors. The
+ value is converted to match the
+ [`units()`](https://rdrr.io/r/base/units.html) attribute of `to`.
+
+- [`blob::blob()`](https://blob.tidyverse.org/reference/blob.html):
+ String, large string, binary, and large binary types can be converted
+ to [`blob::blob()`](https://blob.tidyverse.org/reference/blob.html).
+
+- [`vctrs::list_of()`](https://vctrs.r-lib.org/reference/list_of.html):
+ List, large list, and fixed-size list types can be converted to
+ [`vctrs::list_of()`](https://vctrs.r-lib.org/reference/list_of.html).
+
+- [`matrix()`](https://rdrr.io/r/base/matrix.html): Fixed-size list
+ types can be converted to `matrix(ptype, ncol = fixed_size)`.
+
+- [`data.frame()`](https://rdrr.io/r/base/data.frame.html): Struct types
+ can be converted to
+ [`data.frame()`](https://rdrr.io/r/base/data.frame.html).
+
+- [`vctrs::unspecified()`](https://vctrs.r-lib.org/reference/unspecified.html):
+ Any type can be converted to
+ [`vctrs::unspecified()`](https://vctrs.r-lib.org/reference/unspecified.html);
+ however, a warning will be raised if any non-null values are
+ encountered.
+
+In addition to the above conversions, a null array may be converted to
+any target prototype except
+[`data.frame()`](https://rdrr.io/r/base/data.frame.html). Extension
+arrays are currently converted as their storage type.
+
+## Examples
+
+``` r
+array <- as_nanoarrow_array(data.frame(x = 1:5))
+str(convert_array(array))
+#> 'data.frame': 5 obs. of 1 variable:
+#> $ x: int 1 2 3 4 5
+str(convert_array(array, to = data.frame(x = double())))
+#> 'data.frame': 5 obs. of 1 variable:
+#> $ x: num 1 2 3 4 5
+```
diff --git a/main/r/reference/convert_array_stream.html
b/main/r/reference/convert_array_stream.html
index 44ec3946..488e7793 100644
--- a/main/r/reference/convert_array_stream.html
+++ b/main/r/reference/convert_array_stream.html
@@ -141,7 +141,7 @@ know that the arrays are valid).</p></dd>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/convert_array_stream.md
b/main/r/reference/convert_array_stream.md
new file mode 100644
index 00000000..190f41ce
--- /dev/null
+++ b/main/r/reference/convert_array_stream.md
@@ -0,0 +1,94 @@
+# Convert an Array Stream into an R vector
+
+Converts `array_stream` to the type specified by `to`. This is a
+low-level interface; most users should use
+[`as.data.frame()`](https://rdrr.io/r/base/as.data.frame.html) or
+[`as.vector()`](https://rdrr.io/r/base/vector.html) unless finer-grained
+control is needed over the conversion. See
+[`convert_array()`](convert_array.md) for details of the conversion
+process; see [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md) for
+default inferences of `to`.
+
+## Usage
+
+``` r
+convert_array_stream(array_stream, to = NULL, size = NULL, n = Inf)
+
+collect_array_stream(array_stream, n = Inf, schema = NULL, validate = TRUE)
+```
+
+## Arguments
+
+- array_stream:
+
+ A [nanoarrow_array_stream](as_nanoarrow_array_stream.md).
+
+- to:
+
+ A target prototype object describing the type to which `array` should
+ be converted, or `NULL` to use the default conversion as returned by
+ [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md). Alternatively,
+ a function can be passed to perform an alternative calculation of the
+ default ptype as a function of `array` and the default inference of
+ the prototype.
+
+- size:
+
+ The exact size of the output, if known. If specified, slightly more
+ efficient implementation may be used to collect the output.
+
+- n:
+
+ The maximum number of batches to pull from the array stream.
+
+- schema:
+
+ A [nanoarrow_schema](as_nanoarrow_schema.md) or `NULL` to guess based
+ on the first schema.
+
+- validate:
+
+ Use `FALSE` to skip the validation step (i.e., if you know that the
+ arrays are valid).
+
+## Value
+
+- `convert_array_stream()`: An R vector of type `to`.
+
+- `collect_array_stream()`: A
+ [`list()`](https://rdrr.io/r/base/list.html) of
+ [nanoarrow_array](as_nanoarrow_array.md)
+
+## Examples
+
+``` r
+stream <- as_nanoarrow_array_stream(data.frame(x = 1:5))
+str(convert_array_stream(stream))
+#> 'data.frame': 5 obs. of 1 variable:
+#> $ x: int 1 2 3 4 5
+str(convert_array_stream(stream, to = data.frame(x = double())))
+#> 'data.frame': 0 obs. of 1 variable:
+#> $ x: num
+
+stream <- as_nanoarrow_array_stream(data.frame(x = 1:5))
+collect_array_stream(stream)
+#> [[1]]
+#> <nanoarrow_array struct[5]>
+#> $ length : int 5
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 1
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> $ children :List of 1
+#> ..$ x:<nanoarrow_array int32[5]>
+#> .. ..$ length : int 5
+#> .. ..$ null_count: int 0
+#> .. ..$ offset : int 0
+#> .. ..$ buffers :List of 2
+#> .. .. ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> .. .. ..$ :<nanoarrow_buffer data<int32>[5][20 b]> `1 2 3 4 5`
+#> .. ..$ dictionary: NULL
+#> .. ..$ children : list()
+#> $ dictionary: NULL
+#>
+```
diff --git a/main/r/reference/example_ipc_stream.html
b/main/r/reference/example_ipc_stream.html
index e85645fa..44410c1d 100644
--- a/main/r/reference/example_ipc_stream.html
+++ b/main/r/reference/example_ipc_stream.html
@@ -73,7 +73,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/example_ipc_stream.md
b/main/r/reference/example_ipc_stream.md
new file mode 100644
index 00000000..bc46376e
--- /dev/null
+++ b/main/r/reference/example_ipc_stream.md
@@ -0,0 +1,30 @@
+# Example Arrow IPC Data
+
+An example stream that can be used for testing or examples.
+
+## Usage
+
+``` r
+example_ipc_stream(compression = c("none", "zstd"))
+```
+
+## Arguments
+
+- compression:
+
+ One of "none" or "zstd"
+
+## Value
+
+A raw vector that can be passed to
+[`read_nanoarrow()`](read_nanoarrow.md)
+
+## Examples
+
+``` r
+as.data.frame(read_nanoarrow(example_ipc_stream()))
+#> some_col
+#> 1 0
+#> 2 1
+#> 3 2
+```
diff --git a/main/r/reference/index.html b/main/r/reference/index.html
index cfd2131f..3304ad13 100644
--- a/main/r/reference/index.html
+++ b/main/r/reference/index.html
@@ -36,8 +36,7 @@
-
- </div><div class="section level2">
+ <dl></dl></div><div class="section level2">
@@ -48,127 +47,148 @@
</dt>
<dd>Register an array stream finalizer</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_array.html">as_nanoarrow_array()</a></code>
</dt>
<dd>Convert an object to a nanoarrow array</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_array_stream.html">as_nanoarrow_array_stream()</a></code>
</dt>
<dd>Convert an object to a nanoarrow array_stream</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_buffer.html">as_nanoarrow_buffer()</a></code>
</dt>
<dd>Convert an object to a nanoarrow buffer</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_schema.html">as_nanoarrow_schema()</a></code> <code><a
href="as_nanoarrow_schema.html">infer_nanoarrow_schema()</a></code> <code><a
href="as_nanoarrow_schema.html">nanoarrow_schema_parse()</a></code> <code><a
href="as_nanoarrow_schema.html">nanoarrow_schema_modify()</a></code>
</dt>
<dd>Convert an object to a nanoarrow schema</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_schema.python.builtin.object.html">as_nanoarrow_schema(<i><python.builtin.object></i>)</a></code>
<code><a
href="as_nanoarrow_schema.python.builtin.object.html">as_nanoarrow_array(<i><python.builtin.object></i>)</a></code>
<code><a
href="as_nanoarrow_schema.python.builtin.object.html">as_nanoarrow_array_stream(<i><python.builtin.object></i>)</a></code>
<code><a
href="as_nanoarrow_schema.python.builtin.object.html">test_reticulate_wi [...]
</dt>
<dd>Python integration via reticulate</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="as_nanoarrow_vctr.html">as_nanoarrow_vctr()</a></code> <code><a
href="as_nanoarrow_vctr.html">nanoarrow_vctr()</a></code>
</dt>
<dd>Experimental Arrow encoded arrays as R vectors</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="basic_array_stream.html">basic_array_stream()</a></code>
</dt>
<dd>Create ArrayStreams from batches</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a href="convert_array.html">convert_array()</a></code>
</dt>
<dd>Convert an Array into an R vector</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="convert_array_stream.html">convert_array_stream()</a></code> <code><a
href="convert_array_stream.html">collect_array_stream()</a></code>
</dt>
<dd>Convert an Array Stream into an R vector</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="example_ipc_stream.html">example_ipc_stream()</a></code>
</dt>
<dd>Example Arrow IPC Data</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="infer_nanoarrow_ptype.html">infer_nanoarrow_ptype()</a></code>
</dt>
<dd>Infer an R vector prototype</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="infer_nanoarrow_ptype_extension.html">infer_nanoarrow_ptype_extension()</a></code>
<code><a
href="infer_nanoarrow_ptype_extension.html">convert_array_extension()</a></code>
<code><a
href="infer_nanoarrow_ptype_extension.html">as_nanoarrow_array_extension()</a></code>
</dt>
<dd>Implement Arrow extension types</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a href="na_type.html">na_type()</a></code> <code><a
href="na_type.html">na_na()</a></code> <code><a
href="na_type.html">na_bool()</a></code> <code><a
href="na_type.html">na_int8()</a></code> <code><a
href="na_type.html">na_uint8()</a></code> <code><a
href="na_type.html">na_int16()</a></code> <code><a
href="na_type.html">na_uint16()</a></code> <code><a
href="na_type.html">na_int32()</a></code> <code><a
href="na_type.html">na_uint32()</a></code> <code><a href="na_type.html [...]
</dt>
<dd>Create type objects</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a href="na_vctrs.html">na_vctrs()</a></code>
</dt>
<dd>Vctrs extension type</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_array_init.html">nanoarrow_array_init()</a></code> <code><a
href="nanoarrow_array_init.html">nanoarrow_array_set_schema()</a></code>
<code><a href="nanoarrow_array_init.html">nanoarrow_array_modify()</a></code>
</dt>
<dd>Modify nanoarrow arrays</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_buffer_init.html">nanoarrow_buffer_init()</a></code> <code><a
href="nanoarrow_buffer_init.html">nanoarrow_buffer_append()</a></code> <code><a
href="nanoarrow_buffer_init.html">convert_buffer()</a></code>
</dt>
<dd>Create and modify nanoarrow buffers</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_extension_array.html">nanoarrow_extension_array()</a></code>
</dt>
<dd>Create Arrow extension arrays</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_extension_spec.html">nanoarrow_extension_spec()</a></code>
<code><a
href="nanoarrow_extension_spec.html">register_nanoarrow_extension()</a></code>
<code><a
href="nanoarrow_extension_spec.html">unregister_nanoarrow_extension()</a></code>
<code><a
href="nanoarrow_extension_spec.html">resolve_nanoarrow_extension()</a></code>
</dt>
<dd>Register Arrow extension types</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_pointer_is_valid.html">nanoarrow_pointer_is_valid()</a></code>
<code><a
href="nanoarrow_pointer_is_valid.html">nanoarrow_pointer_addr_dbl()</a></code>
<code><a
href="nanoarrow_pointer_is_valid.html">nanoarrow_pointer_addr_chr()</a></code>
<code><a
href="nanoarrow_pointer_is_valid.html">nanoarrow_pointer_addr_pretty()</a></code>
<code><a
href="nanoarrow_pointer_is_valid.html">nanoarrow_pointer_release()</a></code>
<code><a href="nanoarrow_pointer_is_vali [...]
</dt>
<dd>Danger zone: low-level pointer operations</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a
href="nanoarrow_version.html">nanoarrow_version()</a></code> <code><a
href="nanoarrow_version.html">nanoarrow_with_zstd()</a></code>
</dt>
<dd>Underlying 'nanoarrow' C library build</dd>
- </dl><dl><dt>
+
+ <dt>
<code><a href="read_nanoarrow.html">read_nanoarrow()</a></code>
<code><a href="read_nanoarrow.html">write_nanoarrow()</a></code>
@@ -183,7 +203,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/index.md b/main/r/reference/index.md
new file mode 100644
index 00000000..c20ee2c8
--- /dev/null
+++ b/main/r/reference/index.md
@@ -0,0 +1,100 @@
+# Package index
+
+## All functions
+
+- [`array_stream_set_finalizer()`](array_stream_set_finalizer.md) :
+ Register an array stream finalizer
+- [`as_nanoarrow_array()`](as_nanoarrow_array.md) : Convert an object to
+ a nanoarrow array
+- [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md) :
+ Convert an object to a nanoarrow array_stream
+- [`as_nanoarrow_buffer()`](as_nanoarrow_buffer.md) : Convert an object
+ to a nanoarrow buffer
+- [`as_nanoarrow_schema()`](as_nanoarrow_schema.md)
+ [`infer_nanoarrow_schema()`](as_nanoarrow_schema.md)
+ [`nanoarrow_schema_parse()`](as_nanoarrow_schema.md)
+ [`nanoarrow_schema_modify()`](as_nanoarrow_schema.md) : Convert an
+ object to a nanoarrow schema
+-
[`as_nanoarrow_schema(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`as_nanoarrow_array(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`as_nanoarrow_array_stream(`*`<python.builtin.object>`*`)`](as_nanoarrow_schema.python.builtin.object.md)
+
[`test_reticulate_with_nanoarrow()`](as_nanoarrow_schema.python.builtin.object.md)
+ : Python integration via reticulate
+- [`as_nanoarrow_vctr()`](as_nanoarrow_vctr.md)
+ [`nanoarrow_vctr()`](as_nanoarrow_vctr.md) : Experimental Arrow
+ encoded arrays as R vectors
+- [`basic_array_stream()`](basic_array_stream.md) : Create ArrayStreams
+ from batches
+- [`convert_array()`](convert_array.md) : Convert an Array into an R
+ vector
+- [`convert_array_stream()`](convert_array_stream.md)
+ [`collect_array_stream()`](convert_array_stream.md) : Convert an Array
+ Stream into an R vector
+- [`example_ipc_stream()`](example_ipc_stream.md) : Example Arrow IPC
+ Data
+- [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md) : Infer an R
+ vector prototype
+- [`infer_nanoarrow_ptype_extension()`](infer_nanoarrow_ptype_extension.md)
+ [`convert_array_extension()`](infer_nanoarrow_ptype_extension.md)
+ [`as_nanoarrow_array_extension()`](infer_nanoarrow_ptype_extension.md)
+ : Implement Arrow extension types
+- [`na_type()`](na_type.md) [`na_na()`](na_type.md)
+ [`na_bool()`](na_type.md) [`na_int8()`](na_type.md)
+ [`na_uint8()`](na_type.md) [`na_int16()`](na_type.md)
+ [`na_uint16()`](na_type.md) [`na_int32()`](na_type.md)
+ [`na_uint32()`](na_type.md) [`na_int64()`](na_type.md)
+ [`na_uint64()`](na_type.md) [`na_half_float()`](na_type.md)
+ [`na_float()`](na_type.md) [`na_double()`](na_type.md)
+ [`na_string()`](na_type.md) [`na_large_string()`](na_type.md)
+ [`na_string_view()`](na_type.md) [`na_binary()`](na_type.md)
+ [`na_large_binary()`](na_type.md)
+ [`na_fixed_size_binary()`](na_type.md)
+ [`na_binary_view()`](na_type.md) [`na_date32()`](na_type.md)
+ [`na_date64()`](na_type.md) [`na_time32()`](na_type.md)
+ [`na_time64()`](na_type.md) [`na_duration()`](na_type.md)
+ [`na_interval_months()`](na_type.md)
+ [`na_interval_day_time()`](na_type.md)
+ [`na_interval_month_day_nano()`](na_type.md)
+ [`na_timestamp()`](na_type.md) [`na_decimal32()`](na_type.md)
+ [`na_decimal64()`](na_type.md) [`na_decimal128()`](na_type.md)
+ [`na_decimal256()`](na_type.md) [`na_struct()`](na_type.md)
+ [`na_sparse_union()`](na_type.md) [`na_dense_union()`](na_type.md)
+ [`na_list()`](na_type.md) [`na_large_list()`](na_type.md)
+ [`na_list_view()`](na_type.md) [`na_large_list_view()`](na_type.md)
+ [`na_fixed_size_list()`](na_type.md) [`na_map()`](na_type.md)
+ [`na_dictionary()`](na_type.md) [`na_extension()`](na_type.md) :
+ Create type objects
+- [`na_vctrs()`](na_vctrs.md) : Vctrs extension type
+- [`nanoarrow_array_init()`](nanoarrow_array_init.md)
+ [`nanoarrow_array_set_schema()`](nanoarrow_array_init.md)
+ [`nanoarrow_array_modify()`](nanoarrow_array_init.md) : Modify
+ nanoarrow arrays
+- [`nanoarrow_buffer_init()`](nanoarrow_buffer_init.md)
+ [`nanoarrow_buffer_append()`](nanoarrow_buffer_init.md)
+ [`convert_buffer()`](nanoarrow_buffer_init.md) : Create and modify
+ nanoarrow buffers
+- [`nanoarrow_extension_array()`](nanoarrow_extension_array.md) : Create
+ Arrow extension arrays
+- [`nanoarrow_extension_spec()`](nanoarrow_extension_spec.md)
+ [`register_nanoarrow_extension()`](nanoarrow_extension_spec.md)
+ [`unregister_nanoarrow_extension()`](nanoarrow_extension_spec.md)
+ [`resolve_nanoarrow_extension()`](nanoarrow_extension_spec.md) :
+ Register Arrow extension types
+- [`nanoarrow_pointer_is_valid()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_dbl()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_chr()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_addr_pretty()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_release()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_move()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_export()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_schema()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_array()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_allocate_array_stream()`](nanoarrow_pointer_is_valid.md)
+ [`nanoarrow_pointer_set_protected()`](nanoarrow_pointer_is_valid.md) :
+ Danger zone: low-level pointer operations
+- [`nanoarrow_version()`](nanoarrow_version.md)
+ [`nanoarrow_with_zstd()`](nanoarrow_version.md) : Underlying
+ 'nanoarrow' C library build
+- [`read_nanoarrow()`](read_nanoarrow.md)
+ [`write_nanoarrow()`](read_nanoarrow.md) : Read/write serialized
+ streams of Arrow data
diff --git a/main/r/reference/infer_nanoarrow_ptype.html
b/main/r/reference/infer_nanoarrow_ptype.html
index 56a6bdc5..8a6f20a6 100644
--- a/main/r/reference/infer_nanoarrow_ptype.html
+++ b/main/r/reference/infer_nanoarrow_ptype.html
@@ -95,7 +95,7 @@ the array should be materialized.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/infer_nanoarrow_ptype.md
b/main/r/reference/infer_nanoarrow_ptype.md
new file mode 100644
index 00000000..eb19e465
--- /dev/null
+++ b/main/r/reference/infer_nanoarrow_ptype.md
@@ -0,0 +1,69 @@
+# Infer an R vector prototype
+
+Resolves the default `to` value to use in
+[`convert_array()`](convert_array.md) and
+[`convert_array_stream()`](convert_array_stream.md). The default
+conversions are:
+
+## Usage
+
+``` r
+infer_nanoarrow_ptype(x)
+```
+
+## Arguments
+
+- x:
+
+ A [nanoarrow_schema](as_nanoarrow_schema.md),
+ [nanoarrow_array](as_nanoarrow_array.md), or
+ [nanoarrow_array_stream](as_nanoarrow_array_stream.md).
+
+## Value
+
+An R vector of zero size describing the target into which the array
+should be materialized.
+
+## Details
+
+- null to
+ [`vctrs::unspecified()`](https://vctrs.r-lib.org/reference/unspecified.html)
+
+- boolean to [`logical()`](https://rdrr.io/r/base/logical.html)
+
+- int8, uint8, int16, uint16, and int13 to
+ [`integer()`](https://rdrr.io/r/base/integer.html)
+
+- uint32, int64, uint64, float, and double to
+ [`double()`](https://rdrr.io/r/base/double.html)
+
+- string and large string to
+ [`character()`](https://rdrr.io/r/base/character.html)
+
+- struct to [`data.frame()`](https://rdrr.io/r/base/data.frame.html)
+
+- binary and large binary to
+ [`blob::blob()`](https://blob.tidyverse.org/reference/blob.html)
+
+- list, large_list, and fixed_size_list to
+ [`vctrs::list_of()`](https://vctrs.r-lib.org/reference/list_of.html)
+
+- time32 and time64 to
+ [`hms::hms()`](https://hms.tidyverse.org/reference/hms.html)
+
+- duration to [`difftime()`](https://rdrr.io/r/base/difftime.html)
+
+- date32 to [`as.Date()`](https://rdrr.io/r/base/as.Date.html)
+
+- timestamp to [`as.POSIXct()`](https://rdrr.io/r/base/as.POSIXlt.html)
+
+Additional conversions are possible by specifying an explicit value for
+`to`. For details of each conversion, see
+[`convert_array()`](convert_array.md).
+
+## Examples
+
+``` r
+infer_nanoarrow_ptype(as_nanoarrow_array(1:10))
+#> integer(0)
+```
diff --git a/main/r/reference/infer_nanoarrow_ptype_extension.html
b/main/r/reference/infer_nanoarrow_ptype_extension.html
index fa05731c..11088293 100644
--- a/main/r/reference/infer_nanoarrow_ptype_extension.html
+++ b/main/r/reference/infer_nanoarrow_ptype_extension.html
@@ -96,7 +96,7 @@ of type <code>schema</code>.</p></li>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/infer_nanoarrow_ptype_extension.md
b/main/r/reference/infer_nanoarrow_ptype_extension.md
new file mode 100644
index 00000000..623ec978
--- /dev/null
+++ b/main/r/reference/infer_nanoarrow_ptype_extension.md
@@ -0,0 +1,52 @@
+# Implement Arrow extension types
+
+Implement Arrow extension types
+
+## Usage
+
+``` r
+infer_nanoarrow_ptype_extension(
+ extension_spec,
+ x,
+ ...,
+ warn_unregistered = TRUE
+)
+
+convert_array_extension(
+ extension_spec,
+ array,
+ to,
+ ...,
+ warn_unregistered = TRUE
+)
+
+as_nanoarrow_array_extension(extension_spec, x, ..., schema = NULL)
+```
+
+## Arguments
+
+- extension_spec:
+
+ An extension specification inheriting from 'nanoarrow_extension_spec'.
+
+- x, array, to, schema, ...:
+
+ Passed from [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md),
+ [`convert_array()`](convert_array.md),
+ [`as_nanoarrow_array()`](as_nanoarrow_array.md), and/or
+ [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md).
+
+- warn_unregistered:
+
+ Use `FALSE` to infer/convert based on the storage type without a
+ warning.
+
+## Value
+
+- `infer_nanoarrow_ptype_extension()`: The R vector prototype to be used
+ as the default conversion target.
+
+- `convert_array_extension()`: An R vector of type `to`.
+
+- `as_nanoarrow_array_extension()`: A
+ [nanoarrow_array](as_nanoarrow_array.md) of type `schema`.
diff --git a/main/r/reference/na_type.html b/main/r/reference/na_type.html
index 417a031f..535cc43e 100644
--- a/main/r/reference/na_type.html
+++ b/main/r/reference/na_type.html
@@ -294,7 +294,7 @@ null values.</p></dd>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/na_type.md b/main/r/reference/na_type.md
new file mode 100644
index 00000000..4d1b6533
--- /dev/null
+++ b/main/r/reference/na_type.md
@@ -0,0 +1,240 @@
+# Create type objects
+
+In nanoarrow, types, fields, and schemas are all represented by a
+[nanoarrow_schema](as_nanoarrow_schema.md). These functions are
+convenience constructors to create these objects in a readable way. Use
+`na_type()` to construct types based on the constructor name, which is
+also the name that prints/is returned by
+[`nanoarrow_schema_parse()`](as_nanoarrow_schema.md).
+
+## Usage
+
+``` r
+na_type(
+ type_name,
+ byte_width = NULL,
+ unit = NULL,
+ timezone = NULL,
+ precision = NULL,
+ scale = NULL,
+ column_types = NULL,
+ item_type = NULL,
+ key_type = NULL,
+ value_type = NULL,
+ index_type = NULL,
+ ordered = NULL,
+ list_size = NULL,
+ keys_sorted = NULL,
+ storage_type = NULL,
+ extension_name = NULL,
+ extension_metadata = NULL,
+ nullable = NULL
+)
+
+na_na(nullable = TRUE)
+
+na_bool(nullable = TRUE)
+
+na_int8(nullable = TRUE)
+
+na_uint8(nullable = TRUE)
+
+na_int16(nullable = TRUE)
+
+na_uint16(nullable = TRUE)
+
+na_int32(nullable = TRUE)
+
+na_uint32(nullable = TRUE)
+
+na_int64(nullable = TRUE)
+
+na_uint64(nullable = TRUE)
+
+na_half_float(nullable = TRUE)
+
+na_float(nullable = TRUE)
+
+na_double(nullable = TRUE)
+
+na_string(nullable = TRUE)
+
+na_large_string(nullable = TRUE)
+
+na_string_view(nullable = TRUE)
+
+na_binary(nullable = TRUE)
+
+na_large_binary(nullable = TRUE)
+
+na_fixed_size_binary(byte_width, nullable = TRUE)
+
+na_binary_view(nullable = TRUE)
+
+na_date32(nullable = TRUE)
+
+na_date64(nullable = TRUE)
+
+na_time32(unit = c("ms", "s"), nullable = TRUE)
+
+na_time64(unit = c("us", "ns"), nullable = TRUE)
+
+na_duration(unit = c("ms", "s", "us", "ns"), nullable = TRUE)
+
+na_interval_months(nullable = TRUE)
+
+na_interval_day_time(nullable = TRUE)
+
+na_interval_month_day_nano(nullable = TRUE)
+
+na_timestamp(unit = c("us", "ns", "s", "ms"), timezone = "", nullable = TRUE)
+
+na_decimal32(precision, scale, nullable = TRUE)
+
+na_decimal64(precision, scale, nullable = TRUE)
+
+na_decimal128(precision, scale, nullable = TRUE)
+
+na_decimal256(precision, scale, nullable = TRUE)
+
+na_struct(column_types = list(), nullable = FALSE)
+
+na_sparse_union(column_types = list())
+
+na_dense_union(column_types = list())
+
+na_list(item_type, nullable = TRUE)
+
+na_large_list(item_type, nullable = TRUE)
+
+na_list_view(item_type, nullable = TRUE)
+
+na_large_list_view(item_type, nullable = TRUE)
+
+na_fixed_size_list(item_type, list_size, nullable = TRUE)
+
+na_map(key_type, item_type, keys_sorted = FALSE, nullable = TRUE)
+
+na_dictionary(value_type, index_type = na_int32(), ordered = FALSE)
+
+na_extension(storage_type, extension_name, extension_metadata = "")
+```
+
+## Arguments
+
+- type_name:
+
+ The name of the type (e.g., "int32"). This form of the constructor is
+ useful for writing tests that loop over many types.
+
+- byte_width:
+
+ For `na_fixed_size_binary()`, the number of bytes occupied by each
+ item.
+
+- unit:
+
+ One of 's' (seconds), 'ms' (milliseconds), 'us' (microseconds), or
+ 'ns' (nanoseconds).
+
+- timezone:
+
+ A string representing a timezone name. The empty string "" represents
+ a naive point in time (i.e., one that has no associated timezone).
+
+- precision:
+
+ The total number of digits representable by the decimal type
+
+- scale:
+
+ The number of digits after the decimal point in a decimal type
+
+- column_types:
+
+ A [`list()`](https://rdrr.io/r/base/list.html) of
+ [nanoarrow_schema](as_nanoarrow_schema.md)s.
+
+- item_type:
+
+ For `na_list()`, `na_large_list()`, `na_fixed_size_list()`, and
+ `na_map()`, the [nanoarrow_schema](as_nanoarrow_schema.md)
+ representing the item type.
+
+- key_type:
+
+ The [nanoarrow_schema](as_nanoarrow_schema.md) representing the
+ `na_map()` key type.
+
+- value_type:
+
+ The [nanoarrow_schema](as_nanoarrow_schema.md) representing the
+ `na_dictionary()` or `na_map()` value type.
+
+- index_type:
+
+ The [nanoarrow_schema](as_nanoarrow_schema.md) representing the
+ `na_dictionary()` index type.
+
+- ordered:
+
+ Use `TRUE` to assert that the order of values in the dictionary are
+ meaningful.
+
+- list_size:
+
+ The number of elements in each item in a `na_fixed_size_list()`.
+
+- keys_sorted:
+
+ Use `TRUE` to assert that keys are sorted.
+
+- storage_type:
+
+ For `na_extension()`, the underlying value type.
+
+- extension_name:
+
+ For `na_extension()`, the extension name. This is typically namespaced
+ separated by dots (e.g., nanoarrow.r.vctrs).
+
+- extension_metadata:
+
+ A string or raw vector defining extension metadata. Most Arrow
+ extension types define extension metadata as a JSON object.
+
+- nullable:
+
+ Use `FALSE` to assert that this field cannot contain null values.
+
+## Value
+
+A [nanoarrow_schema](as_nanoarrow_schema.md)
+
+## Examples
+
+``` r
+na_int32()
+#> <nanoarrow_schema int32>
+#> $ format : chr "i"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 2
+#> $ children : list()
+#> $ dictionary: NULL
+na_struct(list(col1 = na_int32()))
+#> <nanoarrow_schema struct>
+#> $ format : chr "+s"
+#> $ name : chr ""
+#> $ metadata : list()
+#> $ flags : int 0
+#> $ children :List of 1
+#> ..$ col1:<nanoarrow_schema int32>
+#> .. ..$ format : chr "i"
+#> .. ..$ name : chr "col1"
+#> .. ..$ metadata : list()
+#> .. ..$ flags : int 2
+#> .. ..$ children : list()
+#> .. ..$ dictionary: NULL
+#> $ dictionary: NULL
+```
diff --git a/main/r/reference/na_vctrs.html b/main/r/reference/na_vctrs.html
index 50b52782..4541d048 100644
--- a/main/r/reference/na_vctrs.html
+++ b/main/r/reference/na_vctrs.html
@@ -92,7 +92,7 @@ is sufficient here.</p></dd>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/na_vctrs.md b/main/r/reference/na_vctrs.md
new file mode 100644
index 00000000..48bc2e46
--- /dev/null
+++ b/main/r/reference/na_vctrs.md
@@ -0,0 +1,45 @@
+# Vctrs extension type
+
+The Arrow format provides a rich type system that can handle most R
+vector types; however, many R vector types do not roundtrip perfectly
+through Arrow memory. The vctrs extension type uses
+[`vctrs::vec_data()`](https://vctrs.r-lib.org/reference/vec_data.html),
+[`vctrs::vec_restore()`](https://vctrs.r-lib.org/reference/vec_proxy.html),
+and
+[`vctrs::vec_ptype()`](https://vctrs.r-lib.org/reference/vec_ptype.html)
+in calls to [`as_nanoarrow_array()`](as_nanoarrow_array.md) and
+[`convert_array()`](convert_array.md) to ensure roundtrip fidelity.
+
+## Usage
+
+``` r
+na_vctrs(ptype, storage_type = NULL)
+```
+
+## Arguments
+
+- ptype:
+
+ A vctrs prototype as returned by
+ [`vctrs::vec_ptype()`](https://vctrs.r-lib.org/reference/vec_ptype.html).
+ The prototype can be of arbitrary size, but a zero-size vector is
+ sufficient here.
+
+- storage_type:
+
+ For [`na_extension()`](na_type.md), the underlying value type.
+
+## Value
+
+A [nanoarrow_schema](as_nanoarrow_schema.md).
+
+## Examples
+
+``` r
+vctr <- as.POSIXlt("2000-01-02 03:45", tz = "UTC")
+array <- as_nanoarrow_array(vctr, schema = na_vctrs(vctr))
+infer_nanoarrow_ptype(array)
+#> POSIXlt of length 0
+convert_array(array)
+#> [1] "2000-01-02 03:45:00 UTC"
+```
diff --git a/main/r/reference/nanoarrow-package.html
b/main/r/reference/nanoarrow-package.html
index a57fe500..3855c504 100644
--- a/main/r/reference/nanoarrow-package.html
+++ b/main/r/reference/nanoarrow-package.html
@@ -61,7 +61,7 @@
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow-package.md
b/main/r/reference/nanoarrow-package.md
new file mode 100644
index 00000000..f262d8c4
--- /dev/null
+++ b/main/r/reference/nanoarrow-package.md
@@ -0,0 +1,31 @@
+# nanoarrow: Interface to the 'nanoarrow' 'C' Library
+
+Provides an 'R' interface to the 'nanoarrow' 'C' library and the 'Apache
+Arrow' application binary interface. Functions to import and export
+'ArrowArray', 'ArrowSchema', and 'ArrowArrayStream' 'C' structures to
+and from 'R' objects are provided alongside helpers to facilitate
+zero-copy data transfer among 'R' bindings to libraries implementing the
+'Arrow' 'C' data interface.
+
+## See also
+
+Useful links:
+
+- <https://arrow.apache.org/nanoarrow/latest/r/>
+
+- <https://github.com/apache/arrow-nanoarrow>
+
+- Report bugs at <https://github.com/apache/arrow-nanoarrow/issues>
+
+## Author
+
+**Maintainer**: Dewey Dunnington <[email protected]>
+([ORCID](https://orcid.org/0000-0002-9415-4582))
+
+Authors:
+
+- Apache Arrow <[email protected]> \[copyright holder\]
+
+Other contributors:
+
+- Apache Software Foundation <[email protected]> \[copyright holder\]
diff --git a/main/r/reference/nanoarrow_array_init.html
b/main/r/reference/nanoarrow_array_init.html
index 9b0d8b7c..1782795a 100644
--- a/main/r/reference/nanoarrow_array_init.html
+++ b/main/r/reference/nanoarrow_array_init.html
@@ -142,7 +142,7 @@ modified parameters such that the original array remains
valid.</p></li>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_array_init.md
b/main/r/reference/nanoarrow_array_init.md
new file mode 100644
index 00000000..610d10f1
--- /dev/null
+++ b/main/r/reference/nanoarrow_array_init.md
@@ -0,0 +1,86 @@
+# Modify nanoarrow arrays
+
+Create a new array or from an existing array, modify one or more
+parameters. When importing an array from elsewhere,
+`nanoarrow_array_set_schema()` is useful to attach the data type
+information to the array (without this information there is little that
+nanoarrow can do with the array since its content cannot be otherwise
+interpreted). `nanoarrow_array_modify()` can create a shallow copy and
+modify various parameters to create a new array, including setting
+children and buffers recursively. These functions power the `$<-`
+operator, which can modify one parameter at a time.
+
+## Usage
+
+``` r
+nanoarrow_array_init(schema)
+
+nanoarrow_array_set_schema(array, schema, validate = TRUE)
+
+nanoarrow_array_modify(array, new_values, validate = TRUE)
+```
+
+## Arguments
+
+- schema:
+
+ A [nanoarrow_schema](as_nanoarrow_schema.md) to attach to this
+ `array`.
+
+- array:
+
+ A [nanoarrow_array](as_nanoarrow_array.md).
+
+- validate:
+
+ Use `FALSE` to skip validation. Skipping validation may result in
+ creating an array that will crash R.
+
+- new_values:
+
+ A named [`list()`](https://rdrr.io/r/base/list.html) of values to
+ replace.
+
+## Value
+
+- `nanoarrow_array_init()` returns a possibly invalid but initialized
+ array with a given `schema`.
+
+- `nanoarrow_array_set_schema()` returns `array`, invisibly. Note that
+ `array` is modified in place by reference.
+
+- `nanoarrow_array_modify()` returns a shallow copy of `array` with the
+ modified parameters such that the original array remains valid.
+
+## Examples
+
+``` r
+nanoarrow_array_init(na_string())
+#> <nanoarrow_array string[0]>
+#> $ length : int 0
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 3
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> ..$ :<nanoarrow_buffer data_offset<int32>[null] ``
+#> ..$ :<nanoarrow_buffer data<string>[null] ``
+#> $ dictionary: NULL
+#> $ children : list()
+
+# Modify an array using $ and <-
+array <- as_nanoarrow_array(1:5)
+array$length <- 4
+as.vector(array)
+#> [1] 1 2 3 4
+
+# Modify potentially more than one component at a time
+array <- as_nanoarrow_array(1:5)
+as.vector(nanoarrow_array_modify(array, list(length = 4)))
+#> [1] 1 2 3 4
+
+# Attach a schema to an array
+array <- as_nanoarrow_array(-1L)
+nanoarrow_array_set_schema(array, na_uint32())
+as.vector(array)
+#> [1] 4294967295
+```
diff --git a/main/r/reference/nanoarrow_buffer_init.html
b/main/r/reference/nanoarrow_buffer_init.html
index 501d8480..711a3d5d 100644
--- a/main/r/reference/nanoarrow_buffer_init.html
+++ b/main/r/reference/nanoarrow_buffer_init.html
@@ -93,7 +93,7 @@ a function of <code>array</code> and the default inference of
the prototype.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_buffer_init.md
b/main/r/reference/nanoarrow_buffer_init.md
new file mode 100644
index 00000000..8212d253
--- /dev/null
+++ b/main/r/reference/nanoarrow_buffer_init.md
@@ -0,0 +1,49 @@
+# Create and modify nanoarrow buffers
+
+Create and modify nanoarrow buffers
+
+## Usage
+
+``` r
+nanoarrow_buffer_init()
+
+nanoarrow_buffer_append(buffer, new_buffer)
+
+convert_buffer(buffer, to = NULL)
+```
+
+## Arguments
+
+- buffer, new_buffer:
+
+ [nanoarrow_buffer](as_nanoarrow_buffer.md)s.
+
+- to:
+
+ A target prototype object describing the type to which `array` should
+ be converted, or `NULL` to use the default conversion as returned by
+ [`infer_nanoarrow_ptype()`](infer_nanoarrow_ptype.md). Alternatively,
+ a function can be passed to perform an alternative calculation of the
+ default ptype as a function of `array` and the default inference of
+ the prototype.
+
+## Value
+
+- `nanoarrow_buffer_init()`: An object of class 'nanoarrow_buffer'
+
+- `nanoarrow_buffer_append()`: Returns `buffer`, invisibly. Note that
+ `buffer` is modified in place by reference.
+
+## Examples
+
+``` r
+buffer <- nanoarrow_buffer_init()
+nanoarrow_buffer_append(buffer, 1:5)
+
+array <- nanoarrow_array_modify(
+ nanoarrow_array_init(na_int32()),
+ list(length = 5, buffers = list(NULL, buffer))
+)
+as.vector(array)
+#> [1] 1 2 3 4 5
+```
diff --git a/main/r/reference/nanoarrow_extension_array.html
b/main/r/reference/nanoarrow_extension_array.html
index 79cab35f..835df9d4 100644
--- a/main/r/reference/nanoarrow_extension_array.html
+++ b/main/r/reference/nanoarrow_extension_array.html
@@ -94,7 +94,7 @@ schema.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_extension_array.md
b/main/r/reference/nanoarrow_extension_array.md
new file mode 100644
index 00000000..ffdc0085
--- /dev/null
+++ b/main/r/reference/nanoarrow_extension_array.md
@@ -0,0 +1,49 @@
+# Create Arrow extension arrays
+
+Create Arrow extension arrays
+
+## Usage
+
+``` r
+nanoarrow_extension_array(
+ storage_array,
+ extension_name,
+ extension_metadata = NULL
+)
+```
+
+## Arguments
+
+- storage_array:
+
+ A [nanoarrow_array](as_nanoarrow_array.md).
+
+- extension_name:
+
+ For [`na_extension()`](na_type.md), the extension name. This is
+ typically namespaced separated by dots (e.g., nanoarrow.r.vctrs).
+
+- extension_metadata:
+
+ A string or raw vector defining extension metadata. Most Arrow
+ extension types define extension metadata as a JSON object.
+
+## Value
+
+A [nanoarrow_array](as_nanoarrow_array.md) with attached extension
+schema.
+
+## Examples
+
+``` r
+nanoarrow_extension_array(1:10, "some_ext", '{"key": "value"}')
+#> <nanoarrow_array some_ext{int32}[10]>
+#> $ length : int 10
+#> $ null_count: int 0
+#> $ offset : int 0
+#> $ buffers :List of 2
+#> ..$ :<nanoarrow_buffer validity<bool>[null] ``
+#> ..$ :<nanoarrow_buffer data<int32>[10][40 b]> `1 2 3 4 5 6 7 8 9 10`
+#> $ dictionary: NULL
+#> $ children : list()
+```
diff --git a/main/r/reference/nanoarrow_extension_spec.html
b/main/r/reference/nanoarrow_extension_spec.html
index 3c74968f..52853473 100644
--- a/main/r/reference/nanoarrow_extension_spec.html
+++ b/main/r/reference/nanoarrow_extension_spec.html
@@ -99,7 +99,7 @@ registered.</p></li>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_extension_spec.md
b/main/r/reference/nanoarrow_extension_spec.md
new file mode 100644
index 00000000..9ea79b4c
--- /dev/null
+++ b/main/r/reference/nanoarrow_extension_spec.md
@@ -0,0 +1,57 @@
+# Register Arrow extension types
+
+Register Arrow extension types
+
+## Usage
+
+``` r
+nanoarrow_extension_spec(data = list(), subclass = character())
+
+register_nanoarrow_extension(extension_name, extension_spec)
+
+unregister_nanoarrow_extension(extension_name)
+
+resolve_nanoarrow_extension(extension_name)
+```
+
+## Arguments
+
+- data:
+
+ Optional data to include in the extension type specification
+
+- subclass:
+
+ A subclass for the extension type specification. Extension methods
+ will dispatch on this object.
+
+- extension_name:
+
+ An Arrow extension type name (e.g., nanoarrow.r.vctrs)
+
+- extension_spec:
+
+ An extension specification inheriting from 'nanoarrow_extension_spec'.
+
+## Value
+
+- `nanoarrow_extension_spec()` returns an object of class
+ 'nanoarrow_extension_spec'.
+
+- `register_nanoarrow_extension()` returns `extension_spec`, invisibly.
+
+- `unregister_nanoarrow_extension()` returns `extension_name`,
+ invisibly.
+
+- `resolve_nanoarrow_extension()` returns an object of class
+ 'nanoarrow_extension_spec' or NULL if the extension type was not
+ registered.
+
+## Examples
+
+``` r
+nanoarrow_extension_spec("mynamespace.mytype", subclass =
"mypackage_mytype_spec")
+#> [1] "mynamespace.mytype"
+#> attr(,"class")
+#> [1] "mypackage_mytype_spec" "nanoarrow_extension_spec"
+```
diff --git a/main/r/reference/nanoarrow_pointer_is_valid.html
b/main/r/reference/nanoarrow_pointer_is_valid.html
index fbffbe69..25e1cd68 100644
--- a/main/r/reference/nanoarrow_pointer_is_valid.html
+++ b/main/r/reference/nanoarrow_pointer_is_valid.html
@@ -158,7 +158,7 @@ types.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_pointer_is_valid.md
b/main/r/reference/nanoarrow_pointer_is_valid.md
new file mode 100644
index 00000000..844168a9
--- /dev/null
+++ b/main/r/reference/nanoarrow_pointer_is_valid.md
@@ -0,0 +1,109 @@
+# Danger zone: low-level pointer operations
+
+The [nanoarrow_schema](as_nanoarrow_schema.md),
+[nanoarrow_array](as_nanoarrow_array.md), and
+[nanoarrow_array_stream](as_nanoarrow_array_stream.md) classes are
+represented in R as external pointers (`EXTPTRSXP`). When these objects
+go out of scope (i.e., when they are garbage collected or shortly
+thereafter), the underlying object's `release()` callback is called if
+the underlying pointer is non-null and if the `release()` callback is
+non-null.
+
+## Usage
+
+``` r
+nanoarrow_pointer_is_valid(ptr)
+
+nanoarrow_pointer_addr_dbl(ptr)
+
+nanoarrow_pointer_addr_chr(ptr)
+
+nanoarrow_pointer_addr_pretty(ptr)
+
+nanoarrow_pointer_release(ptr)
+
+nanoarrow_pointer_move(ptr_src, ptr_dst)
+
+nanoarrow_pointer_export(ptr_src, ptr_dst)
+
+nanoarrow_allocate_schema()
+
+nanoarrow_allocate_array()
+
+nanoarrow_allocate_array_stream()
+
+nanoarrow_pointer_set_protected(ptr_src, protected)
+```
+
+## Arguments
+
+- ptr, ptr_src, ptr_dst:
+
+ An external pointer to a `struct ArrowSchema`, `struct ArrowArray`, or
+ `struct ArrowArrayStream`.
+
+- protected:
+
+ An object whose scope must outlive that of `ptr`. This is useful for
+ array streams since at least two specifications involving the array
+ stream specify that the stream is only valid for the lifecycle of
+ another object (e.g., an AdbcStatement or OGRDataset).
+
+## Value
+
+- `nanoarrow_pointer_is_valid()` returns TRUE if the pointer is non-null
+ and has a non-null release callback.
+
+- `nanoarrow_pointer_addr_dbl()` and `nanoarrow_pointer_addr_chr()`
+ return pointer representations that may be helpful to facilitate
+ moving or exporting nanoarrow objects to other libraries.
+
+- `nanoarrow_pointer_addr_pretty()` gives a pointer representation
+ suitable for printing or error messages.
+
+- `nanoarrow_pointer_release()` returns `ptr`, invisibly.
+
+- `nanoarrow_pointer_move()` and `nanoarrow_pointer_export()` reeturn
+ `ptr_dst`, invisibly.
+
+- `nanoarrow_allocate_array()`, `nanoarrow_allocate_schema()`, and
+ `nanoarrow_allocate_array_stream()` return an
+ [array](as_nanoarrow_array.md), a [schema](as_nanoarrow_schema.md),
+ and an [array stream](as_nanoarrow_array_stream.md), respectively.
+
+## Details
+
+When interacting with other C Data Interface implementations, it is
+important to keep in mind that the R object wrapping these pointers is
+always passed by reference (because it is an external pointer) and may
+be referred to by another R object (e.g., an element in a
+[`list()`](https://rdrr.io/r/base/list.html) or as a variable assigned
+in a user's environment). When importing a schema, array, or array
+stream into nanoarrow this is not a problem: the R object takes
+ownership of the lifecycle and memory is released when the R object is
+garbage collected. In this case, one can use `nanoarrow_pointer_move()`
+where `ptr_dst` was created using `nanoarrow_allocate_*()`.
+
+The case of exporting is more complicated and as such has a dedicated
+function, `nanoarrow_pointer_export()`, that implements different logic
+schemas, arrays, and array streams:
+
+- Schema objects are (deep) copied such that a fresh copy of the schema
+ is exported and made the responsibility of some other C data interface
+ implementation.
+
+- Array objects are exported as a shell around the original array that
+ preserves a reference to the R object. This ensures that the buffers
+ and children pointed to by the array are not copied and that any
+ references to the original array are not invalidated.
+
+- Array stream objects are moved: the responsibility for the object is
+ transferred to the other C data interface implementation and any
+ references to the original R object are invalidated. Because these
+ objects are mutable, this is typically what you want (i.e., you should
+ not be pulling arrays from a stream accidentally from two places).
+
+If you know the lifecycle of your object (i.e., you created the R object
+yourself and never passed references to it elsewhere), you can slightly
+more efficiently call `nanoarrow_pointer_move()` for all three pointer
+types.
diff --git a/main/r/reference/nanoarrow_version.html
b/main/r/reference/nanoarrow_version.html
index 9462a0a2..0b98ceda 100644
--- a/main/r/reference/nanoarrow_version.html
+++ b/main/r/reference/nanoarrow_version.html
@@ -76,7 +76,7 @@ was compiled against.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/nanoarrow_version.md
b/main/r/reference/nanoarrow_version.md
new file mode 100644
index 00000000..8a0b8d1e
--- /dev/null
+++ b/main/r/reference/nanoarrow_version.md
@@ -0,0 +1,31 @@
+# Underlying 'nanoarrow' C library build
+
+Underlying 'nanoarrow' C library build
+
+## Usage
+
+``` r
+nanoarrow_version(runtime = TRUE)
+
+nanoarrow_with_zstd()
+```
+
+## Arguments
+
+- runtime:
+
+ Compare TRUE and FALSE values to detect a possible ABI mismatch.
+
+## Value
+
+A string identifying the version of nanoarrow this package was compiled
+against.
+
+## Examples
+
+``` r
+nanoarrow_version()
+#> [1] "0.8.0-SNAPSHOT"
+nanoarrow_with_zstd()
+#> [1] TRUE
+```
diff --git a/main/r/reference/read_nanoarrow.html
b/main/r/reference/read_nanoarrow.html
index 0c7a81f8..7617002c 100644
--- a/main/r/reference/read_nanoarrow.html
+++ b/main/r/reference/read_nanoarrow.html
@@ -118,7 +118,7 @@ and the recommended file extension is
<code>.arrows</code>.</p>
</div>
<div class="pkgdown-footer-right">
- <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.1.3.</p>
+ <p>Site built with <a href="https://pkgdown.r-lib.org/";
class="external-link">pkgdown</a> 2.2.0.</p>
</div>
</footer></div>
diff --git a/main/r/reference/read_nanoarrow.md
b/main/r/reference/read_nanoarrow.md
new file mode 100644
index 00000000..2b26c497
--- /dev/null
+++ b/main/r/reference/read_nanoarrow.md
@@ -0,0 +1,69 @@
+# Read/write serialized streams of Arrow data
+
+Reads/writes connections, file paths, URLs, or raw vectors from/to
+serialized Arrow data. Arrow documentation typically refers to this
+format as "Arrow IPC", since its origin was as a means to transmit
+tables between processes (e.g., multiple R sessions). This format can
+also be written to and read from files or URLs and is essentially a high
+performance equivalent of a CSV file that does a better job maintaining
+types.
+
+## Usage
+
+``` r
+read_nanoarrow(x, ..., lazy = FALSE)
+
+write_nanoarrow(data, x, ...)
+```
+
+## Arguments
+
+- x:
+
+ A [`raw()`](https://rdrr.io/r/base/raw.html) vector, connection, or
+ file path from which to read binary data. Common extensions indicating
+ compression (.gz, .bz2, .zip) are automatically uncompressed.
+
+- ...:
+
+ Currently unused.
+
+- lazy:
+
+ By default, `read_nanoarrow()` will read and discard a copy of the
+ reader's schema to ensure that invalid streams are discovered as soon
+ as possible. Use `lazy = TRUE` to defer this check until the reader is
+ actually consumed.
+
+- data:
+
+ An object to write as an Arrow IPC stream, converted using
+ [`as_nanoarrow_array_stream()`](as_nanoarrow_array_stream.md).
+ Notably, this includes a
+ [`data.frame()`](https://rdrr.io/r/base/data.frame.html).
+
+## Value
+
+A [nanoarrow_array_stream](as_nanoarrow_array_stream.md)
+
+## Details
+
+The nanoarrow package implements an IPC writer; however, you can also
+use
+[`arrow::write_ipc_stream()`](https://arrow.apache.org/docs/r/reference/write_ipc_stream.html)
+to write data from R, or use the equivalent writer from another Arrow
+implementation in Python, C++, Rust, JavaScript, Julia, C#, and beyond.
+
+The media type of an Arrow stream is
+`application/vnd.apache.arrow.stream` and the recommended file extension
+is `.arrows`.
+
+## Examples
+
+``` r
+as.data.frame(read_nanoarrow(example_ipc_stream()))
+#> some_col
+#> 1 0
+#> 2 1
+#> 3 2
+```
