Unpack / pack operator

I'm looking to find various ways that a packing / unpacking operator is implemented. As an example:

*[1,2,3]    --> 1,2,3     (one array scalar value unpacked to three values)
*1,2,3      --> [1,2,3]   (three values packed to one scalar array value)

Is this a common operator in languages? If so, how is it usually represented?

Other possible terms:

• Destructuring / structuring
• Unpacking / packing

The way to achieve this depends on the language.

In python values can be packed / unpacked using tuples:

mytuple = (1,2,3)   # Packing into a tuple
(a,b,c) = mytuple   # Unpacking
print(f'{a}, {b}, {c}')

In c++11, it can be done by using std::tie():

#include <iostream>
#include <tuple>

int main()
{
    auto mytuple = std::tuple<int,int,int>{1,2,3}; // Packing into a tuple
    int a, b, c;
    std::tie(a,b,c) = mytuple;                     // Unpacking (std::tie)
    std::cout << a << " " << b << " " << c << std::endl;
    return 0;
}

And, in c++17 and newer, structured bindings can be used:

#include <iostream>
#include <tuple>

int main()
{
    auto mytuple = std::tuple{1,2,3}; // Packing into a tuple
    auto[a,b,c] = mytuple;            // Unpacking (structured binding)
    std::cout << a << " " << b << " " << c << std::endl;
    return 0;
}

I will describe the whole related works and syntax in Python.

Packing variables as a collection and unpacking iterables to some variables:

iterable = (1, 2, 3, 4)  # Packing by Tuple explicitly
iterable = 1, 2, 3, 4  # Packing by Tuple implicitly
iterable = [1, 2, 3, 4]  # Packing by List
nested_iterable = (1, 2, (4, 5, 6))  # Packing nested items
mapping = {"a": 1, "b": 2}

a, b, c, d = iterable  # Unpacking using Tuple implicitly
(a, b, c, d) = iterable  # Unpacking using Tuple explicitly
[a, b, c, d] = iterable  # Unpacking using List
a, _, _, d = iterable  # Ignoring some values by conventionally using the _ (called Throwaway) variable
a, *middle_items, d = iterable  # Using * to group remaining items as a List
a, b, c, *d = iterable  # Using * for a single element is also grouped as a single item List
a, b, c, d, *e = iterable  # If there are no other elements, e becomes an empty List
a, *_ = iterable  # Ignoring remaining items
a, b, (c, d, e) = nested_iterable  # Unpacking nested items using Tuple
a, b, [c, d, e] = nested_iterable  # Unpacking nested items using mixed Tuple and List
a_key, b_key = mapping  # The items get iterated for unpacking, so, here, only keys got returned
(a_key, a_value), (b_key, b_value) = mapping.items()  # Unpacking a mapping using items method

Note: You cannot apply the * operator multiple times in a single unpacking.

Unpacking iterables as positional arguments and mappings as named arguments along with Packing remaining positional and named arguments:

def normal_function(a, b, c, d):
    ...

items = [2, 3, 4, 5]
mapping = {"a": 2, "b": 3, "c": 4, "d": 5}

normal_function(*items)  # Positional unpacking to function arguments.
normal_function(**mapping)  # Named unpacking to function arguments.

def variadic_function(a, b, c, *remaining_positional_args, d, e, f, **remaining_named_args):
    # remaining_positional_args is a Tuple and remaining_named_args is a Dict
    # d, e, f must be filled by the name
    ...

Packing and unpacking, also known as destructuring and structuring, is a common concept in many programming languages. It allows for the assignment of multiple values to multiple variables in a single statement, or for the passing of multiple values as arguments to a function.

In C++, you can use structured bindings (since C++17) to unpack the elements of an array or tuple into separate variables:

#include <array>
#include <iostream>
#include <tuple>

int main() {
     std::array<int, 3> myarray = {1, 2, 3};
     auto [a, b, c] = myarray;
     std::cout << a << ' ' << b << ' ' << c << '\n'; // prints 1 2 3

     std::tuple<int, int, int> mytuple = {4, 5, 6};
     auto [x, y, z] = mytuple;
     std::cout << x << ' ' << y << ' ' << z << '\n'; // prints 4 5 6
     }

