EEP 78: Multi-valued comprehensions

lib/compiler/src/sys_coverage.erl

@@ -509,16 +509,15 @@ munge_expr({call,Anno,Expr,Exprs}, Vars0) ->
     {MungedExprs, Vars2} = munge_args(Exprs, Vars1),
     {{call,Anno,MungedExpr,MungedExprs}, Vars2};
 munge_expr({lc,Anno,Expr,Qs}, Vars0) ->
-    {MungedExpr, Vars1} = munge_expr(?BLOCK1(Expr), Vars0),
+    {MungedExpr, Vars1} = munge_comprehension(Expr, Vars0),
     {MungedQs, Vars2} = munge_qualifiers(Qs, Vars1),
     {{lc,Anno,MungedExpr,MungedQs}, Vars2};
 munge_expr({bc,Anno,Expr,Qs}, Vars0) ->
     {MungedExpr,Vars1} = munge_expr(?BLOCK1(Expr), Vars0),
     {MungedQs, Vars2} = munge_qualifiers(Qs, Vars1),
     {{bc,Anno,MungedExpr,MungedQs}, Vars2};
-munge_expr({mc,Anno,{map_field_assoc,FAnno,K,V},Qs}, Vars0) ->
-    Expr = {map_field_assoc,FAnno,?BLOCK1(K),?BLOCK1(V)},
-    {MungedExpr, Vars1} = munge_expr(Expr, Vars0),
+munge_expr({mc,Anno,Expr,Qs}, Vars0) ->
+    {MungedExpr, Vars1} = munge_comprehension(Expr, Vars0),
     {MungedQs, Vars2} = munge_qualifiers(Qs, Vars1),
     {{mc,Anno,MungedExpr,MungedQs}, Vars2};
 munge_expr({block,Anno,Body}, Vars0) ->
@@ -592,6 +591,18 @@ is_atomic({nil,_}) -> true;
 is_atomic({var,_,_}) -> true;
 is_atomic(_) -> false.
 
+munge_comprehension([Expr|Exprs], Vars0) ->
+    {MungedExpr, Vars1} = munge_comprehension(Expr, Vars0),
+    {MungedExprs, Vars2} = munge_comprehension(Exprs, Vars1),
+    {[MungedExpr|MungedExprs], Vars2};
+munge_comprehension([], Vars) ->
+    {[], Vars};
+munge_comprehension({map_field_assoc,Anno,K,V}, Vars0) ->
+    Expr = {map_field_assoc,Anno,?BLOCK(K),?BLOCK(V)},
+    munge_expr(Expr, Vars0);
+munge_comprehension(Expr, Vars0) ->
+    munge_expr(?BLOCK1(Expr), Vars0).
+
 munge_exprs(Exprs, Vars) ->
     munge_exprs(Exprs, Vars, []).
 

lib/compiler/src/v3_core.erl

@@ -710,12 +710,12 @@ expr({cons,L,H0,T0}, St0) ->
     {annotate_cons(A, H1, T1, St1),Eps,St1};
 expr({lc,L,E,Qs0}, St0) ->
     {Qs1,St1} = preprocess_quals(L, Qs0, St0),
