Optional elements in vector literal

General Usage
1

is there a nice way to optionally include an element in a vector literal construction? something like foo = [1, 2, @maybe x 3, 4, 5] where only if x==true is 3 included.

2

answering myself, i suppose insert! is good enough: foo=[1,2,4,5]; insert!(foo, 3, 3)

3

This may depend on what you mean by “literal”. insert! is not really a literal syntax because a temporary array is getting constructed and then manipulated. For a true literal, we would want to achieve the result at construction.

julia> x = true
true

julia> foo = [y for (i,y) in pairs(1:5) if i!=3 || x]
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> x = false
false

julia> foo = [y for (i,y) in pairs(1:5) if i!=3 || x]
4-element Vector{Int64}:
 1
 2
 4
 5

julia> f(x) = [y for (i,y) in pairs(1:5) if i!=3 || x]
f (generic function with 2 methods)

julia> @code_lowered f(true)
CodeInfo(
1 ─       #33 = %new(Main.:(var"#33#35"))
│   %2  = #33
│   %3  = Main.:(var"#34#36")
│   %4  = Core.typeof(x)
│   %5  = Core.apply_type(%3, %4)
│         #34 = %new(%5, x)
│   %7  = #34
│   %8  = 1:5
│   %9  = Main.pairs(%8)
│   %10 = Base.Filter(%7, %9)
│   %11 = Base.Generator(%2, %10)
│   %12 = Base.collect(%11)
└──       return %12
)

The array comprehension syntax gets lowered to several layers of lazy iterators before being collected. Only at collection is the array allocated and formed. Notably see Iterators.filter which creates a Iterators.Filter.

4

This also works:

using Base.Iterators

g(x) = collect(flatten([[1,2],x ? [3] : Int[],[4,5]]))

and

julia> g(false) == [1,2,4,5]
true

julia> g(true) == [1,2,3,4,5]
true

With this method, in case x is false, the unincluded element is not even materialized or computed (especially important for complex elements).

1 Like
5

Using Iterators.flatten is nice. Do note that a type assertion might be good for the return type since the method is currently type unstable. The array comprehension is type stable.

julia> f(x) = [y for (i,y) in pairs(1:5) if i!=3 || x]
f (generic function with 2 methods)

julia> @code_warntype f(true)
MethodInstance for f(::Bool)
  from f(x) in Main at REPL[114]:1
Arguments
  #self#::Core.Const(f)
  x::Bool
Locals
  #50::var"#50#52"{Bool}
  #49::var"#49#51"
Body::Vector{Int64}
1 ─       (#49 = %new(Main.:(var"#49#51")))
│   %2  = #49::Core.Const(var"#49#51"())
│   %3  = Main.:(var"#50#52")::Core.Const(var"#50#52")
│   %4  = Core.typeof(x)::Core.Const(Bool)
│   %5  = Core.apply_type(%3, %4)::Core.Const(var"#50#52"{Bool})
│         (#50 = %new(%5, x))
│   %7  = #50::var"#50#52"{Bool}
│   %8  = (1:5)::Core.Const(1:5)
│   %9  = Main.pairs(%8)::Core.Const(Base.Pairs(1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5))
│   %10 = Base.Filter(%7, %9)::Core.PartialStruct(Base.Iterators.Filter{var"#50#52"{Bool}, Base.Pairs{Int64, Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}, UnitRange{Int64}}}, Any[var"#50#52"{Bool}, Core.Const(Base.Pairs(1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5))])
│   %11 = Base.Generator(%2, %10)::Core.PartialStruct(Base.Generator{Base.Iterators.Filter{var"#50#52"{Bool}, Base.Pairs{Int64, Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}, UnitRange{Int64}}}, var"#49#51"}, Any[Core.Const(var"#49#51"()), Core.PartialStruct(Base.Iterators.Filter{var"#50#52"{Bool}, Base.Pairs{Int64, Int64, LinearIndices{1, Tuple{Base.OneTo{Int64}}}, UnitRange{Int64}}}, Any[var"#50#52"{Bool}, Core.Const(Base.Pairs(1 => 1, 2 => 2, 3 => 3, 4 => 4, 5 => 5))])])
│   %12 = Base.collect(%11)::Vector{Int64}
└──       return %12


julia> g(x) = collect(flatten(( (1,2), x ? (3,) : (), (4,5) )))
g (generic function with 1 method)

julia> @code_warntype g(true)
MethodInstance for g(::Bool)
  from g(x) in Main at REPL[116]:1
Arguments
  #self#::Core.Const(g)
  x::Bool
Locals
  @_3::Union{Tuple{}, Tuple{Int64}}
Body::Any
1 ─ %1  = Core.tuple(1, 2)::Core.Const((1, 2))
└──       goto #3 if not x
2 ─       (@_3 = Core.tuple(3))
└──       goto #4
3 ─       (@_3 = ())
4 ┄ %6  = @_3::Union{Tuple{}, Tuple{Int64}}
│   %7  = Core.tuple(4, 5)::Core.Const((4, 5))
│   %8  = Core.tuple(%1, %6, %7)::Core.PartialStruct(Tuple{Tuple{Int64, Int64}, Union{Tuple{}, Tuple{Int64}}, Tuple{Int64, Int64}}, Any[Core.Const((1, 2)), Union{Tuple{}, Tuple{Int64}}, Core.Const((4, 5))])
│   %9  = Main.flatten(%8)::Base.Iterators.Flatten
│   %10 = Main.collect(%9)::Any
└──       return %10
6

Yes, you’re right, I thought the Int[] in the definition would be enough for inference, but adding Vector{Int} is enough:

g(x) = collect(flatten(Vector{Int}[[1,2],x ? [3] : Int[],[4,5]]))

and:

julia> @code_warntype g(false)
...
│   %11 = Main.collect(%10)::Vector{Int64}
└──       return %11

Actually, the problem was with the tuples, which made flatten unstable. Perhaps a good compromise is:

g(x) = collect(flatten(( (1,2), x ? [3] : Int[], (4,5) )))

which is type stable.