why does even statement with a value get stuffed into the output p

i don't have powershell on this computer so my syntax maybe off a little. But 
i'll explain what is going on

anything that is returned from a function, or an expression gets put into 
the pipeline.. so if you run

1..10
"hello"

  , you'll get an array of 10 integers and a string.

being a shell, and wanting the user to be able to do thinks quickly they 
didn't want to have to explicting do write-object...
but what is happening with your situation is that arraylist.add method (if 
you look it up in the dotnet framework help) returns a value.. (the index in 
the arraylist if i am not mistaken.. so powershell is adding this to the 
pipeline.. you can CONSUME that result so that powershell doesn't add it to t 
he pipeline in a number of ways

the first would be to put it into a variable

$local:dummy =  $list.add(20)

however that is not so elegant.. there is an easier way and that it to 
typecast the result as void, and i think this is the syntax

[void]$list.add(20)

also i don't think the return keyword is needed (but i could be wrong.. you 
could write this function like this:

function foo 
{ 
$list = new-object Collections.ArrayList 
[void]$list.add(10) 
[void]$list.add(20) 
$list 
} 

hope that helps.
-------
Karl Prosser
maker of powershell analyzer
 http://www.**--****.com/ 

I realize this is how it is, but I don't think this is how it should be. 
It seems that the majority of statements in a function are not intended 
to be pushed into the pipeline. This means that the majority of 
statements need to be redirected for the sake of the few (usually one) 
that I actually want pushed into the pipeline.

There was a long discussion about this during the earlier betas. If i 
remember correctly one of the suggestions was to use two keywords, something 
like "function" and "scriptlet" etc. where former would not automatically 
emit anything to the pipeline, and latter would just like function does now. 
Since PS v1 is so close of beeing done, i think we'll have to live with the 
current situation.

One way to easily discard any pipeline output without adding [void] etc to 
every line producing unwanted output is to use something like this:

function foo {
  $list = new-object Collections.ArrayList
  &{
    $list.add(10)
    $list.add(20)
  } | out-null
  $list
}

A few of us where actually brainstorming just such a concept a few weeks 
ago.  There are pros and cons to the idea but please file a feature request 
for this.

BTW - you might ask, "if you where thinking about doing it, why do I need to 
file a feature request?".  The answer is that we put potential features into 
different buckets depending upon where they came from.  Features requested 
from users are (as a general rule) in a higher priority bucket.

-- 
Jeffrey Snover [MSFT]
Windows PowerShell/Aspen Architect
Microsoft Corporation
This posting is provided "AS IS" with no warranties, no confers rights.
Visit the Windows PowerShell Team blog at: 
 http://www.**--****.com/ 
Visit the Windows PowerShell ScriptCenter at: 
 http://www.**--****.com/ 

Okay, I did. Thanks. :-)

maybe a way to do with, would be a keyword with a scope, and everything 
within that scope gets consumed (not returned, or put into the pipeline) 
unless explicitly told to?
I choose the void keyword just an example, but beign a keyword it would be 
included in base documentation, and peoples books etc.. and their is 
consistency with the typecast [void]

what do you think
i.e
function foo
{
 void {
   $list = new-object Collections.ArrayList
   $list.add(10)
   $list.add(20)
   return $list
  }
}

Perhaps this could be done as a "void" function that takes a script block...

function void([scriptblock]$block)
{
   &$block | out-null
}

function foo
{
   $local:list = new-object Collections.ArrayList
   void {
     $list.add(10)
     $list.add(20)
   }
   return $list
}


This works, but it's not much of an improvement over:

function foo
{
   $local:list = new-object Collections.ArrayList
   $list.add(10) | out-null
   $list.add(20) | out-null
   return $list
}

or

function foo
{
   $local:list = new-object Collections.ArrayList
   ($list.add(10); $list.add(20)) | out-null
   return $list
}


But it's a neat idea. :-)

> function void([scriptblock]$block)

That IS a neat idea.

-- 
Jeffrey Snover [MSFT]
Windows PowerShell/Aspen Architect
Microsoft Corporation
This posting is provided "AS IS" with no warranties, no confers rights.
Visit the Windows PowerShell Team blog at: 
 http://www.**--****.com/ 
Visit the Windows PowerShell ScriptCenter at: 
 http://www.**--****.com/