<div dir="ltr"><div>Similarly, bit comprehensions can benefit also, but not as useful as flexibly as the list comprehension case:</div><div><br></div><div>[ X + Y || << X:8, Y:8 >>  <= << 1:8, 2:8, 3:8, 4:8, 0:1 >> ]. %% discards final byte<br>
</div><div>[ X + Y || << X:8, Y:8, Z:8 >>  <= << 1:8, 2:8, 0:8, 3:8, 4:8, 0:8, 1:8 >> ]. %% discards every 3rd byte and trailing<br></div><div>[ X + Y || << 1:8, Y:8, Z:8 >>  <= << 1:8, 2:8, 0:8, 3:8, 4:8, 0:8, 1:8 >> ]. %% discards every 3rd byte and trailing<br>
</div><div>[ X + Y || << X:8, Y:8, Z:8 >>  <= << 1:8, 2:8, 0:8, 3:8, 4:8, 0:8, 1:8 >>, X =:= 1 ]. %% discards pair except matching structure with 1st byte =:= 1<br></div><div><br></div><div>Cheers,</div>
<div><br></div><div>Darach.</div></div><div class="gmail_extra"><br><br><div class="gmail_quote">On Thu, Jan 16, 2014 at 4:58 PM,  <span dir="ltr"><<a href="mailto:amindfv@gmail.com" target="_blank">amindfv@gmail.com</a>></span> wrote:<br>
<blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Or! You can write:<br>
<br>
[ A || A = {a, _} <- Foos() ]<br>
<br>
Both of these examples work in Haskell also.<br>
<br>
Tom<br>
<br>
<br>
El Jan 16, 2014, a las 11:55, <a href="mailto:amindfv@gmail.com">amindfv@gmail.com</a> escribió:<br>
<div class="HOEnZb"><div class="h5"><br>
> This is intentional. I use a pattern like this a lot:<br>
><br>
> -type foo :: {'a', string()} | {'b', string()}.<br>
><br>
> Foos() -> [{a, "hello"}, {b, "goodbye"}].<br>
><br>
> As() -> [ S || {a, S} <- Foos() ]. % ["hello"]<br>
><br>
> Tom<br>
><br>
><br>
> El Jan 16, 2014, a las 11:39, Rich Neswold <<a href="mailto:rich.neswold@gmail.com">rich.neswold@gmail.com</a>> escribió:<br>
><br>
>> Hello,<br>
>><br>
>> This morning I became aware of a (powerful) feature of list<br>
>> comprehensions. Take the following example:<br>
>><br>
>>   [ X + Y || {X, Y} <- L].<br>
>><br>
>> If we set L to [{1,2}, ok, {1,3}], we get the result [3,4] instead of<br>
>> a pattern match exception (as I was expecting.) This means that list<br>
>> comprehensions give you a "free" lists:filter/2 in the generator<br>
>> expressions!<br>
>><br>
>> I've looked through the OTP documentation, quite a few Stack Overflow<br>
>> questions, and several list comprehension tutorials and none of them<br>
>> explicitly state that generator expressions filter elements that don't<br>
>> match their pattern. The web pages emphasize generators and guards are<br>
>> like combinations of lists:map and lists:filter, which isn't exactly<br>
>> correct. For instance, the above example is not the same as:<br>
>><br>
>>   lists:map(fun ({X, Y}) -> X + Y end, L).<br>
>><br>
>> but is more equivalent to:<br>
>><br>
>>   lists:foldr(fun ({X, Y}, Acc) -> [X + Y | Acc];<br>
>>                   (_, Acc) -> Acc<br>
>>               end, [], L).<br>
>><br>
>> Is this an expected, but undocumented, feature of list comprehensions?<br>
>> Or am I in "undefined behavior" territory?<br>
>><br>
>> --<br>
>> Rich<br>
>> _______________________________________________<br>
>> erlang-questions mailing list<br>
>> <a href="mailto:erlang-questions@erlang.org">erlang-questions@erlang.org</a><br>
>> <a href="http://erlang.org/mailman/listinfo/erlang-questions" target="_blank">http://erlang.org/mailman/listinfo/erlang-questions</a><br>
_______________________________________________<br>
erlang-questions mailing list<br>
<a href="mailto:erlang-questions@erlang.org">erlang-questions@erlang.org</a><br>
<a href="http://erlang.org/mailman/listinfo/erlang-questions" target="_blank">http://erlang.org/mailman/listinfo/erlang-questions</a><br>
</div></div></blockquote></div><br></div>