Runic format

Author: mtfishman

NDTensors/src/vendored/TypeParameterAccessors/src/base/abstractarray.jl

@@ -2,7 +2,7 @@ struct Self end
 position(a, ::Self) = Position(0)
 position(::Type, ::Self) = Position(0)
 function set_type_parameters(type::Type, ::Self, param)
-  return error("Can't set the parent type of an unwrapped array type.")
+    return error("Can't set the parent type of an unwrapped array type.")
 end
 
 position(::Type{AbstractArray}, ::typeof(eltype)) = Position(1)
@@ -17,15 +17,15 @@ position(::Type{<:BitArray}, ::typeof(ndims)) = Position(1)
 default_type_parameters(::Type{<:BitArray}) = (1,)
 
 function set_eltype(array::AbstractArray, param)
-  return convert(set_eltype(typeof(array), param), array)
+    return convert(set_eltype(typeof(array), param), array)
 end
 
 ## This will fail if position of `ndims` is not defined for `type`
 function set_ndims(type::Type{<:AbstractArray}, param)
-  return set_type_parameters(type, ndims, param)
+    return set_type_parameters(type, ndims, param)
 end
 function set_ndims(type::Type{<:AbstractArray}, param::NDims)
-  return set_type_parameters(type, ndims, ndims(param))
+    return set_type_parameters(type, ndims, ndims(param))
 end
 
 # Trait indicating if the AbstractArray type is an array wrapper.
@@ -47,48 +47,48 @@ is_wrapped_array(arraytype::Type{<:AbstractArray}) = (parenttype(arraytype) ≠
 using SimpleTraits: Not, @traitfn
 
 @traitfn function unwrap_array_type(
-  arraytype::Type{ArrayType}
-) where {ArrayType;IsWrappedArray{ArrayType}}
-  return unwrap_array_type(parenttype(arraytype))
+        arraytype::Type{ArrayType}
+    ) where {{ArrayType; IsWrappedArray{ArrayType}}}
+    return unwrap_array_type(parenttype(arraytype))
 end
 
 @traitfn function unwrap_array_type(
-  arraytype::Type{ArrayType}
-) where {ArrayType;!IsWrappedArray{ArrayType}}
-  return arraytype
+        arraytype::Type{ArrayType}
+    ) where {{ArrayType; !IsWrappedArray{ArrayType}}}
+    return arraytype
 end
 
 # For working with instances.
 unwrap_array_type(array::AbstractArray) = unwrap_array_type(typeof(array))
 
 function set_parenttype(t::Type, param)
-  return set_type_parameters(t, parenttype, param)
+    return set_type_parameters(t, parenttype, param)
 end
 
 @traitfn function set_eltype(
-  type::Type{ArrayType}, param
-) where {ArrayType<:AbstractArray;IsWrappedArray{ArrayType}}
-  new_parenttype = set_eltype(parenttype(type), param)
-  # Need to set both in one `set_type_parameters` call to avoid
-  # conflicts in type parameter constraints of certain wrapper types.
-  return set_type_parameters(type, (eltype, parenttype), (param, new_parenttype))
+        type::Type{ArrayType}, param
+    ) where {{ArrayType <: AbstractArray; IsWrappedArray{ArrayType}}}
+    new_parenttype = set_eltype(parenttype(type), param)
+    # Need to set both in one `set_type_parameters` call to avoid
+    # conflicts in type parameter constraints of certain wrapper types.
+    return set_type_parameters(type, (eltype, parenttype), (param, new_parenttype))
 end
 
 @traitfn function set_eltype(
-  type::Type{ArrayType}, param
-) where {ArrayType<:AbstractArray;!IsWrappedArray{ArrayType}}
-  return set_type_parameters(type, eltype, param)
+        type::Type{ArrayType}, param
+    ) where {{ArrayType <: AbstractArray; !IsWrappedArray{ArrayType}}}
+    return set_type_parameters(type, eltype, param)
 end
 
 for wrapper in [:PermutedDimsArray, :(Base.ReshapedArray), :SubArray]
