[RELEASE] Pugs 6.2.5 is released!

[Autrijus Tang]

On behalf of the Pugs team, I am elated to announce the release of
Pugs 6.2.5, with much more comprehensive OO support, hyper and reduction
metaoperators on user-defined operators, as well as experimental
coroutine support.

Also of note is `pugs.pm` and `Inline::Pugs`, two Perl 5 modules that
lets you inline Perl 6 code in Perl 5 programs. The docs/quickref/
series of documents is also helpful as a companion to the Synopses.

You can download Pugs from a nearby CPAN mirror, or from pugscode.org:

http://pugscode.org/dist/Perl6-Pugs-6.2.5.tar.gz
SIZE = 1012358
SHA1 = d3e02bb907702850a847d410da046609

A Pugs/Parrot live CD, contributed by iblech, is available as well:

http://linide.sf.net/pugs-livecd-6.2.5.iso

Amazingly, the project's velocity is still increasing, with 680 new
commits, compared to 507 from 6.2.3. The graph below shows the growth
of number of commits and committers:

http://linide.sourceforge.net/pugs-svngraph-6.2.5.png

Again, my sincere gratitude to all lambdacamels for making this release
as exciting and enjoyable as it is. See you next week!

Thanks,
/Autrijus/

== 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 and 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 inline Perl 6 into 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` now gives better diagnostics to `cmp_ok()`
* `fp` module added for functional programming

=== Tests, Examples and Documentations

* Many new test and 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 as `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 into `t/rules/`
* Removed usage of `force_todo()` in favor of `:todo`

=== Bug Fixes

* Bare blocks containing `$_` is now executed correctly
* Correct parsing for user-defined nullary functions
* Hash and array sub parameters are read-only by default, same as scalars
* Post-term invocation in interpolation no longer eat 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)` can now MMD dispatch over all 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

[Vadim]

> On behalf of the Pugs team, I am elated to announce the release of
> Pugs 6.2.5, with much more comprehensive OO support, hyper and reduction
> metaoperators on user-defined operators, as well as experimental
> coroutine support.
>

Could you please advice, how is it possible to use external library, or
better just C code?
Perl6 <-> C binding.

Should I use Haskell for this? Should I use parrot?

To be more concrete, I want to start using Tcl/Tk from within perl6
(like currently Tcl::Tk CPAN module does this)
At first I tried TclHaskell, which currently is out of date, and it took
considerable efforts for me, unknowledgable in Haskell, to make it
compile, but even after that is is non-trivial to move on, however seems
doable.

Which approach will you advice?

TIA.

Best regards,
Vadim.

[Autrijus Tang]

I think the best bet yet is to use Perl5's Tk binding, either by
improving Inline::Pugs or improving Pugs's Perl 5 embedding support.
The first one may be easier.

Thanks,
/Autrijus/

[Vadim]

В Втр, 24.05.2005, в 14:58, Autrijus Tang пишет:

Perl5's Tk binding is based on older Tk verion, so I, personally, prefer
using more up-to-date Tcl/Tk via Tcl::Tk.

But my personal preferences left aside, and returning to more general
question, what is most preferable way for *any* C library binding?
Is it via Perl5 currently?
(look at Tcl/Tk like ordinary C library)

Any chances on using Haskel's C support? Parrot?

PS. As long as Tcl::Tk is much more lightweight compared to perlTk, it
could require less work on adopting it, anyway...

Best regards,
Vadim.

[Jonathan Worthington]

If I were doing this then I'd take my C library and write some kind of
wrapper for it using Parrot. Parrot's NCI (Native Call Interface) lets you
load a dynamically linked library/shared object and call functions in it (I
once wrote a script that auto-gen'd Parrot calls for the entire Win32 API).
Then you can write a Perl6 module that inlines PIR (Parrot code) that loads
your Parrot code wrapping the C library and calls the functions you want,
and wrap all of this again in some nice Perl 6 module/class.

I believe that the plan is that Pugs will be re-written from Haskell into
Perl 6, so writing your binding to the C library with Haskell's support for
doing so probably won't be a long-term solution to your needs.

Hope this helps, and corrections welcome (all(qw/beer wine baileys/) ==
none(@good_idea) ;-)).

Jonathan