-    lc_tq(L, E, Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
+    lc_tq(L, wrap_list(E), Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
 expr({bc,L,E,Qs}, St) ->
     bc_tq(L, E, Qs, St);
 expr({mc,L,E,Qs0}, St0) ->
     {Qs1,St1} = preprocess_quals(L, Qs0, St0),
-    mc_tq(L, E, Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
+    mc_tq(L, wrap_list(E), Qs1, #c_literal{anno=lineno_anno(L, St1),val=[]}, St1);
 expr({tuple,L,Es0}, St0) ->
     {Es1,Eps,St1} = safe_list(Es0, St0),
     A = record_anno(L, St1),
@@ -967,7 +967,7 @@ expr({op,_,'++',{lc,Llc,E,Qs0},More}, St0) ->
     %% number variables in the environment for letrec.
     {Mc,Mps,St1} = safe(More, St0),
     {Qs,St2} = preprocess_quals(Llc, Qs0, St1),
-    {Y,Yps,St} = lc_tq(Llc, E, Qs, Mc, St2),
+    {Y,Yps,St} = lc_tq(Llc, wrap_list(E), Qs, Mc, St2),
     {Y,Mps++Yps,St};
 expr({op,_,'andalso',_,_}=E0, St0) ->
     {op,L,'andalso',E1,E2} = right_assoc(E0, 'andalso'),
@@ -1623,21 +1623,29 @@ fun_tq(Cs0, L, St0, NameInfo) ->
 		vars=Args,clauses=Cs1,fc=Fc,name=NameInfo},
     {Fun,[],St4}.
 
-%% lc_tq(Line, Exp, [Qualifier], Mc, State) -> {LetRec,[PreExp],State}.
+wrap_list(List) when is_list(List) -> List;
+wrap_list(Other) -> [Other].
+
+%% lc_tq(Line, Exprs, [Qualifier], Mc, State) -> {LetRec,[PreExp],State}.
 %%  This TQ from Simon PJ pp 127-138.
 
-lc_tq(Line, E, [#igen{}|_T] = Qs, Mc, St) ->
-    lc_tq1(Line, E, Qs, Mc, St);
-lc_tq(Line, E, [#izip{}=Zip|Qs], Mc, St) ->
-    zip_tq(Line, E, Zip, Mc, St, Qs);
-lc_tq(Line, E, [#ifilter{}=Filter|Qs], Mc, St) ->
-    filter_tq(Line, E, Filter, Mc, St, Qs, fun lc_tq/5);
-lc_tq(Line, E0, [], Mc0, St0) ->
-    {H1,Hps,St1} = safe(E0, St0),
+lc_tq(Line, Es, [#igen{}|_T] = Qs, Mc, St) ->
+    lc_tq1(Line, Es, Qs, Mc, St);
+lc_tq(Line, Es, [#izip{}=Zip|Qs], Mc, St) ->
+    zip_tq(Line, Es, Zip, Mc, St, Qs);
+lc_tq(Line, Es, [#ifilter{}=Filter|Qs], Mc, St) ->
+    filter_tq(Line, Es, Filter, Mc, St, Qs, fun lc_tq/5);
+lc_tq(Line, Es0, [], Mc0, St0) ->
+    {Hs1,Hps,St1} = safe_list(Es0, St0),
     {T1,Tps,St} = force_safe(Mc0, St1),
-    Anno = lineno_anno(Line, St),
-    E = ann_c_cons(Anno, H1, T1),
-    {set_anno(E, [compiler_generated|Anno]),Hps ++ Tps,St}.
+    Anno = lineno_anno(erl_anno:set_generated(true, Line), St),
+    E = ann_c_cons_all(Anno, Hs1, T1),
+    {E,Hps ++ Tps,St}.
+
+ann_c_cons_all(Anno, [H | Hs], T) ->
+    ann_c_cons(Anno, H, ann_c_cons_all(Anno, Hs, T));
+ann_c_cons_all(_Anno, [], T) ->
+    T.
 
 lc_tq1(Line, E, [#igen{anno=#a{anno=GA}=GAnno,
 		      acc_pat=AccPat,acc_guard=AccGuard,
@@ -1924,9 +1932,9 @@ bzip_tq1(Line, E, #izip{anno=#a{anno=_GA}=GAnno,
               body=append(Pres) ++
                   [#iapply{anno=LAnno,op=F,args=Args++[Mc]}]},[],St4}.
 
-mc_tq(Line, {map_field_assoc,Lf,K,V}, Qs, Mc, St0) ->
-    E = {tuple,Lf,[K,V]},
-    {Lc,Pre0,St1} = lc_tq(Line, E, Qs, Mc, St0),
+mc_tq(Line, Es0, Qs, Mc, St0) ->
+    Es = map(fun({map_field_assoc,Lf,K,V}) -> {tuple,Lf,[K,V]} end, Es0),
+    {Lc,Pre0,St1} = lc_tq(Line, Es, Qs, Mc, St0),
     {LcVar,St2} = new_var(St1),
     Pre = Pre0 ++ [#iset{var=LcVar,arg=Lc}],
     Call = #icall{module=#c_literal{val=maps},

lib/compiler/test/lc_SUITE.erl

@@ -24,7 +24,7 @@
 	 init_per_testcase/2,end_per_testcase/2,
 	 basic/1,deeply_nested/1,no_generator/1,
 	 empty_generator/1,no_export/1,shadow/1,
-	 effect/1]).
+	 effect/1,multi/1]).
 
 -include_lib("common_test/include/ct.hrl").
 
@@ -43,7 +43,8 @@ groups() ->
        empty_generator,
        no_export,
        shadow,
-       effect
+       effect,
+       multi
       ]}].
 
 init_per_suite(Config) ->
@@ -284,6 +285,10 @@ do_effect(Lc, L) ->
     ok = Lc(F, L),
     lists:reverse(erase(?MODULE)).
 
+multi(Config) when is_list(Config) ->
+    [true, false] = [true, false || true],
+    [1, 2, 5, 6] = [X, X + 1 || X <- [1, 5]].
+
 id(I) -> I.
 
 -file("bad_lc.erl", 1).

lib/compiler/test/mc_SUITE.erl

@@ -25,7 +25,7 @@
 -export([all/0,suite/0,groups/0,init_per_suite/1,end_per_suite/1,
 	 init_per_group/2,end_per_group/2,
          basic/1,duplicate_keys/1,mixed/1,
-         shadow/1,bad_generators/1]).
+         shadow/1,bad_generators/1,multi/1]).
 
 -include_lib("common_test/include/ct.hrl").
 
@@ -40,7 +40,8 @@ groups() ->
        duplicate_keys,
        mixed,
        shadow,
-       bad_generators]}].
+       bad_generators,
+       multi]}].
 
 init_per_suite(Config) ->
     test_lib:recompile(?MODULE),
@@ -298,6 +299,14 @@ bad_generators(_Config) ->
     end,
     ok.
 
+multi(_Config) ->
+    Exp = #{true => 1, false => 2},
+    Exp = #{true => 1, false => 2 || true},
+    Exp2 = #{1 => 1, 2 => 2, 5 => 5, 6 => 6},
+    Exp2 = #{X => X, X + 1 => X + 1 || X <- [1, 5]},
+    Exp3 = #{1 => 4, 5 => 8},
+    Exp3 = #{X => X+1, X => X+3 || X <- [1, 5]}.
+
 id(I) -> I.
 
 -file("bad_mc.erl", 1).

lib/stdlib/src/erl_eval.erl

@@ -927,28 +927,30 @@ do_apply(F, Anno, FunOrModFun, Args) when is_function(F, 3) ->
 do_apply(F, _Anno, FunOrModFun, Args) when is_function(F, 2) ->
     F(FunOrModFun, Args).
 
-%% eval_lc(Expr, [Qualifier], Bindings, LocalFunctionHandler,
+%% eval_lc(ExprOrExprs, [Qualifier], Bindings, LocalFunctionHandler,
 %%         ExternalFuncHandler, RetBindings) ->
 %%	{value,Value,Bindings} | Value
 
+eval_lc(Es, Qs, Bs, Lf, Ef, RBs, FUVs) when is_list(Es) ->
+    ret_expr(lists:reverse(eval_lc1(Es, Qs, Bs, Lf, Ef, FUVs, [])), Bs, RBs);
 eval_lc(E, Qs, Bs, Lf, Ef, RBs, FUVs) ->
-    ret_expr(lists:reverse(eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, [])), Bs, RBs).
+    eval_lc([E], Qs, Bs, Lf, Ef, RBs, FUVs).
 
-eval_lc1(E, [{zip, Anno, Gens}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+eval_lc1(Es, [{zip, Anno, Gens}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
     {VarList, Bs1} = convert_gen_values(Gens, [], Bs0, Lf, Ef, FUVs),
-    eval_zip(E, [{zip, Anno, VarList}|Qs], Bs1, Lf, Ef, FUVs, Acc0, fun eval_lc1/7);
-eval_lc1(E, [Q|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+    eval_zip(Es, [{zip, Anno, VarList}|Qs], Bs1, Lf, Ef, FUVs, Acc0, fun eval_lc1/7);
+eval_lc1(Es, [Q|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
     case is_generator(Q) of
         true ->
-            CF = fun(Bs, Acc) -> eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
+            CF = fun(Bs, Acc) -> eval_lc1(Es, Qs, Bs, Lf, Ef, FUVs, Acc) end,
             eval_generator(Q, Bs0, Lf, Ef, FUVs, Acc0, CF);
         false ->
-            CF = fun(Bs) -> eval_lc1(E, Qs, Bs, Lf, Ef, FUVs, Acc0) end,
+            CF = fun(Bs) -> eval_lc1(Es, Qs, Bs, Lf, Ef, FUVs, Acc0) end,
             eval_filter(Q, Bs0, Lf, Ef, CF, FUVs, Acc0)
     end;
-eval_lc1(E, [], Bs, Lf, Ef, FUVs, Acc) ->
-    {value,V,_} = expr(E, Bs, Lf, Ef, none, FUVs),
-    [V|Acc].
+eval_lc1(Es, [], Bs, Lf, Ef, FUVs, Acc) ->
+    {Vs, _} = expr_list(Es, Acc, Bs, Bs, Lf, Ef, FUVs),
+    Vs.
 
 %% convert values for generator vars from abstract form to flattened lists
 convert_gen_values([{Generate, Anno, P, L0}|Qs], Acc, Bs0, Lf, Ef,FUVs)
@@ -1251,30 +1253,37 @@ eval_bc1(E, [], Bs, Lf, Ef, FUVs, Acc) ->
     {value,V,_} = expr(E, Bs, Lf, Ef, none, FUVs),
     <<Acc/bitstring,V/bitstring>>.
 
-%% eval_mc(Expr, [Qualifier], Bindings, LocalFunctionHandler,
+%% eval_mc(ExprOrExprs, [Qualifier], Bindings, LocalFunctionHandler,
 %%         ExternalFuncHandler, RetBindings) ->
 %%	{value,Value,Bindings} | Value
 
-eval_mc(E, Qs, Bs, Lf, Ef, RBs, FUVs) ->
-    L = eval_mc1(E, Qs, Bs, Lf, Ef, FUVs, []),
+eval_mc(Es, Qs, Bs, Lf, Ef, RBs, FUVs) when is_list(Es) ->
+    L = eval_mc1(Es, Qs, Bs, Lf, Ef, FUVs, []),
     Map = maps:from_list(reverse(L)),
-    ret_expr(Map, Bs, RBs).
+    ret_expr(Map, Bs, RBs);
+eval_mc(E, Qs, Bs, Lf, Ef, RBs, FUVs) ->
+    eval_mc([E], Qs, Bs, Lf, Ef, RBs, FUVs).
 
-eval_mc1(E, [{zip, Anno, Gens}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+eval_mc1(Es, [{zip, Anno, Gens}|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
     {VarList, Bs1} = convert_gen_values(Gens, [], Bs0, Lf, Ef, FUVs),
-    eval_zip(E, [{zip, Anno, VarList}|Qs], Bs1, Lf, Ef, FUVs, Acc0, fun eval_mc1/7);
-eval_mc1(E, [Q|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
+    eval_zip(Es, [{zip, Anno, VarList}|Qs], Bs1, Lf, Ef, FUVs, Acc0, fun eval_mc1/7);
+eval_mc1(Es, [Q|Qs], Bs0, Lf, Ef, FUVs, Acc0) ->
     case is_generator(Q) of
         true ->
-            CF = fun(Bs, Acc) -> eval_mc1(E, Qs, Bs, Lf, Ef, FUVs, Acc) end,
+            CF = fun(Bs, Acc) -> eval_mc1(Es, Qs, Bs, Lf, Ef, FUVs, Acc) end,
             eval_generator(Q, Bs0, Lf, Ef, FUVs, Acc0, CF);
         false ->
-            CF = fun(Bs) -> eval_mc1(E, Qs, Bs, Lf, Ef, FUVs, Acc0) end,
+            CF = fun(Bs) -> eval_mc1(Es, Qs, Bs, Lf, Ef, FUVs, Acc0) end,
             eval_filter(Q, Bs0, Lf, Ef, CF, FUVs, Acc0)
     end;
-eval_mc1({map_field_assoc,Lfa,K0,V0}, [], Bs, Lf, Ef, FUVs, Acc) ->
-    {value,KV,_} = expr({tuple,Lfa,[K0,V0]}, Bs, Lf, Ef, none, FUVs),
-    [KV|Acc].
+eval_mc1(Es, [], Bs, Lf, Ef, FUVs, Acc) ->
+    eval_mc2(Es, Bs, Lf, Ef, FUVs, Acc).
+
+eval_mc2([{map_field_assoc,_,K0,V0}|Es], Bs, Lf, Ef, FUVs, Acc) ->
+    {[K,V],_} = expr_list([K0,V0], Bs, Lf, Ef, FUVs),
+    eval_mc2(Es, Bs, Lf, Ef, FUVs, [{K,V}|Acc]);
+eval_mc2([], _Bs, _Lf, _Ef, _FUVs, Acc) ->
+    Acc.
 
 eval_zip(E, [{zip, Anno, VarList}|Qs], Bs0, Lf, Ef, FUVs, Acc0, Fun) ->
     Gens = case check_bad_generators(VarList, {Bs0, Lf, Ef}, []) of
@@ -1530,13 +1539,14 @@ expr_list(Es, Bs, Lf, Ef) ->
     expr_list(Es, Bs, Lf, Ef, empty_fun_used_vars()).
 
 expr_list(Es, Bs, Lf, Ef, FUVs) ->
-    expr_list(Es, [], Bs, Bs, Lf, Ef, FUVs).
+    {Vs, Bs1} = expr_list(Es, [], Bs, Bs, Lf, Ef, FUVs),
+    {reverse(Vs), Bs1}.
 
 expr_list([E|Es], Vs, BsOrig, Bs0, Lf, Ef, FUVs) ->
     {value,V,Bs1} = expr(E, BsOrig, Lf, Ef, none, FUVs),
     expr_list(Es, [V|Vs], BsOrig, merge_bindings(Bs1, Bs0, element(2, E), Ef), Lf, Ef, FUVs);
 expr_list([], Vs, _, Bs, _Lf, _Ef, _FUVs) ->
-    {reverse(Vs),Bs}.
+    {Vs,Bs}.
 
 eval_op(Op, Arg1, Arg2, Anno, Bs, Ef, RBs) ->
     do_apply(erlang, Op, [Arg1,Arg2], Anno, Bs, Ef, RBs).

lib/stdlib/src/erl_expand_records.erl

@@ -276,6 +276,11 @@ record_test_in_body(Anno, Expr, Name, St0) ->
                         {atom,NAnno,is_record}},
             [Var,{atom,Anno,Name},{integer,Anno,length(Fs)+1}]}]}, St).
 
+expr_or_exprs(Es, St) when is_list(Es) ->
+    exprs(Es, St);
+expr_or_exprs(E, St) ->
+    expr(E, St).
+
 exprs([E0 | Es0], St0) ->
     {E,St1} = expr(E0, St0),
     {Es,St2} = exprs(Es0, St1),
@@ -302,15 +307,15 @@ expr({cons,Anno,H0,T0}, St0) ->
     {{cons,Anno,H,T},St2};
 expr({lc,Anno,E0,Qs0}, St0) ->
     {Qs1,St1} = lc_tq(Anno, Qs0, St0),
-    {E1,St2} = expr(E0, St1),
+    {E1,St2} = expr_or_exprs(E0, St1),
     {{lc,Anno,E1,Qs1},St2};
 expr({bc,Anno,E0,Qs0}, St0) ->
     {Qs1,St1} = lc_tq(Anno, Qs0, St0),
     {E1,St2} = expr(E0, St1),
     {{bc,Anno,E1,Qs1},St2};
 expr({mc,Anno,E0,Qs0}, St0) ->
     {Qs1,St1} = lc_tq(Anno, Qs0, St0),
-    {E1,St2} = expr(E0, St1),
+    {E1,St2} = expr_or_exprs(E0, St1),
     {{mc,Anno,E1,Qs1},St2};
 expr({tuple,Anno,Es0}, St0) ->
     {Es1,St1} = expr_list(Es0, St0),

lib/stdlib/src/erl_lint.erl

@@ -402,6 +402,8 @@ format_error_1(update_literal) ->
     ~"expression updates a literal";
 format_error_1(illegal_zip_generator) ->
     ~"only generators are allowed in a zip generator.";
+format_error_1(illegal_map_exact_in_comprehension) ->
+    ~"illegal map association, did you mean to use `=>`?";
 %% --- patterns and guards ---
 format_error_1(illegal_map_assoc_in_pattern) -> ~"illegal pattern, did you mean to use `:=`?";
 format_error_1(illegal_pattern) -> ~"illegal pattern";
@@ -4033,7 +4035,7 @@ icrt_export([], _, _, _, Acc) ->
 
 handle_comprehension(E, Qs, Vt0, St0) ->
     {Vt1, Uvt, St1} = lc_quals(Qs, Vt0, St0),
-    {Evt,St2} = comprehension_expr(E, Vt1, St1),
+    {Evt,St2} = comprehension_exprs(E, Vt1, St1),
     Vt2 = vtupdate(Evt, Vt1),
     %% Shadowed global variables.
     {_,St3} = check_old_unused_vars(Vt2, Uvt, St2),
@@ -4050,8 +4052,19 @@ handle_comprehension(E, Qs, Vt0, St0) ->
     Vt = vt_no_unsafe(vt_no_unused(Vt4)),
     {Vt, St}.
 
+comprehension_exprs(Es, Vt, St0) when is_list(Es) ->
+    foldl(fun (E, {Esvt, St1}) ->
+                  {Evt, St2} = comprehension_expr(E, Vt, St1),
+                  vtmerge_pat(Evt, Esvt, St2)
+          end, {[], St0}, Es);
+comprehension_exprs(E, Vt, St) ->
+    comprehension_expr(E, Vt, St).
+
 comprehension_expr({map_field_assoc,_,K,V}, Vt0, St0) ->
     expr_list([K,V], Vt0, St0);
+comprehension_expr({map_field_exact,A,K,V}, Vt0, St0) ->
+    St = add_error(A, illegal_map_exact_in_comprehension, St0),
+    expr_list([K,V], Vt0, St);
 comprehension_expr(E, Vt, St) ->
     expr(E, Vt, St).
 

lib/stdlib/src/erl_parse.yrl

@@ -357,10 +357,15 @@ sigil -> sigil_prefix string sigil_suffix : build_sigil('$1', '$2', '$3').
 
 list_comprehension -> '[' expr '||' lc_exprs ']' :
 	{lc,?anno('$1'),'$2','$4'}.
-map_comprehension -> '#' '{' map_field_assoc '||' lc_exprs '}' :
+list_comprehension -> '[' expr ',' exprs '||' lc_exprs ']' :
+    {lc,?anno('$1'),['$2'|'$4'],'$6'}.
+map_comprehension -> '#' '{' map_field '||' lc_exprs '}' :
 	{mc,?anno('$1'),'$3','$5'}.
+map_comprehension -> '#' '{' map_field ',' map_fields '||' lc_exprs '}' :
+    {mc,?anno('$1'),['$3'|'$5'],'$7'}.
 binary_comprehension -> '<<' expr_max '||' lc_exprs '>>' :
 	{bc,?anno('$1'),'$2','$4'}.
+
 lc_exprs -> lc_expr : ['$1'].
 lc_exprs -> lc_expr ',' lc_exprs : ['$1'|'$3'].
 lc_exprs -> zc_exprs : [{zip, ?anno(hd('$1')), '$1'}].
@@ -930,10 +935,10 @@ processed (see section [Error Information](#module-error-information)).
         {'remote', anno(), abstract_expr(), abstract_expr()}.
 
 -type af_list_comprehension() ::
-        {'lc', anno(), af_template(), af_qualifier_seq()}.
+        {'lc', anno(), af_template() | [af_template()], af_qualifier_seq()}.
 
 -type af_map_comprehension() ::
-        {'mc', anno(), af_assoc(abstract_expr()), af_qualifier_seq()}.
+        {'mc', anno(), af_assoc(abstract_expr()) | [af_assoc(abstract_expr())], af_qualifier_seq()}.
 
 -type af_binary_comprehension() ::
         {'bc', anno(), af_template(), af_qualifier_seq()}.