-  @eval begin
-    position(type::Type{<:$wrapper}, ::typeof(eltype)) = Position(1)
-    position(type::Type{<:$wrapper}, ::typeof(ndims)) = Position(2)
-  end
+    @eval begin
+        position(type::Type{<:$wrapper}, ::typeof(eltype)) = Position(1)
+        position(type::Type{<:$wrapper}, ::typeof(ndims)) = Position(2)
+    end
 end
 for wrapper in [:(Base.ReshapedArray), :SubArray]
-  @eval position(type::Type{<:$wrapper}, ::typeof(parenttype)) = Position(3)
+    @eval position(type::Type{<:$wrapper}, ::typeof(parenttype)) = Position(3)
 end
 for wrapper in [:PermutedDimsArray]
-  @eval position(type::Type{<:$wrapper}, ::typeof(parenttype)) = Position(5)
+    @eval position(type::Type{<:$wrapper}, ::typeof(parenttype)) = Position(5)
 end

NDTensors/src/vendored/TypeParameterAccessors/src/base/linearalgebra.jl

@@ -1,25 +1,25 @@
 using LinearAlgebra:
-  Adjoint,
-  Diagonal,
-  Hermitian,
-  LowerTriangular,
-  Symmetric,
-  Transpose,
-  UnitLowerTriangular,
-  UnitUpperTriangular,
-  UpperTriangular
+    Adjoint,
+    Diagonal,
+    Hermitian,
+    LowerTriangular,
+    Symmetric,
+    Transpose,
+    UnitLowerTriangular,
+    UnitUpperTriangular,
+    UpperTriangular
 
 for wrapper in [
-  :Transpose,
-  :Adjoint,
-  :Symmetric,
-  :Hermitian,
-  :UpperTriangular,
-  :LowerTriangular,
-  :UnitUpperTriangular,
-  :UnitLowerTriangular,
-  :Diagonal,
-]
-  @eval position(::Type{<:$wrapper}, ::typeof(eltype)) = Position(1)
-  @eval position(::Type{<:$wrapper}, ::typeof(parenttype)) = Position(2)
+        :Transpose,
+        :Adjoint,
+        :Symmetric,
+        :Hermitian,
+        :UpperTriangular,
+        :LowerTriangular,
+        :UnitUpperTriangular,
+        :UnitLowerTriangular,
+        :Diagonal,
+    ]
+    @eval position(::Type{<:$wrapper}, ::typeof(eltype)) = Position(1)
+    @eval position(::Type{<:$wrapper}, ::typeof(parenttype)) = Position(2)
 end

NDTensors/src/vendored/TypeParameterAccessors/src/base/similartype.jl

