[svn:perl6-synopsis] r9253 - doc/trunk/design/syn

2006-05-14 Thread larry 
Author: larry
Date: Sun May 14 10:39:58 2006
New Revision: 9253

Modified:
   doc/trunk/design/syn/S02.pod
   doc/trunk/design/syn/S06.pod

Log:
Got rid of default @@_ array and postfix ==>.
May now pipe to * multiple times.
Pipe batches sent to * are received with *** now.
(*** also specifies receiver location for current pointy end.)


Modified: doc/trunk/design/syn/S02.pod
==
--- doc/trunk/design/syn/S02.pod(original)
+++ doc/trunk/design/syn/S02.podSun May 14 10:39:58 2006
@@ -12,9 +12,9 @@
 
   Maintainer: Larry Wall <[EMAIL PROTECTED]>
   Date: 10 Aug 2004
-  Last Modified: 12 May 2006
+  Last Modified: 14 May 2006
   Number: 2
-  Version: 40
+  Version: 41
 
 This document summarizes Apocalypse 2, which covers small-scale
 lexical items and typological issues.  (These Synopses also contain
@@ -506,6 +506,12 @@
 is effectively immutable, the optimizer is free to recognize C<*>
 and optimize in the context of what operator it is being passed to.
 
+A variant of C<*> is the C<**> term.  It is generally understood to
+be a multidimension form of C<*> when that makes sense.
+
+The C<***> variant serves as the insertion point of a list of pipes.
+That insertion point may be targeted by piping to C<*>.  See S06.
+
 Other uses for C<*> will doubtless suggest themselves over time.  These
 can be given meaning via the MMD system, if not the compiler.  In general
 a C should be interpreted as maximizing the degrees of freedom

Modified: doc/trunk/design/syn/S06.pod
==
--- doc/trunk/design/syn/S06.pod(original)
+++ doc/trunk/design/syn/S06.podSun May 14 10:39:58 2006
@@ -13,9 +13,9 @@
 
   Maintainer: Larry Wall <[EMAIL PROTECTED]>
   Date: 21 Mar 2003
-  Last Modified: 13 May 2006
+  Last Modified: 14 May 2006
   Number: 6
-  Version: 34
+  Version: 35
 
 
 This document summarizes Apocalypse 6, which covers subroutines and the
@@ -860,6 +860,25 @@
 operation, it must be something else that can be interpreted as a
 list receiver.
 
+Any list operator is considered a variadic operation, so ordinarily
+a list operator adds any piped input to the end of its list.
+But sometimes you want to interpolate elsewhere, so the C<***> term
+may be used to indicating the target of a pipe without the use of a
+temporary array:
+
+foo() ==> say ***, " is what I meant";
+bar() ==> ***.baz();
+
+Piping to the C<*> "whatever" term is considered a pipe to the lexically
+following C<***> term:
+
+0..*   ==> *;
+'a'..* ==> *;
+pidigits() ==> *;
+
+# outputs "(0, 'a', 3)\n"...
+for zip(***) { .perl.say }
+
 You may use a variable (or variable declaration) as a receiver, in
 which case the list value is bound as the "todo" of the variable.
 Do not think of it as an assignment, nor as an ordinary binding.
@@ -979,19 +998,8 @@
 In particular, you can use C<@@foo> to interpolate a multidimensional slice
 in an array or hash subscript.
 
-Every lexical scope can use its own implicitly declared C<@_> variable
-as the default receiver.  So instead of using C<@@foo> above you can
-just say
-
-0..*   ==> ;
-'a'..* ==> ;
-pidigits() ==> ;
-
-# outputs "(0, 'a', 3)\n"...
-for zip(@@_) { .perl.say }
-
-If C<@@_> is currently empty, then C would act on a
-zero-dimensional slice (i.e. C), and output nothing
+If C<@@foo> is currently empty, then C acts on a
+zero-dimensional slice (i.e. C), and outputs nothing
 at all.
 
 Note that with the current definition, the order of pipes is preserved
@@ -999,14 +1007,14 @@
 
 So
 
-('a'..*; 0..*) ==> ;
- for zip(@@_ <== @foo) -> [$a, $i, $x] { ...}
+('a'..*; 0..*) ==> *;
+ for zip(*** <== @foo) -> [$a, $i, $x] { ...}
 
 is the same as
 
-'a'..* ==> ;
- 0..*  ==> ;
- for zip(@@_ <== @foo) -> [$a, $i, $x] { ...}
+'a'..* ==> *;
+ 0..*  ==> *;
+ for zip(*** <== @foo) -> [$a, $i, $x] { ...}
 
 which is the same as
 
@@ -1014,14 +1022,14 @@
 
 And
 
-@foo ==> ;
-0..* ==> ;
-for each(@@_) -> $x, $i { ...}
+@foo ==> *;
+0..* ==> *;
+for each(***) -> $x, $i { ...}
 
 is the same as
 
-0..* ==> ;
-for each(@foo; @@_) -> $x, $i { ...}
+0..* ==> *;
+for each(@foo; ***) -> $x, $i { ...}
 
 which is the same as

Parrot 0.4.4 "Feather" Released!

2006-05-14 Thread Leopold Toetsch 

On behalf of the Parrot team I'm proud to announce another
monthly release of Parrot.

I'd like to thank all involved people as well as our
sponsors for supporting us.

What is Parrot?

Parrot is a virtual machine aimed at running Perl6 and other dynamic
languages, see  for more information.

Parrot 0.4.4 changes and news

- hierarchical class names
- APL compiler
  - under development
  - understands simple vector ops, strings
  - demonstrates use of Unicode in Parrot
- pgc, a compiler for rules and operator precedence parsers
- Major redesign and improvements for PGE
  - compilers understand named parameter options
  - :ratchet option implemented to support non-backtracking quantifiers
- TGE (tree grammar engine) for tree transformations
  - tgc, tree grammar compiler
- perl6 compiler
  - support for many operators, lexical scalars, regex matches
- new pheme (Parrot scheme) compiler

After some pause you can grab it from
.

As parrot is still in steady development we recommend that you
just get the latest and best from SVN by following the directions at


Turn your web browser towards  for more
information about Parrot, get involved, and:

Have fun!
leo

Perl 6 User FAQ (perl.perl6.meta) -- Version: 2006-05-13 (beta 2)

2006-05-14 Thread Conrad Schneiker 

This note is crossposted to perl.perl6.language; please include
perl.perl6.meta on replies.]

