ANN: Haddock version 2.1.0

Hi everyone,

I'm pleased to announce Haddock 2.1.0.

Hackage page: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/haddock-2.1.0

Changes since last version:

  * Fix a bug that made links point to the defining module instead
    of the "best" one (e.g Int pointing to GHC.Base instead of Data.Int)

  * Fix a couple of smaller bugs

  * The representation of DocName was changed in the library

  * Add a flag --no-warnings for turning off warnings

David

Re: ANN: Haddock version 2.1.0

On 2008.05.01 15:42:19 +0200, David Waern <david.waern <at> gmail.com> scribbled 0.5K characters:
> Hi everyone,
>
> I'm pleased to announce Haddock 2.1.0.
>
> Hackage page: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/haddock-2.1.0
>
> Changes since last version:
>
>   * Fix a bug that made links point to the defining module instead
>     of the "best" one (e.g Int pointing to GHC.Base instead of Data.Int)
>
>   * Fix a couple of smaller bugs
>
>   * The representation of DocName was changed in the library
>
>   * Add a flag --no-warnings for turning off warnings
>
> David

Out of curiosity: does this release fix the 'type'/--^ bug? I know I kept running into it on well-documented projects.

--
gwern
package Yakima Tzvrif Knife Tony Weekly Bob HRT TOS DJC

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe <at> haskell.org

Re: ANN: Haddock version 2.1.0

No it doesn't, but it's on the TODO list. It needs a fix in GHC.

By the way, I'm going to experiment with doing the parsing of comments
on the Haddock side instead of in GHC.
If that works out, we won't have to fix these things in GHC anymore.

If anyone wants to help out with Haddock, the darcs repository is at
http://code.haskell.org/haddock

David

2008/5/1 Gwern Branwen <gwern0 <at> gmail.com>:
> On 2008.05.01 15:42:19 +0200, David Waern <david.waern <at> gmail.com> scribbled 0.5K characters:
>
>
> > Hi everyone,
>  >
>  > I'm pleased to announce Haddock 2.1.0.
>  >
>  > Hackage page: http://hackage.haskell.org/cgi-bin/hackage-scripts/package/haddock-2.1.0
>  >
>  > Changes since last version:
>  >
>  >   * Fix a bug that made links point to the defining module instead
>  >     of the "best" one (e.g Int pointing to GHC.Base instead of Data.Int)
>  >
>  >   * Fix a couple of smaller bugs
>  >
>  >   * The representation of DocName was changed in the library
>  >

www.haskell.org Problem?

I'm doing

darcs get http://www.haskell.org/crypto

at the moment but it's just hanging.

Is there a problem on the server?

Thanks, Dominic.

www.haskell.org Problem?

On May 3, 2008, at 11:09 AM, Dominic Steinitz wrote:

> Is there a problem on the server?

I appears that all of haskell.org is down.

- Jake

Re: Matrix multiplication

Hi,

Thanks for all your nice replies. I did this matrix-multiplication 
experiment for a seminar on multithreading where I have to give a talk 
on Unified Parallel C. At first I thought I should not mention haskell 
as an alternative because of the speed. But now I might do some slides 
about the advantages/(disadvantages?) of side-effekt free languages, 
maybe ndp. In my opinion these C extension are not a nice solution. 
Unified Parallel C parallelizes only for-loops and distributes the 
workload by uniformly cutting an array in pieces and then setting an 
"affinity" so that a CPU works on that data. The trick they are really 
proud of is that the compiler knows in this way where to put the data in 
a NUMA-system (Non-Uniform Memory Architecture). I am not really sure if 
this language extension can cope with programs where pieces need 
considerably different calulation times.

I forgot to mention that I used ghc 6.8.2 and sorry for that stupid 
example (a had to take something that fits on a presentation-slide).

Cheers, Tillmann

Don Stewart schrieb:
> The other thing here is that he's using unboxed, nested arrays in C,
> while using naive lists in Haskell.
> 
> To actually compare them, you'd need to use nested STUArrays.
> 
> Hopefully we'll have a library for these soon (as a result of the ndp
> lib). Otherwise, use on one of the matrix libraries (hmatrix/
> gslhaskell)

