use named tuples as keyword varargs. fixes #4916

also fixes #9972

NEWS.md

@@ -14,6 +14,11 @@ New language features
   * Named tuples, with the syntax `(a=1, b=2)`. These behave very similarly to tuples,
     except components can also be accessed by name using dot syntax `t.a` ([#22194]).
 
+  * Keyword argument containers (`kw` in `f(; kw...)`) are now named tuples. Dictionary
+    functions like `haskey` and indexing can be used on them, and name-value pairs can be
+    iterated using `pairs(kw)`. `kw` can no longer contain multiple entries for the same
+    argument name ([#4916]).
+
  * Custom infix operators can now be defined by appending Unicode
    combining marks, primes, and sub/superscripts to other operators.
    For example, `+̂ₐ″` is parsed as an infix operator with the same

base/boot.jl

@@ -149,8 +149,6 @@ export
     # constants
     nothing, Main
 
-const AnyVector = Array{Any,1}
-
 abstract type Number end
 abstract type Real     <: Number end
 abstract type AbstractFloat <: Real end
@@ -476,4 +474,42 @@ function (g::GeneratedFunctionStub)(@nospecialize args...)
     end
 end
 
+NamedTuple() = NamedTuple{(),Tuple{}}(())
+
+"""
+    NamedTuple{names}(args::Tuple)
+
+Construct a named tuple with the given `names` (a tuple of Symbols) from a tuple of values.
+"""
+NamedTuple{names}(args::Tuple) where {names} = NamedTuple{names,typeof(args)}(args)
+
+using .Intrinsics: sle_int, add_int
+
+macro generated()
+    return Expr(:generated)
+end
+
+function NamedTuple{names,T}(args::T) where {names, T <: Tuple}
+    if @generated
+        N = nfields(names)
+        flds = Array{Any,1}(N)
+        i = 1
+        while sle_int(i, N)
+            arrayset(false, flds, :(getfield(args, $i)), i)
+            i = add_int(i, 1)
+        end
+        Expr(:new, :(NamedTuple{names,T}), flds...)
+    else
+        N = nfields(names)
+        NT = NamedTuple{names,T}
+        flds = Array{Any,1}(N)
+        i = 1
+        while sle_int(i, N)
+            arrayset(false, flds, getfield(args, i), i)
+            i = add_int(i, 1)
+        end
+        ccall(:jl_new_structv, Any, (Any, Ptr{Void}, UInt32), NT, fields, N)::NT
+    end
+end
+
 ccall(:jl_set_istopmod, Void, (Any, Bool), Core, true)

base/coreimg.jl

@@ -57,6 +57,7 @@ include("reduce.jl")
 include("bitarray.jl")
 include("bitset.jl")
 include("associative.jl")
+include("namedtuple.jl")
 
 # core docsystem
 include("docs/core.jl")

base/distributed/cluster.jl

@@ -381,7 +381,7 @@ function addprocs(manager::ClusterManager; kwargs...)
 end
 
 function addprocs_locked(manager::ClusterManager; kwargs...)
-    params = merge(default_addprocs_params(), AnyDict(kwargs))
+    params = merge(default_addprocs_params(), AnyDict(pairs(kwargs)))
     topology(Symbol(params[:topology]))
 
     if PGRP.topology != :all_to_all

base/distributed/managers.jl

@@ -36,8 +36,8 @@ end
 
 function check_addprocs_args(kwargs)
     valid_kw_names = collect(keys(default_addprocs_params()))
-    for keyname in kwargs
-        !(keyname[1] in valid_kw_names) && throw(ArgumentError("Invalid keyword argument $(keyname[1])"))
+    for keyname in keys(kwargs)
+        !(keyname in valid_kw_names) && throw(ArgumentError("Invalid keyword argument $(keyname)"))
     end
 end
 

base/distributed/messages.jl

@@ -38,17 +38,17 @@ null_id(id) =  id == RRID(0, 0)
 struct CallMsg{Mode} <: AbstractMsg
     f::Function
     args::Tuple
-    kwargs::Array
+    kwargs
 end
 struct CallWaitMsg <: AbstractMsg
     f::Function
     args::Tuple
-    kwargs::Array
+    kwargs
 end
 struct RemoteDoMsg <: AbstractMsg
     f::Function
     args::Tuple
-    kwargs::Array
+    kwargs
 end
 struct ResultMsg <: AbstractMsg
     value::Any

base/essentials.jl

@@ -634,26 +634,6 @@ function vector_any(@nospecialize xs...)
     a
 end
 
-function as_kwargs(xs::Union{AbstractArray,Associative})
-    n = length(xs)
-    to = Vector{Any}(uninitialized, n*2)
-    i = 1
-    for (k, v) in xs
-        to[i]   = k::Symbol
-        to[i+1] = v
-        i += 2
-    end
-    return to
-end
-
-function as_kwargs(xs)
-    to = Vector{Any}()
-    for (k, v) in xs
-        ccall(:jl_array_ptr_1d_push2, Void, (Any, Any, Any), to, k::Symbol, v)
-    end
-    return to
-end
-
 """
     invokelatest(f, args...; kwargs...)
 

base/interactiveutil.jl

@@ -406,7 +406,7 @@ function gen_call_with_extracted_types(__module__, fcn, ex0)
             return quote
                 local arg1 = $(esc(args[1]))
                 $(fcn)(Core.kwfunc(arg1),
-                       Tuple{Vector{Any}, Core.Typeof(arg1),
+                       Tuple{NamedTuple, Core.Typeof(arg1),
                              $(typesof)($(map(esc, args[2:end])...)).parameters...})
             end
         elseif ex0.head == :call

base/methodshow.jl

@@ -75,7 +75,7 @@ function arg_decl_parts(m::Method)
 end
 
 function kwarg_decl(m::Method, kwtype::DataType)
-    sig = rewrap_unionall(Tuple{kwtype, Core.AnyVector, unwrap_unionall(m.sig).parameters...}, m.sig)
+    sig = rewrap_unionall(Tuple{kwtype, NamedTuple, unwrap_unionall(m.sig).parameters...}, m.sig)
     kwli = ccall(:jl_methtable_lookup, Any, (Any, Any, UInt), kwtype.name.mt, sig, typemax(UInt))
     if kwli !== nothing
         kwli = kwli::Method

base/namedtuple.jl

@@ -1,5 +1,7 @@
 # This file is a part of Julia. License is MIT: https://julialang.org/license
 
+if module_name(@__MODULE__) === :Base
+
 """
     NamedTuple{names,T}(args::Tuple)
 
@@ -24,16 +26,6 @@ function NamedTuple{names,T}(args::Tuple) where {names, T <: Tuple}
     end
 end
 
-"""
-    NamedTuple{names}(args::Tuple)
-
-Construct a named tuple with the given `names` (a tuple of Symbols) from a tuple of
-values.
-"""
-function NamedTuple{names}(args::Tuple) where {names}
-    NamedTuple{names,typeof(args)}(args)
-end
-
 """
     NamedTuple{names}(nt::NamedTuple)
 
@@ -50,7 +42,7 @@ function NamedTuple{names}(nt::NamedTuple) where {names}
     end
 end
 
-NamedTuple() = NamedTuple{(),Tuple{}}(())
+end # if Base
 
 length(t::NamedTuple) = nfields(t)
 start(t::NamedTuple) = 1
@@ -60,6 +52,8 @@ endof(t::NamedTuple) = nfields(t)
 getindex(t::NamedTuple, i::Int) = getfield(t, i)
 getindex(t::NamedTuple, i::Symbol) = getfield(t, i)
 indexed_next(t::NamedTuple, i::Int, state) = (getfield(t, i), i+1)
+isempty(::NamedTuple{()}) = true
+isempty(::NamedTuple) = false
 
 convert(::Type{NamedTuple{names,T}}, nt::NamedTuple{names,T}) where {names,T} = nt
 convert(::Type{NamedTuple{names}}, nt::NamedTuple{names}) where {names} = nt
@@ -213,3 +207,32 @@ values(nt::NamedTuple) = Tuple(nt)
 haskey(nt::NamedTuple, key::Union{Integer, Symbol}) = isdefined(nt, key)
 get(nt::NamedTuple, key::Union{Integer, Symbol}, default) = haskey(nt, key) ? getfield(nt, key) : default
 get(f::Callable, nt::NamedTuple, key::Union{Integer, Symbol}) = haskey(nt, key) ? getfield(nt, key) : f()
+
+@pure function diff_names(an::Tuple{Vararg{Symbol}}, bn::Tuple{Vararg{Symbol}})
+    names = Symbol[]
+    for n in an
+        if !sym_in(n, bn)
+            push!(names, n)
+        end
+    end
+    (names...,)
+end
+
+"""
+    structdiff(a::NamedTuple{an}, b::Union{NamedTuple{bn},Type{NamedTuple{bn}}}) where {an,bn}
+
+Construct a copy of named tuple `a`, except with fields that exist in `b` removed.
+`b` can be a named tuple, or a type of the form `NamedTuple{field_names}`.
+"""
+function structdiff(a::NamedTuple{an}, b::Union{NamedTuple{bn}, Type{NamedTuple{bn}}}) where {an, bn}
+    if @generated
+        names = diff_names(an, bn)
+        types = Tuple{Any[ fieldtype(a, n) for n in names ]...}
+        vals = Any[ :(getfield(a, $(QuoteNode(n)))) for n in names ]
+        :( NamedTuple{$names,$types}(($(vals...),)) )
+    else
+        names = diff_names(an, bn)
+        types = Tuple{Any[ fieldtype(typeof(a), n) for n in names ]...}
+        NamedTuple{names,types}(map(n->getfield(a, n), names))
+    end
+end

base/replutil.jl

@@ -311,14 +311,13 @@ function showerror(io::IO, ex::MethodError)
     ft = typeof(f)
     name = ft.name.mt.name
     f_is_function = false
-    kwargs = Any[]
+    kwargs = NamedTuple()
     if startswith(string(ft.name.name), "#kw#")
         f = ex.args[2]
         ft = typeof(f)
         name = ft.name.mt.name
         arg_types_param = arg_types_param[3:end]
-        temp = ex.args[1]
-        kwargs = Any[(temp[i*2-1], temp[i*2]) for i in 1:(length(temp) ÷ 2)]
+        kwargs = ex.args[1]
         ex = MethodError(f, ex.args[3:end])
     end
     if f == Base.convert && length(arg_types_param) == 2 && !is_arg_types
@@ -362,7 +361,7 @@ function showerror(io::IO, ex::MethodError)
         end
         if !isempty(kwargs)
             print(io, "; ")
-            for (i, (k, v)) in enumerate(kwargs)
+            for (i, (k, v)) in enumerate(pairs(kwargs))
                 print(io, k, "=")
                 show(IOContext(io, :limit => true), v)
                 i == length(kwargs) || print(io, ", ")
@@ -452,7 +451,7 @@ function showerror_nostdio(err, msg::AbstractString)
     ccall(:jl_printf, Cint, (Ptr{Void},Cstring), stderr_stream, "\n")
 end
 
-function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
+function show_method_candidates(io::IO, ex::MethodError, kwargs::NamedTuple = NamedTuple())
     is_arg_types = isa(ex.args, DataType)
     arg_types = is_arg_types ? ex.args : typesof(ex.args...)
     arg_types_param = Any[arg_types.parameters...]
@@ -582,7 +581,7 @@ function show_method_candidates(io::IO, ex::MethodError, kwargs::Vector=Any[])
                 if !isempty(kwargs)
                     unexpected = Symbol[]
                     if isempty(kwords) || !(any(endswith(string(kword), "...") for kword in kwords))
-                        for (k, v) in kwargs
+                        for (k, v) in pairs(kwargs)
                             if !(k in kwords)
                                 push!(unexpected, k)
                             end

doc/src/manual/functions.md

@@ -517,14 +517,12 @@ function f(x; y=0, kwargs...)
 end
 ```
 
-Inside `f`, `kwargs` will be a collection of `(key,value)` tuples, where each `key` is a symbol.
-Such collections can be passed as keyword arguments using a semicolon in a call, e.g. `f(x, z=1; kwargs...)`.
-Dictionaries can also be used for this purpose.
-
-One can also pass `(key,value)` tuples, or any iterable expression (such as a `=>` pair) that
-can be assigned to such a tuple, explicitly after a semicolon. For example, `plot(x, y; (:width,2))`
-and `plot(x, y; :width => 2)` are equivalent to `plot(x, y, width=2)`. This is useful in situations
-where the keyword name is computed at runtime.
+Inside `f`, `kwargs` will be a named tuple. Named tuples (as well as dictionaries) can be passed as
+keyword arguments using a semicolon in a call, e.g. `f(x, z=1; kwargs...)`.
+
+One can also pass `key => value` expressions after a semicolon. For example, `plot(x, y; :width => 2)`
+is equivalent to `plot(x, y, width=2)`. This is useful in situations where the keyword name is computed
+at runtime.
 
 The nature of keyword arguments makes it possible to specify the same argument more than once.
 For example, in the call `plot(x, y; options..., width=2)` it is possible that the `options` structure

src/array.c

@@ -1139,15 +1139,6 @@ JL_DLLEXPORT void jl_array_ptr_1d_append(jl_array_t *a, jl_array_t *a2)
     }
 }
 
-JL_DLLEXPORT void jl_array_ptr_1d_push2(jl_array_t *a, jl_value_t *b, jl_value_t *c)
-{
-    assert(jl_typeis(a, jl_array_any_type));
-    jl_array_grow_end(a, 2);
-    size_t n = jl_array_nrows(a);
-    jl_array_ptr_set(a, n - 2, b);
-    jl_array_ptr_set(a, n - 1, c);
-}
-
 JL_DLLEXPORT jl_value_t *(jl_array_data_owner)(jl_array_t *a)
 {
     return jl_array_data_owner(a);

src/builtins.c

@@ -962,12 +962,12 @@ JL_CALLABLE(jl_f_invoke_kwsorter)
                                                       jl_nfields(argtypes));
     }
     if (jl_is_tuple_type(argtypes)) {
-        // construct a tuple type for invoking a keyword sorter by putting `Vector{Any}`
+        // construct a tuple type for invoking a keyword sorter by putting the kw container type
         // and the type of the function at the front.
         size_t i, nt = jl_nparams(argtypes) + 2;
         if (nt < jl_page_size/sizeof(jl_value_t*)) {
             jl_value_t **types = (jl_value_t**)alloca(nt*sizeof(jl_value_t*));
-            types[0] = jl_array_any_type; types[1] = jl_typeof(func);
+            types[0] = (jl_value_t*)jl_namedtuple_type; types[1] = jl_typeof(func);
             for(i=2; i < nt; i++)
                 types[i] = jl_tparam(argtypes,i-2);
             argtypes = (jl_value_t*)jl_apply_tuple_type_v(types, nt);