How to end a program in an unix shell?

PowerShell is superficially similar to Unix shells. PowerShell has aliases for many of the commands you are used to in Unix, like ls, rm, cp, mv, etc. However, the way that the cmdlets behind the aliases work is quite different.

In a *nix shell, everything is text based, so output from one command can be piped to another, but the receiving program must know how to parse/interpret the text from the pipeline. This is the main difference between PowerShell and *nix shells... in PowerShell, everything that gets passed around is an object.

The consequence of this is that piping from one command to another is not just piping stdout to stdin. It's piping a full-fledged .net object to the receiver. Therefore, the receiver just needs to know how to handle an object of that type. It doesn't need to implement any parsing of text, but it needs to understand how to call methods and properties (members) of the input object.

In a *nix command line program, you would write code that reads from stdin and parses its information from the text another program generated. In PowerShell, you would do something like this:

function changeName($myObject)
{
    if ($myObject.GetType() -eq [MyType])
    {
        #print the current name to screen
        $myObject.Name
        #change string in the 'name' property
        $myObject.Name = "NewName"
    }
    return $myObject
}

Calling this code on the command line might look like:

PS> $myObject = New-Object MyType -arg "OriginalName"
PS> $myObject = changeName $myNewObject
OriginalName
PS> $myObject.Name
NewName

You could also do the same as above using the piping mechanism, but you can see the major difference here in that we're passing an object and not text:

PS> $myObject = New-Object MyType -arg "OriginalName" | changeName
OriginalName
PS> $myObject.Name
NewName

Forgetting this major difference, I would say there are other superficial similarities, but mostly just syntactically. PowerShell syntax seems to have been designed with the *nix shell users in mind, so a lot of the language style is similar.

There's a Scheme Shell that's probably very close to what you're looking for. I haven't used it myself.

UPDATE :

I just installed and tried it myself. It appears that scsh is more of an interactive Scheme interpreter and scripting language than a really useful interactive shell. You can't just type

echo hello

the syntax appears to be

(run (echo hello))

and it took several minutes of Googling just to find that. The first example here is:

gunzip < paper.tex.gz | detex | spell | lpr -Ppulp &

which translates to:

(& (| (gunzip) (detex) (spell) (lpr -Ppulp)) (< paper.tex.gz))

but that doesn't tell you how to run a simple shell command.

This FAQ entry says:

4.6 Can I use scsh as an interactive shell?

Well, technically you can: just run the "scsh" command and you will enter a Scheme 48 session with all scsh functions available. However, this is definitely not suitable for interactive work: there is no command-line editing, no command-line history, no file/function name completion, no terse syntax, etc.

To alleviate these problems, Martin Gasbichler and Eric Knauel have written Commander S, which runs on top of scsh and provides a comfortable interactive environment. One of its novel features is that it can understand the output of many Unix commands, and allows the user to browse and manipulate it in useful ways. More information about Commander S can be found in the paper describing it: http://www.deinprogramm.de/scheme-2005/05-knauel/05-knauel.pdf Instructions about how to obtain and install Commander S are available from the scsh Web site: http://www.scsh.net/resources/commander-s.html

So maybe that's the real answer.