Re: Matrix multiplication

Tillmann.Vogt:
> Hi,
> 
> Thanks for all your nice replies. I did this matrix-multiplication 
> experiment for a seminar on multithreading where I have to give a talk 
> on Unified Parallel C. At first I thought I should not mention haskell 
> as an alternative because of the speed. But now I might do some slides 
> about the advantages/(disadvantages?) of side-effekt free languages, 
> maybe ndp. In my opinion these C extension are not a nice solution. 
> Unified Parallel C parallelizes only for-loops and distributes the 
> workload by uniformly cutting an array in pieces and then setting an 
> "affinity" so that a CPU works on that data. The trick they are really 

This sounds very similar to nested data parallelism, so probably worth
talking about.

    http://haskell.org/haskellwiki/Data_Parallel_Haskell

The key trick is that instead of only knowing how to parallelise (pure)
for-loops, a whole suite of combinators can be parallelised, and on
nested structures. So, quite promising.

> proud of is that the compiler knows in this way where to put the data in 
> a NUMA-system (Non-Uniform Memory Architecture). I am not really sure if 
> this language extension can cope with programs where pieces need 
> considerably different calulation times.

Interesting.

Re: How to define tail function for Even/Odd GADT lists?

> However, we were not able to write a function that returns the tail.

>> tailList :: Flip b c => List a b -> List a c
>> tailList (Cons _ xs) = xs

The problem here is that the caller will probably not know which "Flip
b c".  OTOH the Cons of type "List a b" already contains a "Flip b c"
proof, so you really don't need to receive it.

Of course, in order to be able to write "List a c" you still need to
introduce a "c" variable somewhere.  This should be done as follows:

tailList: List a b -> (Flip b c => List a c)

-- Stefan

ANN: SmallCheck 0.3

SmallCheck 0.3: another lightweight testing library in Haskell
--------------------------------------------------------------

A new version of SmallCheck can be obtained from:

   http://www.cs.york.ac.uk/fp/smallcheck0.3.tar

Main differences from 0.2:
* existential quantifiers now have unique variants for which two
   witnesses are reported when uniqueness fails;
* the over-generating coseries method for functions of functional
   arguments has been replaced;
* additional examples;
* test counters are now Integers, not Ints!

SmallCheck is similar to QuickCheck (Claessen and Hughes 2000-) but
instead of testing for a sample of randomly generated values, SmallCheck
tests properties for all the finitely many values up to some depth,
progressively increasing the depth used.

         Folk-law: if there is any case in which a program
         fails, there is almost always a simple one.

         Corollary: if a program does not fail in any
         simple case, it almost never fails.

Other possible sales pitches:
* write test generators for your own types more easily
* be sure any counter-examples found are minimal
* write properties using existentials as well as universals

ANNOUNCE: Sessions 2008.5.2

Howdy,

I'm pleased to announce the general availability of Session Types for
Haskell, version 2008.5.2. It is available from my website[0],
Hackage[1][2] and I've just updated the online tutorial[3] to take into
account the recent changes and new features.

[0] http://wellquite.org/non-blog/sessions-2008.5.2.tar.gz
[1] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/sessions-2008.5.2
[2] http://hackage.haskell.org/
[3] http://wellquite.org/sessions/tutorial_1.html

Session types are a means of describing communication between multiple
threads, and statically verifying that the communication being performed
is safe and conforms to the specification. The library supports
multiple, concurrent channels being open and actions upon those channels
being interleaved; forking new threads; the communication of process
IDs, allowing threads to establish new channels between each other;
higher-order channels, allowing an established channel to be sent over a
channel to another process; and many other features common to session
type systems.

The significant new changes in this version are:

 a) an entirely new means to specify session types. This removes the old
absolute indexing, is composeable and far more flexible and powerful
than the old system.

 b) support for higher-order channels and session types allowing channels
to be sent and received. This permits additional communication patterns