October 2006 - Haskell

Re: Haskell Weekly News: September 27, 2006
by Cyril Schmidt 24 Oct '06

24 Oct '06

Donald Bruce Stewart wrote: >Conference roundup > The [41]Commercial Users of Functional Programming workshop (CUFP), > held in association with [42]ICFP, attracted a record turn-out this > year. [...] > * Haskell programming at Credit Suisse. Howard Mansell talked about > Haskell programming at [44]Credit Suisse in New York. Sadly, I was unable to attend. Is the presentation, by any chance, available online? Pointers to other related info will be much appreciated. (Yes, I know that a report of the conference will be published, but that won't happen before December :( Regards, Cyril

4 5

Pugs gains SMP parallelism support.
by Audrey Tang 23 Oct '06

23 Oct '06

I hacked +RTS -N support into Pugs today; here's a short writeup: http://pugs.blogs.com/pugs/2006/10/smp_paralleliza.html Pugs's current implementation for concurrent operations on lists is very naive: chan <- newChan forM ([0..] `zip` xs) $ \(n, x) -> forkIO $ do rv <- runEvalIO env (reduce x) writeChan chan (n, rv) fmap (map snd . sort) (replicateM (length xs) (readChan chan)) While the initial result on Linux 2.6 is encouraging, on OSX/Intel with two CPUs it actually slightly slows down the program when running on -N2 or above. I wonder if there is a more efficient way doing this... Thanks, Audrey

5 12

ANN: MissingH 0.16.0
by John Goerzen 19 Oct '06

19 Oct '06

Hello, The latest version of MissingH is now up at http://quux.org/devel/missingh The changes for this version are: * NEW: MissingH.Quantity that is used to render numbers as binary units (MB, KB, etc) or SI units, or other similar units * NEW: MissingH.ProgressTracker that is used to track the progress of long-running tasks, measure their speed, and give estimated completion times * Update to support GHC 6.6 + Remove FiniteMap support everywhere (no longer supported in GHC) + Remove MissingH.Printf (has been deprecated since 0.13.0 due to Text.Printf) + Update README + Fix MissingH.FTP.Server for GHC 6.6.0 compatibility + Update cabal file for GHC 6.6 compatibility * Patch from Jeremy Shaw to add to MissingH.HUnit the ability to turn QuickCheck tests into HUnit tests * Patch from Joe Edmonds to MissingH.Wash.Mail.MailParser to accept a slight violation of RFC2822 in which date headers may have a single-digit date * Fix a logic error in MemoryBuffer's vPutStr that could corrupt data when a write occurs after a seek, and wrote a test to detect this condition. Thanks to Bulat Ziganshin for finding this. * New function in MissingH.List to merge two sorted lists into a single sorted whole. Patch from Clifford Beshers. * Work around lack of signals on Windows in MissingH.Cmd. * Make sure Data.Bits is imported in MissingH.IO.StatCompat. -- John Goerzen Author, Foundations of Python Network Programming http://www.amazon.com/exec/obidos/tg/detail/-/1590593715

1 0

cabal/haddock
by Johannes Waldmann 19 Oct '06

19 Oct '06

Hello. What's the current state of Haddock support in Cabal? I checked that "runhaskell Setup.hs haddock" works fine, but how can I reference the documentation of (cabalized) package Y from the docs of package X? - Last I asked this, the answer was "write your hooks in Setup.hs" but I was hoping that meanwhile I could just put the info in the .cabal file. -- -- Johannes Waldmann -- Tel/Fax (0341) 3076 6479/80 -- ---- http://www.imn.htwk-leipzig.de/~waldmann/ -------

2 1

Haskell Weekly News: October 19, 2006
by dons＠cse.unsw.edu.au 19 Oct '06

19 Oct '06

--------------------------------------------------------------------------- Haskell Weekly News http://haskell.org/haskellwiki/HWN Issue 45 - October 19, 2006 --------------------------------------------------------------------------- Welcome to issue 45 of HWN, a weekly newsletter covering developments in the Haskell community. A big week, with a swag of new releases, including the long awaited GHC 6.6. Announcements * GHC version 6.6. The GHC Team [1]announced a new release of GHC! There have been many changes since the 6.4.2 release. For details, see [2]the release notes. Binary builds, source and packages are all found at [3]GHC's home. 1. http://article.gmane.org/gmane.comp.lang.haskell.general/14367/ 2. http://haskell.org/ghc/docs/6.6/html/users_guide/release-6-6.html 3. http://www.haskell.org/ghc/ * Haddock version 0.8. Simon Marlow [4]announced Haddock 0.8, including: cabalisation, Hoogle support, image inclusion. [5]Read more. 4. http://article.gmane.org/gmane.comp.lang.haskell.general/14358/ 5. http://www.haskell.org/haddock * Pugs 6.2.13 released. Audrey Tang [6]announced that after nearly four months of development and 3400+ commits, [7]Pugs 6.2.13, the leading Perl6 implementation written in Haskell, is now available. 6. http://pugs.blogs.com/pugs/2006/10/pugs_6213_relea.html 7. http://pugscode.org/ * STM invariants and exceptions. Tim Harris [8]announced that new transactional memory features have been committed to GHC. The main change is to add support for dynamically checked data invariants of the kind described in [9]this paper (pdf). There are two operations: always X :: STM Bool -> STM () and alwaysSucceeds X :: STM a -> STM (). More details in [10]here (pdf). 8. http://article.gmane.org/gmane.comp.lang.haskell.general/14356/ 9. http://research.microsoft.com/~tharris/papers/2006-transact.pdf 10. http://research.microsoft.com/~tharris/papers/2005-ppopp-composable.pdf * Cabal version 1.1.6 is now available. Duncan Coutts [11]announced that [12]Cabal, the common architecture for building applications and libraries, version 1.1.6 is now available. It is included in GHC version 6.6. 11. http://article.gmane.org/gmane.comp.lang.haskell.libraries/5228/ 12. http://haskell.org/cabal/ * Fun in the Afternoon: Thurs 16th Nov in Oxford. Jeremy Gibbons [13]announced that he, Graham Hutton and Conor McBride at Nottingham are organizing a seminar, [14]Fun in the Afternoon, on functional programming and related topics. The idea is to have a small number of talks as an antidote to mid-term blues, three afternoons a year. The hope is that talks will be informal and fun, and that there will be plenty of scope for discussion and chat as well. Looks fun! 13. http://article.gmane.org/gmane.comp.lang.haskell.general/14373/ 14. http://sneezy.cs.nott.ac.uk/fun/ * HC&A Call for Contributions. Andres Loeh [15]asked for contributions towards the 11th [16]Haskell Communities & Activities Report, a bi-annual overview of the state of Haskell as well as Haskell-related projects of all flavours. 15. http://article.gmane.org/gmane.comp.lang.haskell.general/14384/ 16. http://www.haskell.org/communities/ * Generic Haskell version 1.60 (Diamond). Utrecht's Generic Haskell Team [17]announced a new release of [18]Generic Haskell, an extension of Haskell that facilitates generic programming. Generic Haskell includes: type-indexed values and type-indexed types. The Generic Haskell compiler takes Generic Haskell source and produces Haskell code. This release adds support for Generic Views. 17. http://article.gmane.org/gmane.comp.lang.haskell.general/14374/ 18. http://www.generic-haskell.org/ * Streams 0.1 available for GHC 6.6. Bulat Ziganshin [19]announced that the Streams 0.1 library is now compatible GHC 6.6. 19. http://article.gmane.org/gmane.comp.lang.haskell.general/14383/ Haskell' This section covers the [20]Haskell' standardisation process. * [21](Pattern) Guards in lambdas 20. http://hackage.haskell.org/trac/haskell-prime 21. http://thread.gmane.org/gmane.comp.lang.haskell.prime/1750/focus=1750 Discussion * GADT terminology. Oleg Kiselyov [22]argued that the term GADT should be reserved for truly generalised algebraic data types, and not just normal data types written in GADT syntax. 22. http://thread.gmane.org/gmane.comp.lang.haskell.general/14363/focus=14363 * Extended functionality for record field accessors. Henning Thielemann [23]proposed some record system extensions. 23. http://article.gmane.org/gmane.comp.lang.haskell.cafe/15944/ Jobs * Senior Back-end Web Application Developer. Lime Wire. [24]PhD a plus, extra credit for knowing Haskell. 24. http://www.crunchboard.com/job/1138 Blog noise [25]Haskell news from the blogosphere. * [26]First Steps with Haskell for Web Applications * [27]Haskell and Personal Publishing Platform Ramblings * [28]A type-based solution to the 'strings problem' * [29]5 Principles For Programming * [30]The Misguided Faith in Unit Tests * [31]The functional language that?s right under your nose * [32]Games, Strategies and the Self-Composition of the List Monad * [33]Flapjax - Functional Reactive Ajax * [34]Haskell-style parser combinators in Factor: s-expression reader * [35]Concepts behind the C# 3.0 language * [36]Explicit Typing, Trail Blazing, and Packrat Parsing * [37]What is so cool about Functional Programming? 25. http://planet.haskell.org/ 26. http://mult.ifario.us/articles/2006/10/11/first-steps-with-haskell-for-web-… 27. http://mult.ifario.us/articles/2006/10/18/more-haskell-and-personal-publish… 28. http://blog.moertel.com/articles/2006/10/18/a-type-based-solution-to-the-st… 29. http://empathybox.com/archives/8 30. http://blogs.concedere.net:8080/blog/discipline/software+engineering/?perma… 31. http://www.b-list.org/weblog/2006/10/11/functional-language-s-right-under-y… 32. http://sigfpe.blogspot.com/2006/10/games-strategies-and-self-composition.ht… 33. http://lambda-the-ultimate.org/node/1771 34. http://www.bluishcoder.co.nz/2006/10/factor-parser-combinator-example.html 35. http://www.codeproject.com/useritems/csharp3-concepts.asp 36. http://www.knowing.net/PermaLink,guid,0cc63c2f-e167-406d-a00e-4f390e9494f6.… 37. http://www.gaetanocaruana.com/2006/10/02/what-is-so-cool-about-functional-p… Quotes of the Week * M. David Peterson : With the help of our friendly local ex-professors and Haskell geeks Dr. Meijer and Dr. L�mmel, I have learned to stop worrying and love monad comprehensions * SamB: O(n^2) is better than O(hair-gone) * chessguy: I didn't think Pennsylvania had anybody cool enough to know Haskell in it * int-e: What, unsafeCoerce# is kind-preserving? How boring! * lennart: Floating point numbers are terrible. I maintain that before using them people should have an floating point drivers license * xerox: #haskell is a good code optimizer. * sigfpe: Haskell is so strict about type safety that randomly generated snippets of code that successfully typecheck are likely to do something useful, even if you've no idea what that useful thing is. About the Haskell Weekly News Each week, new editions are posted to [38]the Haskell mailing list as well as to [39]the Haskell Sequence and [40]Planet Haskell. [41]RSS is also available, and headlines appear on [42]haskell.org. The Haskell Weekly News is also [43]available in Spanish translation. To help create new editions of this newsletter, please see the [44]contributing information. Send stories to dons at cse.unsw.edu.au. The darcs repository is available at darcs get http://www.cse.unsw.edu.au/~dons/code/hwn 38. http://www.haskell.org/mailman/listinfo/haskell 39. http://sequence.complete.org/ 40. http://planet.haskell.org/ 41. http://sequence.complete.org/node/feed 42. http://haskell.org/ 43. http://haskell.org/haskellwiki/HWN/es 44. http://haskell.org/haskellwiki/HWN

1 0

ANN: Pugs 6.2.13
by Audrey Tang 19 Oct '06

19 Oct '06

(Cross-posted to haskell@, at the suggestion from Don Stewart) After nearly four months of development and 3400+ commits, I'm very glad to announce that Pugs 6.2.13 is now available: http://pugs.blogs.com/dist/Perl6-Pugs-6.2.13.tar.gz SIZE: 6839270 SHA1: b06b8434c64e9bb5e3ab482282fbae0a6ba69218 Motivated by increasing use of Pugs in production, this is an extra release in the 6.2.x series, offering another 200%+ improvement in performance, comprehensive support for interoperability with Perl 5 modules, a built-in grammar engine via native perl5 embedding, and much better support for roles, classes and objects. The web-based presence of Pugs and Perl 6 has improved as well: * http://run.pugscode.org/ puts the Pugs shell in your browser. * http://spec.pugscode.org/ annotates the Synopses with "smart-linked" tests. * http://smoke.pugscode.org/ annotates that further with fail/pass/todo records. * http://rakudo.org/perl6/ is a Wiki dedicated to collect Perl 6 related information. * http://www.programmersheaven.com/2/Perl6-FAQ offers a comprehensive FAQ on Perl 6. Thanks again to all lambdacamels on #perl6 for building this new ship together; it is truly an exhilarating voyage. :-) Have -Ofun! Audrey (The change log below is also available in HTML format: http://pugs.blogs.com/pugs/2006/10/pugs_6213_relea.html#more ) = Changes for 6.2.13 (r14401) - 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

1 0

HASKELL TUTORIAL WANTED FOR RHO 06
by Luigi Liquori 18 Oct '06

18 Oct '06

Dear HASKELL people. we are organizing in Kings College, London (23-24 october) one small workshop on the Rewriting Calculus. http://rho.loria.fr/workshop2006.html In one phrase, rewriting calculus http://rho.loria.fr/ is lambda calculus with sophisticated pattern matching features which is able to capture a large class of Term Rewriting Systems. *** Without any doubt, the closest functional language featuring pattern matching is HASKELL! *** We will be honored whether some UK-HASKELL "acholyte" could give to us a 1 hour talk about HASKELL, with a particular focus on pattern matching features and types, compilers, et al. Of course we would be happy to take any expense into account. We have already contacted some of us, but time is running ... In any case, we you will be happy to join us, to learn a bit about the Rewriting calculus (preliminary program attached!) All the best, Grazie mille, Luigi Liquori, Claude Kirchner and Maribel Fernandez (the WS organizers) -- Luigi Liquori, Ph.D, INRIA Researcher, Sophia Antipolis Project Team Mascotte Vox : +33 4 92 38 71 93 Fax : +33 4 92 38 79 71 Hom : +33 4 93 67 09 72 MobFr: +33 6 65 39 51 32 MobIt: +39 3 49 16 56 45 1 Off : Lagrange LS28 Url : www-sop.inria.fr/mascotte/Luigi.Liquori Eml : Let (*,#)=(.,@) in Luigi*Liquori#inria*fr Pst : INRIA, 2004 Route des Lucioles - BP 93 FR-06902 Sophia Antipolis, France

1 1

Lexically scoped type variables
by Simon Peyton-Jones 18 Oct '06

18 Oct '06

This message is about scoped type variables. I'm sending it to the Haskell mailing list, because I think that the question of scoped type variables is of general interest to Haskellers, but I suggest that you all send *replies* to Haskell Café, where this thread originated. Simon The thread was provoked by Nicholas's message about scoped type variables http://www.haskell.org/pipermail/haskell-cafe/2006-October/018947.html I've thought a lot about this scoped-type-variable issue, and failed to come up with a truly satisfactory solution. As several of you have noticed, GHC 6.6 changes design wrt GHC 6.4. Perhaps it'd help if I explained what the problem is, and then some of you may be able to figure out a better solution. For reference GHC 6.6: http://www.haskell.org/ghc/docs/latest/html/users_guide/type-extensions.htm… GHC 6.4: http://www.haskell.org/ghc/docs/6.4.2/html/users_guide/type-extensions.html… | I'd like to not have to introduce the forall, because with that comes | introducing the entire context of the type. Thus I have to maintain | any changes to the context, which I would prefer to leave to inference | for modularity's sake. | | In 6.4 I was able to fix this without having to introduce the forall; | I could introduce scoped type-variables in patterns to get the job | done. Well, there is something to be said for the forall approach [plan (B)] -- it is fully explicit, and you can see exactly what the program means. One way forward would be to allow you to abbreviate the context of the type signature (since that is often the awkward bit) to "...", and approach you mention as "partial type signatures". The only other reasonable alternative that I know of is plan (A), the one taken by earlier versions of GHC, and OCaml. As Oleg puts it: | Which of the two occurrences of the type variable |'a| a binding one? Who | cares... It just works: within the same expression, the same type | variable stands for the same type. (I think it does matter which the binding occurrence is, because Oleg's comment begs the question "when are two type variables in the same expression?". In earlier versions of GHC, it was precisely specified which was the binding occurrence. However, that's a detail.) A big difference between the two approaches is that with (B) a type variable stands for a *type variable*, whereas in (A) it stands for a *type*. So why did we switch from (A) to (B)? Because of type inference for GADTs. If you read our paper "unification based type inference for GADTs" (on my home page) you'll see that a programmer-written type signatures always describes a rigid type ("rigid" means completely known from birth -- no nonsense about unification etc.) It's very important for GADTs to know when a type is rigid (see the paper). That invariant in turn motivates the rigidity of type variables, and hence plan (B). Now, one could combine (A) and (B). It'd be possible to have rigid type variables (bound by foralls) standing for type variables, and wobbly ones (bound by patterns) standing for types. That would do what you want, but it'd be yet more complicated, and I hesitate before making GHC's type system more complicated. Other alternatives would be: do something about partial type signatures; or make GADT type inference more sophisticated (and thereby perhaps less predicatable). So there you have it. For myself I'm not yet convinced that plan (B) is so bad. Maybe we should do something about partial type signatures, which might be useful regardless of scoped type variables. But I'd welcome better designs. It's an annoying issue because it *must* be solved (not having scoped type variables is unacceptable); but no solution seems satisfying. However, Haskell Prime must incorporate scoped type variables in some form!

1 0

Haskell web forum
by Bulat Ziganshin 18 Oct '06

18 Oct '06

Hello haskell, i definitely think that to rise up Haskell popularity we need now to create web forum. comparing to mail lists, it allows to faster "include in communication" because all previous discussions are easily available and simplifies participation for "strangers" that just have several questions and don't want to subscribe/unsubscribe and setup mail filters. moreover, participation in web forums requires less technical knowledge and prevent spamming of mail address used i heard that nowadays completed solutions available that need just to install but i don't have experience of setting up and administering of web forum. can anyone set up web forum on haskell.org server? i can perform all user-level administration, wiping of spam messages and so on.. alternatively, is there a good place to set up "main" Haskell web forum? from my POV, main requirements should be availability of message base for archiving, and ability to create sub-forums. I plan to create Russian section here, in order to help russian-speaking developers to master Haskell -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

13 16

Streams 0.1 ported to GHC 6.6
by Bulat Ziganshin 17 Oct '06

17 Oct '06

Hello Lyle and all, i'm glad to inform you that Stream 0.1 library is now compatible with just released GHC 6.6. please download new version as http://www.haskell.org/library/Streams.tar.gz this archive contains file Streams.cabal.6.6 that is cabal file developed specially for new GHC. if you use ghc 6.6, just rename it to Streams.cabal and then build library as usual -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

2 1