= Changes for 6.2.13 (r14402) - October 17, 2006

== Build System

* Perl 5 embedding is now enabled by default
** For Windows users, Perl 5.8.x is required
** Set the `PUGS_EMBED` environment variable to `noperl5` to disable this

* Prompting for Parrot embedding is now disabled by default
** Set the `PUGS_EMBED` environment variable to `parrot` to enable this

* Support for compiling using GHC 6.6
** GHC 6.4.1+ is still supported, but 6.6 will be required in the next release

== Feature Changes

=== Interactive Shell and Command-Line Flags

* New `pugs -d` flag to display a trace for debugging
* The `:r` command now resets the environment once, not twice
* The return value of blocks, such as `gather {...}`, is displayed correctly
* `$_` is no longer clobbered with the result of each expression's evaluation

=== Perl 5 Interoperability

* Arrays and Hashes now round-trip from Pugs to Perl 5 land and back
* Importing functions from Perl 5: `use perl5:CGI <header param>`
* Passing unboxed values across runtimes no longer leaks memory
* When embedding Perl 5.8+, Unicode flag is now on for Pugs-to-Perl5 strings
* `eval($str, :lang<perl5>)` now accepts non-ASCII characters in `$str`

=== Lexical Syntax

* Capture literals: `\($bar: 1, 2, 3, named => 4)`
* Here-docs now work as specced; also warns against inconsistent indentation
* Interpolation of chained calls: `"$foo.meth.meth.meth.meth()"`
* List comprehension: `for 0 < list(@x) < 10 {...}`
* Named character escapes: `"\c[LATIN CAPITAL LETTER Y]"`
* New grammatical category `term:`, separated from the `prefix:` category
* New magical variables: `$?COMPILER` and `$?VERSION`
* Parse for `LABEL: STMT`, although it's currently treated the same as `STMT`
* Pod directives: `=begin`/`=end` and `=for` now terminate without `=cut`
* Pod variables: `$=FOO` and `@=FOO` give you access to the Pod section FOO
* Quote adverbs no longer take non-parens brackets: `rx:P5{...}` is valid again
* Shell-like quoting rules implemented for `<< $x "qq" 'q' >>`
* Signature literals: `:($foo is copy = 42, $, @)`
* Support for UTF-8, UTF-16 and UTF-32 encoded source files
* Support for backquotes and `qx/.../` for capturing external command output
* User-defined infix associativity: `sub infix:<foo> is assoc('right') {...}`
* `"\123"` and `"\03"` are now errors; write `"\d123"` and `"\o03"` instead
* `$::x` now means exactly the same a `$x`, instead of `$*x`
* `%h<>` now means `%h{}` -- the entire hash, not the empty string as key
* `($::('x'))` with two adjacent closing parens now parses correctly
* `0_123_456` now parses as `0d123456`, not an error
* `1<2>` is now a fatal error: Odd number of elements in Hash
* `q()` and `qw()` with parentheses are parsed as functions, not quotes

=== Declarators and Operators

* Argument interpolation via prefix `|` and `|<<` 
* Binding to qualified uninitialised symbols: `&fully::qualify := sub {...}`
* Contextual variables are now declared with `my $x is context`, not `env $x`
* Hyperised reduce operators: `[>>+<<]` and `[\>>+<<]`
* Implicit invocation assignment: `.= uc` is parsed as `$_ = $_.uc`
* Mid-block redeclaration no longer allowed: `my $x; { $x = 1; my $x = 2 }`
* Negated comparison operators: `!eqv`, `!=:=` etc; `!~~` replaces `!~`
* New infix comparison operators: `===` and `eqv`
* New infix non-short-circuiting boolean AND operator: `?&`
* Nullary reduction of builtin operators gives identity values: `[*]() === 1`
* Postfix operators can be called with a dot: `.++`, `$x.++`, `$x.\ ++`
* Prefix `=` now iterates on arrays as well: `=@array`
* Short-circuiting chained comparison: `1 > 2 > die('foo')` no longer fails
* Smart matching against code objects: `$obj ~~ { 1 > $_ > 5 }`
* Smart matching against implicit invocation: `$obj ~~ .meth`, `$obj ~~ .[0]`
* Typed constraints on autovivification: `my Hash $x; $x[0] = 1` now fails
* Typed declarations: `my Dog $fido`, `my T ($x, $y)`
* `*` is now always a term, never a prefix operator

=== Blocks and Statements

* Implicit invocation in `when`: `when .true {...}`, `when .<key> {...}`
* Listops in conditions no longer consume the block: `for say {...}`
* Loop topics are not forced into rw: `for 1..3 { $_++ }` now fails correctly
* New `&break` and `&continue` primitives for use within `when` blocks
* New `&leave` primitive for exiting from the innermost block
* New postfix `given` statement modifier: `.say given foo()`
* Support for `FIRST`, `NEXT`, `LAST` loop control blocks
* Support for `START`, `PRE`, `POST`, `KEEP`, `UNDO`, `ENTER`, `LEAVE` blocks
* Support for repeat blocks: `repeat {...} while 1`, `repeat while 1 {...}`
* Support for the `&each` list interleaver: `for each(@a; @b) -> $x, $y {...}`
* The `for` loop no longer double-flattens lists: `for %h.pairs -> $p {...}`
* Topicalisers for `if`, `else`, `while`, `given` blocks: `if EXPR -> $x {...}`
* Topicalisers for postfix `for` loop: `-> $x {...} for 1,2,3`
* `&last` and `&redo` now work in `repeat {...}` and `loop {...}` blocks
* `&take` no longer flattens array literals: `take [1,2,3];`
* `&take` now works in functions called from within a `gather {...}` block
* `BEGIN(...)`, `END(...)`, etc., are now parsed as calls, not syntax errors
* `END {...}` in `.pm` files are no longer ignored when executed directly 
* `INIT {...}` now works correctly inside `eval "..."`
* `do {...}` is now a loop block that takes standard loop controls
* `do {...}` with statement modifiers is explicitly disallowed

=== Regexes and Grammars

* Anonymous tokens and rules anchor on both ends: `123 ~~ token{2}` is false
* New `s[...] = EXPR` and `s[...] = .meth` syntax; `s[...][...]` is deprecated
* New `tr///` syntax for transliteration; `y///` will not be supported
* Pugs::Compiler::Rule (PCR) replaces Parrot/PGE as the default engine
* Support for `:c/:continue`, `<prior>`, and much more: see PCR's ChangeLog
* `$()`, `@()` and `%()` parse correctly as `$$/`, `@$/` and `%$/`
* `/.../` matches `$_` under Int, Num and void context in addition to Bool
* `m:g/(1)|(2)/` now returns only successfully matched subcaptures

=== Modules and Routines

