Code readability after fixing deprecation warnings

I understand a lot of discussion preceded this release but I just wanted to supply some real life examples of changes in code. I received deprecation warnings like the ones below:

┌ Warning: `findfirst(A, v)` is deprecated, use `something(findfirst(isequal(v), A), 0)` instead.
│   caller = (::getfield(CompScienceMeshes, Symbol("##2#3")))(::Int64) at none:0
└ @ CompScienceMeshes .\none:0
┌ Warning: `find(f::Function, A::AbstractArray)` is deprecated, use `(LinearIndices(A))[findall(f, A)]` instead.
│   caller = boundary(::CompScienceMeshes.Mesh{3,3,Float64}) at mesh.jl:326

This leads to the following changes in code:

#i = findfirst(simplex, v)                                    # 0.6
 i = something(findfirst(isequal(v), simplex),0)              # 0.7

#i = find(x -> x < 2, sum(abs.(conn), dims=1))      # 0.6
 sums = sum(abs.(conn), dims=1)                     # 0.7
 i = (LinearIndices(sums))[findall(x->x<2, sums)]   # 0.7

Especially the second example sticks out as it forces the array to be bound to a named variable. Are there convenience functions for this?

When using the new findfirst API idiomatically, one should check for nothing rather than converting nothing to 0 and then checking for 0. That change requires manual refactoring generally, however; the deprecation just gives you an equivalent expression that will get your code working. You’ll have to refactor it later to make better use of the new patterns and idioms.

In the second case you probably don’t want to convert to linear indices at all since you’ll most likely just use them to index back into sums or some other array with the same shape (but we can’t know that for sure in the deprecation warning). Both the conversion to linear indices and the use of a linear index to index into an array can be expensive for general arrays; linear indexing is only efficient in the very particular case of dense, contiguous arrays. The new API can be efficient for completely general kinds of arrays. Instead, you can just index into sums directly with the cartesian indices returned by findall:

julia> sums = randn(3, 2)
3×2 Array{Float64,2}:
  2.71005  -0.450136
  1.11099  -0.703645
 -2.03338   0.578714

julia> findall(x->x > 0, sums)
3-element Array{CartesianIndex{2},1}:
 CartesianIndex(1, 1)
 CartesianIndex(2, 1)
 CartesianIndex(3, 2)

julia> sums[findall(x->x > 0, sums)]
3-element Array{Float64,1}:

Again, this kind of refactoring is not really plausible to do automatically and requires manual intervention.