Set theory operations with dynamic arrays

Actually, I came up with a reasonably elegant way to do n-ary union and intersection where the input is an array of thunks, each thunk representing a set. This is union:

=LET(_l, LAMBDA(x,LAMBDA(x)),
 sets, VSTACK(_l(B4:B11), _l(C4:C9), _l(D4:D12)),
 UNIQUE(DROP(REDUCE(0,sets, LAMBDA(s,x,VSTACK(s,x()))),1)))

Lines 1 and 2 just set up the simulated input. This really does nothing but stack all the sets together and run unique on the whole. Intersection is much more interesting:

=LET(_l, LAMBDA(x, LAMBDA(x)),
 sets, VSTACK(_l(B4:B11), _l(C4:C9), _l(D4:D12)),
 union, UNIQUE(DROP(REDUCE(0, sets, LAMBDA(s,x, VSTACK(s, x()))), 1)),
 not_x, UNIQUE(DROP(REDUCE(0, sets, LAMBDA(s,x, VSTACK(s, UNIQUE(VSTACK(x(), union), , 1)))), 1)),
 UNIQUE(VSTACK(union,not_x), , 1))

This takes advantage of De Morgan's Law. In this case, the set complement is just the set subtracted from the union. (We don't need to double the set being subtracted since it's entirely contained in the union.) So we compute the union as before, then we compute the union of the complements of all the sets. Finally we take the complement of that (subtract it from the union) to get our answer.

I'm two years late to the party, but in case anyone is still watching, I think there's a much easier way to do this, and it does support n-ary union. I assume that sets are already unique, but I don't expect them to be sorted.

Union is the simplest:

=LET(A, B4:B11, B, D4:D8, UNIQUE(VSTACK(A, B)))

Since VSTACK takes multiple arguments, so does this union operation. 

Symmetric Difference is next-easiest.

=LET(A, B4:B11, B, D4:D8, UNIQUE(VSTACK(A, B), ,1))

The "really unique" option turns UNIQUE from a natural union to a natural symmetric difference. Note: The multi-way symmetric difference isn't (in my view) terribly useful, and this function does not produce that. This operation seems to be called the "unique union" by at least some people. Anyway, it's very handy.

Set subtraction is a bit more clever. To get A-B

=LET(A, B4:B11, B, D4:D8, UNIQUE(VSTACK(A, B, B), ,1))

This works because doubling B guarantees that none of B will be in the result, but elements of A not in B are unaffected. Or, having a set twice in the unique union obliterates all of its elements, so what's left is the set subtraction. To subtract more sets, just chain them on the end, two at a time. E.g. A, B, B, C, C.

Intersection is the harder one, but it's not that hard. 

=LET(A, B4:B11, B, D4:D8, UNIQUE(VSTACK(UNIQUE(VSTACK(A, B)), UNIQUE(VSTACK(A, B), ,1)), ,1))

It simply does a symmetric difference between the union of two sets and the symmetric difference of the two. I keep thinking there's a way to simplify this, but I'm not seeing it. Unfortunately, this doesn't give the n-ary intersection: It just gives elements that appear in at least two sets. Here's an n-ary intersection that uses GROUPBY. You basically dump all the sets together and let groupby count the unique elements. 

=LET(n, 3, A, B4:B11, B, C4:C8, C, D4:D11, stack,VSTACK(A, B, C),
 set_cnt, GROUPBY(stack, SEQUENCE(ROWS(stack), 1, 0), COUNT, 0, 0),
 set, CHOOSECOLS(set_cnt, 1), counts, CHOOSECOLS(set_cnt,2),
 x_cnt, FILTER(set_cnt, counts=n), CHOOSECOLS(x_cnt, 1))

This is so ugly I keep thinking there must be a better way, but I'm not seeing it. It's also annoying to have to pass in 3, but there's no way to tell how many sets there were after you've merged them together.

MarkolaKrai 

File attached

MarkolaKrai 

Dressing it up a bit!

Union:                = SetOperateλ(setA, setB, Unionλ);
Intersection:         = SetOperateλ(setA, setB, Intersectλ);
Difference1:          = SetOperateλ(setA, setB, Diffλ);
Difference2:          = SetOperateλ(setB, setA, Diffλ);
Symmetric difference: = SetOperateλ(setA, setB, SymDiffλ);

where

SetOperateλ
= LET(
    items,     VSTACK(A, B),
    distinct,  SORT(UNIQUE(items)),
    isA,       COUNTIFS(A,distinct),
    isB,       COUNTIFS(B,distinct),
    criterion, MAP(isA, isB, Fnλ),
    FILTER(distinct, criterion)
  )

and

Unionλ      = OR(x, y);
Intersectλ  = AND(x, y);
Diffλ       = AND(x, NOT(y));
SymDiffλ    = XOR(x, y);

MarkolaKrai 

Perhaps with REDUCE:

=REDUCE("Not in List2",list1,LAMBDA(a,v,IF(OR(v=list2),a,VSTACK(a,v))))