I’ve recently been blogged about unions, intersections, diffs and disjunctive unions of elements in arrays. I thought I do the same for structs.

First up here’s how to do a union:

```function union(required struct a, required struct b) {
return a.append(b);
}

set1 = {"a": 1, "b": 2};
set2 = {"c": 3, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:3, d:4}
```

OK, that was easy. Wait a second, not so hasty!

Before we move on, let’s dig a little deeper. What do you think the values of `set1` and `set2` are after we called the `union` function?

Let’s run the code again and take a look.

```function union(required struct a, required struct b) {
return a.append(b);
}

set1 = {"a": 1, "b": 2};
set2 = {"c": 3, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:3, d:4}
// check set1 and set2 values
writeDump(set1); // {a:1, b:2, c:3, d:4}
writeDump(set2); // {c:3, d:4}
```

As you can see, `set1` is no longer the same as when we passed it to the function. Instead the function has mutated it. As structs are passed by reference, not by value, in CFML, then any changes to the struct inside the function will act on the original struct. This could be an unwanted side effect and lead to bugs in our code. let’s fix that.

```function union(required struct a, required struct b) {
return a.duplicate().append(b);
}

set1 = {"a": 1, "b": 2};
set2 = {"c": 3, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:3, d:4}
// check set1 and set2 values
writeDump(set1); // {a:1, b:2}
writeDump(set2); // {c:3, d:4}
```

By adding the `duplicate` method we end up with a clone of the original struct. Now any changes we make inside the function only apply to the clone and the original variable is left intact.

OK, so we’re done with `union`. Well, not quite. What happens if you have the same key in both structs? Let’s try that.

```function union(required struct a, required struct b) {
return a.duplicate().append(b);
}

set1 = {"a": 1, "b": 2, "c": 3};
set2 = {"c": 3, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:3, d:4}
```

Great, our code still returns the expected result. Can we move on now? Sorry, no, we need to know what happens if the key is the same, but the value is different?

```function union(required struct a, required struct b) {
return a.duplicate().append(b);
}

set1 = {"a": 1, "b": 2, "c": 31};
set2 = {"c": 32, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:32, d:4}
```

We now see that the value of `c` from `set2` is the value we get in the returned result. That may suit us, on the other hand, maybe I want the values from `set1` to take priority. We can do that like so:

```function union(required struct a, required struct b) {
return a.duplicate().append(b, false);
}

set1 = {"a": 1, "b": 2, "c": 31};
set2 = {"c": 32, "d": 4};

writeDump(union(set1, set2)); // {a:1, b:2, c:31, d:4}
```

By passing a value of `false` as the 2nd parameter of the `append()` method, we are saying ‘Do not overwrite existing key value pairs’.

One final thing we should check is does the case of the key matter here?

```set1 = {"A": 1, "B": 2, "C": 31};
set2 = {"c": 32, "d": 4};

writeDump(union(set1, set2)); // {A:1, B:2, C:31, d:4}
```

The answer is that a keyname of `C` is treated as a match for the keyname of `c`. The case of the key is also preserved in the result.

You may think I’ve gone a bit over the top in my examples (and maybe I have!), but I think it’s useful to know how these things work. Hopefully it’ll save someone some headaches!