@@ -5,75 +5,75 @@ like `OffsetArrays` or named indices
 (such as ITensors).
 """
 function set_indstype(arraytype::Type{<:AbstractArray}, dims::Tuple)
-  return set_ndims(arraytype, NDims(length(dims)))
+    return set_ndims(arraytype, NDims(length(dims)))
 end
 
 function similartype(arraytype::Type{<:AbstractArray}, eltype::Type, ndims::NDims)
-  return similartype(similartype(arraytype, eltype), ndims)
+    return similartype(similartype(arraytype, eltype), ndims)
 end
 
 function similartype(arraytype::Type{<:AbstractArray}, eltype::Type, dims::Tuple)
-  return similartype(similartype(arraytype, eltype), dims)
+    return similartype(similartype(arraytype, eltype), dims)
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}
-) where {ArrayT;!IsWrappedArray{ArrayT}}
-  return arraytype
+        arraytype::Type{ArrayT}
+    ) where {{ArrayT; !IsWrappedArray{ArrayT}}}
+    return arraytype
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, eltype::Type
-) where {ArrayT;!IsWrappedArray{ArrayT}}
-  return set_eltype(arraytype, eltype)
+        arraytype::Type{ArrayT}, eltype::Type
+    ) where {{ArrayT; !IsWrappedArray{ArrayT}}}
+    return set_eltype(arraytype, eltype)
 end
 
 function similartype(arraytype::Type{<:BitArray}, elt::Type)
-  if is_parameter_specified(arraytype, ndims)
-    return Array{elt,ndims(arraytype)}
-  end
-  return Array{elt}
+    if is_parameter_specified(arraytype, ndims)
+        return Array{elt, ndims(arraytype)}
+    end
+    return Array{elt}
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, dims::Tuple
-) where {ArrayT;!IsWrappedArray{ArrayT}}
-  return set_indstype(arraytype, dims)
+        arraytype::Type{ArrayT}, dims::Tuple
+    ) where {{ArrayT; !IsWrappedArray{ArrayT}}}
+    return set_indstype(arraytype, dims)
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, ndims::NDims
-) where {ArrayT;!IsWrappedArray{ArrayT}}
-  return set_ndims(arraytype, ndims)
+        arraytype::Type{ArrayT}, ndims::NDims
+    ) where {{ArrayT; !IsWrappedArray{ArrayT}}}
+    return set_ndims(arraytype, ndims)
 end
 
 function similartype(
-  arraytype::Type{<:AbstractArray}, dim1::Base.DimOrInd, dim_rest::Base.DimOrInd...
-)
-  return similartype(arraytype, (dim1, dim_rest...))
+        arraytype::Type{<:AbstractArray}, dim1::Base.DimOrInd, dim_rest::Base.DimOrInd...
+    )
+    return similartype(arraytype, (dim1, dim_rest...))
 end
 
 ## Wrapped arrays
-@traitfn function similartype(arraytype::Type{ArrayT}) where {ArrayT;IsWrappedArray{ArrayT}}
-  return similartype(unwrap_array_type(arraytype), NDims(arraytype))
+@traitfn function similartype(arraytype::Type{ArrayT}) where {{ArrayT; IsWrappedArray{ArrayT}}}
+    return similartype(unwrap_array_type(arraytype), NDims(arraytype))
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, eltype::Type
-) where {ArrayT;IsWrappedArray{ArrayT}}
-  return similartype(unwrap_array_type(arraytype), eltype, NDims(arraytype))
+        arraytype::Type{ArrayT}, eltype::Type
+    ) where {{ArrayT; IsWrappedArray{ArrayT}}}
+    return similartype(unwrap_array_type(arraytype), eltype, NDims(arraytype))
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, dims::Tuple
-) where {ArrayT;IsWrappedArray{ArrayT}}
-  return similartype(unwrap_array_type(arraytype), dims)
+        arraytype::Type{ArrayT}, dims::Tuple
+    ) where {{ArrayT; IsWrappedArray{ArrayT}}}
+    return similartype(unwrap_array_type(arraytype), dims)
 end
 
 @traitfn function similartype(
-  arraytype::Type{ArrayT}, ndims::NDims
-) where {ArrayT;IsWrappedArray{ArrayT}}
-  return similartype(unwrap_array_type(arraytype), ndims)
+        arraytype::Type{ArrayT}, ndims::NDims
+    ) where {{ArrayT; IsWrappedArray{ArrayT}}}
+    return similartype(unwrap_array_type(arraytype), ndims)
 end
 
 # This is for uniform `Diag` storage which uses
@@ -82,12 +82,12 @@ end
 # `FillArray` instead. This is a stand-in
 # to make things work with the current design.
 function similartype(numbertype::Type{<:Number})
-  return numbertype
+    return numbertype
 end
 
 # Instances
 function similartype(array::AbstractArray, eltype::Type, dims...)
-  return similartype(typeof(array), eltype, dims...)
+    return similartype(typeof(array), eltype, dims...)
 end
 similartype(array::AbstractArray, eltype::Type) = similartype(typeof(array), eltype)
 similartype(array::AbstractArray, dims...) = similartype(typeof(array), dims...)