Perl6-Pugs - Changes

Changes for 6.2.13 (r14402) - October 17, 2006

== Build System

Perl 5 embedding is now enabled by default ** For Windows users, Perl 5.8.x is required ** Set the `PUGS_EMBED` environment variable to `noperl5` to disable this
Prompting for Parrot embedding is now disabled by default ** Set the `PUGS_EMBED` environment variable to `parrot` to enable this
Support for compiling using GHC 6.6 ** GHC 6.4.1+ is still supported, but 6.6 will be required in the next release

== Feature Changes

=== Interactive Shell and Command-Line Flags

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

=== Perl 5 Interoperability

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

=== Lexical Syntax

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

=== Declarators and Operators

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

=== Blocks and Statements

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

=== Regexes and Grammars

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

=== Modules and Routines

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

=== Classes and Objects

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

=== Built-in Primitives

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

== Bundled Modules

=== New modules

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

=== [ext/CGI/]

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

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

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

=== [ext/Rosetta/]

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

=== [ext/Set-Relation/]

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

=== [ext/Test/]

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

== Test Suite

=== [util/prove6]

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

=== [util/smartlinks.pl]

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

=== [util/smokeserv/]

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

=== [t/]

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

== Examples and Utilities

=== [examples/]

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

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

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

=== [misc/runpugs/]

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

== Documentation

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

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

=== [docs/Perl6/Spec/]

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

=== [docs/Pugs/Doc/]

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

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

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

== Perl 6 on Perl 5

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

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

=== [v6/]

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

== Experimental projects

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

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

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

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

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

An Perl 6 implementation on Ruby 1.9+
See its own documentation for more information
- Changes for 6.2.12 (r10930) - June 26, 2006

== Licensing Changes

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

== New Perl 6 modules

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

== Updated modules

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

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

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

== Test, Examples and Documentations

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

== Feature Changes

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

== Bug Fixes

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

== Bundled Modules

=== New Perl 6 modules

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

=== Updated modules

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

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

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

== Test, Examples and Documentations

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

== New Features

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

== Bug Fixes

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

== Backends

=== JavaScript backend

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

=== Parrot backend

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

=== PIL^N backend

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

=== Perl6-ObjectSpace

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

== Feature Changes

=== Shared components

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

=== JavaScript backend

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

=== Perl 5 backend

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

== Bug Fixes

=== Shared components

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

=== JavaScript backend

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

== Bundled Modules

=== New Perl 6 modules

Perl6-Container-Array, Perl6-Value-List ** Prototype modules for implementing Lazy lists in Perl 6
Log-Selective
Cipher - Cipher API suite for cryptographic ciphers
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 `cruderepl.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 PUGSSAFEMODE 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 `evalyaml()` 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 `evalhaskell()` 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