Extructure - a flexible destructure library for Elixir

Hey guys (and gals),

Letting you know I finally release this Extructure library. Here’s some info copied from its docs:

By default the library is using loose (flexible) matching, allowing for implicit structural conversions (maps, lists and tuples, from one to another). Tuple and list key pair element order are also taken loosely by default.

Supports destructure-like implicit keys (with the same name as the variable) as well as optional values, flexible keyword and key pair tuple size and order of elements, implicit transformation between a map, list and a key pair tuple.

Also supports toggling between the loose mode and the standard Elixir pattern matching (“rigid”) mode where none of the flexibilities except for the optional variables are allowed.

Fully enforces pattern matching between the left and right side once taken into account the optional values and structural transformation.

For example, instead of:

  first_name: fist_name,
  last_name: last_name,
} = socket.assigns

age = socket.assigns[ :age]

just write:

%{ first_name, last_name, _age} <~ socket.assigns

or implicitly transform the map into a list:

[ first_name, last_name, _age] <~ socket.assigns

or use a different order:

[ last_name, _age, first_name] <~ socket.assigns

or set a default value:

[ last_name, age( 25), first_name] <~ socket.assigns



Great library for destructing!

I have several questions.

  1. Why did you chose arguments like age(25) instead of more common age \\ 25 like defaults in arguments of functions? This kind of specification of defaults is less intuitive for Elixir developers and it makes impossible to use macros inside the left part of <~/2

  2. Why did you chose _defaults_to_nil syntax ? I think explicit defaults_to_nil \\ 25 or defaults_to_nil(nil) is just more obvious

1 Like

Thanks for the compliments.

As for your question, it’s not like I had that option. Namely, the following generates a syntax error:

%{ a, b \\ 25} <~ %{ a: 1, b: 2}

as it does not work for maps, and I wanted to have a uniform way of expressing the variables (the same syntax works with lists and tuples).


Hmm, yeah, for maps the only valid syntax is left => right, left: right and variable, call(args). I’ve experienced the similar issue here: Using map syntax %{} as list brackets for integers · Issue #10964 · elixir-lang/elixir · GitHub


Just released Extructure v0.1.1 with added support for loose list head | tail extraction.

Ex (from docs):

[ b | rest] <~ [ a: 1, b: 2, c: 3]
# => [ b: 2, a: 1, c: 3]

[ b | [ a, c]] <~ [ a: 1, b: 2, c: 3, d: 4]
# => [ b: 2, a: 1, c: 3]

[ a | [ b, c( 25)]] <~ %{ a: 1, b: 2}
# => [a: 1, b: 2, c: 25]

[ b | %{ c: %{ d}}] <~ [ a: 1, b: 2, c: %{ d: 5}]
# => [ { :b, 2} | %{ a: 1, c: %{ d: 5}}

New features available in v0.2.1 (as per the changelog):


  • Support transforming entire structures on the right side by specifying an empty map, tuple or list, e.g.:
[ a: a = %{}] <~ [ a: [ b: 2, c: 3]]
# a
# => %{b: 2, c: 3}
  • Support destructuring from module (named) structures as if plain maps, e.g:
[ hour, minute, second] <~ DateTime.utc_now()
# => [hour: 15, minute: 44, second: 14]

The new v0.3.1 now supports string keys (in addition to atoms) to facilitate destructuring in such use cases as JSON properties and LiveView params, e.g.:

params = %{
  "a" => 1,
  "b" => 2

@[ a, b, _c] <~ params
# a => 1
# b => 2
# c => nil
1 Like

Extructure v1.0 is out


How and why didn’t I see this project before?!

Will use the hell out of it. Thank you!

1 Like

You’re welcome.

Is there anyway to do use this in function heads? I find function heads like:

def func(%{"variable1" => variable1, "variable2" => variable2}) do

can get quite verbose, of course you can extract values in the first line of the function body, but sometimes having it in the function head serves additional benefits. I’ve used the Destructure library before which allows you to do the following:

def func(s(%{variable1, variable2})) do

Since your library uses slightly different syntax %{a, b} <~ vs d(%{a, b}), I was wondering if it would be possible to support function head destructuring or not.


Not as of yet, but it can be easily added. The only problem is to figure out what syntax to use. Personally, I dislike introducing new macros (like the d/1 or the s/1). I need to do some brainstorming on this.

Thanks for the suggestion.