Fix typos and reformat

Author: emmt

src/arrays.jl

@@ -8,8 +8,8 @@ tuple of `AbstractUnitRange{eltype(Dims)}`s. Any integer in `args...` is replace
 instance of `Base.OneTo{eltype(Dims)}`.
 
 The array dimensions or ranges may also be provided as a tuple.
-[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which
-`as_array_axes` is applicable.
+[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which `as_array_axes`
+is applicable.
 
 Also see [`as_array_shape`](@ref), [`as_array_size`](@ref), [`as_array_axis`](@ref),
 [`ArrayAxes`](@ref), `Dims`, and [`new_array`](@ref).
@@ -25,8 +25,8 @@ as_array_axes(args::RelaxedArrayShape) = map(as_array_axis, args)
 
 converts array dimension or range `arg` to a canonical array axis, that is an instance of
 `AbstractUnitRange{eltype(Dims)}`. If `arg` is an integer, `Base.OneTo{eltype(Dims)}(arg)`
-is returned. [`eltype(RelaxedArrayShape)`](@ref RelaxedArrayShape) is the union of types
-to which `as_array_axis` is applicable.
+is returned. [`eltype(RelaxedArrayShape)`](@ref RelaxedArrayShape) is the union of types to
+which `as_array_axis` is applicable.
 
 Also see [`as_array_axes`](@ref), [`as_array_dim`](@ref), and `Dims`.
 
@@ -62,20 +62,19 @@ as_array_dim(rng::AbstractRange{<:Integer}) =
 
 converts array dimensions or ranges `args...` to a canonical form of array shape, one of:
 
-* array size, that is a tuple of `Int`s. This is the result if all of `args...` are
-  integers or instances of `Base.OneTo`, the latter, if any, being replaced by their
-  lengths.
+* array size, that is a tuple of `Int`s. This is the result if all of `args...` are integers
+  or instances of `Base.OneTo`, the latter, if any, being replaced by their lengths.
 
 * array axes, that is a tuple of `AbstractUnitRange{Int}`s. This is the result if any of
   `args...` are non-`Base.OneTo` ranges, the integers being converted to instances of
   `Base.OneTo{eltype(Dims)}`.
 
 The array dimensions or ranges may also be provided as a tuple.
-[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which
-`as_array_shape` is applicable.
+[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which `as_array_shape`
+is applicable.
 
-Also see [`as_array_size`](@ref), [`as_array_axes`](@ref), [`ArrayAxes`](@ref), `Dims`,
-and [`new_array`](@ref).
+Also see [`as_array_size`](@ref), [`as_array_axes`](@ref), [`ArrayAxes`](@ref), `Dims`, and
+[`new_array`](@ref).
 
 """
 as_array_shape(::Tuple{}) = ()
@@ -90,11 +89,11 @@ converts array dimensions or ranges `args...` to a canonical form of array size,
 tuple of `eltype(Dims)`s. Any range in `args...` is replaced by its length.
 
 The array dimensions or ranges may also be provided as a tuple.
-[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which
-`as_array_size` is applicable.
+[`RelaxedArrayShape{N}`](@ref) is the union of types of `N`-tuples to which `as_array_size`
+is applicable.
 
-Also see [`as_array_shape`](@ref), [`as_array_axes`](@ref), [`as_array_dim`](@ref),
-`Dims`, and [`new_array`](@ref).
+Also see [`as_array_shape`](@ref), [`as_array_axes`](@ref), [`as_array_dim`](@ref), `Dims`,
+and [`new_array`](@ref).
 
 """
 as_array_size(::Tuple{}) = ()
@@ -110,8 +109,8 @@ create a new array with element type `T` and shape defined by `inds...`, a list
 dimension lengths and/or index ranges. The shape may also be specified as a tuple.
 
 If `inds...` contains any index range other than `Base.OneTo`, an `OffsetArray{T}` is
-returned; otherwise an `Array{T}` is returned. In the former case, an exception is thrown
-if the package `OffsetArrays` has not been loaded.
+returned; otherwise an `Array{T}` is returned. In the former case, an exception is thrown if
+the package `OffsetArrays` has not been loaded.
 
 Also see [`as_array_shape`](@ref), [`as_array_axes`](@ref), and [`as_array_size`](@ref).
 
@@ -158,10 +157,9 @@ convert_eltype(::Type{T}, ::Type{X}) where {T,X} =
     error("don't know how to convert the element type of type `$X` to `$T`")
 
 # As of Julia 1.11 `AbstractMatrix{T}(A)` or `AbstractArray{T}(A)` can be used to convert
-# element type of `A` for Adjoint, Bidiagonal, Diagonal, Hermitian,
-# LinearAlgebra.LQPackedQ, LowerTriangular, SymTridiagonal, Symmetric, Transpose,
-# Tridiagonal, UnitLowerTriangular, UnitUpperTriangular, UpperHessenberg, UpperTriangular,
-# etc.
+# element type of `A` for Adjoint, Bidiagonal, Diagonal, Hermitian, LinearAlgebra.LQPackedQ,
+# LowerTriangular, SymTridiagonal, Symmetric, Transpose, Tridiagonal, UnitLowerTriangular,
+# UnitUpperTriangular, UpperHessenberg, UpperTriangular, etc.
 convert_eltype(::Type{T}, A::AbstractArray{T}) where {T} = A
 convert_eltype(::Type{T}, A::AbstractArray) where {T} = AbstractArray{T}(A)
 convert_eltype(::Type{T}, ::Type{<:Array{<:Any,N}}) where {T,N} = Array{T,N}
@@ -193,8 +191,8 @@ end
 # Convert element type for numbers.
 convert_eltype(::Type{T}, ::Type{<:Number}) where {T} = T
 
-# Convert element type for tuples. See `_countuple` in `base/tuple.jl` for the best
-# way to extract the number of elements in a tuple given its type.
+# Convert element type for tuples. See `_countuple` in `base/tuple.jl` for the best way to
+# extract the number of elements in a tuple given its type.
 convert_eltype(::Type{T}, ::Type{<:NTuple{N,Any}}) where {N,T} = NTuple{N,T}
 convert_eltype(::Type{T}, A::NTuple{N,T}) where {N,T} = A
 convert_eltype(::Type{T}, A::Tuple) where {T} = map(as(T), A)
@@ -237,8 +235,8 @@ convert_eltype(::Type{T}) where {T} = Converter(convert_eltype, T)
 yields an array which lazily converts its entries to type `T`. More specifically, a call
 like `B[i]` yields `as(T,A[i])`.
 
-Consider using [`convert_eltype(T, A)`](@ref convert_eltype) to perform the conversion
-once and immediately.
+Consider using [`convert_eltype(T, A)`](@ref convert_eltype) to perform the conversion once
+and immediately.
 
 """
 as_eltype(::Type{T}, A::AbstractArray{T}) where {T} = A

src/funcs.jl

@@ -3,8 +3,8 @@
 """
     return_type(f, argtypes...) -> T
 
-yields the type of the result returned by the callable object `f` when called
-with arguments of types `argtypes...`.
+yields the type of the result returned by the callable object `f` when called with arguments
+of types `argtypes...`.
 
 See the warning in the documentation of `Base.promote_op` for the fragility of such
 inference in some cases. There are no such issues if `f` is an instance of

src/macros.jl

@@ -1,8 +1,8 @@
 """
     TypeUtils.@public args...
 
-declares `args...` as being `public` even though they are not exported. For Julia version
-< 1.11, this macro does nothing. Using this macro also avoid errors with CI and coverage
+declares `args...` as being `public` even though they are not exported. For Julia version <
+1.11, this macro does nothing. Using this macro also avoid errors with CI and coverage
 tools.
 
 """

src/methods.jl

@@ -14,8 +14,8 @@ as(::Type{Tuple}, x::CartesianIndex) = Tuple(x)
 as(::Type{Tuple}, x::CartesianIndices) = x.indices
 for X in (:CartesianIndex, :CartesianIndices)
     @eval begin
-        # For more specific tuple types, first extract tuple contents, then
-        # convert to the requested tuple type.
+        # For more specific tuple types, first extract tuple contents, then convert to the
+        # requested tuple type.
         as(::Type{T}, x::$X) where {T<:Tuple} = as(T, as(Tuple, x))
 
         # Use the constructors to convert tuples to Cartesian index/indices.
@@ -149,13 +149,13 @@ Array
 #
 # - https://stackoverflow.com/questions/42229901/getting-the-parameter-less-type
 #
-# The latter leads to define the method as (in old versions of Julia, the field
-# name was `:primary`, but since Julia 0.7, it should be `:wrapper`):
+# The latter leads to define the method as (in old versions of Julia, the field name was
+# `:primary`, but since Julia 0.7, it should be `:wrapper`):
 #
 #     @inline parameterless(::Type{T}) where {T} = getfield(Base.typename(T), :wrapper)
 #
-# The actual implementation is borrowed from `ConstructionBase` and should be
-# less likely to be broken by internal changes in Julia:
+# The actual implementation is borrowed from `ConstructionBase` and should be less likely to
+# be broken by internal changes in Julia:
 #
 parameterless(::Type{T}) where {T} = getfield(parentmodule(T), nameof(T))
 
@@ -165,8 +165,8 @@ parameterless(::Type{T}) where {T} = getfield(parentmodule(T), nameof(T))
 
 yield whether number `x` can be negated while retaining the same type. The result only
 depends on the type of `x`. The result is `false` for `typeof(x) <:
-Union{U,Rational{U},Complex{U}} where {U<:Union{Bool,Unsigned}}` as well as quantities
-based on these bare numeric types.
+Union{U,Rational{U},Complex{U}} where {U<:Union{Bool,Unsigned}}` as well as quantities based
+on these bare numeric types.
 
 """
 is_signed(x::Number) = is_signed(typeof(x))

src/numbers.jl

@@ -4,8 +4,8 @@
     bare_type(x) -> T <: Union{Real,Complex}
 
 yields the bare numeric type `T` backing the storage of `x` which may be a number or a
-numeric type. If `x` has units, they are discarded. Hence `T` is always a dimensionless
-real or complex type.
+numeric type. If `x` has units, they are discarded. Hence `T` is always a dimensionless real
+or complex type.
 
 Examples:
 
@@ -27,8 +27,8 @@ yields the promoted bare numeric type of `args...`.
 ---
     bare_type() -> TypeUtils.BareNumber
 
-yields the union of bare numeric types that may be returned by `bare_type` when called
-with no arguments.
+yields the union of bare numeric types that may be returned by `bare_type` when called with
+no arguments.
 
 """
 bare_type() = BareNumber
@@ -43,8 +43,8 @@ bare_type(::Type{T}) where {T<:Number} = typeof(one(T))
 
 yields the bare numeric type `T` backing the storage of `x` which may be a number of a
 numeric type. If `x` is a complex, `T` is the bare numeric type of the real and imaginary
-parts of `x`. If `x` has units, they are discarded. Hence `T` is always a dimensionless
-real type.
+parts of `x`. If `x` has units, they are discarded. Hence `T` is always a dimensionless real
+type.
 
 Examples:
 
@@ -89,12 +89,12 @@ end
 """
     convert_bare_type(T, x)
 
-converts `x` so that its bare numeric type is that of `T`. Argument `x` may be a number or
-a numeric type, while argument `T` must be a numeric type. If `x` is one of `missing`,
+converts `x` so that its bare numeric type is that of `T`. Argument `x` may be a number or a
+numeric type, while argument `T` must be a numeric type. If `x` is one of `missing`,
 `nothing`, `undef`, or the type of one of these singletons, `x` is returned.
 
-This method may be extended with `T<:TypeUtils.BareNumber` and for `x` of
-non-standard numeric type.
+This method may be extended with `T<:TypeUtils.BareNumber` and for `x` of non-standard
+numeric type.
 
 """
 convert_bare_type(::Type{T}, x) where {T} = convert_bare_type(bare_type(T), x)
@@ -197,10 +197,9 @@ floating_point_type() = AbstractFloat
 """
     convert_floating_point_type(T, x)
 
-converts `x` so that its bare real type is the floating-point type of `T`. Argument `x`
-may be a number or a numeric type, while argument `T` must be a numeric type. If `x` is
-one of `missing`, `nothing`, `undef`, or the type of one of these singletons, `x` is
-returned.
+converts `x` so that its bare real type is the floating-point type of `T`. Argument `x` may
+be a number or a numeric type, while argument `T` must be a numeric type. If `x` is one of
+`missing`, `nothing`, `undef`, or the type of one of these singletons, `x` is returned.
 
 This method may be extended with `T<:AbstractFloat` and for `x` of non-standard numeric
 type.
@@ -212,8 +211,8 @@ convert_floating_point_type(::Type{T}, x) where {T} =
 """
     convert_floating_point_type(T) -> f
 
-yields a callable object `f` such that `f(x)` yields `convert_floating_point_type(T, x)`
-for any `x`.
+yields a callable object `f` such that `f(x)` yields `convert_floating_point_type(T, x)` for
+any `x`.
 
 """
 convert_floating_point_type(::Type{T}) where {T} =
@@ -265,8 +264,8 @@ assert_floating_point(name::Union{Symbol,AbstractString}, ::Type{T}) where {T} =
 """
     nearest(T::Type, x) -> y::T
 
-yields the value or instance of type `T` that is the nearest to `x`. For `T` integer and
-`x` real, it can be seen as rounding with clamping.
+yields the value or instance of type `T` that is the nearest to `x`. For `T` integer and `x`
+real, it can be seen as rounding with clamping.
 
 """
 nearest(::Type{T}, x::T) where {T} = x
@@ -293,8 +292,8 @@ end
 
 # Non-integer real to nearest integer.
 function nearest(::Type{T}, x::Real) where {T<:Integer}
-    # We cannot use `ifelse` here because conversion may throw an `InexactError`. This
-    # will occur anyway for `NaN`s.
+    # We cannot use `ifelse` here because conversion may throw an `InexactError`. This will
+    # occur anyway for `NaN`s.
     r = round(x)
     if r ≤ (lo = typemin(T))
         return lo

src/precision.jl

@@ -65,10 +65,9 @@ get_precision(::Type{S}, ::Type{T}) where {S<:AbstractFloat,T<:AbstractFloat} =
 
 yields an object `y` similar to `x` but with numerical precision specified by the
 floating-point type `T`. If `x` has already the required precision or if setting its
-precision is irrelevant or not implemented, `x` is returned unchanged. Setting the
-precision shall not change the dimensions of dimensionful numbers. If `T` is
-`AbstractFloat`, the default floating-point type [`TypeUtils.default_precision`](@ref) is
-assumed.
+precision is irrelevant or not implemented, `x` is returned unchanged. Setting the precision
+shall not change the dimensions of dimensionful numbers. If `T` is `AbstractFloat`, the
+default floating-point type [`TypeUtils.default_precision`](@ref) is assumed.
 
 For a number `x`, `adapt_precision(T, x)` behaves as [`convert_real_type(T, x)`](@ref
 convert_real_type) and `adapt_precision(T, typeof(x))` may be used to infer the
@@ -90,8 +89,8 @@ specialized for other object types defined in foreign packages by specializing:
 TypeUtils.adapt_precision(::Type{T}, x::SomeType) where {T<:TypeUtils.Precision} = ...
 ```
 
-where `SomeType` is the object type and where the restriction `T<:TypeUtils.Precision` is
-to make sure the above method is only called with a concrete floating-point type `T`.
+where `SomeType` is the object type and where the restriction `T<:TypeUtils.Precision` is to
+make sure the above method is only called with a concrete floating-point type `T`.
 
 See also [`get_precision`](@ref), [`convert_real_type`](@ref),
 [`TypeUtils.Precision`](@ref), and [`TypeUtils.default_precision`](@ref).

src/structs.jl

@@ -4,8 +4,8 @@
     destructure(Vector, obj) -> vals::Vector
     destructure(Vector{T}, obj) -> vals::Vector{T}
 
-destructure object `obj` as a tuple or a vector of field values. Any structures in `obj`
-are recursively destructured. For example, a complex is destructured as two reals.
+destructure object `obj` as a tuple or a vector of field values. Any structures in `obj` are
+recursively destructured. For example, a complex is destructured as two reals.
 
 See also [`destructure!`](@ref), [`restructure`](@ref), and [`struct_length`](@ref).
 
@@ -84,8 +84,8 @@ end
 restructures values `vals[offset+1:offset+n]` into an object `obj` of type `T`. Here `n =
 struct_length(T)` is the total number of values stored by an object of type `T`.
 
-The default constructor must exist for type `T` and, recursively, for any structured
-fields of `T`.
+The default constructor must exist for type `T` and, recursively, for any structured fields
+of `T`.
 
 See also [`destructure`](@ref), [`destructure!`](@ref), and [`struct_length`](@ref).
 
@@ -133,8 +133,8 @@ end
     struct_length(x) -> n
     struct_length(typeof(x)) -> n
 
-yield the total number of values stored by the fields of a structured object `x`. The
-result only depends on the type of `x`.
+yield the total number of values stored by the fields of a structured object `x`. The result
+only depends on the type of `x`.
 
 """
 struct_length(x) = struct_length(typeof(x))