How to find all instances where a given value in a map matches any element in a list of strings

Trying to expand my working ability with Elixir, and I'm having trouble getting this to work. This is a contrived example simplifying a similar problem I have. Given a list of towns and a list of people and addresses, how do I go about finding when one of the town strings is contained in the list of maps of name and address.

    list_of_towns = ["denver", "sacramento", "nashville"]

    people_details = [
      %{
        name: "joe",
        address: "123 main st, sacramento"
      },
      %{
        name: "jack",
        address: "456 international ave, oakland"
      },
      %{
        name: "sam",
        address: "789 main st, nashville"
      }
    ]

    defmodule Locator do
      def check_towns(people_details, list_of_towns) do
        for town <- list_of_towns do
          for person <- people_details do
            if String.contains?(person[:address], town) do
              person
            end
          end
          |> Enum.reject(fn x -> is_nil(x) end)
        end
      end
    end

I'd like this to return just the list of maps where the sets intersect

    [
     %{
        name: "joe",
        address: "123 main st, sacramento"
      },
      %{
        name: "sam",
        address: "789 main st, nashville"
      }
    ]

but this returns

    [
      [],
      [%{address: "123 main st, sacramento", name: "joe"}],
      [%{address: "789 main st, nashville", name: "sam"}]
    ]

So how do I clean this up, so I don't have the empty array, and the subsequent results aren't wrapped like arrays as well?
Also, I'm pretty sure this syntax is idiomatically crap, so I'd be happy to see a better way.

One does not need a comprehension here. When the problem description contains “find” word, one usually uses either Enum.find/2 or Access.

Here is one of possible ways to accomplish the task.

Enum.filter(people_details, fn %{address: address} -> 
  Enum.any?(list_of_towns, &String.contains?(address, &1))
end)

#⇒ [
#   %{address: "123 main st, sacramento", name: "joe"},
#   %{address: "789 main st, nashville", name: "sam"}
# ]

Whether you are still after [ab]using a comprehension, use it as filter, not as another loop.

for person <- people_details,
    List.last(String.split(person.address, ", ")) in list_of_towns,
  do: person           

#⇒ [
#   %{address: "123 main st, sacramento", name: "joe"},
#   %{address: "789 main st, nashville", name: "sam"}
# ]

<!-- language-all: lang-elixir -->

You can do this using a comprehension like this:

for %{address: address} = person_detail <- people_details,
    town <- list_of_towns,
    String.contains?(address, town),
    do: person_detail

It enumerates all the person_detail and town permutations, filters based on your condition, and returns the person_details that match. Note that it will return duplicates if an address matches multiple town strings - but that indicates a bug with your filter condition.

Result:

[
  %{address: "123 main st, sacramento", name: "joe"},
  %{address: "789 main st, nashville", name: "sam"}
]

However, I wouldn't write this code normally - the first part of Aleksei's answer is what I'd write too.