Julia: Best practice to unpack parameters inside a function

Question

I can unpack a tuple. I'm trying to write a function (or macro) that would unpack a subset of these from an instance of the type-constructor Parameters(). That is, I know how to do:

a,b,c = unpack(p::Parameters)

But I would like to do something like this:

b,c = unpack(p::Parameters, b,c)

or maybe even lazier:

unpack(p::Parameters, b, c)

This is to avoid writing things like:

function unpack_all_oldstyle(p::Parameters)
    a=p.a; b=p.b; c=p.c; ... z=p.z;
    return a,b,c,...,z
end

There's something wrong with my approach, but hopefully there is a fix.

In case it wasn't clear from the wording of my question, I'm a total ignoramus. I read about unpacking the ellipsis here: how-to-pass-tuple-as-function-arguments

    "module UP tests Unpacking Parameters"
    module UP

    struct Parameters
      a::Int64
      b::Int64
      c::Int64
    end

    "this method sets default parameters and returns a tuple of default values"
    function Parameters(;
      a::Int64 = 3,
      b::Int64 = 11,
      c::Int64 = 101
      )
      Parameters(a, b, c)
    end

    "this function unpacks all parameters"
    function unpack_all(p::Parameters)
        return p.a, p.b, p.c
    end

    "this function tests the unpacking function: in the body of the function one can now refer to a rather than p.a : worth the effort if you have dozens of parameters and complicated expressions to compute, e.g. type (-b+sqrt(b^2-4*a*c))/2/a instead of (-p.b+sqrt(p.b^2-4*p.a *p.c))/2/p.a"
    function unpack_all_test(p::Parameters)
        a, b, c = unpack_all(p)
        return a, b, c
    end

    """
    This function is intended to unpack selected parameters. The first, unnamed argument is the constructor for all parameters. The second argument is a tuple of selected parameters.
    """
    function unpack_selected(p::Parameters; x...)
        return p.x
    end

    function unpack_selected_test(p::Parameters; x...)
        x = unpack_selected(p, x)
        return x
    end

    export Parameters, unpack_all, unpack_all_test, unpack_selected, unpack_selected_test

    end

    p = UP.Parameters() # make an instance
    UP.unpack_all_test(p)
    ## (3,11,101) ## Test successful

    UP.unpack_selected_test(p, 12)
    ## 12  ## intended outcome

    UP.unpack_selected_test(p, b)
    ## 11  ## intended outcome

    UP.unpack_selected_test(p, c, b, a)
    ## (101,11,3)  ## intended outcome

Answer 1

There already exists one: Parameters.jl.

julia> using Parameters

julia> struct Params
           a::Int64
           b::Int64
           c::Int64
       end

julia> @unpack a, c = Params(1,2,3)
Params(1,2,3)

julia> a,c
(1,3)

julia> @with_kw struct Params
           a::Int64 = 3
           b::Int64 = 11
           c::Int64 = 101
       end
julia> @unpack c,b,a = Params()
Params
  a: Int64 3
  b: Int64 11
  c: Int64 101


julia> c,b,a
(101,11,3)

BTW, you can fix your unpack_selected by:

unpack_selected(p::Parameters, fields...) = map(x->getfield(p, x), fields).

# note that, the selected field names should be Symbol here
julia> unpack_selected(p, :b)
(11,)

julia> unpack_selected(p, :c, :b, :a)
(101,11,3)