Feedback on the draft FAQ below will be appreciated. TIA.

Anyone have a contact at Google they can ping about getting
Google Groups to start picking up comp.perl6.meta?

= Perl 6 User FAQ (perl.perl6.meta) ==

  Version: 2006-05-14 (beta 2)

TABLE OF CONTENTS

* About perl.perl6.meta (and this FAQ)
* About Perl 6  # True marketing hype, in both senses. :-)
* General Perl 6 status # On the move!
* Latest Perl 6 developments
* Perl 6 info and docs  # For the few that will RTFM first. :-)
* Where to get Perl 6   # <- "I want it now!!" <-
* Useful Perl 6 modules
* Perl 6 features in the latest Perl 5
* Perl 5 modules implementing Perl 6 features
* Incremental migration from Perl 5 to Perl 6
* Other useful resources
* How you can help out with Perl 6
* Glossary
* Copyright, license, and disclosure

=== About perl.perl6.meta (and this FAQ) ===

(Newbie warning! Perl 6 is still UNDER CONSTRUCTION. Don't make 
important plans that depend on it just yet. Please see other sections 
below about intermediate Perl 6-related solutions you can use now.)


A major aim of this newsgroup (NG) is to help out early-adapters of
Perl 6 (including early learners and early test drivers). This is a
forum for seeking and sharing the latest general news and information
about *using* (versus creating) Perl 6. (Presently, the other Perl 6
NGs are primarily for developers *of* Perl 6, versus for Perl 6
developers.) However, the time for sharing the -Ofun more widely has
arrived. Some enterprising folks are already using *pieces* of the
emerging Perl 6 infrastructure for $work. Parts of Perl 6 are being
implemented in Perl 5 (some internally, some as modules).  Wider
experimentation with Perl 6 will help test out the emerging collection 
of docs, and help determine practical priorities for improvements.


Suggested additional content (preferably including the content, or
links to it) and corrections for this FAQ are always welcome. Please
post them to perl.perl6.meta with the subject line "FAQ feedback".

Think of this NG as the prototype for the future comp.lang.perl6.misc
NG. When traffic warrants it, we'll apply for official Usenet "big 8"
comp.* status.

You can access this NG several ways:

* Point your newsreader to (nntp.perl.org). Need a decent Windows
  newsreader? (http://www.mozilla.com/thunderbird/) works for me.
* Some time soon, you should also be able to find us on Google Groups.
* Subject lines of NG posts with link to each post can be found at
  this archive: (http://www.nntp.perl.org/group/perl.perl6.meta).
* Here's the RSS feed:
  (http://www.nntp.perl.org/rss/perl.perl6.meta.rdf).

<>

=== About Perl 6 ===

What is Perl 6? Perl 6 is an extensively refactored, super-modernized,
and ultra-supercharged derivative of Perl 5. Simple things will still
be simple to do, but you'll have enormously more "programming
leverage" available for tackling challenging tasks. Here is a good
introductory article on why Perl 6 is needed, and what it is:
(http://www.perl.com/pub/a/2006/01/12/what_is_perl_6.html).

When it comes to embracing "embrace and extend", Perl 6 is
exceptionally promiscuous: Perl 6 has (selectively) borrowed widely
from our many friends, including Ruby, Python, Smalltalk, Lisp,
Haskell, and others. Here is a brief summary of some notable Perl 6
features, starting from the list in
(http://dev.perl.org/perl6/faq.html), plus a variety of additions and
extensions:

* optional explicit strong typing
* proper parameter lists
* active metadata on values, variables, subroutines, and types
* declarative classes with strong encapsulation
* full OO exception handling
* support for the concurrent use of multiple versions of a module
* extensive and powerful introspection facilities (including of POD)
* LL and LR grammars (including a built-in grammar for Perl 6 itself)
* subroutine overloading
* multiple dispatch (multimethods)
* named arguments
* a built-in switch statement
* hierarchical construction and destruction
* distributive method dispatch
* method delegation
* named regexes
* overlapping and exhaustive regex matches within a string
* named captures
* parse-tree pruning
* incremental regex matching against input streams
* macros (that are implemented in Perl itself)
* full Unicode processing support
* user-definable operators (from the full Unicode set)
* chained comparisons
* a universally accessible aliasing mechanism
* lexical exporting (via a cleaner, declarative syntax)
* multimorphic equality tests
* state variables
* hypothetical variables
* hyperoperators (i.e. vector processing)
* function currying
* junctions (i.e. superpositional values, subroutines, and types)
* coroutines
* better threading
* better garbage collection
* much better foreign function interface (cross-language support)
* invariant sigils, plus twigils (minimalist symbolic "Hungarian")
* many widely usefu