Consider a function with several optional parameters. E.g.:

```VBA
Function foo(Optional a, Optional b, Optional c, Optional d)

```

If I want to call the specific function only with the arguments are not null, or some other test, (because the function raises an error otherwise, **unless the argument is missing**). 

An example would be the Collection class. There are 3 optional parameters to the Add method. Many custom classes wrap this class - such as to create an indexable class Persons of a 'Person' custom class or something like that. A wrapper has to deal with 6 combinations: adding a Key only, adding a Key and specifying Before, adding a Key and specifying After, not adding a Key and specifying Before, not adding a Key and specifying After, no Key and no Before/After. It would get even worse if writing a wrapper to something like Workbook.Save that has a dozen Optional parameters.

I am not aware of an alternative to some tedious construct like:

```VBA
If a <> Null Then
    If b <> Null Then
        If c <> Null Then
            If d <> Null Then
                foo a, b, c, d
            Else
                foo a, b, c
            End If
        Else
            If d <> Null Then
                foo a, b, d
            Else
                foo a, b
            End If
        End If
    Else
    '... Etc ...

```

Clearly the number of nested Ifs and general code overhead roughly doubles for each additional optional variable.

In .NET there is the type System.Type.Missing that can be passed in, allowing the expression to be a lot more simple.

Like in C# it can be as clean as:

```C#.NET
foo(a ?? Missing, b ?? Missing, c ?? Missing, d ?? Missing);

```

(this says 'if a is null then pass in Missing (or perhaps behind the scenes it refactors the call itself), a call equivalent to not passing in anything for the optional argument a, and etc)

And if it were implemented, an equivalent could be in VBA using in-line iff ('IIF(boolean, true, false)')

Is there a workaround for VBA that I am missing?