root/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