[t/spec] Create zip-metaop.t to test the new Zop.

[pugs.git] / ChangeLog

= Changes for 6.28.0 (rXXXXX) - June XX, 2007

== Licensing Changes

* The license for Pugs in general (not third-party components) is now
simplified to be just the final Artistic 2.0, rather than the disjunction
of the Artistic 2.0 beta 5 and the GPL.  Such a disjunction has no benefit
since the Artistic 2.0 is GPL compatible on its own.  This said, the
Artistic/MIT disjunction still exists where it did before.  So LICENSE/ now
contains the text of the Artistic version 2.0 final rather than the text of
the Artistic version 2.0 beta 5.

* LICENSE/ now contains the texts of the GPL version 3.0 and LGPL version
3.0 (which were published on 2007 June 29th), rather than the GPL version 2
and LGPL version 2.1.  All projects outside of third-party/ (which have
their own copies of their licenses) which were licensed under some member
of the GPL family allow the use of the newest versions, so there is no
reason to also retain copies of older versions in LICENSE/.

== Build System

* The config file that you must make in order to receive credit for smokes
is now named "smoker.yml" rather than ".smoker.yml"; this hand-made file
is now not hidden, which is consistent with Pugs' "config.yml" nature.

== Feature Changes

=== Interactive Shell and Command-Line Flags



=== Perl 5 Interoperability



=== Lexical Syntax



=== Declarators and Operators



=== Blocks and Statements

* Topicalisers for `if`, `elsif` and `else` blocks: `if EXPR -> $x {...}`

=== Regexes and Grammars



=== Modules and Routines



=== Classes and Objects



=== Built-in Primitives



== Bundled Modules

=== New modules

* [ext/HTTP/] - A general purpose HTTP toolkit for Perl 6
* [ext/MessageBus/] - Message Bus with PubSub protocol
* [ext/Muldis-Rosetta/] - Full-featured truly relational DBMS in Perl
** This is a rewrite of ext/Rosetta/, which is now deleted
** Note, any further release changes for Muldis Rosetta will be detailed in
   its own Changes file rather than the general Pugs ChangeLog file
* [ext/Web/] - A general purpose Web toolkit for Perl 6


=== [ext/Locale-KeyedText/]

* Added French localization file lib/Locale/KeyedText/L/fr.pm

=== [ext/<Foo>]



== Test Suite

=== [util/<foo>]



=== [t/]



== Examples and Utilities

=== [examples/]



=== [examples/<foo>]



=== [misc/<foo>]



== Documentation

=== [docs/<foo>]



== Perl 6 on Perl 5

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



=== [v6/]



== Experimental projects

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



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



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




= 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 `while` and `given` blocks: `while EXPR -> $x {...}`
* `&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
* FA-DFA

=== 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
* XML::SAX
* 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
* `SUPER::`, `BUILDALL` and `DESTROYALL`
* `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