In JavaScript, the spread operator (…) is used for unpacking. It works similarly to the asterisk operator in Python:

function myfunc(a, b, c) {
    console.log(a, b, c);
}

let myarray = [1, 2, 3];
myfunc(...myarray); // prints 1 2 3

In Python, the asterisk (*) operator is used for unpacking. For example, you can use it to unpack the elements of a list or tuple and pass them as separate arguments to a function:

def myfunc(a, b, c):
    print(a, b, c)

mylist = [1, 2, 3]
myfunc(*mylist) # prints 1 2 3

> The syntax and behavior may vary depending on the language and its version

You mention array, but packing and unpacking just mean, respectively, making 1 boundle out of multiple entities before passing the whole bundle to a function, and passing the constituents of a bundle as separate arguemnts to a function.

What the bundle actualy is (an array, a tuple, a struct) is kind of an implementation detail, as long as you have a way to create one out of the constituensts, and a way to pull the constituents out of one.

In C++, a std::tuple is preferrable, because that gives you freedom on both the number and the types of entities you can bundle together. A std::array would restrict you to use the same type for all entities, so it's out of question in most scenarii.

So when you want to pack together more entities before passing them to a function, you just use std::make_tuple.

For unpacking, the situation is more complex, but luckly there's some ready-to-use library solution: Boost.Hana offers boost::hana::unpack, which allows you to do something like this

constexpr auto add = [](auto x, auto y, auto z) {
    return x + y + z;
};
std::cout << hana::unpack(hana::make_tuple(1, 2, 3), add); // prints 6

(The example uses boost::hana::tuple, but it's easy to extend Hana to make hana::unpack work for std::tuples as well.)

In this respect, std::tie and structured bindings are kind of the minimal building blocks, because they allow you to give names to the individual entities before you pass them to the desired function. With reference to the example above, you could rewrite it as

constexpr auto add = [](auto x, auto y, auto z) {
    return x + y + z;
};
auto const& [a, b, c] = std::make_tuple(1, 2, 3);
std::cout << add(a, b, c); // prints 6

which is bit more cumbersome, because you have to invent name that might not actually make much sense, depending on the specific case, clearly; as much clearly, if the tuple is just a collection of unrelated things which will take unrelated code paths, then maybe structured binding makes more sense.

In other languages packing and unpacking is more straightforward. Take JavaScript, where arrays can be etherogenous; packing more things just means enclosing them in a ,-separated list inside [ and ]. For unpacking, there's the ... operator. Here's native JavaScript code that corresponds to the C++ code above which uses a full-fledge libarary:

<!-- begin snippet: js hide: false console: true babel: false -->

<!-- language: lang-js -->

add = x => x[0] + x[1] + x[2]
console.log(add([1, 2, 3])) // prints 6
add = (x, y, z) => x + y + z;
console.log(add(...[1, 2, 3])) // prints 6

<!-- end snippet -->

Finally, in a language like Haskell, where functions are all curried, i.e. they accept arguments one by one, packing and unpacking fundamentally coincide with uncurrying and currying respectively:

add3'curried = \x y z -> x + y + z -- === curry3 add3'uncurried
triple = (1, 2, 3)
uncurry3 add3'curried $ triple -- prints 6

add3'uncurried = \(x, y, z) -> x + y + z -- === uncurry3 add3'curried
curry3 add3'uncurried 1 2 3 -- prints 6

Here's how array destructuring and structuring might be implemented in different languages:

js

Destructuring:

const [a, b, c] = [1, 2, 3]; // Unpacks the array into individual variables a, b, and c

Structuring:

const packedArray = [a, b, c]; // Packs the values into a new array

py

Destructuring:

a, b, c = (1, 2, 3)  # Unpacks the tuple into individual variables a, b, and c

Structuring:

packed_tuple = (a, b, c)  # Packs the values into a new tuple

cpp

C++ doesn't have a direct built-in mechanism for array destructuring or structuring like JavaScript or Python. However, you can achieve similar results using the following approaches:

Destructuring:
You can manually assign values from an array to individual variables.

int arr[] = {1, 2, 3};
int a = arr[0];
int b = arr[1];
int c = arr[2];

Structuring:
You can create an array or a data structure to hold the values.

int a = 1;
int b = 2;
int c = 3;
int arr[] = {a, b, c};