How to pattern matching on function calls

Hi. Suppose that I have this map:

session = %{
  user: %{
    get_image: fn -> %{image: "abcd.jpg"} end

And I want to get image name by pattern matching like this:

%{user: get_image.(): %{image: image}} = session
IO.inspect image # I expect this result: "abdc.jpg"
# but I will get unexpected token error.

How can I do that?
On other words, I want to pattern matching on result of calling get_images. Without pattern matching we can do this and it will work:

IO.inspect session.user.get_image.().image # result is: "abcd.jpg"

PS: I think that this approach is not according to functional paradigm, but I want to know that is this possible or not!

Pattern matching is useful to match on the shape of data and maybe extract data from it.
What you’re trying to do is to match on a pattern and also run functions in a pattern.

It’s also not clear what you’re trying to do and this looks like an XY Problem

In this map, the get_image field is a function, but here:

The syntax is not valid, and also they look like completely different data structures, since in the pattern you expect another map to be in the user map.

From your last snippet:

I may be wrong, but it looks like you’re trying to have code that looks like it would do in an OOP language. It’s not clear why would a get_image function exist in a data structure that holds data about the user. It may make sense in the OOP world where classes mix data and behaviour and objects kind of know how to work with themselves, but in functional land this doesn’t hold.

Let’s say you have a user map that looks like this:
user = %{image: nil}
And your session:
session = %{user: user}

If you want to populate the user’s image field, you need a function to do that:

# Let's also suppose the user may have other fields besides `image`
get_image = fn user -> %{user | image: "abcd.jpg"} end

It takes a user, and updates the image field.

So now that you have that function, you need to use it to update the user inside the session, you can do that with update_in or put_in:
session = update_in(session.user, get_image)
It will run get_image in the user and return the updated session

Now that you have your session populated, in some other part of your code you can use pattern matching to extract the image from it:

%{user: %{image: image}} = session
IO.inspect(image) # "abcd.jpg"

What I’m trying to show is that transforming data and pattern matching are two completely different things, so you should work with them separately. When you’re in a pattern, you’re not building new data, you’re, well, defining a pattern. At the point you pattern match, the data was already transformed and you want to know something about it or assert it has a given shape.


If you pattern match, you generally won’t need a function to get the image, because you can capture the value of image whenever you pass the session as a parameter:

session = %{user: %{image: "user_image.jpg"}}

def some_function_using_the_session_image(%{user: %{image: image}} = _session) do
  # image is available here

result = some_function_using_the_session_image(session)