ARROW-7479: [Rust][Ruby][R] Fix typos

This PR fixes typos in files under `rust`, `ruby`, and `r` directories

Closes #6108 from kiszk/ARROW-7479 and squashes the following commits:

07098de <Kazuaki Ishizaki> address review comment
1c8927e <Kazuaki Ishizaki> address review comment
3b35733 <Kazuaki Ishizaki> fix typo
a22296b <Kazuaki Ishizaki> address review comment
529a376 <Kazuaki Ishizaki> fix typos

Authored-by: Kazuaki Ishizaki <[email protected]>
Signed-off-by: Sutou Kouhei <[email protected]>

Author: kiszk

r/R/csv.R

@@ -67,7 +67,7 @@
 #' @param as_data_frame Should the function return a `data.frame` or an
 #' [arrow::Table][Table]?
 #'
-#' @return A `data.frame`, or an Table if `as_data_frame = FALSE`.
+#' @return A `data.frame`, or a Table if `as_data_frame = FALSE`.
 #' @export
 #' @examples
 #' \donttest{

r/R/dplyr.R

@@ -21,7 +21,7 @@
 arrow_dplyr_query <- function(.data) {
   # An arrow_dplyr_query is a container for an Arrow data object (Table,
   # RecordBatch, or Dataset) and the state of the user's dplyr query--things
-  # like selected colums, filters, and group vars.
+  # like selected columns, filters, and group vars.
 
   # For most dplyr methods,
   # method.Table == method.RecordBatch == method.Dataset == method.arrow_dplyr_query

r/R/parquet.R

@@ -60,7 +60,7 @@ read_parquet <- function(file,
 #' @param compression_level compression level. Meaning depends on compression algorithm
 #' @param use_dictionary Specify if we should use dictionary encoding. Default `TRUE`
 #' @param write_statistics Specify if we should write statistics. Default `TRUE`
-#' @param data_page_size Set a target threshhold for the approximate encoded
+#' @param data_page_size Set a target threshold for the approximate encoded
 #'    size of data pages within a column chunk (in bytes). Default 1 MiB.
 #' @param properties properties for parquet writer, derived from arguments
 #'   `version`, `compression`, `compression_level`, `use_dictionary`,
@@ -254,7 +254,7 @@ make_valid_version <- function(version, valid_versions = valid_parquet_version)
 #' - `compression_level`: Compression level; meaning depends on compression algorithm
 #' - `use_dictionary`: Specify if we should use dictionary encoding. Default `TRUE`
 #' - `write_statistics`: Specify if we should write statistics. Default `TRUE`
-#' - `data_page_size`: Set a target threshhold for the approximate encoded
+#' - `data_page_size`: Set a target threshold for the approximate encoded
 #'    size of data pages within a column chunk (in bytes). Default 1 MiB.
 #'
 #' @details The parameters `compression`, `compression_level`, `use_dictionary`

r/man/ParquetWriterProperties.Rd

@@ -1002,7 +1002,7 @@ arrow::Status CheckCompatibleStruct(SEXP obj,
 }
 
 std::shared_ptr<arrow::Array> Array__from_vector(
-    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_infered) {
+    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_inferred) {
   // short circuit if `x` is already an Array
   if (Rf_inherits(x, "Array")) {
     return Rcpp::ConstReferenceSmartPtrInputParameter<std::shared_ptr<arrow::Array>>(x);
@@ -1020,9 +1020,9 @@ std::shared_ptr<arrow::Array> Array__from_vector(
     return arrow::r::MakeStringArray(x);
   }
 
-  // factors only when type has been infered
+  // factors only when type has been inferred
   if (type->id() == Type::DICTIONARY) {
-    if (type_infered || arrow::r::CheckCompatibleFactor(x, type)) {
+    if (type_inferred || arrow::r::CheckCompatibleFactor(x, type)) {
       return arrow::r::MakeFactorArray(x, type);
     }
 
@@ -1031,7 +1031,7 @@ std::shared_ptr<arrow::Array> Array__from_vector(
 
   // struct types
   if (type->id() == Type::STRUCT) {
-    if (!type_infered) {
+    if (!type_inferred) {
       STOP_IF_NOT_OK(arrow::r::CheckCompatibleStruct(x, type));
     }
 
@@ -1066,16 +1066,16 @@ std::shared_ptr<arrow::DataType> Array__infer_type(SEXP x) {
 // [[arrow::export]]
 std::shared_ptr<arrow::Array> Array__from_vector(SEXP x, SEXP s_type) {
   // the type might be NULL, in which case we need to infer it from the data
-  // we keep track of whether it was infered or supplied
-  bool type_infered = Rf_isNull(s_type);
+  // we keep track of whether it was inferred or supplied
+  bool type_inferred = Rf_isNull(s_type);
   std::shared_ptr<arrow::DataType> type;
-  if (type_infered) {
+  if (type_inferred) {
     type = arrow::r::InferType(x);
   } else {
     type = arrow::r::extract<arrow::DataType>(s_type);
   }
 
-  return arrow::r::Array__from_vector(x, type, type_infered);
+  return arrow::r::Array__from_vector(x, type, type_inferred);
 }
 
 // [[arrow::export]]
@@ -1084,12 +1084,12 @@ std::shared_ptr<arrow::ChunkedArray> ChunkedArray__from_list(Rcpp::List chunks,
   std::vector<std::shared_ptr<arrow::Array>> vec;
 
   // the type might be NULL, in which case we need to infer it from the data
-  // we keep track of whether it was infered or supplied
-  bool type_infered = Rf_isNull(s_type);
+  // we keep track of whether it was inferred or supplied
+  bool type_inferred = Rf_isNull(s_type);
   R_xlen_t n = XLENGTH(chunks);
 
   std::shared_ptr<arrow::DataType> type;
-  if (type_infered) {
+  if (type_inferred) {
     if (n == 0) {
       Rcpp::stop("type must be specified for empty list");
     }
@@ -1106,11 +1106,11 @@ std::shared_ptr<arrow::ChunkedArray> ChunkedArray__from_list(Rcpp::List chunks,
     vec.push_back(array);
   } else {
     // the first - might differ from the rest of the loop
-    // because we might have infered the type from the first element of the list
+    // because we might have inferred the type from the first element of the list
     //
     // this only really matters for dictionary arrays
     vec.push_back(
-        arrow::r::Array__from_vector(VECTOR_ELT(chunks, 0), type, type_infered));
+        arrow::r::Array__from_vector(VECTOR_ELT(chunks, 0), type, type_inferred));
 
     for (R_xlen_t i = 1; i < n; i++) {
       vec.push_back(arrow::r::Array__from_vector(VECTOR_ELT(chunks, i), type, false));

r/man/read_delim_arrow.Rd

@@ -253,7 +253,7 @@ namespace r {
 Status count_fields(SEXP lst, int* out);
 
 std::shared_ptr<arrow::Array> Array__from_vector(
-    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_infered);
+    SEXP x, const std::shared_ptr<arrow::DataType>& type, bool type_inferred);
 
 template <typename T>
 std::vector<std::shared_ptr<T>> List_to_shared_ptr_vector(SEXP x) {

r/man/write_parquet.Rd

@@ -292,7 +292,7 @@ std::shared_ptr<arrow::RecordBatch> RecordBatch__from_arrays(SEXP schema_sxp, SE
     }
   }
 
-  // generate schema from the types that have been infered
+  // generate schema from the types that have been inferred
   std::shared_ptr<arrow::Schema> schema;
 
   std::vector<std::shared_ptr<arrow::Field>> fields(num_fields);

r/src/array_from_vector.cpp

@@ -443,7 +443,7 @@ test_that("Array$create() handles data frame -> struct arrays (ARROW-3811)", {
   expect_equivalent(a$as_vector(), df)
 })
 
-test_that("Array$create() can handle data frame with custom struct type (not infered)", {
+test_that("Array$create() can handle data frame with custom struct type (not inferred)", {
   df <- tibble::tibble(x = 1:10, y = 1:10)
   type <- struct(x = float64(), y = int16())
   a <- Array$create(df, type = type)

r/src/arrow_types.h

@@ -59,7 +59,7 @@ class Field
     #     There is a shortcut for convenience. If field description
     #     doesn't have `:data_type`, all keys except `:name` are
     #     processes as data type description. For example, the
-    #     following field descrptions are the same:
+    #     following field descriptions are the same:
     #
     #     ```ruby
     #     {name: "visible", data_type: {type: :boolean}}

r/src/recordbatch.cpp

@@ -811,7 +811,7 @@ pub struct ListArray {
 }
 
 impl ListArray {
-    /// Returns an reference to the values of this list.
+    /// Returns a reference to the values of this list.
     pub fn values(&self) -> ArrayRef {
         self.values.clone()
     }
@@ -946,7 +946,7 @@ pub struct FixedSizeListArray {
 }
 
 impl FixedSizeListArray {
-    /// Returns an reference to the values of this list.
+    /// Returns a reference to the values of this list.
     pub fn values(&self) -> ArrayRef {
         self.values.clone()
     }
@@ -1745,7 +1745,7 @@ mod tests {
     #[test]
     fn test_time64_nanosecond_array_from_vec() {
         // Test building a primitive array with null values
-        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 convensions
+        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 conventions
         // work
 
         // 1e6:        00:00:00.001
@@ -1942,7 +1942,7 @@ mod tests {
 
     #[test]
     fn test_primitive_array_builder() {
-        // Test building an primitive array with ArrayData builder and offset
+        // Test building a primitive array with ArrayData builder and offset
         let buf = Buffer::from(&[0, 1, 2, 3, 4].to_byte_slice());
         let buf2 = buf.clone();
         let data = ArrayData::builder(DataType::Int32)

r/tests/testthat/test-Array.R

@@ -215,14 +215,14 @@ pub trait ArrayBuilder: Any {
     /// Builds the array
     fn finish(&mut self) -> ArrayRef;
 
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     ///
     /// This is most useful when one wants to call non-mutable APIs on a specific builder
     /// type. In this case, one can first cast this into a `Any`, and then use
     /// `downcast_ref` to get a reference on the specific builder.
     fn as_any(&self) -> &Any;
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     ///
     /// This is most useful when one wants to call mutable APIs on a specific builder
     /// type. In this case, one can first cast this into a `Any`, and then use
@@ -240,12 +240,12 @@ pub struct PrimitiveBuilder<T: ArrowPrimitiveType> {
 }
 
 impl<T: ArrowPrimitiveType> ArrayBuilder for PrimitiveBuilder<T> {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -354,12 +354,12 @@ impl<T: ArrayBuilder> ArrayBuilder for ListBuilder<T>
 where
     T: 'static,
 {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -455,12 +455,12 @@ impl<T: ArrayBuilder> ArrayBuilder for FixedSizeListBuilder<T>
 where
     T: 'static,
 {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -559,12 +559,12 @@ impl BinaryArrayBuilder for StringBuilder {}
 impl BinaryArrayBuilder for FixedSizeBinaryBuilder {}
 
 impl ArrayBuilder for BinaryBuilder {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -586,12 +586,12 @@ impl ArrayBuilder for BinaryBuilder {
 }
 
 impl ArrayBuilder for StringBuilder {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -613,12 +613,12 @@ impl ArrayBuilder for StringBuilder {
 }
 
 impl ArrayBuilder for FixedSizeBinaryBuilder {
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     fn as_any(&self) -> &Any {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     fn as_any_mut(&mut self) -> &mut Any {
         self
     }
@@ -784,7 +784,7 @@ impl ArrayBuilder for StructBuilder {
         Arc::new(self.finish())
     }
 
-    /// Returns the builder as an non-mutable `Any` reference.
+    /// Returns the builder as a non-mutable `Any` reference.
     ///
     /// This is most useful when one wants to call non-mutable APIs on a specific builder
     /// type. In this case, one can first cast this into a `Any`, and then use
@@ -793,7 +793,7 @@ impl ArrayBuilder for StructBuilder {
         self
     }
 
-    /// Returns the builder as an mutable `Any` reference.
+    /// Returns the builder as a mutable `Any` reference.
     ///
     /// This is most useful when one wants to call mutable APIs on a specific builder
     /// type. In this case, one can first cast this into a `Any`, and then use

ruby/red-arrow/lib/arrow/field.rb

@@ -89,7 +89,7 @@ pub enum SparseTensorIndexCOOOffset {}
 
 /// ----------------------------------------------------------------------
 /// EXPERIMENTAL: Data structures for sparse tensors
-/// Coodinate (COO) format of sparse tensor index.
+/// Coordinate (COO) format of sparse tensor index.
 ///
 /// COO's index list are represented as a NxM matrix,
 /// where N is the number of non-zero values,

rust/arrow/src/array/array.rs

@@ -310,7 +310,7 @@ fn create_primitive_array(
     make_array(array_data)
 }
 
-/// Reads the correct number of buffers based on list type an null_count, and creates a
+/// Reads the correct number of buffers based on list type and null_count, and creates a
 /// list array ref
 fn create_list_array(
     field_node: &ipc::FieldNode,

rust/arrow/src/array/builder.rs

@@ -285,7 +285,7 @@ fn infer_json_schema(file: File, max_read_records: Option<usize>) -> Result<Arc<
                                 Ok(())
                             }
                             Value::Object(_) => Err(ArrowError::JsonError(
-                                "Reading nested JSON structes currently not supported"
+                                "Reading nested JSON structs currently not supported"
                                     .to_string(),
                             )),
                         }
@@ -1047,7 +1047,7 @@ mod tests {
             List(Box::new(Int64)),
             coerce_data_type(vec![&Int64, &List(Box::new(Int64))]).unwrap()
         );
-        // boolean an number are incompatible, return utf8
+        // boolean and number are incompatible, return utf8
         assert_eq!(
             List(Box::new(Utf8)),
             coerce_data_type(vec![&Boolean, &List(Box::new(Float64))]).unwrap()

rust/arrow/src/ipc/gen/SparseTensor.rs

@@ -65,7 +65,7 @@ pub trait AggregateExpr: Send + Sync {
     fn name(&self) -> String;
     /// Get the data type of this expression, given the schema of the input
     fn data_type(&self, input_schema: &Schema) -> Result<DataType>;
-    /// Evaluate the expressioon being aggregated
+    /// Evaluate the expression being aggregated
     fn evaluate_input(&self, batch: &RecordBatch) -> Result<ArrayRef>;
     /// Create an accumulator for this aggregate expression
     fn create_accumulator(&self) -> Rc<RefCell<dyn Accumulator>>;

rust/arrow/src/ipc/reader.rs

@@ -1426,7 +1426,7 @@ mod tests {
     #[test]
     fn test_column_writer_add_data_pages_with_dict() {
         // ARROW-5129: Test verifies that we add data page in case of dictionary encoding
-        // and no fallback occured so far.
+        // and no fallback occurred so far.
         let file = get_temp_file("test_column_writer_add_data_pages_with_dict", &[]);
         let sink = FileSink::new(&file);
         let page_writer = Box::new(SerializedPageWriter::new(sink));