Why do I need to specify element => element when iterating over an !array.Exists conditional statement?

The function Array.Exists takes a Predicate as the second argument.

https://learn.microsoft.com/en-us/dotnet/api/system.array.exists

A Predicate is a function that takes one element as input, should check if this element meets your criteria and returns a boolean.

https://learn.microsoft.com/en-us/dotnet/api/system.predicate-1

In Code A, your second argument is just a comparison that will get evaluated first (before Array.Exists is even called!), and its boolean value will be passed to the Array.Exists function, which is neither what you want nor what the function expects. You want to check each individual element of your array individually.

Furthermore, if you just write: element == collision.gameObject.layer, the word element is not each element of your array, but rather treated as a variable (which likely does not exist in your scope).

Since you want this comparison to be applied to each individual element of your array, you pass a function, which gets called for every item in your array: This is done in Code B using the Lambda expression: element => element == collision.gameObject.layer, where the current item that is passed to this lambda function is given the name element, and is then compared to collision.gameObject.layer.

In the first case you are attempting to evaluate an expression, then pass the result as an argument to the function;

SomeFunction(argument1, someValue == someConstant);

In the second case you are defining a function, then passing the function as an argument. All three of these examples are equivalent;

bool MyFunction(ElementType element) {
   return element == someConstant;
}

SomeFunction(argument1, MyFunction);

or

SomeFunction(argument1, (element) => {
   return element == someConstant;
});

or

SomeFunction(argument1, element => element == someConstant);

You have to supply a function predicate as the second parameter to the Array.Exists function because that is how the function is defined, as noted on the function description it expects the following Parameters:

1. array T[] The one-dimensional, zero-based Array to search.

2. match Predicate<T> The Predicate that defines the conditions of the elements to search for.

Returns Boolean true if array contains one or more elements that match the conditions defined by the specified predicate; otherwise, false.

Now if you only want to supply the matching element in the array and check if it is found within the array, you can use the Linq function Contains.

your code would be refactored to:

if (!layers.Contains(collision.gameObject.layer))
{
    doStuff();
}