For Comprehension: there's no assignment, only filters?

That‘s how it‘s supposed to work. Assignments evaluate to the value of the left hand side (left == (a = left)). If that value is falsy the current generated value is filtered.

That doesn‘t mean you cannot use assignments, but you need to be careful with ones, which can return falsy values.

Given the original comment and @LostKobrakai 's response, I’m thinking something like this would achieve what you want:

(Modifying the original code snippet.)

data = [%{a: 1, b: 2}, %{a: 2}]

for datum <- data,
  {:ok, b} = {:ok, datum[:b]},
  b == nil do
    datum
end

I understand that b = datum[:b] is an expression and it would return the value of datum[:b], what i want to highlight is that assignment is common, and having it treated always as filter result in really suprising gotcha, and you would need to be really careful everywhere as faulty value like nil and false is commonly used (ex: Ecto get_entity function has possibility return nil, Map.get default to nil, access pattern [:b] default to nil).

That’s true, wrapping it inside {:ok, } tuple does solve the issue, but in spirit of idiomatic code, it looks like more noisy compared to

for datum <- data,
  b = datum[:b],
  b == nil do
    datum
end

in spirit of idiomatic code, wouldn’t it better to make for treat b = datum[:b] as purely assignment operator? though i understand it probably will create breaking change. alternatively, maybe making a macro let which would transform let(b = datum[:b]) to {:ok, b} = {:ok, datum[:b]} would be more feasible?

example if there’s let

for datum <- data,
  let(b = datum[:b]),
  b == nil do
    datum
end

Just realize it, but probably only {} would work too, still thinking having let would be better though:

data = [%{a: 1, b: 2}, %{a: 2}]

for datum <- data,
  {b} = {datum[:b]},
  b == nil do
    datum
end

or

data = [%{a: 1, b: 2}, %{a: 2}]

for datum <- data,
  {b = datum[:b]},
  b == nil do
    datum
end

In your case you could also do:

for datum when not is_map_key(datum, :b) <- data do
  datum
end

thanks for pointing that out!

what do you think about having an assignment syntax in for which are not used as filter though? should wrapping assignment in {} be default practice when using for comprehension?

In such cases I also tend to do this:

for x <- list,
    y <- [may_be_nil(x)],
    do: y

So that is likely the approach I would go with if it can’t be done with a guard?

That’s interesting, thinking assignment as a special case of generator. Should i update elixir tutorial at https://elixir-lang.org/getting-started/comprehensions.html (and maybe other related docs) to this syntax (and maybe add warning about using = in for?)

dirs = ['/home/mikey', '/home/james']

for dir <- dirs,
    file <- File.ls!(dir),
    path <- [Path.join(dir, file)],
    File.regular?(path) do
  File.stat!(path).size
end

I don’t think it is worth doing this change in general, because it can be nil in many cases and sometimes you want to discard nil values, but we probably need to add a note to the API documentation just in case.