Update syntax highlight tags for REPL code examples

Author: abhro

docs/src/advanced.md

@@ -66,7 +66,7 @@ StructArrays provides a function `StructArrays.append!!(dest, src)` (unexported)
 
 `StructArrays.append!!` works like `append!(dest, src)` if `dest` can contain all element types in `src` iterator; i.e., it _mutates_ `dest` in-place:
 
-```julia
+```julia-repl
 julia> dest = StructVector((a=[1], b=[2]))
 1-element StructArray(::Array{Int64,1}, ::Array{Int64,1}) with eltype NamedTuple{(:a, :b),Tuple{Int64,Int64}}:
  (a = 1, b = 2)
@@ -82,7 +82,7 @@ true
 
 Unlike `append!`, `append!!` can also _widen_ element type of `dest` array:
 
-```julia
+```julia-repl
 julia> StructArrays.append!!(dest, [(a = missing, b = 6)])
 3-element StructArray(::Array{Union{Missing, Int64},1}, ::Array{Int64,1}) with eltype NamedTuple{(:a, :b),Tuple{Union{Missing, Int64},Int64}}:
  NamedTuple{(:a, :b),Tuple{Union{Missing, Int64},Int64}}((1, 2))

docs/src/examples.md

@@ -1,6 +1,6 @@
 ## Example usage to store complex numbers
 
-```julia
+```julia-repl
 julia> using StructArrays, Random
 
 julia> Random.seed!(4);
@@ -24,7 +24,7 @@ julia> StructArrays.components(s) # obtain all field arrays as a named tuple
 
 Note that the same approach can be used directly from an `Array` of complex numbers:
 
-```julia
+```julia-repl
 julia> StructArray([1+im, 3-2im])
 2-element StructArray(::Array{Int64,1}, ::Array{Int64,1}) with eltype Complex{Int64}:
  1 + 1im
@@ -33,7 +33,7 @@ julia> StructArray([1+im, 3-2im])
 
 ## Example usage to store a data table
 
-```julia
+```julia-repl
 julia> t = StructArray((a = [1, 2], b = ["x", "y"]))
 2-element StructArray(::Array{Int64,1}, ::Array{String,1}) with eltype NamedTuple{(:a, :b),Tuple{Int64,String}}:
  (a = 1, b = "x")
@@ -56,7 +56,7 @@ julia> push!(t, (a = 3, b = "z"))
 
 ## Example usage with StaticArray elements
 
-```julia
+```julia-repl
 julia> using StructArrays, StaticArrays
 
 julia> x = StructArray([SVector{2}(1,2) for i = 1:5])
@@ -84,4 +84,4 @@ julia> B = StructArray([SArray{Tuple{2,2,2}}(reshape(1:8,2,2,2)) for i = 1:5]);
 [:, :, 2] =
  5  7
  6  8
-```
+```

docs/src/index.md

@@ -46,7 +46,7 @@ StructArray(log(j+2.0*im) for j in 1:10)
 
 Another option is to create an uninitialized `StructArray` and then fill it with data. Just like in normal arrays, this is done with the `undef` syntax:
 
-```julia
+```julia-repl
 julia> s = StructArray{ComplexF64}(undef, 2, 2)
 2×2 StructArray(::Array{Float64,2}, ::Array{Float64,2}) with eltype Complex{Float64}:
  6.91646e-310+6.91646e-310im  6.91646e-310+6.91646e-310im
@@ -88,7 +88,7 @@ julia> soa.re
 
 `StructArray`s supports using custom array types. It is always possible to pass field arrays of a custom type. The "custom array of `struct`s to `struct` of custom arrays" transformation will use the `similar` method of the custom array type. This can be useful when working on the GPU for example:
 
-```julia
+```julia-repl
 julia> using StructArrays, CuArrays
 
 julia> a = CuArray(rand(Float32, 10));
@@ -126,7 +126,7 @@ julia> StructArray(c)
 
 If you already have your data in a `StructArray` with field arrays of a given format (say plain `Array`) you can change them with `replace_storage`:
 
-```julia
+```julia-repl
 julia> s = StructArray([1.0+im, 2.0-im])
 2-element StructArray(::Array{Float64,1}, ::Array{Float64,1}) with eltype Complex{Float64}:
  1.0 + 1.0im
@@ -142,7 +142,7 @@ julia> replace_storage(CuArray, s)
 
 `StructArray`s also provides a `LazyRow` wrapper for lazy row iteration. `LazyRow(t, i)` does not materialize the i-th row but returns a lazy wrapper around it on which `getproperty` does the correct thing. This is useful when the row has many fields only some of which are necessary. It also allows changing columns in place.
 
-```julia
+```julia-repl
 julia> t = StructArray((a = [1, 2], b = ["x", "y"]));
 
 julia> LazyRow(t, 2).a
@@ -159,7 +159,7 @@ julia> t
 
 To iterate in a lazy way one can simply iterate `LazyRows`:
 
-```julia
+```julia-repl
 julia> map(t -> t.b ^ t.a, LazyRows(t))
 2-element Array{String,1}:
  "x"
@@ -168,10 +168,10 @@ julia> map(t -> t.b ^ t.a, LazyRows(t))
 
 ## Applying a function on each field array
 
-```julia
+```julia-repl
 julia> struct Foo
-       a::Int
-       b::String
+           a::Int
+           b::String
        end
 
 julia> s = StructArray([Foo(11, "a"), Foo(22, "b"), Foo(33, "c"), Foo(44, "d"), Foo(55, "e")]);

src/interface.jl

@@ -19,7 +19,7 @@ this will have fields with the same names and types as `T`.
 This can be overloaded for custom types if required, in which case
 [`StructArrays.component`](@ref) and [`StructArrays.createinstance`](@ref)
 should also be defined.
-    
+
 ```julia-repl
 julia> StructArrays.staticschema(Complex{Float64})
 NamedTuple{(:re, :im),Tuple{Float64,Float64}}