Method for dropping an element of NamedTuple

[Datseris]

I am trying to do:

d = (solver = 2, b = 3)
f = same tuple as d but without :solver 

The JuliaData/NamedTuples has a delete method, so one can do something like f = delete(d, :solver). It would be nice to have it for Core.NamedTuple as well, if possible.

[Datseris]

Current workaround:

julia> d = (solver = 2, b = 3, c = 4)
(solver = 2, b = 3, c = 4)

julia> inter = [p for p in pairs(d) if p[1] != :solver]
2-element Array{Pair{Symbol,Int64},1}:
 :b => 3
 :c => 4

julia> f = (; inter...)
(b = 3, c = 4)

(answered on Slack, I think by araslan)

[JeffreySarnoff]

julia> function dropnames(namedtuple::NamedTuple, names::Tuple{Vararg{Symbol}}) 
            keepnames = Base.diff_names(Base._nt_names(namedtuple), names)
           return NamedTuple{keepnames}(namedtuple)
       end
dropnames (generic function with 1 method)

julia> d = (solver = 2, b = 3, c = 4)
(solver = 2, b = 3, c = 4)

julia> dropnames(d, (:solver,))
(b = 3,)

julia> dropnames(d, (:b,))
(solver = 2,)

julia> dropnames(d, (:b,:solver))
NamedTuple()

julia> dropnames(d, (:oops,))
(solver = 2, b = 3)

[Datseris]

Very nice! Can it also become part of Base or I am being too greedy?

[JeffreySarnoff]

Base has my permission.

[chethega]

Is the inference failure OK (everything becomes Any)?

I would imagine that most use-cases could get away with @generated and val-type symbols (the symbol to drop is a source-code literal). On the other hand, I'd imagine that most uses are not performance critical.

[JeffBezanson]

There are some utilities for implementing this in base/namedtuple.jl. If diff_names is used to remove the requested name(s) then @JeffreySarnoff's implementation will be inferable.

[JeffreySarnoff]

dropnames implementation improved ^^

[Datseris]

@JeffreySarnoff Will you do a PR for this?

(I really hope that this is in the next beta :P )

[JeffreySarnoff]

I don't know what to do about this:

julia> function dropnames(namedtuple::NamedTuple, names::Tuple{Vararg{Symbol}}) 
            keepnames = Base.diff_names(Base._nt_names(namedtuple), names)
           return NamedTuple{keepnames}(namedtuple)
       end
julia> code_warntype(dropnames, (NamedTuple, Tuple{Vararg{Symbol}}))
Body::Any
1 1 ─ %1 = Base.diff_names::typeof(Base.diff_names)                                         │
  │   %2 = Base._nt_names::typeof(Base._nt_names)                                           │
  │   %3 = %2(%%namedtuple)::Any                                                            │
  │   %4 = %1(%3, %%names)::Tuple{Vararg{Symbol,N} where N}                                 │
2 │   %5 = Core.apply_type(Main.NamedTuple, %4)::Type{NamedTuple{_1,T} where T<:Tuple} where _1
  │   %6 = %5(%%namedtuple)::Any                                                            │
  └──      return %6                                                                        │

[JeffBezanson]

That happens because NamedTuple is too abstract (in the cal to code_warntype).

[JeffreySarnoff]

submitted PR #27725

[brenhinkeller]

Looks like the PR that implemented this got approved after some debate about naming, but then never merged