something = Number 6
something = "lalala"
-> error

Equals: 

   name = object
   name = argspec block
   name = proto args

something = { arg @hasattr "test" } thing
            ^ weak
rover = Dog("Rover")
        ^ strong
number = Number 6
         ^ python

For Python object construction: 

set = { 1, 2, 3 }
test = { Test "1" "2" "3" }

So, say MyTable is a subproto of the python Table, and...

t = MyTable("Test")

ah: 

t = MyTable MyTable("Test")

For function importions: 

script main
else default

   name = object (assign)
   name = argspec block (create function)
   name = proto args (instantiate proto)
   name = block object (type object)
   name = py object (type object)
   name = proto proto args (type and instantiate proto)

. normally doesn't work over : because everything should have variables set.

#!/usr/bin/env pluvo

* grep.pvo - Search Files for Pattern
Author: Sean B. Palmer, inamidst.com

usage
   "grep.pvo [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) {@lines filenames}
      /$pattern/ line { out line }

You should be able to set operators, so...

++ = mytwoplus

Shame that method ++ (args) { ... } won't work. Well, it'll "work", but then
try using ++ inside the block... You'd have to use @++ or something.

Hmm...

Thing = (arg)
   method "++" (args)
      ...

Not so bad. Not sure what its actual effect should be though. Perhaps set
Thing["operators"]["++"] = themethod.

Thing = (arg)
   method {Operator "++"} (args)
      ...

Thing = (arg)
   method Operator "++" (args)
      ...

Thing = (arg)
   opmethod ++ (args)
      ...

Thing = (arg)
   methop ++ (args)
      ...

method "++" still seems best. Then the question is how to refer to the methop,
e.g. to pass it around. You can easily call it by just doing: 

   obj = { Thing ++ }

But that calls it, whereas you might just want the block. Obviously there
should be some mechanism anyway to access the special variables, but that would
probably be too messy for this.

Hmm...

{@special Thing}:"operators":"++"

@op Thing "++"

p = { Thing @op ++ }

Perhaps have @args be an Object instance (from which everything should derive),
and then set its variables, so that {args.filenames} will work.

Examples release names: 

   Zoophagous Armadillo
   Articlated Bear
   Chromatic Donkey

How to do yield? It'd have to give a suspend command response, but the point in
the code would have to be marked. Quite a panoply of command statements...

(implicit return), return, provide, break, continue, quit, yield...

I was wondering about a specific Generator or Continuation proto that could be
derived from. Not even sure about the derivation syntax yet, though, especially
given the proposed typing syntax.

Dog = (name) Animal
   ...

Or, heh, even...

@kind Animal
Dog = (name)
   ...

Anyway, this'd mean that generators would have to be called with Table
arguments rather than usual arguments.

@proto Animal
Dog = (name)
   ...

Dog = (name)
   @proto Animal
   ...

Hmm, since # can be used as an operator... Oh wait, actually, it can't since
it'll create a comment in midline too. Shame, 'cause it'd be nice to do
something like # and % in Bash. Could always use ^ and $ I suppose: 

filename = "test.txt"
say { filename $ ".txt" }

Pretty good syntax, really.

-- 
Sean B. Palmer, inamidst.com