* Allow space-separated adverbial named arguments: `f( :x<foo> :$y :!z )`
* Multi-dispatching now handles named, slurpy and optional arguments
* Multi-dispatching now handles parenthesized expressions as arguments
* Named arguments with no matching parameters is now an error
* New `&c.call($capture)` method to call without a caller frame
  (similar to Perl 5's `goto &sub`, but it returns)
* New `&c.signature` method to get a Signature object from a Code object
* Parse for the `proto` routine modifier: `proto method foo ($x) {...}`
* Precompiled `.pm.yml` files with mismatching AST version will no longer load
* Support for user-defined unary and optional-unary prefix macros
* The main package is now ::Main, not ::main
* `&?CALLER_CONTINUATION` is now fully reentrant
* `&yield` in coroutines works correctly within loop blocks
* `sub ($x = 0 is copy)` no longer allowed; say `sub ($x is copy = 0)` instead
* `sub f ($x is lazy) {...}` no longer evaluates $x more than once
* `sub f (@x?) {...}; f()` now sets `@x` to `[]`, not `[undef]` 

=== Classes and Objects

* Attribute-like method call syntax: `@.method(1)`, `$.method: 2, 3, 4`
* Class attributes: `class C { my $.x is rw }`
* Class name literals are now term macros, not prefix functions
* Compile-time self-mixin no longer allowed: `role A does A`
* Default initialiser expression for attributes: `class C { has $.x = 123 }`
* Dot attributes are now method calls: `@.x` is the same as `@(self.x)`
* Dynamic method calls: `$obj.$meth`
* Hyperised method calls: `$obj.>>meth`
* Quantified method calls: `$obj.*meth`, `$obj.+meth` and `$obj.?meth`
* Reopening classes: `class C is also {...}`
* Role mixins: `role R {...} class C does R {...}`
* `$?SELF` is gone; write `self` instead
* `BUILDALL`/`DESTROYALL` trigger once per class even with diamond inheritance
* `does R` and `is C` statements in class body now evaluate in compile time

=== Built-in Primitives

* New `&HOW`, `&WHAT` and `&WHICH` functions replace `&meta`, `&ref` and `&id`
* New `&VAR` macro to force lvalue evaluation of an expression
* New `&comb` function, a dual to `&split` but matches the wanted parts
* New `&crypt` function to create one-way digest strings
* New `&fork` function to create a new process
* New `&printf` function for formatted printing
* New `&quotemeta` function for escaping strings
* Support for `%b` in formatted printing
* The `&system` function no longer dies when the command does not exist 
* The `.as` method is renamed to `.fmt` for formatted printing 
* The `.perl` method now returns Unicode strings

== Bundled Modules

=== New modules

* [ext/Automata-Cellular/] - Build and render cellular automata in a terminal
* [ext/Math-Basic/] - Basic mathematical functions and constants
* [ext/Math-Random-Kiss/] - Pseudo-random number generator
* [ext/re/] - Pragma to choose among grammar engine backends

=== [ext/CGI/] 

* A new `as_yaml` method to dump CGI parameters as YAML
* Allow initializing the CGI object with a hash of parameters
* New `Dump` function adapted from Perl 5's CGI.pm
* New basic tests for `escapeHTML` and `unescapeHTML`, which were broken
* New tests for `PATH_INFO`
* Only send the Content-Type: header if we actually have a content-type
* Only send the Status: header if it's a redirect, or if it's explicitly added
* Refactored into an OO-only module.  N.B.: this breaks backwards compatibility!
* Some work on charset handling, though a `charset` method is still missing
* The `content_type` method is renamed to `type` for compatibility
* The `cookies` attribute is renamed to `cookie` for compatibility

=== [ext/HTTP-Server-Simple/]

* The old non-standard `./method` syntax has been replaced with `self.method`

=== [ext/Rosetta/]

* Significant updates to the `lib/Rosetta/SeeAlso.pod` documentation

=== [ext/Set-Relation/]

* Renamed from [ext/Relation/]
* Beginning of separate `Set::Tuple` and `Set::Relation` classes

=== [ext/Test/]

* Converted `Test.pm` documentation from Kwid to Pod syntax
* The `eval_ok` and `eval_is` functions are gone; use `is eval` instead,
  which runs its string in the current lexical scope rather than in
  Test's (which is usually what you want)

== Test Suite

=== [util/prove6]

* Can now run only a portion of the test suite, or even a single file
* Original shell script rewritten in Perl 5 for improved portability
* Support for multiple Pugs backends and multiple Perl 6 implementations

=== [util/smartlinks.pl]

* A new visualiser of smartlinks used in the test suite
* Generates much nicer cross-referenced HTML pages
* See annotated specs in action on [http://spec.pugscode.org/]
* Smartlinks replace the old [util/catalog_tests.pl]

=== [util/smokeserv/]

* See the `SYN` links on [http://smoke.pugscode.org/] for this in action
* Smoke client now uploads raw `.yml` results as well as `.html`
* The smokeserver now annotates the spec with test results using smartlinks

=== [t/]

* All tests now begin with `use v6-alpha;` instead of `use v6;`
* Many, many more smartlinks have been added into the spec
* Programs and modules in [examples/] are tested for syntactic correctness
* Tests in [t_disabled/] are merged back into the main test suite
* [t/02-test-pm/] created to ensure that `Test.pm` works as advertised
* [t/blocks/] renamed from [t/subroutines/]
* [t/closure_traits/] created to test closure traits (`FIRST`, `LAST`, etc.)
* `#!/usr/bin/pugs` is gone from all test files
* `eval_ok` and `eval_is` are now `ok eval` and `is eval`, so that eval'd
  strings will be run in the current lexical scope

== Examples and Utilities

=== [examples/]

* All Perl 5 programs have been renamed from `*.p5` to `*-p5.pl`
* All Perl 6 programs have been renamed from `*.p6` to `*.pl`
* All references to them, except in talks, have been likewise updated

=== [examples/games/dispatch_quiz.pl]

* A game to test your knowledge about Perl 6's multi-dispatch system

=== [misc/runpugs/]

* A web teminal for running an interactive Pugs shell on the web
* WebTerminal: a library for building web terminals for interactive shells
* See [http://run.pugscode.org/] for a live demo

== Documentation

=== [docs/Perl6/Perl5/Differences.pod]

* Significantly updated and linked from [http://spec.pugscode.org/]

=== [docs/Perl6/Spec/]

* A new S16 draft for IO/IPC/signals as [docs/Perl6/Spec/IO.pod]
* A new S26 draft for documentation as [docs/Perl6/Spec/Documentation.pod]
* Revamped S29 draft in [docs/Perl6/Spec/Functions.pod]

=== [docs/Pugs/Doc/]

* New directory for Pugs-specific documentation
* [docs/Pugs/Doc/Hack/Style.pod] - Haskell style guide for Pugs hackers

=== [docs/talks/extraction.xul]

* Slides from Nathan Gray's /Practical Extraction with Perl 6/ talk

== Perl 6 on Perl 5

=== [perl5/Pugs-Compiler-Perl6/]

* The `v6.pm` implementation of Perl 6 now handles `./pugs -CPerl5` commands
* See its own ChangeLog for more information

=== [v6/]

* A new subproject to write a Perl 6 compiler in Perl 6
* Bootstrapped from the `v6.pm` compiler on the perl5 runtime
* See its own ChangeLog for more information

== Experimental projects

=== [misc/pX/Common/P5_to_P6_Translation/]

* Converts Perl 5.9.4+'s YAML syntax tree into Perl 6
* Handles regexes, arrays, hashes and many builtin functions
* See its own documentation for more information

=== [misc/pX/Common/convert_regexp_to_six.pl]

* Converts Perl 5 regex into Perl 6
* See its own documentation for more information

=== [misc/pX/Common/redsix/]

* An Perl 6 implementation on Ruby 1.9+
* See its own documentation for more information

= Changes for 6.2.12 (r10930) - June 26, 2006

== Licensing Changes

* The [src/] tree and the `pugs` executable are now released under the
permissive MIT license, in addition to Artistic and GPL
* A new [third-party/] tree to hold bundled prerequisites originated
from non-Pugs projects

== New Perl 6 modules

* [ext/Relation/] - Relation type for Perl 6 (incomplete)
* [ext/Getopt-Std/] - Simple command-line parsing

== Updated modules

* [ext/Locale-KeyedText/] - Added export_as_hash() methods
* [ext/Rosetta/]: Multiple additions and rewrites
** Merged ext/Rosetta-Engine-Native/ in, renamed to ::Example
** Now officially incorporates "The Third Manifesto"
** Rewrote half of Language.pod
** Updated the DESCRIPTION and class list of Rosetta.pm
** Added new core module Rosetta::Shell and example shell.pl
** Added new documentation file Rosetta::SeeAlso
** Various other documentation additions and edits
* [ext/Test/]: Avoid the use of junctions to make Parrot/Perl6's life easier

== Perl 6 on Perl 5 (under [misc/pX/Common/])

* Data-Bind - Implement Perl 6's calling/binding convention on Perl 5
* Inline-Parrot - a C version of Inline-Parrot - uses NCI for data exchange
* Module-Compile - precompile Perl 5 modules transparently
* P5_to_P6_Translation - beginning of a Perl 5.9 MAD tree parser and translater to Perl 6
* Pugs-Compiler-Perl6 - Compiler for Perl 6 (implements 'use v6-pugs'):
    use v6-pugs; say "Perl 6"; use v5; print "Perl 5"
* Pugs-Compiler-Precedence - an operator precedence parser, built around Parse::Yapp
* Pugs-Compiler-Rule - Compiler for Perl 6 Rules
* Pugs-Grammar-MiniPerl6 - translate Perl 6 rules into haskell Parsec
* Pugs-Grammar-Perl6 - a Perl 6 parser - parses Test.pm!
* lrep - a bootstrapped, very minimal Perl 6 compiler written in Perl 6
* re-override - Swaps in an alternate regexp engine:
    ./perl -we 'use re::override-perl6; print "a" =~ /<word>**{1}/;'

== Test, Examples and Documentations

* Restored this ChangeLog's entries for v6.0.0 thru v6.0.8, which were
truncated in r8916, apparently from gnome's copy-paste buffer limit
* [docs/Perl6/Doc] hierarchy, installable `Perl6::Doc`
* [docs/Perl6/FAQ/Capture.pod] - FAQ on the new Signature/Capture convention
* [docs/Perl6/FAQ/FUD.pod] - Fears, Uncertainties and Doubts about Perl 6
* [docs/talks/p6myths2.html]: Juerd's talk "Perl 6 Myths"
* [docs/talks/peek.spork]: Gaal's OSDC talk "A Peek into Pugs Internals"
* [examples/concurrency/]: Added sample usage on Software Transactional Memory
* [examples/qotw/]: Added the QOTW 8 Expert solution
* [examples/rules/]: Added a sample BASIC parser
* [src/Pugs/Parser] - Perl 6 grammars for Capture.pg and Signature.pg 
* [util/cperl-mode.el] - Emacs mode for Perl 6

== Feature Changes

* Pugs now builds in a single pass
* Removed support for GHC 6.4.0 and added support for GHC 6.5
* Removed support for Parrot 0.4.4 or below and added support for Parrot 0.4.5
* &?SUB is replaced with &?ROUTINE; $?SUBNAME is replaced with &?ROUTINE.name
* Arguments beginning in parens, such as `f ('x')=>1`, is now always positional
* Array and hash sigilled match variables, such as `@0`, `@<foo>` and `%<bar>`
* Assignment with non-obviously-scalar left-hand side is now in list context:
** `@a = 1,2,3` now parses as `@a = (1,2,3)`
* Broke down Parser and AST.Internals to smaller files so rebuilds are faster
* Builtin functions no longer defaults to `$_`; write `.ord` instead of `ord`
* Compile `Prelude.pm` and `Test.pm`, to YAML bytecode for faster loading
* Declarators are now lexical: `{ $x++ unless my $x }` increments `$OUTER::x`
* Declarators can now occur at expression position: `my $x + my $y` works
* Declarators no longer take qualified names: `our $Foo::x` is invalid
* Experimental support for Software Transactional Memory and atomic blocks
* Hash initializers now revert to bias-to-left behavior as in Perl 5
** In `{X => 1, X => 2}`, the value of X is 2, not 1
* If a block ends on a line by itself, an implicit `;` is assumed if possible
* In the interactive shell, :d and :D (dump parse tree) now continues the parse
from the current environment; use :reset to reset the environment
* More helpful diagnostics when calling unsafe builtins under safe mode
* Multiline support in the interactive shell reports unrecoverable parsefails
* Names of named arguments must always be a bareword now, such as:
    f(name=>1); f(:name(1));
* New AST-dumping backends: `Parse-Pretty`, `Parse-YAML`, `Parse-HsYAML`
* Parse-time binding `::=` is now fully supported 
* Proper desugaring of `.=` expressions, such as `@a .= map(&sqrt)`
* Prototype objects: `my Dog $fifo` now assigns `::Foo` into `$fido`
* Removed support for `require ::Class::Literal`
* Removed support for `rx_` macros in Prelude for user-defined rule handlers
* Quotelike constructs such as `rx` and `qq` no longer takes `#` as delimiter
* Support for Unicode bracket characters for quotelike operators
* Support for bracketed comments: #(...), #<<< ... >>>, etc
* Support for controlled backtracking and whitespace sensitivity via distinct
`token`/`regex`/`rule` delecarators
* Support for environmental variables such as `$ENV::PWD` and `$+PATH`
* Support for implicit-topic dereferences such as `.[0]` and `.<foo>`
* Support for long dot syntax: $foo\   .blah
* Support for scan metaoperators: `[\+] 1,2,3` evaluates to `(1, 3, 6)`
* The `-M` command line switch can take import arguments: `pugs -Mlib=foo`
* The parser is now much faster by being mostly predictive (non-backtracking)
* The postfix infiniterange is no more; write `1..*` instead of `1...`
* Two `my $x` declarations in the same scope is now no-op instead of an error
* Use `Data.ByteString` for fast string representation
* Using libraries from embedded Perl 5 can import functions now
* Whitespace disambiguation implemented on `if`, `unless` and `for`:
   if %ENV{ 3 } { 4 }   # hash lookup on %ENV
   if %ENV { 3 } { 4 }  # %ENV by itself
* YAML bytecode is now versioned to reduce incompatibilities
* `&not` is now unary instead of a list operator
* `:!foo` is now a shorthand for `foo => False`
* `bool::true` and `bool::false` are renamed to `Bool::True` and `Bool::False`
* `make upload-smoke` now uploads smoke test automatically
* `my $!x` is now recognized as an alternative spelling for `my $x` 
* `q:code {...}` gives ASTs in macros
* `readline` and `=$fh` now autochomps

== Bug Fixes

* (1.3 % 1) was evaluating to 0; now it evaluates to 0.3 like everybody else
* An uninitialized Code is no longer nullary: `my &f; f 1` is not a parsefail
* Chained assignments now return lvalues properly: `$x = %y = (1,2,3,4);`
* Implicit variables ($^x) is no longer allowed in statemeent-level bare blocks
* Implicit variables following a declarator was broken: `{my $x; $^y}.(42)` 
* In `(@x, @y) = (1,2,3)`, the `@y` is now cleared into an empty list
* Invalid rules in embedded Parrot no longer triggers an uncatchable `exit`
* Lexical imports are no longer discarded upon block reentry 
* Method invocant is `self` and `$?SELF` but no longer `$_`
* Named-only subs such as `sub f (:$x!) {}` no longer parse as unary positional
* Opening a file for writing now turns autoflushing on by default
* Short-circuit operators now works again
* Statement-level `return` and `yield` now propagates contexts correctly
* Statement-level bare blocks now counts as one scope for `OUTER`, not two
* Statement-level bare blocks now runs under all contexts: (sub { { 3 } }).()
* Strings outside ASCII range no longer raises exceptions at the PGE/Parrot bridge
* The bogus comma-less block argument form `map {$_} 1,2,3` is no longer supported
* `%.foo` and `@.foo` now always flattens in argument lists
* `&slurp` and `&readline` evaluates eagerly and no longer races with `&unlink`
* `1.` was parsed as a valid integer, causing ambiguities; it's now invalid
* `@foo.perl` works correctly when `@foo` is recursive
* `f(())` now passes `&f` an empty list, not `undef`
* `sign` and `<=>` now fails on undefined arguments, instead of returning undef
* `slurp` works correctly on UTF-8 files
* `sub f (@x) {}; f([1,2,3])` now works as it's no longer under slurpy context

= Changes for 6.2.11 (r8934) - Feb 1, 2006

== Bundled Modules

=== New Perl 6 modules

* [ext/Parse-Rule/] - A Rules engine port in perl 6
* [ext/Rosetta/] - A federated relational database (incomplete)
* [ext/Rosetta-Engine-Native/] - A back-end for Rosetta testing (incomplete)

=== Updated modules

* [ext/File-Spec/] - Rewritten to define its own exported wrapper subs
* [ext/Locale-KeyedText/] - Rewrote with a strong resemblence to the original
** Split up `translate_message()` for more granular Translator usage
** Objects now become something useful when coerced into a string
** Added `Locale::KeyedText::L::en`, LKT now throws Message exceptions
** Template Modules now have a different variable interpolation format
** Created 2 running [examples/] from pod that was removed from KeyedText.pm
** Deleted old test suite (yet to be replaced); now only tests compilation
* [ext/libwww-perl] - Rewrote `HTTP::Header::Util` with gather/take syntax
* [ext/Test] - `&fail` renamed to `&flunk` to avoid conflict with builtin

=== Experimental modules (in misc/, not installed)

* [misc/Parser-Mini/] - Experimental *thin* p6 parser
* misc/Rosetta-Incubator/ broken up:
** Locale::KeyedText was merged into the rewritten one in ext/
** SQL::Routine and Rosetta were merged together, became Rosetta in ext/
** The license of Rosetta is now GPL (with extra linking provision)
** Remainder (SQLBuilder, SQLParser, Eng/Generic, Emu/DBI) was deleted
* [misc/sixpan/] - Prototype of new CPAN tools in Perl 5

== Test, Examples and Documentations

* Add timing data prints to smoke harness, to help spot hanging/slow tests
* Tests in [ext/] and [t/] - Temporary workaround the breaking of `use_ok`
* [Makefile.PL] - Begins with an overview POD section on the build system
* [TASKS] - Tracking current things to do
* [docs/AES/S17draft.pod] - Draft synopsis for Perl 6's concurrency
* [docs/AES/S22draft.pod] - Draft synopsis for Perl 6's CPAN
* [docs/articles/tpr.pod] - An introduction article to Pugs
* [docs/feather] - Feather.perl6.nl web site
* [docs/getting_started] - Pointers for people new to Pugs
* [docs/notes/context_coercion.pod] - Notes on implementing contexts
* [docs/notes/context_coersion.pod] - Notes on implementing contexts
* [docs/notes/docs_evil_plan.txt] - Plan for Perl 6 documentation
* [docs/notes/multimethods.pod] - Description of the canonical MMD algorithm
* [docs/p6doc/] - Perl 6 language tutorials and documentation
* [docs/quickref/] - Various updates and improvements from new Synopses
* [docs/quickref/fears] - assorted fears about Perl 6
* [examples/cookbook/] - New recipes
* [examples/network/wiki/] - demo wiki
* [examples/rpn/] - RPN calculator in Perl 6, Perl 6, and Haskell
* [util/run-smoke.pl] - Support for `PUGS_SMOKE_EXCLUDE_EXT` environment variable
* [util/catalog_tests.pl] - Annotate smoke reports with colored sources/specs

== New Features

* Adverbial number forms: `:16<deadbeef>` and `:16[14,15]`
** This change obsoletes `hex()` and `oct()`
* Calling private methods with `self!method`
* Deep eager sequential evaluation list operator `eager`
* Access to the class metaobject with `.meta`
* Macros can now be called and reinterpolated at runtime
* Multisub declarations in the same scope can now be exported selectively
* Named arguments are now decided at parse time, not as runtime Pair objects
* New YAML tree-dump backends: `-C Parse-YAML`, `-C PIR-YAML`, `-C PIL1-YAML`
* New `\x[abcd]` and `\x[1,2,3,]` forms instead of `\x{abcd}` in qq-strings
* New backend: `-CParse-Pretty`, to show a pretty parse tree
* Parameter syntax changes:
** `+$arg` becomes `:$arg`
** `++$arg` and `+$arg is required` becomes `:$arg!`
** `?$arg` becomes `$arg?`
* Round-trip data serialization with `.yaml` and `eval(..., :lang<yaml>)`
* Support for multiline inputs in interactive shell
* The build system now supports Cygwin again
* Two or more underscores in numbers (eg. `1__0`) is no longer accepted
* Unary `^` support: `^10` is a shorthand for `0..^10`
* `$+x` is now accepted as a shorthand for `$CALLER::x`
* `$CALLER::x` now only sees `env $x` in outer dynamic scopes, not `my $x`
* `$obj.clone` support
* `%*INC` now contains module interface structures, not file system pathnames
* `&die` and `&fail` can take an object argument without stringifying it
* `eqv` is now spelled `===`
* `pugs file.p6 --options` now passes options to the program, not to Pugs
* `self` is an alias for `$?SELF`
* `use Module` now imports its symbols lexically at the consumer's use time
* `use Perl-6` parses correctly now

== Bug Fixes

* Bareword `foo.bar` now always parses as `::foo.bar`, never `foo(.bar)`
* Binding a block to `&infix:<operator>` in BEGIN time now affects parsing
* Fixed embedding of threaded parrot
* Fixed evaluation order in array and hash access
* Fixed splice on scalar
* Improved detection of null patterns; this fixes some endless loops
* Improved hash parsing. `{("a"=>3),}.ref` is again ::Hash, not ::Block
* Infix macros no longer cause parsefail
* Lazy `{...}` executes its closure at most once
* Method calls on simple index lookups now gets dispatched correctly
* Parse (but no implementation) for scoped packages
* When `m:P5/(...)?/` captures nothing, $0 no longer evaluates to true
* `$.foo.bar()` correctly dispatches on the runtime type of `$.foo`
* `&splice` was destroying existing bindings on the array
* `.perl` stringification now escapes unprintable characters
* `1**Inf`, `0**0` and `Inf**0` are defined to 1 regardless of architecture
* `3..2` and `'z'..'a'` return empty lists
* `\(1,2,3,4).elems` no longer throws an exception
* `zip(@a; @b; @c)` no longer flattens the arrays together

== Backends

=== JavaScript backend

* Division by zero raises an error, not return NaN like JS does
* Fix problems with `[=>]` and related operators
* New operators implemented: `+| +& +^ +< +> ~& ~| ~^ +^ ~^`
* PIL/JS compilation now works with exported multisubs
* Support for using Perl 5 modules in JavaScript backend via `-B JS-Perl5`
* `$*PID`
* `.assuming`
* `FIRST {...}` blocks
* `state $variable`
* `unlink()`

=== Parrot backend

* Parrot 0.4.1+ is now required for Parrot targeting and embedding
* Closure creation no longer triggers segfaults
* Lexical variables are now truly lexical instead of emulated by temps
* Upon program exit, embedded Parrot/Perl5 objects are finalized correctly
* Support for modules with lexical imports
* When looking for an external parrot, look in `%ENV<PARROT_PATH>` first

=== PIL^N backend

* New VM written in Haskell which uses the domain specific language PIL^N
** Based on the Perl6-ObjectSpace prototype
** Optionally built with `make pil` (and interactively as `make pili`)
** See [src/PIL/Native/] for the source code
* Class Meta-Model written and bootstrapped in PIL^N
** Basic tests for Meta-Model in [t/pil/]
* Role Meta-Model partially complete in PIL^N
* Some basic Container types written in PIL^N
** See [docs/notes/piln_object_repr_types.pod] for implementation notes
* Haskell implementation of Perl 6 Rules and precedence parser
** See [src/Text/Parser/] for the source code

=== Perl6-ObjectSpace

* Prototype Perl 5 backend, served as the inspiration for the PIL^N backend
** Currently somewhat out of sync with PIL^N
** See [perl5/Perl6-ObjectSpace/] for the source code
* Core set of /native types/ written in Perl 5
** Class Meta-Model bootstrapped using only the native types
** Role Meta-Model and Container types not yet supported
* Based on work from the [perl5/Perl6-MetaModel/]

= Changes for 6.2.10 (r7520) - Oct 10, 2005

== Feature Changes

=== Shared components

* Support for the Haskell Cabal framework, exposing Pugs as a library to other
  Haskell users, paving the way for use in IDEs, as well as future Inline::Pugs
  and Inline::GHC modules
* Adopted the code convention of expanding literal tab chars to spaces
* JavaScript backend can be invoked with `pugs -B JS`
* Perl 5 backend can be invoked with `pugs -B Perl5`
* Pugs will now compile version ranges in 'use/require' statements
* Significant backend enhancements; see below
* `$?PUGS_BACKEND` can be used to tell which runtime is in use 
* `exec` emulated (partially) on Win32

=== JavaScript backend

* Passes 91% of the main test suite (including TODO failures)
* Integrated with MetaModel 1.0
* Faster code generation, taking advantage of `-CPerl5` output
* Switched to continuation passing style (CPS) to properly support
  `return()`, `&?CALLER_CONTINUATION`, coroutines, and `sleep()`
* Improved support for binding and autodereferentiation
* Initial support for multi subs
* Initial support for symbolic dereferentiation
* List construction no longer creates new containers
* Miscellaneous performance improvements
* Named-only arguments (`+$x` and `++$x`) can't be passed positionally anymore
* Parts of the Prelude can be written in Perl 5 now to improve performance
* Perl 5-like regular expressions mostly working
* Proper UTF-8 handling
* Support for "monkey-but" (`$foo but {...}`)
* Support for `$CALLER::` and `$OUTER::`
* Support for `lazy {...}` blocks for delayed evaluation
* Support for `temp` and `let` declarations
* Support for array and hash autovivification
* Support for array and hash slices
* Support for evaluating expressions in the PIL2JS shell (`:e <exp>`)
* Support for junctions
* Support for loading JSAN modules by using `use jsan:Module.Name`
* Support for lvalue subroutines (`foo() = ...`)
* Support for slurpy hashes in subroutine signatures
* Support for the `Proxy` class (not yet user-visible)
* Support for the `eqv` operator
* Using `for` with only one element to loop over works now
* `int()` works correctly on special values like `Inf` or `NaN` now
* `substr()` returns a r/w proxy: `substr($str, $pos, $len) = $replacement`

=== Perl 5 backend

* Passes 33% of the main test suite (including TODO failures)
* Integrated with the Perl 5 edition of MetaModel 2.0
* Compiles and runs Perl 6 version of `Test.pm`
* Infinite lazy lists, Pairs, References, and intrinsic classes
* Multi Sub, Class, Match, exceptions, types and subtypes
* Scalar, Hash and Array containers, with tieing, binding and read-onlyness
* Support for an extensive list of operators
* Supports eval() with Perl 5 and Perl 6 code
* `%ENV` is shared with Perl 5; `@INC` is separate from `@Perl5::INC`

== Bug Fixes

=== Shared components

* Fixed `foo {1}.blah` being misparsed as `foo({1}).blah`
* Fixed a hashref infinite loop
* Fixed infinite loop on sub { 1 }.pairs
* Multiple `sub foo` no longer silently means `multi foo`

=== JavaScript backend

* Fixed evaluation order of assignments and bindings
* Fixed `.values` and `.kv` to return aliases

== Bundled Modules

=== New Perl 6 modules

* Perl6-Container-Array, Perl6-Value-List
** Prototype modules for implementing Lazy lists in Perl 6
* Log-Selective
* Cipher - Cipher API suite for cryptographic ciphers

=== Updated modules

* Locale-KeyedText: Synchronized with p5 version 1.6.2
* Test-Builder: new APIs, including test_pass() and test_fail()

=== Experimental modules (in misc/, not installed)

* Blondie, prototype compiler for native code generation and type-inferencing
  with Attribute Grammers 
* Getopt::Long
* Rosetta-Incubator, a complete set of Rosetta[|::*] and SQL::Routine[|::*]
  modules, restarted development at 2005.09.29

== Test, Examples and Documentations

* Many new tests and test refactoring, we now have 10300+ tests
* Documentation for draft GC API at `docs/notes/GC.pod`
* Data file for curcular prelude exploratory diagram at
  `docs/notes/compilation_of_circular_prelude.graffle`, some
  examples at `docs/notes/circular_prelude_stuff.pl`
* Collaborative journal at `/docs/journal`
* Autrijus's CUFP talk at `/mirror/pugs/docs/talks/cufp2005.txt`
* Theory Model proposal at `docs/notes/theory.pod`

= Changes for 6.2.9 (r6050) - Aug 4, 2005

== Pugs Internals

* New build system in `inc/PugsBuild`
** Configuration preferences are stored in `config.yml`
** Persists across builds, overridable via `%*ENV<PUGS_BUILD_OPTS>`
* `$CALLER::_` is now again usable in defaults
* JavaScript Backend
** Actively progressing in `perl5/PIL2JS`
** Passes 64.00% of the Pugs test suite
* Perl5 Backend
** Begun in `perl5/PIL-Run`
** Primitive interactive shell as `crude_repl.pl`
* Object MetaModel
** Perl 5 prototype is mostly self-hosting 
** New C3-based method dispatch algorithm
** JavaScript version partially completed
** Java version begun (in very early stages)
* Pugs Intermediate Language
** New runcore design begun in `src/PIL`
** QuickCheck-based specification tests added
* Precompilation for arbitrary modules (not enabled by default)

== Bundled Modules

* New Perl 6 modules:
** `MIME::Base64`
** `Recurrence`
** `Span`
* Additions to `libwww-perl`:
** `HTTP::Cookies`
** `HTTP::Query`
** `HTTP::Request::CGI`
** `HTTP::Status`
** `URI::Escape`
* Additions to `DateTime`:
** `DateTime::Set`

== Test, Examples and Documentations

* Many new tests and test refactoring, we now have 8100+ tests
* A number of additions to `examples/cookbook`
* Beginning of Rule-based grammars for Perl6 in `modules/Grammars`
* SVG generation examples in `examples/graphics`
* `STATUS` document added to the top level to keep track of current progress
* `docs/notes/plan` expanded and added macro-related issues
* `examples/algorithms/Newton.pm` implements the newton method with currying
* `examples/network/evalbot.p6` gets safe &print primitive
* `examples/network/seenbot.p6` gets pretty duration printing
* `examples/network/svnbot.p6` supports branch information
* `examples/ppt/cat.p6` added to Perl Power Tools
* iblech's LUGA talk as `Anatomie_eines_Compilers_am_Beispiel_von_Pugs.latex`
* ingy's OSCON talk as `oscon-apocalypse.spork`

== Bug Fixes

* Fix pair binding for functions expecting pairs as arguments
* Global destruction is now guaranteed upon program exit
* Parameter's defaults are now evaluated in its original lexical scope
* Parser for hash subscripting was globbing whitespaces after it
* Primitive listops now handles Pairs as regular arguments
* Various `+$foos` in sub signatures changed to `?$foo` in `Test.pm`
* `%h<x>>` was misparsed as `%h{'x>'}`
* `-Inf` now stringifies as `-Inf`, not `-Infinity`
* `.end` and `.elems` no longer work as scalar methods
* `/a/ ~~ "a"` now works the same way as `"a" ~~ /a/`

= Changes for 6.2.8 (r5577) - July 13, 2005

== Pugs Internals

* Added code generation backends: `PIR`, `PIL`
** Pugs can now generate PIL (Pugs Intermediate Language)
** ...and emit PIR (Parrot Intermediate Representation) from PIL
** New `make pirsmoke` target runs test suite using PIR backend
** `Test.pm` can be compiled to PIR 
** `Prelude/PIR.pm` added with Perl 6 versions of some builtins
** `pugs -CPIL -e 'say 123'` for dumping PIL from code
* Implicit variables like `$^a` now only work in bare blocks
* Initial support for `%*INC`: multiple `require` calls run only once
* Named binding is now done in an inferencing phase before positional binding
* New Haskell builtins: `IO::tell` and internal filehandle test functions
* New PIR-specific builtin: `leave`
* New Prelude builtins: `File::seek`, `localtime`, `trans`
* New builtin classes: `Proxy`, `Control::Caller`, `Time::Local`
* New trait for Prelude.pm: `is builtin` (installs into the global namespace)
* Pairs in variables now bind to named parameters just like pair literals do
* Parse `trusts ClassName` and `my $foo is trait_name` as no-ops
* Parse fractional number literals starting with a leading dot: `.1` `-.1`
* Qualified names and exports now dealt with consistently
* Support for `does RoleName` and `is ClassName` within class declarations
* `&foo` in module `Foo` now looks up `&Foo::foo` as well
* `@?INIT` and `@?CHECK` renamed back to `@*INIT` and `@*CHECK` space
* `Bare` and `Parametric` types merged into `Block`
* `MY`, `OUR`, `OUTER`, `CALLER` can no longer be used as user-defined packages
* `Prelude.pm` is now pre-compiled to reduce startup time
* `multi foo { ... }` is now a shorthand for `multi sub foo { ... }`
* `my Foo $foo .= new(...)` parses and works
* `our` variables in packages now generate qualified symbols
* `use perl5:DBI` replaces the old `use DBI--perl5` syntax

== Bundled Modules

* New Perl 6 modules:
** `DateTime::Set`
** `DateTime`
** `HTTP::Server::Simple`
** `Module::Pluggable::Fast`
** `Perldoc` (partial port)
** `Set::Infinite`
** `Span`
** `Tree::Visitor` and `Tree::Visitor::FindByPath`
** `WTemplate` - the first Perl 6 templating engine
* New Pugs-specific modules:
** `Perl-Compiler`, a PIL representation in Perl 6
** `perl5/PIL-Run`, a Perl 5 prototype of Perl 6 runtime environment
** `perl5/Perl6-MetaModel`, a Perl 5 prototype of Perl 6 object model
* Completed port: `Locale::KeyedText`
** Compiles, executes, and passes whole pristine test suite
** Updated version to 1.5.0, corresponding to the Perl 5 version 1.05
** Some skips and workarounds remain due to missing Pugs features
* Completed port: `Test::Builder`

== Test, Examples and Documentations

* Examples of methods acting on builtin types in `examples/vmethods/`
* Interpreter and debugger for the l33t language in `examples/obfu/l33t.p6`
* Low level sanity tests in `t/01-sanity/` for the PIR code emitter
* More JAPHs added to `examples/japhs/`
* New directories: `examples/continuation` and `examples/unitfunctions`
* Overview of PIL-based compilation roadmap in `docs/notes/plan`
* Perl 6 Rule grammar and related files added to `module/Grammars/`
* Script to generate Haskell source's import graph as `util/importgraph.pl`
* Updates and cleanups to PA01; master copy is now `docs/01Overview.kwid`
* YAPC::NA talk: /Apocalypse Now/ (in `docs/talks/Apocalypse_Now.spork`)

== Bug Fixes

* Call parrot with `-C` (CGP) instead of `-j` (JIT) runcore to avoid segfaults
* Fixed `!~` to mean negated `~~` instead of `ne`
* Fixed `.isa` to agree with smartmatch results
* Fixed order of method invocation in `BUILDALL` and `DESTROYALL`
* New environment variable `PUGS_PARROT_OPTS` for invoking external parrot
* Qualified and global variables may now be used without declaration
* `$hashref.does(Hash)` now returns true
* `&say =:= &say` now evaluates to true
* `(42).kv` now dies and `(42,).kv` works
* `[1] <=> [2]` no longer misparsed as `[1]{'='}[2]`
* `caller` now counts `eval` and the topmost `main` as one frame
* `qq{ ... { code } ... }` no longer ignores the interpolated code 
* `redo` and `next` now works correctly inside loop blocks
* `sleep()` returns seconds slept instead of undef
* `try` is now capable of catching all type casting errors

= Changes for 6.2.7 (r4612) - June 13, 2005

== Pugs Internals

* Add `::?CLASS`, `::?ROLE`, and `::?PACKAGE` magicals
* Allow bypassing the Standard Prelude by setting `$ENV<PUGS_BYPASS_PRELUDE>`
* Experimental heredoc support via `qq:to/END/ ... END`
* Implement `is required` for subroutine parameters
* New builtins: `caller`, `Carp::longmess`, `Scalar::as`
* Obsolete the old `open` builtin in favor of Prelude's `File::open()`
* Rudimentary, source-filter-like macro support added
* Speed up parsing by 100% by caching dynamic grammar rules
* Support for lvalue `substr()`
* `coerce:` and other categories from A12 are parsed in sub names
* `is unsafe` trait to mark subs unavailable in safe mode
* `method foo ($.x) {}` now sets `$.x`
* `undef($x)` is now spelled `undefine($x)`

== Bundled Modules

* New modules added:
** `FindBin`
** `File::Find`
** `POE` (experimental)
** `URI::Escape`
* Extended tests for `Tree`

== Tests, Examples and Documentation

* APW talk: "Apocalypse Now" in `docs/talks/Apocalypse_Now.spork`
* APW talk: "Eine Einfuehrung in Perl 6" in `docs/talks/perl6-apw2005/`
* Documentation for running Pugs in `lib/pugs/run.pod`
* Examples of nested loops in `examples/nested_loops`
* Haskell Workshop paper on Pugs in `docs/talks/hw2005.tex`
* Overview of Pugs source tree in `lib/pugs/hack.pod`
* Overview of Rules bootstrapping plan in `docs/other/rules_bootstrap`
* Some new tests; several tests refactored; we now have 7600+ tests
* Unit manipulation and conversion examples in `units.p6`
* `examples/algorithms` subdir now unifies algorithmic examples

== Bug Fixes

* '\' protects delimiters in rules
* Chained comparisons now work again (were broken in 6.2.6)
* Critical evals (`use`, `require`, `prelude`) now raise parsefail exceptions
* Fix `[].method` and `{}.method` to call `Array::method` and `Hash::method`
* Fix `~{1=>2}` to stringify correctly to `"1\t2\n"`
* Parse errors inside blocks now reported at the position at which they occurred
* Parse array and hash captures in rules
* `Test::is()` now shows the expected result correctly again
* `module Foo {...}` now parses

= Changes for 6.2.6 (r4318) - June 2, 2005

== Pugs Internals

* Pugs can now embed Perl 5 and use CPAN modules
** Perl 5 objects, classes and functions are understood by Pugs
** Pugs objects, classes and functions are understood by Perl 5
** These types can also be used in round-trip callbacks
* All user-defined classes now inherit from "Object"
* Bare blocks now belongs to the `Bare` type; pointy subs are still `Block`
* Class methods: `My::Class.foo()`
* Class objects are initialised from the default class tree
* Exclusive-range operators: `^..`, `..^` and `^..^`
* Experimental compiler backend `Pugs.Compile.Pugs2` (not yet working)
* Experimental `&code.body` support for reified ASTs
* Experimental embed API in `src/perl5/pugsembed.h`
* Fully qualified subroutine names are now parsed
* More core modules refactored for improved compilation speed and readability
* Multi-invocant calls like `foo($x, $y: $z)` are no longer legal
* New builtins: `evalfile`, `nothing`, `getc`
* Parameterless bare blocks now get an implicit $_ by default
* Parameterless pointy blocks no longer get a default parameter list
* Parrot compilation backend now handles qualified subroutine names
* Pugs now has a /Safe/ mode, enable by the PUGS_SAFEMODE environment variable
* Stub implementation for `.does` as an alias of `.isa` (no Roles yet)
* Unix-only builtins: `opendir`, `readdir`, `rewinddir`, `closedir`
* `$str.split(/rule/)` and `$str.split($delim)`
* `&infix<=>` can now be used as the assignment operator
* `Prelude.pm` added to `src/perl6` to implement S29 builtins in Perl 6
* `is export` now works as specified
* `loop {...} while`, `loop {...} until`
* `map` and `reduce` can now take n-ary functions. 
* `when .does(Foo)`, `when $_.does(Foo)` and `when Foo`

== Bundled Modules

* Many more code sketches and documentation added to `Perl-MetaModel`
* New `Benchmark` module added
* `CGI` has been improved:
** Now has: `escapeHTML`, `unescapeHTML`, `redirect`
** Supports more HTTP headers in `header`
** New module `CGI::Util` added
* New `Date` module added
* New `Text::Glob` module added
* New `libwww-perl` distribution added
** `LWP-Simple` now moved here
** `HTTP::Headers`, `HTTP::Message` modules added
* `Test::Builder` is now dangerously close to completely working
* `fp` now exports `&identity` instead of `&id` to avoid clash with `$obj.id`
* `use lib 'path';` now works

== Tests, Examples and Documentations

* Some new test and several tests refactored, we now have 7200+ tests
* Pugs Apocryphon 2 improved and edited in `docs/02Internals.pod`
* Many improvements to `util/perl6.vim` to handle new features 
* More Haddock documentation added to the Haskell source
* New IRC bot `evalbot` added to `examples/network`
* New JAPH for Italian Perl Workshop added in `examples/japh`
* Perl 6 port of Perl Power Tools begun in `examples/ppt`
* Some new additions and cleanup of the cookbook
* `examples/network/screen-nodestatus.p6` added to monitor hosts in GNU screen

== Bug Fixes

* Hyper-reduction prefix operators such as `[+]«` are now parsed
* Single-character class names were not parsed correctly
* Stringifying a Rule no longer throws an uncatchable exception
* Use of undeclared types in signatures no longer breaks MMD
* `(1 => 2 ?? 3 :: 4)` now always constructs a pair
* `Foo.bar()` now dispatches to `&Foo::bar` instead of to `&Class::bar`
* `Foo.isa(Foo)` no longer means `Class.isa(foo)`
* `pugs -MFoo` now means `use Foo`, not `require Foo`
* `readline()` now reads utf-8
* `times` now really works on Win32
* `when .isa(Foo)` is no longer parsed as `when $_ ~~ .isa(Foo)` now

= Changes for 6.2.5 (r3794) - May 24, 2005

== Bundled Modules

* Fix one broken test from the `Set` module

= Changes for 6.2.4 (r3790) - May 24, 2005

== Pugs Internals

* All infix operators now receive reduction forms, such as `[+]`
* All operators now receive hyperised forms, such as `>>+<<` and `~<<`
* Dereferencers: `@{...}` and `@$var`
* Experimental support for `coro { ... }`, `coro name { ... }` and `yield()`
* Experimental support for `lazy {...}`
* External Parrot for Rules is now kept in a single process
* Inheritance: `class Foo is Bar` and `class Foo does Bar`
* Interactive shell commands normalised to always begin with `:`
* MMD handling is now more sophisticated, and `$.chained.attr.methods` works
* Much better error messages, with cascading stack trace
* New `./method` syntax implemented
* Objects numify to a unique value accessible with `$obj.id()`
* Parrot compiler backend now handles namespaces and method calls
* Parsing of hierarchical return types: `sub foo returns Hash of Str`
* Private attributes: `has $:foo` now generates private accessors
* Private methods: `method :foo ()` and `$obj.:foo`
* Switch to sum-of-inheritance-level distance for MMD dispatch on invocants
* Symbolic references: `$::(...)` and `$::some::("var")::($bar)`
* User-defined symbolic infix, postfix and prefix unary functions
* `$?CLASS` and `$?PACKAGE` works; `$?ROLE` currently works as `$?CLASS`
* `&code.name` and `&code.arity` added
* `FIRST {...}` and `my $x = FIRST {...}` support
* `INIT {...}` and `CHECK {...}` blocks in void context and as rvalues
* `OUTER::` scope implemented
* `do {...}` literal added
* `gather {...}` and `take()` implemented
* `submethod BUILD` is called for each parent class as well as the class itself
* `time()` now returns a fractional number
* `try {...}` literal allowed at expression level
* `warn()`, `uniq()`, `fail()`, `times()` implemented

== Bundled Modules

* `Inline::Pugs` and `pugs` module to allow Perl 6 in Perl 5 programs
* `Locale::KeyedText` re-added (this was our first contributed module)
* `Net::IRC`, OO version added
* `Perl::MetaModel`, prototype of Perl 6 OO meta-model in Perl 6 OO
* `Set::Junction` and `Set::Hash` added as implementation backends to `Set`
* `Set` now has many overloaded operators
* `Test::Builder`, with Perl 6 objects (parses, and mostly works -- see tests)
* `Tree::Simple`, renamed to `Tree` and converted to OO
* `Test::cmp_ok` now gives better diagnostic messages
* `fp` module added for functional programming

== Tests, Examples and Documentations

* Many new tests; several tests refactored; we now have 5600+ tests
* Hangman IRC bot created from `hangman.p6`
* IRC logfile to HTML converter added
* Initial sketch of Pugs Apocryphon 2 in `docs/02Internals.pod`
* Much work on internal Haddock Haskell documentation
* OO Wizard RPG game added in `examples/games/`
* Parrot is now included in the Pugs Live CD
* Perl 6 quick reference documents added to `docs/quickref`
* Perl6::Rules test suite incorporated under `t/rules/`
* Replaced `force_todo()` with `:todo`

== Bug Fixes

* Bare blocks containing `$_` are now executed correctly
* Correct parsing for user-defined nullary functions
* Hash and array sub parameters are now read-only by default, same as scalars
* Post-term invocation in interpolation no longer eats trailing whitespace
* Slurpy hash parameters no longer count as nonslurpy during arity matching
* Type-to-type smartmatch, e.g. `Int ~~ Num`, now works
* `$obj.method($arg1, $arg2)` now dispatches based on all the arguments
* `foo 3 and foo 4` is now parsed as two separate function calls
* `loop (;0;) {...}` will no longer execute the loop body
* `map({...} @list)` is no longer valid syntax
* `next` now re-evaluates condition in `loop` constructs
* `returns Foo::Bar` from subs/methods now works
* `split//` now attaches the submatches to the resulting list
* `state $x = 42` now only assigns `$x` once
* `system()` returns proper exit codes

= Changes for 6.2.3 (r3111) - May 12, 2005

== Pugs Internals

* Pugs can now embed Parrot or use an external `parrot` executable
** Under embedded mode, Pugs is a registered Parrot compiler
** `eval_parrot` and `require_parrot` builtins for running PIR code
** `pugs -BParrot` can compile Perl 6 program to PIR and run it in-memory
* Perl 6 Rules support via Parrot/PGE:
** Named rules and subrule support
** The former `$0` (entire match) is now `$<>`
** `$0` is now the same as `~$/[0]`, i.e. the same as Perl 5's `$1`
** `.from`, `.to`, `.matches`
** `//`, `rx//`, `m//`, `rule{}`
** `s///` and `//` in statement level operates on `$_`
* Basic Object support:
** Accessors generated for public attributes
** Identity operator: `=:=`
** Method chaining: `$foo.bar().baz()`
** Method invocant: `method foo ($self: $x)` and topicalized as `$_` 
** Public and private attributes, as well as `has $.attr is rw`
** `$obj ~~ Class` support
** `$obj.clone()` support
** `class Foo {}` works (no inheritance yet)
* Experimental `eval_yaml()` support to parse YAML streams
* Experimental support for prefix reduce metaoperator `[+]`
* Hyper operators now works on arrays too
* Improved `.perl()` format for array, hash and pair objects
* Much faster random access to arrays; it's now O(1) instead of O(n)
* Much improved MMD support
* New `is lazy` trait for parameters
* Refactoring of large Haskell modules to improve compilation speed
* Support for building a profiled Pugs
* Undef in grouped lhs: `my ($x, undef, $y) = 1..3;` is now legal
* `$thread.kill`, `$thread.detach`, `$thread.join`
* `%hash.pick`, `@array.pick` and `(list).pick`
* `reduce` primitive
* `state $var` implemented
* `system(Str: List)` and `exec(Str: List)` on Unix platforms

== Bundled Modules

* All modules have their own `ChangeLog` now
* `Algorithm::TokenBucket`, with closure objects
* `Config::Tiny`, with closure objects
* `Kwid::Event::Parser`, with procedures
* `Net::IRC`, with closure objects
* `Perl::MetaModel`, prototype of Perl 6 OO meta-model in Perl 6
* `Pod::Stream::Parser` renamed to `Pod::Event::Parser` and added more functionality
* `Set`, with Perl 6 objects
* `Test::Builder`, with Perl 6 objects (parses, but does not work yet)
* `Tree::Simple`, with closure objects

== Tests, Examples and Documentations

* Many new test and several tests refactored, we now have 4921 tests
* Documentation for `hangman.p6` added in `examples/games/hangman.pod`
* New "Monads in Perl 6" example in `examples/functional/monads.p6`
* Script to generate a Pugs Live CD in `util/livecd`
* Several IRC bots added to `examples/network` including svnbot and logbot
* TODO tests now use `:todo<reason>` for better reporting
* The first Perl 6 poem in `examples/poetry/`

== Bug Fixes

* Logical short-circuiting operators no longer flattens references
* Prohibit Array and Hash dereference on plain values
* Slurpy context no longer flattens
* Stringifying IO handles is no longer fatal
* `$*PID` now works on Win32
* `%*ENV` now completely works on Win32
* `(a => 3+4)` is now parsed as `(a => (3+4))`, not `(a => 3)+4`
* `any().pick` no longer dies
* `my @x = [1]; @x[0][0] = 2` should now work
* `next` in nested `for {}` blocks no longer escapes the outer loop
* `to => 123` parses again; arrow pairs now always trumps unary functions
* `{}` in P5 rules is no longer closure interpolation

= Changes for 6.2.2 (r2604) - May 1, 2005

== Pugs Internals

* Many performance speed-ups, including:
** New, much much faster implementation type for Pad
** Replace Data.HashTable with STM Map
** Restructured the Eval monad to be reusable on compilers and interpreters
** Position handling and statement reduction logic re-written
** Add strictness to core Monad and object structures
* Functions declared as unary are now parsed as such
* Global subroutine declaration is now visible in the whole file
* Improved Parrot compiler backend support for mod_pugs
* Much better error messages, tracking source file range for expressions
* New loop control routines: `next` and `redo`
* On Win32, `-s` and `-z` now work correctly
* Optimized build is now default; use `make unoptimized` to turn it off
* Pugs can now build on Cygwin
* `#line 123` and `#line 123 "filename"` both work
* `&infix:<%>` raises trappable exception when modulus is zero
* `(undef, $x) = (1, 2)` is now supported
* `@array.end` implemented
* `BEGIN {...}` blocks now work on both statement-level and term level
* `for @a { say }` is now parsed as `for @a -> $_ is rw { say }`
* `for @a -> () { ... }` now consumes one element at a time
* `my $var ::= expr` works
* `print (4)+4` now prints 8, because the whitespace is no longer skipped
* `use Module;` supported and happens at `BEGIN` time
* `|=` `^=` `&=` for junctions

== Tests, Examples and Documentations

* Many new tests and cleanup of older tests, we are now at 4600+ tests
* API documentation available in `docs/haddock/`
* Added an example of IRC bot into `examples/network`
* Added simple POD parser into `ext/Pod-Stream-Parser`
* Added support for generating Haskell documentation with `make haddock`
* Added the tic-tac-toe game from perlmonks into `examples/games/`
* Parallel `make smoke` when `%ENV<PUGS_TESTS_CONCURRENT>` is greater than 1
* Patched local `Test::Harness` to display number of TODO tests
* Progressive powerset generator from perlmonks added to `examples/`
* Smoke testing tool now includes timing data in YAML harness data
* German talk /Perl 6, genau jetzt!/ finished

== Bug Fixes

* Constant references now automatically dereference when used in rvalue context
* Junctive `^` should join junctions instead of autothread them
* Lone block does not count as /simple expression/ anymore
* Repair single statements in shell to preserve lexical context
* Repair the `list` context hinter
* The dot in `123.ref` is now parsed correctly as `(123).ref`
* `$_` in subroutine signatures is no longer slurpy by default
* `$x = \$x` no longer causes an infinite loop
* `NaN` calculations no longer causes infinite loop
* `last if foo` now means `last() if foo()` instead of `last(if(foo()))`
* `one(1,1).pick` bug fixed; it should return `undef`
* `splice([], 1)` no longer causes division by zero errors

= Changes for 6.2.1 (r2288) - April 24, 2005

== Pugs Internals

* Unification of the quoting code, most quoting constructs now work
** <<>> now works
** Regular expressions are parsed as `qq//`, but without backslash protection
** Hash subscripts using `<>` or `<<>>` are parsed as general quotations
** This means interpolation, etc. is done just like `q:w` or `qq:ww`
** `$<delim>` not interpolate in quoting constructs
** `$)`, `$]`, `$#` and `$<ws>` do not interpolate in `rx:P5//` constructs
* Assigning a `List` into a `Scalar` now vivifies it into an `Array`
* Assigning to pairs now works as expected
* Autoextracted `$_` is now `rw` by default
* Better handling for size extensions and `exists()` for negative indices
* Bindings implemented for multiple variables
* Experimental support for `eval_haskell()` builtin
* First stab at a lexical `$*CWD` variable 
* Index in slices now defaults to List: `@a[func_returns_array()]` now works
* Initialize readline properly in interactive shell
* Junctive types in subroutine signatures `sub foo (Str|Array)`
* New builtins: `>>~<<`, `kill()`, `splice`, `readdir()` (list context only)
* Pairs are now always objects and never values
* Passing too many slurpy arguments is now an exception
* Regexps now support `:P5` and `:Perl5` as well as `:perl5`
* Storing into negative array elements now works
* The `Any` parameter type no longer inhibits juctive autothreading
* Variables in rvalue context no longer returns its references
* `%h<>` now acts just like `%h{}` in both lhs and rhs
* `%h<x>` now means `%h{'x'}` instead of `%h{'x',}`
* `'key' => val` now works as named param just like `key => val` did
* `(sub {3} | sub {2})()` implemented
* `:P5` flags now work as `:P5<imsgx>` and `:i` `:g` works too
* `:l filename` no longer needs double quotes in the Shell
* `<>` (list quoting) is now always in list context
* `is rw` and `is copy` implemented in full
* `list()` now actually imposes list context
* `want()` has been implemented, returning a simple string

== Tests, Examples and Documentations

* Many new tests and cleanup of older tests, we are now at 4500+ tests
** removed all usages of todo_* functions since the are now deprecated
* Added `isnt()`, `unlike()`, `skip_rest`, `throws_ok` functions to `Test.pm`
* Added some Perl 6 related talks in `docs/talks`
* Added the `make smoke` target to `Makefile`
* Additions and improvements to the `util/catalog_tests.pl` scripts
* Improvements to `examples/network` and added README file
* Improvments to the `util/p5_to_p6.pl` script
* Major refactoring of the Test.pm module (see `ext/Test/ChangeLog` for details)
* Memory game, first web application written in Perl 6
* New Perl 6 tutorial generator ported to Pugs in `examples/tutorial_gen/`
* New naive baysian text classifier add in `examples/naive_bayesian`
* New quote generator script in `examples/motd`
* Params are now loaded on-demand in `CGI.pm` to take advantage of encoding
* Several new additions to the Perl 6 Cookbook
* Svn graphing script added to `util/`
* Test smoke scripts converted to use `Test::Tap::Model`
* The `fp.p6` file has been broken into seperate files in `examples/fp/`
* UTF-8 URL decoding added to `CGI.pm`

== Bug Fixes

* Accessing `@array[1000]` (without setting it) no longer extends `@array`
* Code blocks as subroutine arguments now results in correct arity
* Code objects now returns the correct subtypes
* Comma is no longer flattened as arguments for infix and postfix functions
* Corrected `chmod` prototype
* Fixed infinite bug when evaluating `+((1|2).values)`
* Fixed passing references into bound variables in subroutines
* Fixed segfault with `:r` in interactive shell
* Hyper operators now extends to the longer, not shorter, lists
* Inf/NaN handling for `**` now works
* Manpage for `Perl6::Pugs` now generated correctly
* RValues at the right hand of array assignment are flattened to prevent loops
* Restore `%h<str> = want()` to impose string context on rhs
* Setting `$*CWD` to invalid directory is no longer fatal
* Slurpy params now applies *-flattening to its arguments
* `$x = 1|2; $x = 3` no longer treats `1|2` as a constant
* `%h<a>` or `%h{'a'}` no longer eats trailing spaces interpolated strings
* `(1,(2,3))` in scalar context is now `[1,[2,3]]`
* `**` no longer truncates the exponent to integer
* `=` now assigns correct slurpy context to rhs
* `=cut` without a newline at EOF is now parsed correctly
* `return() if 1` now works correctly

= Changes for 6.2.0 (r1921) - April 13, 2005

== Pugs Internals

* Major refactor of ITypes subsystem, we now have:
** Nested structures: `$a{1}[2]{3}`
** Autovivification: `$a{1}[2]{3} = <b>`
** Tied magic: `%ENV<USER>`
** Proxy scalars: `%ENV<PATH> ~= '/tmp'`
** Slice assignment: `@x[1,2] = <a b>`
** Anonymous arrays: `[1..10][0] = 0`
** Lazy IArray structures: "Infinite lists, constant time"
** Infinite slices: `@x[1...]`
** and much much more ...
* Experimental support for link external Haskell libraries
** One such module is SHA1.pm: http://tpe.freepan.org/repos/ingy/SHA1/
* New builtins:
** `sum`, `log`, `log10`, `sign`, `pi`, `tan`, `cos`, `atan`
** `zip`, `hash`, `pair`, `isa`, `bytes`, `chars`, `codes`, `graphs`
* New type specific builtins;
** `.kv`, `.pairs`, `.delete`, `.exists`
** `.pick`, `.keys`, `.values`
* Several file test operators
** `-r`, `-w`, `-x`, `-e`, `-z`, `-s`, `-f`, `-d`
* Support for `$*UID`, `$*EUID`, `$*GID`, and `$*EGID` on *nix
* Stacked file test operators now (mostly) work
* Added `is rw` trait for subroutine parameters
* `$*PID` now works on *nix systems 
* Several command line switches implemented: `-I` `-p` `-n` and more
* `s:perl5/.../{ <code> }/` works correctly
* Type casting errors are now more descriptive
* `require ""` now works on UTF-8 files
* Regex substitution is now UTF-8 safe
* `sort {}` now works
* Some support for the /splat/ star `*` 

== Tests, Examples and Documentations

* Many new tests and cleaning up of older tests, we now have 4200+
* `examples/games/hangman.p6` added, with `AUTHORS` as the dictionary file
* `READTHEM` added; recommended reading for aspiring Pugs hackers
* The Perl 6 Cookbook is well underway at `examples/cookbook/`
* Working perl6 modules added to `ext/`
** CGI.pm
** lib.pm
** HTML::Entities
* Several Working Drafts added to `docs/`
** Apocalypse 20 - Debugging
** Synopsis 26 - Perl Documentation
** Synopsis 28 - Special Variables
** Synopsis 27 - Perl Culture (with CPAN drinking game rules)
** Synopsis 29 - Builtin Functions
* Early work on Perl 6 Object System in `docs/class/`

== Bug Fixes

* Parens no longer required for; `last()` and `return()`
* Fixed issue with binding invocant parameters
* Fixed parsing issue with `lc $, $y`
* `$_` now behaves correctly in most cases
* `exit()` now triggers `END {}` correctly
* `undef $x` now works correctly ($x is rw)
* Fixed parsing of default parameters: `sub foo (+$x = 3, +$y = 4)`
* `say` and `print` now default to `$_`
* `map { ... } @list` now parses correctly
* `loop { ... }` now works correctly
* `int(3) + 4` now parses correctly
* Fix parsefail bug on false unaries
* `for (@list)` no longer flattens `@list`
* `$var.method $param` is now illegal: use `$var.method($param)`
* `readline()` in list context is no longer evaluated lazily
* `$list.join('|')` now works
* `xor` and `^^` now returns the true operand instead of `bool::true`
* Named bindings to `%_` repaired

= Changes for 6.0.14 - April 4, 2005

== Pugs Internals

* We now require GHC 6.4 on all platforms
* Added socket primitives: `listen()`, `connect()`, `accept()`
* Added thread primitives: `async()`, `yield()`
* Added string primitives: `chr()`, `ord()`, `hex()`, `split()`
* Adverb pairs: `:key(123)`, `:key<abc>`, `:key[1,2,3]` and `:key`
* `pugscc` may now be invoked outside the pugs source tree
* `slurp()` now works on IO handles
* Non-interpolated `q//` literals
* Tentative `%?CONFIG` hash
* `pugs -V:configvar` now displays that config variable
* Command line improvements (`-I`, `-l`, `-e`, etc.)
* Minimal IMC compiler as `src/IMC.hs`
* Began work on GADTs; the Pad now holds `Symbol Val` types only
* Support definition and invocation of subs with namespaces

== Tests, Examples and Documentations

* Many new tests: we have around 3850 now
* `modules/` have been relocated to FreePAN. See `modules/README`
* `t/Synopsis/` have been relocated to `Perl6::Bible` on CPAN
* HTML generated by testgraph now responds to mouseover
* New autosmoker script added
* Many cross-referencer improvements
* Normalize all `t/` to begin with `#!/usr/bin/pugs`
* `VICTUALS` file added on April Fools
* Debian package scripts in `debian/`
* Updates on the Vim syntax file as `util/perl6.vim`
* `Pugs::MakeMaker` is renamed to `Perl6::MakeMaker`
* First Pugs obfuscation in `examples/obfu/`
* HTTP server and client examples in `examples/network/`

== Bug Fixes

* `~~` now takes variables on the right hand side
* Correct installation locations for `ext/` modules
* `{ block }` in `qq` and `rx` no longer skips trailing whitespaces
* `pugs -e` may now use `@*ARGS` in the one-liner
* `rx:perl:g` no longer ignores the `:g`
* `$:x` and `$.x` now parsed as variable names
* Readline support is correctly probed on `Makefile.PL` time
* Mimick Perl 5's behaviour for function that defaults to `$_`

= Changes for 6.0.13 - March 27, 2005

== Pugs Internals

* Support for `given`, `when` and `elsif` statements
* Support for Perl5 style `-I` on the command line
* Command line equivalents of shell commands `:i` and `!`
* Regex now supports `s:perl5///` and `s:perl5:g///`
* `$1`, `$2` etc can be used in `s:perl5:g///` substitutions 
* Experimental *pugscc* backends generating limited Parrot and Haskell code
* Refactored the /VSub/ type to support currying 
* Support for currying: `&foo.assuming(param => 'bar')`
* New file test primitives: `-d` and `-f`
* New logical primitive: `?|`
* Experimental support for `eval_perl5` (not built by default)
* Experimental Inline support; see `ext/SHA1` for example 
* New magicals: `$*EXECUTABLE_NAME` and `$*PROGRAM_NAME`
* Several numeric builtins: `atan2`, `cos`, `sin`, `sqrt`, `exp`
* Beginings of a Pugs class meta-model

== Test, Examples and Documentations

* New test for junctions, regexp and more; about 3200 tests now
* Added 200+ new TODO tests for objects in `t/oo/`
* Added 20 new Perl 5 modules ported to Perl 6
* Added `t/README`, `modules/README` and `modules/PORTING_HOWTO`
* Much work on the test-cataloger and Synopsis cross-referencer
* Work on plan for smoke testing framework using *YAML* and *Test::Harness*
* Work on HTML output gathered from *Test::Harness* YAML output
* Actual working port of most of *File::Spec* complete with tests and docs
* Added support for outputing test logs with *Test.pm*
* Added documentation to *pugscc*
* Several TODO tests for command line options
* `fix_authors.pl` now handles UTF8 input 
* New golf-based tests in `t/examples/golf.t`
* Added `examples/mandel.p5` for benchmarking against `mandel.p6`
* The first JAPH for Pugs in `examples/japh/`

== Bug Fixes

* Numification now uses the same lexer as numeric literals
* Passing pairs to named parameters works
* Fixed 2-element lists to be proper pairs
* Fixed some error reporting issues in *Test.pm*
* `$!` now has the correct value after `eval`
* `END {...}` now runs after `die`
* Hash keys are now strings
* Contextual logicals like `+^` and `~^` are parsed correctly

= Changes for 6.0.12 - March 21, 2005

== Pugs Internals

* We now require GHC 6.4 on Win32
* Perl5-compatible regular expressions as rx:perl5/.../
* Unicode identifiers now work across all platforms
* Smartmatch ~~ for regex
* Capturing variables as $/.[], $0, $1, $2
* Nested outward CALLER::CALLER::CALLER:: scopes
* x=, xx= and Y=
* => now autoquotes left hand barewords
* ?? :: now parses correctly
* New primitives: index(), rindex(), substr(), sort(), true()
* New primitives: lcfirst(), ucfirst(), lc(), uc(), split()
* New primitives: pick(), values(), nor
* The interactive shell now preserves lexical variable declarations
* String numification now uses the same lexing rule as numeric literals
* Kludgy hack for &sub.goto() now works
* :l in interactive shell for loading modules
* More experimental shell commands like :i and !
* Symbol table now contains Vals instead of Exps

== Tests, Examples and Documentations

* Massive reorganization for t/ hierarchy; we have 2450 subtests now
* Test coverage catalog utility in util/catalog_tests.pl
* New p6ified CPAN modules: Algorithm::Dependency, File::Spec
* Core documentations moved into ext/Pugs-Documentation/
* Locale::KeyedText is made more perl6ish with subtypes
* Test.pm has been massively refactored, and now has its own test suite
* isa_ok(), eval_ok() and eval_is() in Test.pm
* perlpodspec.kwid, describing POD document model and dialects. 
* perlkwidspec.kwid, specification for the Kwid dialect of POD
* PA01.kwid, Kwid version of Pugs Apocryphon 1
* Perl5-Kwid, Perl 5 implementation of the Kwid language

== Bug Fixes

* Infix junction constructors no longer falltens its operands
* Mutable variables are now properly pretty-printed
* "pugscc" was broken on case-sensitive filesystems
* last() no longer work as return() outside loops
* Pugs could not install when perl5's sitelib path did not contain "perl"
* := binding did not preserve the lexical scope at the binding site
* Hanoi.p6 was broken due to premature binding of subroutine parameters
* "&sub.foo" no longer attempts to interpolate

= Changes for 6.0.11 (r690) - March 14, 2005

== Pugs Internals

* Ported to GHC 6.4 final
* Source code is now always treated as UTF-8
* Unicode variable names and subroutines now works, if GHC
  is compiled with unicode support
* We no longer look for Perl6::lib::* namespace in Perl 5;
  Pugs now has its own library path independent from Perl 5
* New primitives: scalar(), list(), reverse(). 
* Infix Y (and its UTF8 form)
* $! is now set after an eval call
* Stub implementation for ~~ and !~ operators
* "make optimized" and "make profiled" targets
* Assignment to array slices
* Assignment now copies variables in RHS, instead of aliasing them
* Declaration of multiple variables with my()
* try {...} works
* Hash stringification
* Lone block without trailing semicolon is parsed correctly
* time() now counts seconds from 2000-01-01 00:00:00
* Assignment operators like .=, //= and ||= etc
* Postfix conditionals now works inside expressions
* --help and -c command line options
* Experimental support for "pugscc", which compiles Perl 6 code
  into stand-alone executables

== Tests, Examples and Documentations

* Much more extensive TODO tests; we have 1477 now
* Sample Perl 6 modules under modules/, including Sample-Module and
  Locale-KeyedText (ported from Perl 5 on CPAN)
* Kwid version of PA01; updated Chinese translations
* One can now build Pugs with Perl 5.6
* examples/sendmoremoney.p6 now really works
* A new, much prettier banner ASCII art
* New junction examples in examples/junctions/
* New golf-based examples in examples/golf/
* Include IRC nicks and UTF8 names in AUTHORS
* Some releng and utility scripts under util/

== Bug Fixes

* In pointy subs, -> () {...} and -> {...} are now distinguished
* require() now reports errors correctly
* Magical $a++ when $a is a string should not return a numified form
* int() now properly truncates, instead of rounds, the operand
* Array and hash variables inside qq strings now won't interpolate without
  explicit brackets, as specced in S02
* my $a == $b no longer parses are my $a = =$b
* Nested ?? :: now parses correctly, even inside brackets
* Postfix ... works again
* [...] is now evaluated in list context
* Duplicate occurence of implicit params like $_ and $^x now works correctly
* =<> now reads the first file in @*ARGS if there is a @*ARGS; it is a TODO
  to make it read all files in @*ARGS
* List associativity now works again
* $?CALLER:: variables in subroutine parameters and defaults are
  now both evaluated in the caller's scope

= Changes for 6.0.10 - March 5, 2005

== Pugs Internals

* Massive `-Wall` cleanup
* Some work on Pugs extension mechanisms (XS for Pugs)
* Complete reworking of the build system
* Support for basic read, write, append I/O
* Added `system()`, `chmod()`, `chop()` and `chomp()`
* Pretty printing now works
* Added the beginings of a Config module
* Ported to GHC 6.4 pre-release
* More works on junctions

== Tests, Examples and Documentations

* Test, tests and more tests, we now have over 1050
* Added several tests for unimplemented features
* Added tail recursive nested worker multisubs into `fp.p6`
* New example: `hanoi.p6`
* Several new junctions examples
* Switched most documentations to the Kwid format
* zh-cn and zh-tw translations of the Apocryphon
* Haskell source documentation begun
* Kwid documentation for `Test.pm`

== Bug Fixes

* Fixed double-evaluation bug in `say($a++)`
* Fixed `@a` interpolation bug
* Postfix `--` now returns the value instead of numified value
* Lone bare blocks in statement level are now always executed
* Fixed `grep`/`map`/`push`/`unshift` parsing so they are properly binOp now
* Fixed prefix function parsing bug that eats more parens than it should

= Changes for 6.0.9 (r335) - February 28, 2005

* First Perl 6 module: `Test.pm`
* First Pugs Apocryphon: `docs/01Overview.html`
* More than 600 unit tests, with a comprehensive coverage
* Relicensed under GPLv2 and Artistic2.0b5
* New flags: `--version`, `-v`, `-c`
* New examples: `examples/fp.p6`, `examples/shuffle.p6`
* New syntaxes: `?? ::`, `our()`, chained `=>`, `END{}`, `=begin END`, `unless`
* New primitives: `defined()`, `unlink()`, `ref()`, `join()`, `require()`, `int()`
* New magicals: `$?SUBNAME`, `%*ENV`, `&?BLOCK`, `&?CALLER_CONTINUATION`, `@*INC`
* New literals: `\d1234`, `0d1234`, `qq[]`, `qw[]`
* Interpolation in double-quoted strings
* Hashes and subscripting
* Bare blocks now assumes outer scope's lexical pad
* Bare blocks in statement level is now always executed
* Closures closes properly; errors are propagated upwards
* A first draft of /Kwid/ documentation format
* A first draft of builtins declarations

= Changes for 6.0.8 - February 21, 2005

* New example code snippet: `examples/quicksort.p6`
* Unit tests ported from th Perl5 tree
* Hashes, Pairs and their access methods
* Much more robust casting between arrays, lists and hashes
* Fixed harness output problem on older perls
* Many Posix-based IO primitives
* Precedence for builtin unary/list functions are parsed correctly
* `unless` construct
* New primitives: `join`, `split`, prefix `++` and `--`
* `+>>` etc changed to `+>` etc
* Stacking multiple prefix and postfix operators now works
* `@*INC`, `&?SUB`, `CALLER::`
* Tests for the /perlego/ dialect
* User-defined function applications now takes arbitary expressions
* Deep recursion detection

= Changes for 6.0.7 - February 18, 2005

* Beginning of synopses-based unit tests
* Two code snippets that runs: `examples/life.p6` and `examples/mandel.p6`
* Code literals -- /sub/, /pointy/ and /bare/ variants all works
* Lexical subroutine declarations via `my sub`
* The `say`, `exit`, `die`, `time`, `open`, `close` primitives
* `Bool.perl` now prints correct literals
* Blocks under void contexts now evaluates automatically
* The `...` (dotdotdot) literal
* Errors are propagated upward using shiftT
* Postfix `++` and `--`
* Ternary `?? ::`
* Assignment to mutable variables and to array slices
* `loop`, `for` and `if` constructs

= Changes for 6.0.5 - February 15, 2005

* The `rand` primitive
* Taking references of junctions no longer create a junction of references
* Illegal divisions are caught
* Chained comparison for four or more terms now works
* Collapsing for /JuncOne/ into two sets: the `none` set and the `one` set
* The evaluator now prints some helpful debugging messages
* New parser logic merged from Michaud and Palmer's `Perl6.grammar`
* Extra semicolon and whitespace in blocks are dealt with
* Space around punctiation operators is now optional
* The /Eval/ monad now supports `shift`/`reset`/`callcc`, lexical and dynamic scopes
* Improved pretty-printing code for syntactic constructs

= Changes for 6.0.4 - February 12, 2005

* The `eval` primitive
* Refactor junctive logic into `Junc.hs`
* /JuncAny/ and /JuncAll/ now collapses operands of the same type correctly
* /JuncOne/ now collapses into an empty set when operands contains duplicates

= Changes for 6.0.3 - February 12, 2005

* Formal parameters declaration and binding
* Invocant-based multimethod dispatch
* Optional(`?`), named(`+` and `++`), slurpy(`*`) parameters with defaulting
* Extraction of higher-order placeholder variables
* Proper semantics and extraction of `@_`, `%_` and `$_`
* Global variables and subroutines: `&*foo`, `$*bar`
* Context propagation from types of formal parameters
* The `returns` / `is returns` trait
* Trailing comma and semicolons are now allowed
* Better handling of exponential primitives
* &prefix: is now consistently added for user-defined subroutines
* Junctions are now proper sets, instead of lists masqueraded as sets
* New operators: `!!` and `nor`
* The `all` junction builder now collapses nested junctions under it

= Changes for 6.0.2 - February 9, 2005

* User-defined subroutine with `$_` and `@_` as parameters
* Variable binding
* Context propagation
* Multimethod dispatch
* Subtype distancing and casting
* Autothreading over chained comparison and multiarg functions
* List associativity
* Array references as literals
* Flattening (slurpy) star

= Changes for 6.0.1 - February 7, 2005

* Fix building on Mac OS X
* Characters in single quotes should not be escaped
* Add one very basic test in `t/`

= Changes for 6.0.0 - February 7, 2005

* Initial CPAN release
* Evaluation of most simple expressions
* Junctions and chained comparisons
* Interactive shell and `#!/usr/bin/pugs` support