Javier suggested that indentation was the way to go, so that's now allowed for
blocks that trail in a command, which is quite a common idiom.

Constraint: You can nest blocks in indentations, but you can't nest
indentations in blocks.

The "<!--@@" thing used by Kanzaki is a really cool documentation idiom and
sort of illustrative of what "%" does.

I'm using "%" also as a prefix now, so there are three spaces. There's the user
space, $, the program space, @, and the library space. Bare variables access
the user space and the program space in that order. You can only access the
library space by using the % prefix.

Hopefully that isn't too confusing with the documentation idiom.

Using ":" as a prefix was dampened by its use as an accessor, i.e. getitem.

There could be a truth method on objects that gets called by if and not etc.

There's more precedent behind using "@" as a kind of documentation operator,
but it looks kinda ugly really: 

#!/usr/bin/env pluvo

@ test.pvo - Some Test Code
Author: Sean B. Palmer, inamidst.com

main = (argv)
   @ "This is the main function"
   say "Hello, world!"

script main

Actually, hmm. It's not too bad really. And I would suspect that %var will be
used a lot more than @var. Note also that library modules can be callable,
which is rather neat, so you can have %average be the mean average, then
%average.mode being the modal average, etc.

Medial # will be allowed, so # is an operator.

Actually, I still prefer % as the docop, so perhaps @ could be the library
sigil? Also, rather than % "doc" I'd prefer %% doc, which really does bring it
in line with Kanzaki's idea.

#!/usr/bin/env pluvo

% test.pvo - Some Test Code
Author: Sean B. Palmer, inamidst.com

main = (argv)
   %% This is the main function
   say "Hello, world!"

script main

Much better. The use of a double % also makes it a bit less confusing with the
library sigil, which is a nice benefit.

%opt.interpolate = false

Hmm, what about user module space? I guess that can be like Python and just
share the % space, though that'll be a bit of a pain since I want to make that
space quite flat. Well, %lines could always be available at %pluvo.lines or
something like that.

Oh rats, that'd be why Python has import: because the search path is expensive
to query when it contains arbitrary directories to search through for modules.
The way around it would be to have Pluvo library functions take precedent and
be compiled into a DB list somewhere, but then that'd make it rather difficult
to use your own modules. You'd have to do, perhaps, %my.lines.

!cat test.txt
| !wc -l

%sys.cat "test.txt"
| %sys.wc "-l"

Hmm.

for (line) {! cat test.txt | wc -l}
   out line

pipe "cat test.txt | wc -l"
   out line

| "cat test.txt | wc -l"
   out line

"cat test.txt | wc -l" | { out line }

"cat test.txt | wc -l" | 
   out line

Something like "| 2" for stderr or whatever.

"cat test.txt | wc -l" | { add result line }
say { "" join result }

"cat test.txt | wc -l" | testlen
out testlen

Oh, Kanzaki's thing uses ** and @, not @@. Here it is: 

http://www.kanzaki.com/parts/xsltdoc.xsl

I tried using ( and ) for { and } for a while, but it looked kinda weird with
the parens floating around rather than being bunched up as they are in Lisp,
and it made it look rather like Lisp too whereas I think it's probably closer
to the brackety languages.

$ ./pluvo.py examples/grep.pvo --test
grep check: pass

$ ./pluvo.py examples/grep.pvo --help
grep.pvo [options] pattern filenames+
-h/--help  Display a help message
-t/--test  Perform builtin code tests

$ ./pluvo.py examples/grep.pvo       
grep.pvo [options] pattern filenames+
-h/--help  Display a help message
-t/--test  Perform builtin code tests

$ ./pluvo.py examples/grep.pvo p
Error: Did not satisfy the argument specification
grep.pvo [options] pattern filenames+

$ ./pluvo.py examples/grep.pvo pat examples/grep.pvo 
   "grep.pvo [options] pattern filenames+"
grep = (filenames pattern)
   %% Grep through filenames for pattern
      if {/$pattern/ line} { out line }
   grep {args.filenames} {args.pattern}

   for (line) {%lines filenames}
      if {/$pattern/ line} { out line }

-> 

   for (line) {%lines filenames}
      /$pattern/ line { out line }

Fun how Symbols can act like :names in Ruby.

@@ Extensions like (:: in ::) XQuery?
Cf. http://lists.w3.org/Archives/Public/public-qt-comments/2003Sep/0059
Cf. MAN vs. OPT in http://www.w3.org/DesignIssues/Mandatory

-- 
Sean B. Palmer, inamidst.com