Can you combine CmdletBinding with unbound parameters?

Question

(Powershell 5)
I have the following coalesce function:

(UPDATE: Removed the "optimized" continue call in the process block.)

function Find-Defined {
    begin   { 
        $ans  = $NULL;
        $Test = { $_ -ne $NULL };
    }
    process { 
        if ( $ans -eq $NULL ) {
            $ans = $_ |? $Test | Select -First 1;
        }
    }
    end     {
        if ( $ans -ne $NULL ) { 
            return $ans;
        }
        else {
            $Args `
                |% { if ( $_ -is [Array] ) { $_ |% { $_ } } else { $_ } } `
                |? $Test `
                | Select -First 1 `
                | Write-Output `
                ;
        }
    }
}

And this works plenty well for me, on command lines like the following:

$NULL, $NULL, 'Legit', 1, 4 | Find-Defined;

$NULL, $NULL | Find-Defined $NULL, @( $NULL, 'Value' ), 3;

$NULL, $NULL | Find-Defined $NULL $NULL 3 4;

You may notice that I encapsulated the decision logic in a ScriptBlock variable. This was because I wanted to parameterize it and I started out trying this.

[CmdletBinding()]param( [ScriptBlock] $Test = { $_ -ne $NULL } );

However, the minute I added CmdletBinding I started to get errors. The binding wanted to try to cast everything in the argument section as a ScriptBlock, so I added

[CmdletBinding(PositionalBinding=$False)]

And then it complained that the unbound arguments couldn't be bound, and so I added:

param( [parameter(Mandatory=$False,Position=0,ValueFromRemainingArguments=$True)][Object[]] $Arguments ...

And whatever I did afterwards added a new error. If I removed the $Test parameter, just localizing it to see what I could do, then I started getting the error I had when developing the first generation:

The input object cannot be bound to any parameters for the command either 
because the command does not take pipeline input or the input and its 
properties do not match any of the parameters that take pipeline input.

... even though I had a process block.

In the end simply removing the param statement, put it back to its flexible function that I liked.

I still would like to broaden this function to accept both a ScriptBlock test and unbound parameters (as well as Common parameters like -Verbose, if that's possible). That way I could have a general algorithm for string coalescing as well:

$Test = { -not [string]::IsNullOrEmpty( [string]$_ ) };
$NULL,$NULL,'','' | Find-Defined -Test $Test $NULL,'','This should be it' 'Not seen'

Am I missing something?

Answer 1

I believe this solve the problem you are trying to solve, but with a bit of a different implementation. When using CmdletBinding everything must be declared. So you need one parameter for the pipeline input and one for the "unbound" parameters.

Based on you question I wrote these test cases:

Describe 'Find-Defined' {
  it 'should retun Legit' {
    $NULL, $NULL, 'Legit', 1, 4 | Find-Defined | should be 'Legit'
  }
  it 'should retun Value' {
    $NULL, $NULL | Find-Defined  $NULL, @( $NULL, 'Value' ), 3 | should be 'Value'
  }
  it 'should retun 3' {
    $NULL, $NULL | Find-Defined $NULL $NULL 3 4 | should be '3'
  }
  it 'Should return "This should be it"' {
    $Test = { -not [string]::IsNullOrEmpty( [string]$_ ) };
    $NULL,$NULL,'','' | Find-Defined -Test $Test $NULL,'','This should be it' 'Not seen'  | should be 'This should be it'
  }
}

Here is my solution, which passes all of the above cases.

function Find-Defined {
  [CmdletBinding()]
  param (
    [ScriptBlock] $Test = { $NULL -ne $_},
    [parameter(Mandatory=$False,ValueFromPipeline =$true)]
    [Object[]] $InputObject,
    [parameter(Mandatory=$False,Position=0,ValueFromRemainingArguments=$True)]
    [Object[]] $Arguments
  )

    begin   { 
        $ans  = $NULL;

        function Get-Value {
          [CmdletBinding()]
          param (
            [ScriptBlock] $Test = { $_ -ne $NULL },
            [parameter(Mandatory=$False,Position=0,ValueFromRemainingArguments=$True)]
            [Object[]] $Arguments,
            $ans = $NULL
          )
          $returnValue = $ans
          if($null -eq $returnValue)
          {
            foreach($Argument in $Arguments)
            {
              if($Argument -is [object[]])
              {
                $returnValue = Get-Value -Test $Test -Arguments $Argument -ans $returnValue
              }
              else
              {
                if ( $returnValue -eq $NULL ) {
                    $returnValue = $Argument |Where-Object $Test | Select-Object -First 1;
                    if($null -ne $returnValue)
                    {
                      return $returnValue
                    }
                }
              }
            }
          }
          return $returnValue
        }
    }
    process { 
        $ans = Get-Value -Test $Test -Arguments $InputObject -ans $ans
    }
    end     {
        $ans = Get-Value -Test $Test -Arguments $Arguments -ans $ans

        if ( $ans -ne $NULL ) { 
            return $ans;
        }
    }
}