Two important paradigms: 

1) Turning lots of args into a single block
2) The quoting thing

Stuff like a coordinate builtin would be great. That should probably go in a
kind of language module, e.g. @pluvo.coordinate or @lang.coordinate; most
likely the former given the yucky connotations of the latter.

Flags were really easy to implement trivially, though "not" and "or" were a
little bit harder. That Flag is a callable datatype may pose a bit of a problem
when I want to pass it as an arg to something that doesn't handle it. And what
about Pluvo functions that want to handle builtin functions etc.?

So the factorial program as it stands is: 

factorial = (n) { 
   n = { run n }
   if {n == 0} { return 1 }
   n * { factorial { n - 1 } }
}

Which should become: 

factorial = (n) { 
   if {n == 0} { return 1 }
   n * { factorial { n - 1 } }
}

But is there an easy way to get it so that 

   factorial n - 1

is valid? It'd require something like: 

factorial = (args*) { 
   if {{args.length} == 1} {
      n = {args:1}
   } else { n = { run {block args} } }

   if {n == 0} { return 1 }
   n * { factorial { n - 1 } }
}

Which it would be nice to derive, decorator-like.

Speaking of decorators, I'll probably use decorators to expand block arguments
to builtin functions, so it shows the approach. In fact, that could be a way of
not expanding in Pluvo functions...

Should start thinking about the strict typing syntax. I think type as a builtin
name is probably the way to go, sadly.

   example = (arg {arg type MyType}) { ... }

or just: 

   example = (arg {type MyType}) { ... }

This means that the block syntax for quoting will have to be
block-first-command length dependent, which is kinda silly.

Also, how about when setting variables?

   var = {arg type MyType} instanceOfMyType

Obviously, it'd be nice to say: 

   var = MyType instanceOfMyType

So that could be possible. But the conditional with $arg will have to be around
anyway to open up the possibility of strict duck typing.

So, current syntax is: 

var = object
var = (argspec) {block}

This'll add stuff like: 

var = {block} object
var = object object

Which is starting to limit options for future stuff quite a bit. Technically
that latter will be var = prototype object, but since there's nothing really to
distinguish a prototype from a closure... And what if we want to strict type a
function?

var = {block} (argspec) {block}

Perhaps? But then what about decorator syntax?

var = {block} (argspec) object {block}

It gets kinda crazy. There could always be a completely different syntax for
this sort of thing, of course. Oh, and there's the instantiation syntax for
prototypes: 

var = object (args)

Which I rather like, given its naturalness. Strict typing could also be
blessed, a la Perl with object orientation.

* * *

String parsing, for the \U+203D stuff, is expensive as per afon: use C
extensions for that? There needs to be a similar thing for regexen. Speaking of
those, regular expression extensibility has to be considered given the grammars
of Perl6.

Though proto can be tested with has_key, variables should just be looked up in
try/except since they're most likely to be available.

The continuing grep story: 

#!/usr/bin/env pluvo

% grep.lu - Grep Some Files
Author: Sean B. Palmer, inamidst.com

usage { 
   "grep.lu [options] <pattern> <filenames>"
   -h/--help  "Display a help message"
   -t/--test  "Perform builtin code tests"
}

grep = (filenames pattern) { 
   % "Grep through filenames for pattern"
   example { 
      grep(("tag:pluvo.org,2006:doc") "pqr")
      => "1. pqrst" 
   }

   for (line) {@file.lines filenames} {
      if {/$pattern/ line} { out line }
   }
}

main = (argv) {
   --help or {argv < 3} { help }
   --test { check grep; quit }
   grep {@args:2:} {@args:1}
}

script main

Or perhaps the usage section should be more automagical...

#!/usr/bin/env pluvo

% grep.lu - Grep Some Files
Author: Sean B. Palmer, inamidst.com

usage { 
   "grep.lu [options] <pattern> <filenames>*"
   -h/--help  "Display a help message"
   -t/--test  "Perform builtin code tests"
}

grep = (filenames pattern) { 
   % "Grep through filenames for pattern"
   example { 
      grep(("tag:pluvo.org,2006:doc") "pqr")
      => "1. pqrst" 
   }

   for (line) {@file.lines filenames} {
      if {/$pattern/ line} { out line }
   }
}

main = (argv) {
   --help or {argv < 3} { help }
   --test { check grep; quit }
   grep {@args.pattern} {@args.filenames}
}

script main

The args could still be in the actual @args list-table.

-- 
Sean B. Palmer, inamidst.com