Re: [GHC] #3134: encodeFloat . decodeFloat

[GHC]

#3134: encodeFloat . decodeFloat
-+--
Reporter:  roland|Owner:  
Type:  bug   |   Status:  new 
Priority:  normal|Milestone:  _|_ 
   Component:  Prelude   |  Version:  6.10.1  
Severity:  normal|   Resolution:  
Keywords:|   Difficulty:  Unknown 
Testcase:|   Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |  
-+--
Changes (by simonmar):

  * difficulty:  = Unknown
  * milestone:  = _|_

Comment:

 Interesting, I thought we had a very old ticket about this, but I can't
 seem to find it.

 Anyway, I suppose the issue is what the representation of NaN and Infinity
 should be in the output of `decodeFloat`.  There is no provision for NaN
 and Infinity in the Haskell definition of `encodeFloat` and `decodeFloat`:

   The function decodeFloat applied to a real floating-point number returns
 the
   significand expressed as an Integer and an appropriately scaled exponent
 (an Int).
   If decodeFloat x yields (m,n), then x is equal in value to mbn, where b
 is the
   floating-point radix, and furthermore, either m and n are both zero or
 else
   bd-1=mbd, where d is the value of floatDigits x. encodeFloat performs
 the
   inverse of this transformation.

 from Section 6.4.6, [http://haskell.org/onlinereport/basic.html]

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3134#comment:1
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3138: Returning a known constructor: GHC generates terrible code for cmonad

[GHC]

#3138: Returning a known constructor: GHC generates terrible code for cmonad
---+
  Reporter:  simonpj   |  Owner:  
  Type:  run-time performance bug  | Status:  new 
  Priority:  normal|  Milestone:  
 Component:  Compiler  |Version:  6.10.1  
  Severity:  normal|   Keywords:  
Difficulty:  Unknown   |   Testcase:  
Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple
---+
 Lennart reports that GHC generates very poor code for his cmonad package.
 If you want to look at a simple example, look at the Inf.hs example
 included in package `cmonad-0.1.1`.
 It's very simple, and ghc generates fantastically bad code for it.

 It would be great if you could nail down why it's so amazingly unoptimal.
 Even with everything inlined and no overloading left, ghc seems to
 ignore the INLINE directives and use dictionaries left and right.
 When I looked at it a year ago or so, it was a return of one
 constructor in a sum.  That is, a function always returns the same
 constructor, so the case
 analysis of the return value is not needed; it should be returned as
 an unboxed tuple instead

 Another unrelated problem, I think, is that ghc needs to promote
 in-memory variables to registers when possible.
 Perhaps the new code generator has such a transformation?

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3138
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3139: automate cabal check in ghc release process

[GHC]

#3139: automate cabal check in ghc release process
-+--
Reporter:  duncan|  Owner:  
Type:  task  | Status:  new 
Priority:  normal|  Component:  Build System
 Version:|   Severity:  normal  
Keywords:|   Testcase:  
  Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple
-+--
 Currently the release manager must run `cabal check` manually on each
 package to check for problems that might cause the packages to be rejected
 when uploaded to Hackage. This should be automated.

 Ideally we would use a dedicated program to do the check because the
 `cabal` command line utility uses a stable version of the Cabal library
 but the latest version of the Cabal library often has additional QA
 checks.

 This was the case for the ghc-6.10.2 release. Hackage rejected the upload
 of `containers-0.2.0.1` with the message:
 {{{
 Unfortunately the language extensions 'DeriveDataTypeable', 'MagicHash'
 break the parser in earlier Cabal versions so you need to specify
 'cabal-version: = 1.2.3'. Alternatively if you require compatability
 with earlier Cabal versions then you may be able to use an equivalent
 compiler-specific flag.
 }}}
 This happened because this QA check is only implemented in Cabal-1.7.x,
 not in the stable version that the `cabal` tool currently uses.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3139
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #601: Replace GMP

[GHC]

#601: Replace GMP
-+--
Reporter:  simonmar  |Owner:
Type:  task  |   Status:  new   
Priority:  normal|Milestone:  _|_   
   Component:  Compiler  |  Version:  None  
Severity:  normal|   Resolution:  None  
Keywords:|   Difficulty:  Difficult (1 week)
Testcase:  N/A   |   Os:  Unknown/Multiple  
Architecture:  Unknown/Multiple  |  
-+--
Comment (by igloo):

 Replying to [comment:9 igloo]:
 
  However, the attached base.html (comparing nofib runs with GMP and
 integer-simple) makes me think that that is infeasible

 I did some digging to find out what was going on. Using an instrumented
 `integer-gmp`, it turned out that, during a build of GHC, there were
 7,312,684 calls to `GHC.Integer` that returns a `J#` result. Of these,
 4,479,189 were calls to `decodeFloat`, and 2,804,132 were calls to
 `quotRem`. This is because functions like `round` call `properFraction`,
 which looked like this:
 {{{
 properFraction x
   = case (decodeFloat x)  of { (m,n) -
 let  b = floatRadix x in
 if n = 0 then
 (fromInteger m * fromInteger b ^ n, 0.0)
 else
 case (quotRem m (b^(negate n))) of { (w,r) -
 (fromInteger w, encodeFloat r n)
 }
 }
 }}}
 where `m` and `n` are `Integer`s (and always `J#`, despite never being big
 enough to need to be).
 In the HEAD this has now been rewritten to use `Int` rather than
 `Integer`, so all of those `J#` integers disappear (we're also looking at
 reducing the number of `round` calls we make, but that no longer affects
 this ticket).

 There are now only 28,741 calls returning `J#` integers; 22,306 of them
 are `wordToInteger` calls, which are very cheap with simple-integer (which
 builds `Integer`s out or `Word#`s).

 Division is probably the slowest operation with simple-integer, so it
 seems likely that this was the cause of the slow-down. We should do some
 new timings to see where we stand.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/601#comment:14
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #3139: automate cabal check in ghc release process

[GHC]

#3139: automate cabal check in ghc release process
--+-
 Reporter:  duncan|  Owner:  
 Type:  task  | Status:  new 
 Priority:  normal|  Milestone:  
Component:  Build System  |Version:  
 Severity:  normal| Resolution:  
 Keywords:|   Testcase:  
   Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple
--+-
Comment (by duncan):

 Note: `cabal upload --check` will do the remote tests by sending the
 packages to the hackage server and having it take a look. This accounts
 for the times when the server is using a later version of the Cabal lib
 (and thus QA checks) than the version the client is using.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3139#comment:1
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #3113: -fdisambiguate-record-fields does not exist anymore

[GHC]

#3113: -fdisambiguate-record-fields does not exist anymore
-+--
Reporter:  fasta |Owner:  
Type:  bug   |   Status:  closed  
Priority:  normal|Milestone:  
   Component:  Documentation |  Version:  6.10.1  
Severity:  normal|   Resolution:  fixed   
Keywords:|   Difficulty:  Unknown 
Testcase:|   Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |  
-+--
Changes (by igloo):

  * status:  new = closed
  * difficulty:  = Unknown
  * resolution:  = fixed

Comment:

 I didn't follow all that (did it refer to an attachment you forgot to
 attach?), but I think this patch fixed the doc bug you're reporting:
 {{{
 Thu Nov 20 12:32:05 GMT 2008  simo...@microsoft.com
   * Fix flag name -XDisambiguateRecordFields
 }}}

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3113#comment:1
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3140: (Windows?) GHCi doesn't load hierachical modules

[GHC]

#3140: (Windows?) GHCi doesn't load hierachical modules
+---
Reporter:  Orphi|  Owner:
Type:  bug  | Status:  new   
Priority:  normal   |  Component:  GHCi  
 Version:  6.10.1   |   Severity:  normal
Keywords:   |   Testcase:
  Os:  Windows  |   Architecture:  x86   
+---
 On Windows, if you double-click a `*.hs` file, GHCi starts up and loads
 the corresponding module. Usually this works fine, however... it seems to
 trip over on hierachical module names. Specifically:

 * Create file `Foo\Bar.hs` containing a module `Foo.Bar` that imports
 `Foo.Baz`.
 * Create file `Foo\Baz.hs` containing a module `Foo.Baz`.
 * Double-click on `Foo\Bar.hs`; GHCi whines that it can't find `Foo.Baz`
 in the search path.

 This happens regardless of whether either of the modules is compiled or
 not. An easy work-around is to invoke GHCi from the command prompt with
 the CWD below the `Foo` folder. But it's kind of tedious to have to do
 that.

 Note that if `Foo.Bar` doesn't import anything (or only modules from
 packages) then it works just fine. GHCi just doesn't seem to be able to
 find source files in the current folder if they have hierachical names.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3140
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #3097: Parser doesn't support doc comments on type aliases

[GHC]

#3097: Parser doesn't support doc comments on type aliases
-+--
Reporter:  waern |Owner:  
Type:  merge |   Status:  new 
Priority:  normal|Milestone:  6.10 branch 
   Component:  Compiler  |  Version:  6.11
Severity:  major |   Resolution:  
Keywords:  Haddock   |   Difficulty:  Unknown 
Testcase:|   Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |  
-+--
Changes (by igloo):

  * type:  bug = merge
  * milestone:  = 6.10 branch

Comment:

 Sorry, it was too late for 6.10.2; the builds were already done. I'll
 leave the ticket as a `merge` in case we do a 6.10.3.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3097#comment:5
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #3137: ghc 6.10.2 fails to compile on Mac OS X Leopard

[GHC]

#3137: ghc 6.10.2 fails to compile on Mac OS X Leopard
-+--
Reporter:  mvanier   |Owner:  
Type:  bug   |   Status:  new 
Priority:  normal|Milestone:  
   Component:  Compiler  |  Version:  6.10.1  
Severity:  major |   Resolution:  
Keywords:|   Difficulty:  Unknown 
Testcase:|   Os:  Unknown/Multiple
Architecture:  Unknown/Multiple  |  
-+--
Comment (by mvanier):

 Replying to [comment:2 igloo]:
  Can you give more details about how you are building GHC, please?
 
  It builds for me on x86 OS X.
 
  The different versions of filepath aren't a problem, incidentally.

 I'm doing

 {{{
 % ./configure --prefix=/pkg/ghc
 % ./make
 }}}

 IOW nothing special except a non-standard installation directory.  I am
 unpacking the ghc-6.10.2-src-extralibs.tar.bz2 tarfile as well as the src
 distribution, obviously.  I compiled ghc-6.10.1 on this exact machine in
 the same way with no problems.

 Conceivably there might be some weird interaction with cabal packages I've
 downloaded and installed.  Any thoughts on this?  I'd be willing to
 reinstall cabal from scratch, since AFAIK I'm not actively using any of
 the packages currently.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3137#comment:3
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3141: directory-1.0.0.3 needs base == 4.* in .cabal file.

[GHC]

#3141: directory-1.0.0.3 needs base == 4.* in .cabal file.
-+--
Reporter:  guest |  Owner: 
Type:  bug   | Status:  new
Priority:  normal|  Component:  libraries/directory
 Version:  6.10.1|   Severity:  normal 
Keywords:|   Testcase: 
  Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple   
-+--
 directory-1.0.0.3 imports Control.Exception.Base that is only exported
 since base-4.* so cabal install directory fails.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3141
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3142: unix-2.3.2.0 needs base = 4.x in .cabal file

[GHC]

#3142: unix-2.3.2.0 needs base = 4.x in .cabal file
-+--
Reporter:  guest |  Owner:  
Type:  bug   | Status:  new 
Priority:  normal|  Component:  libraries/unix  
 Version:|   Severity:  normal  
Keywords:|   Testcase:  
  Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple
-+--
 From the hackage log[1] we can see that unix-2.3.2.0 lacks the appropriate
 lower bound on the version of base (= 4.1) in build-depends.

 
[1]http://hackage.haskell.org/packages/archive/unix/2.3.2.0/logs/failure/ghc-6.10

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3142
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3143: Network.Socket.connect: support for sockets w/ bound local endpoints

[GHC]

#3143: Network.Socket.connect: support for sockets w/ bound local endpoints
-+--
Reporter:  sof   |  Owner:   
Type:  bug   | Status:  new  
Priority:  normal|  Component:  libraries/network
 Version:  6.10.1|   Severity:  normal   
Keywords:|   Testcase:   
  Os:  Unknown/Multiple  |   Architecture:  Unknown/Multiple 
-+--
 Just in case this isn't taken care of by the ongoing rewrite of 'network',
 but there's an age-old limitation in the implementation of
 Network.Socket.connect -- it balks at being given a socket where the
 local endpoint (port,iface) has already been bound.

 i.e., it socket status test ought to be
 not (currentStatus `elem` [NotConnected,Bound])

 The workaround of manually resetting SocketStatus always leaves me
 feeling icky.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3143
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #711: shutdownHaskell() does not return allocated memory on Unix

[GHC]

#711: shutdownHaskell() does not return allocated memory on Unix
-+--
Reporter:  lennart.augusts...@credit-suisse.com  |Owner:  igloo 
  
Type:  bug   |   Status:  new   
  
Priority:  low   |Milestone:  _|_   
  
   Component:  Runtime System|  Version:  6.5   
  
Severity:  minor |   Resolution:
  
Keywords:|   Difficulty:  Easy (1 
hr) 
Testcase:  N/A   |   Os:  
Unknown/Multiple
Architecture:  Unknown/Multiple  |  
-+--
Changes (by thoughtpolice):

  * owner:  simonmar = igloo

Comment:

 Hopefully this patch should fix this issue.

 {{{
 Fri Mar 20 07:49:57 CDT 2009  Austin Seipp mad@gmail.com
   * FIX #711 implement osFreeAllMBlocks for unix
 }}}

 I'm assigning this to igloo so he can take a look at it and merge it when
 necessary into HEAD I suppose (I've run validate and everything turned up
 OK.)

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/711#comment:8
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

[GHC] #3144: ghc panic

[GHC]

#3144: ghc panic
+---
Reporter:  funmler  |  Owner:  
Type:  bug  | Status:  new 
Priority:  normal   |  Component:  Compiler
 Version:  6.10.1   |   Severity:  normal  
Keywords:   |   Testcase:  
  Os:  Linux|   Architecture:  x86 
+---
 ghci fails with

 ghc: panic! (the 'impossible' happened)
   (GHC version 6.10.2 for i386-unknown-linux):
 interactiveUI:setBuffering2

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3144
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [GHC] #3144: ghc panic

[GHC]

#3144: ghc panic
--+-
 Reporter:  funmler   |  Owner:
 Type:  bug   | Status:  new   
 Priority:  normal|  Milestone:
Component:  Compiler  |Version:  6.10.1
 Severity:  normal| Resolution:
 Keywords:|   Testcase:
   Os:  Linux |   Architecture:  x86   
--+-
Comment (by funmler):

 This using the 6.10.2 on a lenny debian install. Please let me know if you
 need more details.

-- 
Ticket URL: http://hackage.haskell.org/trac/ghc/ticket/3144#comment:1
GHC http://www.haskell.org/ghc/
The Glasgow Haskell Compiler___
Glasgow-haskell-bugs mailing list
Glasgow-haskell-bugs@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

Re: [Haskell] Re: ANNOUNCE: GHC version 6.10.2

[Duncan Coutts]

On Thu, 2009-04-02 at 13:47 +0900, Benjamin L.Russell wrote:
 On Wed, 1 Apr 2009 18:48:13 -0700, Lyle Kopnicky li...@qseep.net
 wrote:
 
 Great! But what happened to the time package? It was in 6.10.1. Has it been
 intentionally excluded from 6.10.2?

Yes, the maintainer of the time package asked for it to be removed:

 Can I remove the time package from the GHC build process? I
 want to update it but I don't want to deal with GHC's
 autotools stuff or break the GHC build.


 Then I should probably hold off on installing the new version for now.
 Any estimate on when this problem will be fixed?

The time package will be part of the first platform release (assuming we
get enough volunteers to do the platform release!)

In the mean time you can just:

$ cabal install time


Duncan

___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

ghc-pkg check problem in 6.10.2

[Simon Marlow]

I just noticed that the new 'ghc-pkg check' feature exposes a silly mistake 
in the definition of the rts package that we ship with GHC 6.10.2:


$ ghc-pkg check
There are problems in package rts-1.0:
  include-dirs: PAPI_INCLUDE_DIR doesn't exist or isn't a directory

...

To fix it, issue this command:

 $ ghc-pkg describe rts | sed 's/PAPI_INCLUDE_DIR//' | ghc-pkg update -

and now ghc-pkg check should give no errors:

 $ ghc-pkg check
 $

(Except on Windows, where there also seems to be a problem with the Haddock 
package.  Haddock itself is ok, but the Haddock library has some problems 
with its registration.)


Cheers,
Simon

___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: ghc-pkg check problem in 6.10.2

[David Waern]

2009/4/2 Simon Marlow marlo...@gmail.com:
 I just noticed that the new 'ghc-pkg check' feature exposes a silly mistake
 in the definition of the rts package that we ship with GHC 6.10.2:

 $ ghc-pkg check
 There are problems in package rts-1.0:
  include-dirs: PAPI_INCLUDE_DIR doesn't exist or isn't a directory

 ...

 To fix it, issue this command:

  $ ghc-pkg describe rts | sed 's/PAPI_INCLUDE_DIR//' | ghc-pkg update -

 and now ghc-pkg check should give no errors:

  $ ghc-pkg check
  $

 (Except on Windows, where there also seems to be a problem with the Haddock
 package.  Haddock itself is ok, but the Haddock library has some problems
 with its registration.)

Oh, which problems?

David
___
Glasgow-haskell-users mailing list
Glasgow-haskell-users@haskell.org
http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

Re: [Haskell] Marketing Haskell

[Ryan Ingram]

I, for one, welcome our new Koala overlords.

Thank you, Mr. Peyton-Koala, for this wonderful contribution to our community.

  -- ryan

2009/4/1 Simon Peyton-Jones simo...@microsoft.com:

 Dear Haskell enthusiasts,

 Now that the logo issue finally has been settled, it is time to select
 the proper Haskell mascot.  As you are no doubt aware, Microsoft's
 involvement in Haskell means that we have moved from avoiding success
 at all cost to actively marketing the language, and any language
 striving for success is entirely dependent on a cute and distinctive
 mascot.  Where would Perl be today without its camel?

 Since the recent logo discussion has demonstrated once and for all the
 futility of attempting a democratic process in the Haskell community -
 to be quite honest, the elected logo looks like an error message from an IBM
 mainframe - I have decided to decide on a mascot myself.

 So I hereby declare the official Haskell mascot to be the koala, in
 the form of the image attached below.  Please ensure that this image
 accompanies any material published on the web or on paper.

 Simon


 ___
 Haskell mailing list
 Haskell@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell


___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

Re: [Haskell] Re: ANNOUNCE: GHC version 6.10.2

[Duncan Coutts]

On Thu, 2009-04-02 at 13:47 +0900, Benjamin L.Russell wrote:
 On Wed, 1 Apr 2009 18:48:13 -0700, Lyle Kopnicky li...@qseep.net
 wrote:
 
 Great! But what happened to the time package? It was in 6.10.1. Has it been
 intentionally excluded from 6.10.2?

Yes, the maintainer of the time package asked for it to be removed:

 Can I remove the time package from the GHC build process? I
 want to update it but I don't want to deal with GHC's
 autotools stuff or break the GHC build.


 Then I should probably hold off on installing the new version for now.
 Any estimate on when this problem will be fixed?

The time package will be part of the first platform release (assuming we
get enough volunteers to do the platform release!)

In the mean time you can just:

$ cabal install time


Duncan

___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

[Haskell] Re: Marketing Haskell

[Benjamin L . Russell]

On Wed, 01 Apr 2009 07:24:54 -0700, Jonathan Cast
jonathancc...@fastmail.fm wrote:

The sad thing is, despite the form of this message, I entirely agree
with the content...

Likewise.  Why don't we ask the real Simon to choose an additional
mascot for Haskell?  Something slow and lazy would do

-- Benjamin L. Russell
-- 
Benjamin L. Russell  /   DekuDekuplex at Yahoo dot com
http://dekudekuplex.wordpress.com/
Translator/Interpreter / Mobile:  +011 81 80-3603-6725
Furuike ya, kawazu tobikomu mizu no oto. 
-- Matsuo Basho^ 

___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

Re: [Haskell] Re: Marketing Haskell

[Bulat Ziganshin]

Hello Benjamin,

Thursday, April 2, 2009, 2:54:38 PM, you wrote:

 Likewise.  Why don't we ask the real Simon to choose an additional
 mascot for Haskell?  Something slow and lazy would do

i propose myself...

-- 
Best regards,
 Bulatmailto:bulat.zigans...@gmail.com

___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

[Haskell] CfP: Fourth Working Conference on Programming Languages (ATPS'09)

[Janis Voigtlaender]

   Fourth Working Conference on Programming Languages (ATPS'09)
   ~~
  http://www-ps.informatik.uni-kiel.de/atps09/

   Part of the 39th annual conference of the
   German Gesellschaft für Informatik
   Luebeck (Germany), 28.9.-2.10. 2009

The conference aims at bringing together researchers and developers
interested in the area of programming languages. The conference addresses
all paradigms of programming languages: imperative, object-oriented,
functional, logic, concurrent, parallel, or graphical programming
languages, as well as languages to support the implementation of
distributed systems and concepts for the integration of different
paradigms. The first three Working Conferences on Programming Languages
took place as part of the annual computer science conferences
in Germany (Aachen 1997, Paderborn 1999, Ulm 2004).

Typical but not exclusive topics are:

 * Design of programming languages as well as domain-specific languages
 * Implementation and optimization techniques
 * Analysis and transformation of programs
 * Type systems
 * Semantics and specification techniques
 * Modelling languages, object orientation
 * Internet programming
 * Verification of programs and implementations
 * Tools and programming environments
 * Frameworks, architectures, generative approaches
 * Experiences with specific applications
 * Relations between languages, architectures, processors

Techniques, methods, concepts, and tools to improve the safety
and reliability of programs are also of interest. The conference
also welcomes contributions from enterprises.


Submissions:

Submitted papers must be written in English or German and should
contain unpublished works. Contributions will be judged by
relevance, originality, correctness, and readability.
The significance should be clearly stated and compared to
existing works.

Contributions should not exceed 15 pages (LNI style, see
http://www.gi-ev.de/service/publikationen/lni/autorenrichtlinien/).
They must be submitted in PostScript or PDF format until
April 26, 2009. Detailed information about the electronic submission
is available at the web page of the conference:
http://www-ps.informatik.uni-kiel.de/atps09/

It is also intended to organize a session with short presentations about
unfinished projects and experience reports. Such short contributions
should be clearly marked and submitted like other contributions
as an extended abstract of no more than five pages.

The accepted papers will be published in the proceedings of
the general conference that consists of printed proceedings
that will appear in the GI-Edition Lecture Notes in Informatics (LNI)
with one-page abstracts and a CD containing the full papers.


Import Dates:
~
Submission of contributions:  April 26, 2009
Notification of acceptance/rejection: May 25, 2009
Submission of camera-ready papers:July 1, 2009


Organization:
~
Walter Dosch (University of Luebeck, do...@isp.uni-luebeck.de)
Michael Hanus(University of Kiel, m...@informatik.uni-kiel.de)


Program Committee:
~~
Walter Dosch (Univ. Luebeck, Co-Chair)
Wolfgang Goerigk (b+m Informatik AG)
Juerg Gutknecht (ETH Zuerich)
Michael Hanus (Univ. Kiel, Co-Chair)
Martin Hofmann (Univ. Muenchen)
Petra Hofstedt (TU Berlin)
Frank Huch (Univ. Kiel)
Jens Knoop (TU Wien)
Herbert Kuchen (Univ. Muenster)
Rita Loogen (Univ. Marburg)
Markus Mueller-Olm (Univ. Muenster)
Helmuth Partsch (Univ. Ulm)
Peter Pepper (TU Berlin)
Martin Pluemicke (BA Stuttgart)
Arnd Poetzsch-Heffter (Univ. Kaiserslautern)
Peter Thiemann (Univ. Freiburg)
Janis Voigtlaender (TU Dresden)
Wolf Zimmermann (Univ. Halle)


Information about the main conference:
http://www.informatik2009.de



___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

[Haskell] ANNOUNCE: fad 1.0 -- Forward Automatic Differentiation library

[Bjorn Buckwalter]

I'm pleased to announce the initial release of the Haskell fad
library, developed by Barak A. Pearlmutter and Jeffrey Mark Siskind.
Fad provides Forward Automatic Differentiation (AD) for functions
polymorphic over instances of 'Num'. There have been many Haskell
implementations of forward AD, with varying levels of completeness,
published in papers and blog posts[1], but alarmingly few of these
have made it into hackage -- to date Conal Elliot's vector-spaces[2]
package is the only one I am aware of.

Fad is an attempt to make as comprehensive and usable a forward AD
package as is possible in Haskell. However, correctness is given
priority over ease of use, and this is in my opinion the defining
quality of fad. Specifically, Fad leverages Haskell's expressive
type system to tackle the problem of _perturbation confusion_,
brought to light in Pearlmutter and Siskind's 2005 paper Perturbation
Confusion and Referential Transparency[3]. Fad prevents perturbation
confusion by employing type-level branding as proposed by myself
in a 2007 post to haskell-cafe[4]. To the best of our knowledge all
other forward AD implementations in Haskell are susceptible to
perturbation confusion.

As this library has been in the works for quite some time it is
worth noting that it hasn't benefited from Conal's ground-breaking
work[5] in the area. Once we wrap our heads around his beautiful
constructs perhaps we'll be able to borrow some tricks from him.

As mentioned already, fad was developed primarily by Barak A.
Pearlmutter and Jeffrey Mark Siskind. My own contribution has been
providing Haskell infrastructure support and wrapping up loose ends
in order to get the library into a releasable state. Many thanks
to Barak and Jeffrey for permitting me to release fad under the BSD
license.

Fad resides on GitHub[6] and hackage[7] and is only a cabal install
fad away! What follows is Fad's README, refer to the haddocks for
detailed documentation.

Thanks,
Bjorn Buckwalter


[1] http://www.haskell.org/haskellwiki/Functional_differentiation
[2] http://www.haskell.org/haskellwiki/Vector-space
[3]:  http://www.bcl.hamilton.ie/~qobi/nesting/papers/ifl2005.pdf
[4]: http://thread.gmane.org/gmane.comp.lang.haskell.cafe/22308/
[5]: http://conal.net/papers/beautiful-differentiation/
[6] http://github.com/bjornbm/fad/
[7] http://hackage.haskell.org/cgi-bin/hackage-scripts/package/fad




   Copyright  : 2008-2009, Barak A. Pearlmutter and Jeffrey Mark Siskind
   License: BSD3

   Maintainer : bjorn.buckwal...@gmail.com
   Stability  : experimental
   Portability: GHC only?

Forward Automatic Differentiation via overloading to perform
nonstandard interpretation that replaces original numeric type with
corresponding generalized dual number type.

Each invocation of the differentiation function introduces a
distinct perturbation, which requires a distinct dual number type.
In order to prevent these from being confused, tagging, called
branding in the Haskell community, is used.  This seems to prevent
perturbation confusion, although it would be nice to have an actual
proof of this.  The technique does require adding invocations of
lift at appropriate places when nesting is present.

For more information on perturbation confusion and the solution
employed in this library see:
http://www.bcl.hamilton.ie/~barak/papers/ifl2005.pdf
http://thread.gmane.org/gmane.comp.lang.haskell.cafe/22308/


Installation

To install:
cabal install

Or:
runhaskell Setup.lhs configure
runhaskell Setup.lhs build
runhaskell Setup.lhs install


Examples

Define an example function 'f':

 import Numeric.FAD
 f x = 6 - 5 * x + x ^ 2  -- Our example function

Basic usage of the differentiation operator:

 y   = f 2  -- f(2) = 0
 y'  = diff f 2 -- First derivative f'(2) = -1
 y'' = diff (diff f) 2  -- Second derivative f''(2) = 2

List of derivatives:

 ys = take 3 $ diffs f 2  -- [0, -1, 2]

Example optimization method; find a zero using Newton's method:

 y_newton1 = zeroNewton f 0   -- converges to first zero at 2.0.
 y_newton2 = zeroNewton f 10  -- converges to second zero at 3.0.


Credits
===
Authors: Copyright 2008,
Barak A. Pearlmutter ba...@cs.nuim.ie 
Jeffrey Mark Siskind q...@purdue.edu

Work started as stripped-down version of higher-order tower code
published by Jerzy Karczmarczuk jerzy.karczmarc...@info.unicaen.fr
which used a non-standard standard prelude.

Initial perturbation-confusing code is a modified version of
http://cdsmith.wordpress.com/2007/11/29/some-playing-with-derivatives/

Tag trick, called branding in the Haskell community, from
Bjorn Buckwalter bjorn.buckwal...@gmail.com
http://thread.gmane.org/gmane.comp.lang.haskell.cafe/22308/


___
Haskell mailing list
Haskell@haskell.org

Re: [Haskell] Re: ANNOUNCE: GHC version 6.10.2

[Benjamin L . Russell]

On Thu, 02 Apr 2009 10:42:50 +0100, Duncan Coutts
duncan.cou...@worc.ox.ac.uk wrote:

On Thu, 2009-04-02 at 13:47 +0900, Benjamin L.Russell wrote:
 On Wed, 1 Apr 2009 18:48:13 -0700, Lyle Kopnicky li...@qseep.net
 wrote:
 
 Great! But what happened to the time package? It was in 6.10.1. Has it been
 intentionally excluded from 6.10.2?

Yes, the maintainer of the time package asked for it to be removed:

 Can I remove the time package from the GHC build process? I
 want to update it but I don't want to deal with GHC's
 autotools stuff or break the GHC build.


 Then I should probably hold off on installing the new version for now.
 Any estimate on when this problem will be fixed?

The time package will be part of the first platform release (assuming we
get enough volunteers to do the platform release!)

In the mean time you can just:

$ cabal install time

Okay; no problem.

I just read through the Release notes for version 6.10.2 (see
http://haskell.org/ghc/docs/6.10.2/html/users_guide/release-6-10-2.html),
however, and noticed that the removal of the time package hadn't been
documented there.  Perhaps this information should be included?

-- Benjamin L. Russell
-- 
Benjamin L. Russell  /   DekuDekuplex at Yahoo dot com
http://dekudekuplex.wordpress.com/
Translator/Interpreter / Mobile:  +011 81 80-3603-6725
Furuike ya, kawazu tobikomu mizu no oto. 
-- Matsuo Basho^ 

___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

Re: [Haskell] Re: Marketing Haskell

[Marc A. Ziegert]

slow and lazy... that's me, too. but haskell is not slow.


how about an octopus?

there are some kinds (or all?), which are more chameleon like than real 
chameleons; they can look like strange fishes, stones, or whatever.
they have a decentralized brain (like multi core), are really intelligent (can 
even open cucumber glasses, but probably not 100 bottles of beer) and are from 
the stronger types of animals; strong because they save their energy (glucose 
and oxygen) in their blood for times when they need it -- like being lazy but 
fast.
they can swim backwards and can squeeze themself through holes of the size of 
their own eyes -- reminds me of javascript as backend.
and they are funny and cool: they squirt water at you like dolphins -- the 
Quotes of the Week are funny and cool, too, but you have to wet yourself.

imho, you can compare them to handy parrots (but mute) with colour/sign 
language and chameleon features. and they know some ninja arts; inky, but 
ninjas are cool.

some videos:
The Indonesian Mimic Octopus http://www.youtube.com/watch?v=H8oQBYw6xxc
One Very Clever Octopus http://www.youtube.com/watch?v=VLLQOK1gZE4
Skilled octopus opens bottles http://www.youtube.com/watch?v=wfRqYjv9QgA
Octopus escaping through a one inch hole 
http://www.youtube.com/watch?v=9-azBDt0kik
Wow! Giant octopus - extreme animals - BBC wildlife 
http://www.youtube.com/watch?v=lwAqhThd_EQ
Pulpos: suave inteligencia (Octopus intelligence) 
http://www.youtube.com/watch?v=T8cf7tPoN5o

- marc



Am Donnerstag, 2. April 2009 schrieb Bulat Ziganshin:
 Hello Benjamin,
 
 Thursday, April 2, 2009, 2:54:38 PM, you wrote:
 
  Likewise.  Why don't we ask the real Simon to choose an additional
  mascot for Haskell?  Something slow and lazy would do
 
 i propose myself...
 
 -- 
 Best regards,
  Bulatmailto:bulat.zigans...@gmail.com
 
 ___
 Haskell mailing list
 Haskell@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell
 




signature.asc
Description: This is a digitally signed message part.
___
Haskell mailing list
Haskell@haskell.org
http://www.haskell.org/mailman/listinfo/haskell

Re: [Haskell-cafe] GSoC proposal

[minh thu]

2009/4/2 Csaba Hruska csaba.hru...@gmail.com:
 Abstract:
 The objective of this project is to create a useful, fast and feature rich
 3D rendering engine in Haskell which supports advanced rendering features
 like level of detail, material state sorting, geometry instancing, scene
 handling, fast vertex buffer handling and so on. This would be beneficial
 for various applications, e.g. AI or virtual reality environments,
 simulation, games, and scientific applications.
 Current version available at http://code.google.com/p/lambdacube/
 Content:

 == Project Overview ==

 This project aims to be the first general purpose 3D rendering engine
 written in a pure functional language. There is no graphics library
 available for Haskell that would be suitable as a basis for a complex
 graphical program. My Haskell rendering engine (called Lambda Cube
 Engine) uses the same model and material format as Ogre3D
 (http://www.ogre3d.org). This choice is motivated by the fact that
 Ogre3D has well-designed mesh model and material formats, and it also
 provides exporter plugins for nearly every significant 3D modeling
 software (3DS-Max, Maya, XSI, Blender etc.). This design decision lets
 us reuse existing 3D content and Ogre3D exporter plugins with ease. My
 knowledge of the Ogre3D architecture will help in making correct
 design decisions during development.

 = Current State =

 The source code is surprisingly small considering the current feature
 list. The program consists of 9 small Haskell modules and 2 script
 scanner description files. It can load a model from Ogre XML format
 and it parses the material definition scripts. It prevents model and
 material duplication using a cache. However, the features implemented
 are still just a subset of what these files can describe.

 Here is a list of (mainly) partially working features:
  - mesh loading from XML file
  - parsing material script (see its format:
   http://www.ogre3d.org/docs/manual/manual_14.html#SEC23)
  - caching loaded data
  - loading resource files from zip archive or filesystem
  - rendering data

 There is already an example available, which demonstrates all listed
 features. The example also uses Yampa FRP (Functional Rective
 Programming) library.

 One of the core ideas of the design was separating the high and
 low-level data representations. The high-level representation provides
 a convenient interface for the user and the low-level representation
 ensures efficient rendering on hardware.

 The Lambda Cube Engine depends on some (platform independent)
 libraries:
  - OpenGL binding
  - uulib - Utrecht Parser Combinator library used for script parsing
  - HXT - Haskell XML Toolkit is used for reading XML representation of
   mesh files. There is a more efficient binary version of the mesh
   format that will be supported later.
  - zip-archive - used for loading files from zip files. This helps
   decerase the number of media files.
  - stb-image - this is a temporary solution to support loading various
   image files. A more professional freeimage (freeimage.sf.net)
   loader is planned later.

 = Goals for the Summer =

 Fortunately the current state of the engine is advanced enough to
 start adding some more interesting functionality, such as:

  - Skeletal Animation
   This covers keyframe animation of objects. With skeletal animation
   we can create a very dynamic and alive environment (e.g. walking
   people). Outcome: interpolation function (spline), vertex buffer
   update functions

  - Level Of Detail support
   This is required for good performance and it is a very commonly
   used technique. With this feature we will be able to build
   high-complexity scenes. Outcome: vertex buffer switcher function in
   render pipeline.

  - Shadow Mapping (shadow support)
   Shadows are very a basic requirement of a modern 3D
   application. Shadow mapping is a technique that fits modern
   graphics hardware. Outcome: changes in the render function.

  - Post Processing Effects support (e.g. Motion Blur, HDR)
   This is a relatively new technique. It is widely used in present
   games because it increases visual quality very much.
   Outcome: compositor script parser functions. Some changes in the
   render function.

  - Particle System support
   Particle systems are used to create nice effects like explosions,
   rain, smoke. This is also a very basic technique of computer
   graphics. Outcome: particle system parser functions.

  - Optimization function for rendering
   It is required to minimize the state changes of graphical hardware
   during the rendering process to get top performance. This is one
   of the most important parts of a rendering engine. A well-chosen
   ordering of rendering batches could increase the performance
   considerably. Outcome: a new low-level (incremental) data structure
   and an update function for it.

  - The most interesting planned feature and possibly the most
   difficult one is the mesh modifier 

[Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Gleb Alexeyev]

Don Stewart wrote:

Did you use hubigraph?

http://ooxo.org/hubigraph/

This cabalized project doesn't appear to be on hackage!


Oh, I wasn't aware of hubigraph until now.
Ubigraph has very simple XML-RPC-based API so I used it directly. 
Hubigraph, of course, looks nicer with its custom monad, datatypes for 
shapes etc.


BTW, it seems that you didn't notice the complete source code attached 
to my first message. Like I said it's just a quick and dirty hack, all 
real job is done by vacuum, Ubigraph server and a bit of code 
copy-pasted from vacuum-cairo.


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] GSoC proposal

[Csaba Hruska]

2009/4/2 minh thu not...@gmail.com

 2009/4/2 Csaba Hruska csaba.hru...@gmail.com:
  Abstract:
  The objective of this project is to create a useful, fast and feature
 rich
  3D rendering engine in Haskell which supports advanced rendering features
  like level of detail, material state sorting, geometry instancing, scene
  handling, fast vertex buffer handling and so on. This would be beneficial
  for various applications, e.g. AI or virtual reality environments,
  simulation, games, and scientific applications.
  Current version available at http://code.google.com/p/lambdacube/
  Content:
 
  == Project Overview ==
 
  This project aims to be the first general purpose 3D rendering engine
  written in a pure functional language. There is no graphics library
  available for Haskell that would be suitable as a basis for a complex
  graphical program. My Haskell rendering engine (called Lambda Cube
  Engine) uses the same model and material format as Ogre3D
  (http://www.ogre3d.org). This choice is motivated by the fact that
  Ogre3D has well-designed mesh model and material formats, and it also
  provides exporter plugins for nearly every significant 3D modeling
  software (3DS-Max, Maya, XSI, Blender etc.). This design decision lets
  us reuse existing 3D content and Ogre3D exporter plugins with ease. My
  knowledge of the Ogre3D architecture will help in making correct
  design decisions during development.
 
  = Current State =
 
  The source code is surprisingly small considering the current feature
  list. The program consists of 9 small Haskell modules and 2 script
  scanner description files. It can load a model from Ogre XML format
  and it parses the material definition scripts. It prevents model and
  material duplication using a cache. However, the features implemented
  are still just a subset of what these files can describe.
 
  Here is a list of (mainly) partially working features:
   - mesh loading from XML file
   - parsing material script (see its format:
http://www.ogre3d.org/docs/manual/manual_14.html#SEC23)
   - caching loaded data
   - loading resource files from zip archive or filesystem
   - rendering data
 
  There is already an example available, which demonstrates all listed
  features. The example also uses Yampa FRP (Functional Rective
  Programming) library.
 
  One of the core ideas of the design was separating the high and
  low-level data representations. The high-level representation provides
  a convenient interface for the user and the low-level representation
  ensures efficient rendering on hardware.
 
  The Lambda Cube Engine depends on some (platform independent)
  libraries:
   - OpenGL binding
   - uulib - Utrecht Parser Combinator library used for script parsing
   - HXT - Haskell XML Toolkit is used for reading XML representation of
mesh files. There is a more efficient binary version of the mesh
format that will be supported later.
   - zip-archive - used for loading files from zip files. This helps
decerase the number of media files.
   - stb-image - this is a temporary solution to support loading various
image files. A more professional freeimage (freeimage.sf.net)
loader is planned later.
 
  = Goals for the Summer =
 
  Fortunately the current state of the engine is advanced enough to
  start adding some more interesting functionality, such as:
 
   - Skeletal Animation
This covers keyframe animation of objects. With skeletal animation
we can create a very dynamic and alive environment (e.g. walking
people). Outcome: interpolation function (spline), vertex buffer
update functions
 
   - Level Of Detail support
This is required for good performance and it is a very commonly
used technique. With this feature we will be able to build
high-complexity scenes. Outcome: vertex buffer switcher function in
render pipeline.
 
   - Shadow Mapping (shadow support)
Shadows are very a basic requirement of a modern 3D
application. Shadow mapping is a technique that fits modern
graphics hardware. Outcome: changes in the render function.
 
   - Post Processing Effects support (e.g. Motion Blur, HDR)
This is a relatively new technique. It is widely used in present
games because it increases visual quality very much.
Outcome: compositor script parser functions. Some changes in the
render function.
 
   - Particle System support
Particle systems are used to create nice effects like explosions,
rain, smoke. This is also a very basic technique of computer
graphics. Outcome: particle system parser functions.
 
   - Optimization function for rendering
It is required to minimize the state changes of graphical hardware
during the rendering process to get top performance. This is one
of the most important parts of a rendering engine. A well-chosen
ordering of rendering batches could increase the performance
considerably. Outcome: a new low-level (incremental) data 

[Haskell-cafe] Re: [Haskell-beginners] Re: making translation from imperative code

[Michael Mossey]

Thanks very much for the help... I will look at this over the next couple of 
days. Your code actually addresses a different problem, the one of merging 
separates lists of timed events. I do need to write code to do that eventually, 
so I will try to understand what you have written here. However, the original 
problem concerns visual layout, which actually takes place *after* creating a 
merged list. In layout, items do have times associated with them, but also take 
up physical space. Different items takes up different amounts of space, and at 
any given time, there may be items on all the staves or  just some of them. I 
will try to come up with


(1) a more succinct explanation of the problem (with textual graphics as a 
visual aid)


(2) a more succinct algorithm.

For example, you are right that I'm mixing concerns. The system layout can 
terminate for two reasons: (1) reached the end of the score (2) reached the 
right edge of the page. There might be a way to simplify the loop or fold so 
that these concerns look more unified.


-Mike

PS a question below:

Heinrich Apfelmus wrote:

Michael Mossey wrote:

Heinrich Apfelmus wrote:

Can you elaborate on what exactly the algorithm is doing? Does it just
emit notes/chords/symbols at given positions or does it also try to
arrange them nicely? And most importantly, where does it emit them to,
i.e. what's the resulting data structure?

So far, the problem looks like a basic fold to me.

Here is some Haskell code that explains the problem in
more detail.
[...]


Thanks for the elaboration.

I think the code doesn't separate concerns very well; mixing information
about widths and times, page size and the recursion itself into one big
gnarl.

Also, there is one important issue, namely returning a special value
like -1 as error code in


 tryAgain state =
   case scoreNextTime score (time state) of
-1 - indicateNoMoreChunks state
 t - layoutSystem' (setTime state t)


Don't do this, use  Maybe  instead

tryAgain state = case scoreNextTime score (time state) of
Nothing - indicateNoMoreChunks state
Just t  - layoutSystem' (state { time = t })

where  Nothing  indicates failure and  Just  success.


Back to the gnarl in general, I still don't have a good grasp on the
problem domain, which is key to structuring the algorithm. Therefore,
I'll expand on toy model and you tell me how it differs from the real thing.

The model is this: we are given several lists of notes (f.i. a piano
part and a vocal line) where each note is annotated with the time it is
to be played at. We abstract away the fact that we are dealing with
musical notes and simply consider a list of *events*

type Time = Integer
type Events a = [(Time, a)]

with the invariant that the timestamps are (strictly) increasing:

valid :: Events a - Bool
valid xs = all $ zipWith (\(t1,_) (t2,_) - t1  t2) xs (drop 1 xs)

Now, the toy task is to merge several lists of similar events into one
big list that is ordered by time as well.

merge :: [Events a] - Events [a]

Since some events may now occur simultaneously, the events of the
results are actually lists of primitive events.

One possibility for implementing  merge  is to start with a function to
merge two event lists

merge2 :: Events [a] - Events [a] - Events [a]
merge2 [] ys = ys
merge2 xs [] = xs
merge2 xs@((tx,x):xt) ys@((ty,y):yt) = case compare tx ty of
  LT - (tx,x   ) : merge2 xt ys
  EQ - (tx,x++y) : merge2 xt yt
  GT - (ty,   y) : merge2 xs yt

and to apply it several times

merge = foldr merge2 [] . map lift
where lift = map $ \(t,x) - (t,[x])


Another possibility is to simply concatenate everything first and then
sort by time

merge = map (\((t,x):xs) - (t,x:map snd xs))
  . groupBy ((==) `on` fst)
  . sortBy (comparing fst)
  . concat


The code above can be made more readable by choosing nice names like

   time  = fst
   event = snd

or avoiding pairs altogether and implementing these names as record
fields. Also, the () combinator from  Control.Arrow  is very handy.

   merge = map (time . head  map event)
 . groupBy ((==) `on` time)
 . sortBy  (comparing time)
 . concat


I hope this gives you a few ideas to think about. How does this toy
model differ from the real thing?


Regards,
apfelmus


PS: If some parts of my example code give you trouble, it's probably
fastest to ask around on the #haskell IRC channel.

--
http://apfelmus.nfshost.com

___
Beginners mailing list
beginn...@haskell.org
http://www.haskell.org/mailman/listinfo/beginners

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Reverting to any old version using Darcs

[Nicolas Pouillard]

Excerpts from Peter Verswyvelen's message of Wed Apr 01 23:39:15 +0200 2009:
[...]

 biggest problems I usually see in teams - namely forgetting to add files,
 forgetting to check in dependencies and the inability the merge after
 renames or moves -

Have a look at the --look-for-adds flag that makes the enables the detection
of new files. Removing files is already detected and moving should be done
with darcs mv which makes it pretty close to what one can expect.

Best regards,

-- 
Nicolas Pouillard
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Daryoush Mehrtash]

When I try to install the hubigraph I get the following error:


:~/Desktop/hubigraph-0.1$ cabal install
Resolving dependencies...
'haxr-3000.1.1.2' is cached.
Configuring haxr-3000.1.1.2...
Preprocessing library haxr-3000.1.1.2...
Building haxr-3000.1.1.2...
[1 of 6] Compiling Network.XmlRpc.DTD_XMLRPC ( Network/XmlRpc/DTD_XMLRPC.hs,
dist/build/Network/XmlRpc/DTD_XMLRPC.o )

Network/XmlRpc/DTD_XMLRPC.hs:183:4:
Warning: Pattern match(es) are overlapped
 In the definition of `fromElem':
 fromElem (CMisc _ : rest) = ...
 fromElem (CString _ s : rest) = ...
 fromElem rest = ...
[2 of 6] Compiling Network.XmlRpc.Base64 ( Network/XmlRpc/Base64.hs,
dist/build/Network/XmlRpc/Base64.o )
[3 of 6] Compiling Network.XmlRpc.Internals ( Network/XmlRpc/Internals.hs,
dist/build/Network/XmlRpc/Internals.o )
[4 of 6] Compiling Network.XmlRpc.Server ( Network/XmlRpc/Server.hs,
dist/build/Network/XmlRpc/Server.o )
[5 of 6] Compiling Network.XmlRpc.Client ( Network/XmlRpc/Client.hs,
dist/build/Network/XmlRpc/Client.o )

Network/XmlRpc/Client.hs:113:23:
Not in scope: type constructor or class `ConnError'

Network/XmlRpc/Client.hs:113:51:
Not in scope: type constructor or class `ConnError'
cabal: Error: some packages failed to install:
HUBIGraph-0.1 depends on haxr-3000.1.1.2 which failed to install.
haxr-3000.1.1.2 failed during the building phase. The exception was:
exit: ExitFailure 1

Any ideas?

Thanks,

Daryoush

On Thu, Apr 2, 2009 at 12:25 AM, Gleb Alexeyev gleb.alex...@gmail.comwrote:

 Don Stewart wrote:

 Did you use hubigraph?

http://ooxo.org/hubigraph/

 This cabalized project doesn't appear to be on hackage!

  Oh, I wasn't aware of hubigraph until now.
 Ubigraph has very simple XML-RPC-based API so I used it directly.
 Hubigraph, of course, looks nicer with its custom monad, datatypes for
 shapes etc.

 BTW, it seems that you didn't notice the complete source code attached to
 my first message. Like I said it's just a quick and dirty hack, all real job
 is done by vacuum, Ubigraph server and a bit of code copy-pasted from
 vacuum-cairo.


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Announcement: Beta of Leksah IDE available

[Duncan Coutts]

On Wed, 2009-04-01 at 22:13 +0200, David Waern wrote:
 2009/4/1 jutaro j...@arcor.de:
  I guess you mean the dialog which should help leksah to find sources
  for installed packages. It needs this so you can go to all the definitions
  in the base packages ... This is very handy if it works. Look to the manual
  for details.
 
 Maybe could add support to Cabal for installing sources? Should be
 very useful to have in general.

http://hackage.haskell.org/trac/hackage/ticket/364


Duncan

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] binary package: memory problem decoding an IntMap

[Manlio Perillo]

Hi.

I'm having memory problems decoding a big IntMap.

The data structure is:

IntMap (UArr (Word16 :*: Word8))


There are 480189 keys, and a total of 100480507 elements
(Netflix Prize).
The size of the encoded (and compressed) data is 184 MB.

When I load data from the Netflix Prize data set, total memory usage is
1030 Mb.

However when I try to decode the data, memory usage grows too much (even 
using the -F1.1 option in the RTS).



The problem seems to be with `fromAscList` function, defined as:

fromList :: [(Key,a)] - IntMap a
fromList xs
  = foldlStrict ins empty xs
  where
ins t (k,x)  = insert k x t

(by the way, why IntMap module does not use Data.List.foldl'?).

The `ins` function is not strict.



This seems an hard problem to solve.
First of all, IntMap should provide strict variants of the implemented 
functions.

And the binary package should choose whether use the strict or lazy version.


For me, the simplest solution is to serialize the association list 
obtained from `toAscList` function, instead of directly serialize the 
IntMap.


The question is: can I reuse the data already serialized?
Is the binary format of `IntMap a` and `[(Int, a)]` compatible?



Thanks  Manlio Perillo
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Reverting to any old version using Darcs

[Ketil Malde]

Peter Verswyvelen bugf...@gmail.com writes:

 Forgetting to add a file can be a nasty one, since if you discover
 that too late, the original file at patch time might not exist
 anymore (how do you guys solve this? Just plain discipline I
 guess?).

I've done this once, but with the cabal dependencies, not darcs.  Thus
the uploaded sdist was missing one of the source files, and
consequently failed to build.

I suppose the best way is to test this with a separate test repository
which you don't touch, except from pulling from your development repo
and checking that it builds.

-k
-- 
If I haven't seen further, it is by standing in the footprints of giants
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Announcement: Beta of Leksah IDE available

[David Waern]

2009/4/2 Duncan Coutts duncan.cou...@worc.ox.ac.uk:
 On Wed, 2009-04-01 at 22:13 +0200, David Waern wrote:
 2009/4/1 jutaro j...@arcor.de:
  I guess you mean the dialog which should help leksah to find sources
  for installed packages. It needs this so you can go to all the definitions
  in the base packages ... This is very handy if it works. Look to the manual
  for details.

 Maybe could add support to Cabal for installing sources? Should be
 very useful to have in general.

 http://hackage.haskell.org/trac/hackage/ticket/364

Jutaru, perhaps a nice Hackathon project? :-)

David
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ZipList monad, anyone?

[Patai Gergely]

 Having spent several months on this exact problem, I'll say that I
 consider it pretty unlikely.
I wouldn't be very surprised if that was the case.

 A clever data structure might give you logarithmic or even amortized
 constant time access in sequential cases, but you probably will not have
 good garbage collection properties (all data will remain for all time).
I guess cleverness should be concentrated on aging streams properly. But
I do see how the ability to extract the diagonal conflicts with such
efforts.

 Stick with Applicative for this type of thing.  Monad will drive you
 insane :-)
In fact, even applicative is far from trivial. ;) For instance, I still
can't see how I could implement the * operator with stateless streams
that don't need to keep track of their local time (needed when combining
them with stateful streams, that is).

Gergely

-- 
http://www.fastmail.fm - Access all of your messages and folders
  wherever you are

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ZipList monad, anyone?

[Patai Gergely]

 Yes, although you should use an actual infinite list type if you're
 depending on that.
I know, I just wanted to stick with the basic list type for the sake of
the discussion.

 In fact, the Stream package provides an infinite list type with
 Applicative and Monad instances.
I didn't know that, but now that I checked it out, it is indeed the same
thing.

 Really, you're better off just using Nat - a. The primary advantage
 to using a list over a function is avoiding recomputation, but nothing
 is getting recomputed here.
Well, at least streams can be made efficient in the absence of bind, as
opposed to functions, but I see your point. After all, that's the
problem with bind: it receives a function, which has no visible internal
structure, so it can only grow as you combine it with other things...

Gergely

-- 
http://www.fastmail.fm - A no graphics, no pop-ups email service

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ZipList monad, anyone?

[Patai Gergely]

 For instance, if we consider just join, with the above definition:
 
   join [[1,2],[3]] = [1, _|_]
 
 Which, I think, is fairly undesirable. You can try to avoid bottoms like
 so:
Well, there is a trick you can use here: wrap everything in a Maybe. Not
that it helps with the efficiency issue, but at least you can mark the
empty spots of the diagonal, since it's possible to check the length of
the list before extracting its nth element. Which leads to some kind of
MaybeZipList:

newtype MaybeZipList a = MZL { getMZL :: [Maybe a] }
deriving Show

instance Monad MaybeZipList where
return = MZL . repeat . Just
MZL mxs = f = MZL $ zipWith bind mxs [0..]
where bind mx n = do
x - mx
let ys = getMZL (f x)
if length (take (n+1) ys) = n
then Nothing else ys !! n

But it's still not perfect, since the laws only apply modulo extra
Nothings at the end of the resulting lists...

 This monad works fine for size enforced vectors
Sure, I just can't see any good use for those. After all, if you use
arrays, you have to keep the whole structure in the memory just to
discard most of it.

Thanks for all the answers!

Gergely

-- 
http://www.fastmail.fm - Or how I learned to stop worrying and
  love email again

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Announcement: Beta of Leksah IDE available

[Simon Marlow]

David Waern wrote:

2009/4/2 Duncan Coutts duncan.cou...@worc.ox.ac.uk:

On Wed, 2009-04-01 at 22:13 +0200, David Waern wrote:

2009/4/1 jutaro j...@arcor.de:

I guess you mean the dialog which should help leksah to find sources
for installed packages. It needs this so you can go to all the definitions
in the base packages ... This is very handy if it works. Look to the manual
for details.

Maybe could add support to Cabal for installing sources? Should be
very useful to have in general.

http://hackage.haskell.org/trac/hackage/ticket/364


Jutaru, perhaps a nice Hackathon project? :-)


I think there's some design work to do there.  See the discussion on the 
GHC ticket: http://hackage.haskell.org/trac/ghc/ticket/2630.


In short: just keeping the source code around isn't enough.  You need some 
metadata in order to make sense of the source code - for example, you can't 
feed the source code to the GHC API without knowing which additional flags 
need to be passed, and those come from the .cabal file.  Also you probably 
want to stash the results of the 'cabal configure' step so that you can get 
a view of the source code that is consistent with the version(s?) you 
compiled.  We need to think about about backwards and 
forwards-compatibility of whatever metadata format is used.


And then you'll need Cabal APIs to extract the metadata.  So we need to 
think about what APIs make sense, and the best way to do that is to think 
about what tool(s) you want to write and use that to drive the API design.


Perhaps all this is going a bit too far.  Maybe we want to just stash the 
source code and accept that there are some things that you just can't do 
with it.  However, I imagine that pretty soon people will want to feed the 
source code into the GHC API, and at that point we have to tackle the build 
metadata issues.


Cheers,
Simon
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] SciMark2 benchmark

[Jon Harrop]

Has anyone ported the SciMark2 benchmark suite to Haskell?

-- 
Dr Jon Harrop, Flying Frog Consultancy Ltd.
http://www.ffconsultancy.com/?e
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Announcement: Beta of Leksah IDE available

[jutaro]

Hi Simon,
you quite nicely describe what leksah is doing already. Try to find find the
source code for all installed packages by locating cabal files, parse the
module sources via the Ghc API (actually not so much the API), using info
from cabal files for this (which is a dark art). It extracts comments and
locations. It's quite an ad hoc solution. On my machine it's 97% successful,
but its a notorious support theme, because it depends so much on the
environment. 
Jürgen


Simon Marlow-7 wrote:
 
 David Waern wrote:
 2009/4/2 Duncan Coutts duncan.cou...@worc.ox.ac.uk:
 On Wed, 2009-04-01 at 22:13 +0200, David Waern wrote:
 2009/4/1 jutaro j...@arcor.de:
 I guess you mean the dialog which should help leksah to find sources
 for installed packages. It needs this so you can go to all the
 definitions
 in the base packages ... This is very handy if it works. Look to the
 manual
 for details.
 Maybe could add support to Cabal for installing sources? Should be
 very useful to have in general.
 http://hackage.haskell.org/trac/hackage/ticket/364
 
 Jutaru, perhaps a nice Hackathon project? :-)
 
 I think there's some design work to do there.  See the discussion on the 
 GHC ticket: http://hackage.haskell.org/trac/ghc/ticket/2630.
 
 In short: just keeping the source code around isn't enough.  You need some 
 metadata in order to make sense of the source code - for example, you
 can't 
 feed the source code to the GHC API without knowing which additional flags 
 need to be passed, and those come from the .cabal file.  Also you probably 
 want to stash the results of the 'cabal configure' step so that you can
 get 
 a view of the source code that is consistent with the version(s?) you 
 compiled.  We need to think about about backwards and 
 forwards-compatibility of whatever metadata format is used.
 
 And then you'll need Cabal APIs to extract the metadata.  So we need to 
 think about what APIs make sense, and the best way to do that is to think 
 about what tool(s) you want to write and use that to drive the API design.
 
 Perhaps all this is going a bit too far.  Maybe we want to just stash the 
 source code and accept that there are some things that you just can't do 
 with it.  However, I imagine that pretty soon people will want to feed the 
 source code into the GHC API, and at that point we have to tackle the
 build 
 metadata issues.
 
 Cheers,
   Simon
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe
 
 

-- 
View this message in context: 
http://www.nabble.com/Announcement%3A-Beta-of-Leksah-IDE-available-tp22816032p22846713.html
Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

Read more about it on its webpage: http://vs.renci.org/jeff/buster

Yes, it’s to solve a particular problem.  And yes, this is a rough
draft of an explanation of how it works.  I’ve not even really
solidified the vocabulary yet, but I have this module which couches a
large, abstract, interactive (both with the user and the system),
multicomponent application in terms of a bus, inputs, behaviours, and
events.

* Time is continuous and infinite.
* An event is a static, discrete item associated with a particular time.
* The bus is the discrete view of event in time at an instant.
* A widget is an IO action that assigns events to a particular
time based only upon sampling the outside world (other events and
behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
readable network socket is an widget, the mouse is an widget, the
keyboard is an widget, a multitouch gesture engine is a widget.
* A behaviour is a continuous item — it exists for the entire
program and for all times — which maps events on the bus to other
events on the bus.  It is an IO action as well — where widgets only
sample the outside world and are in a sense read only, behaviours
encapsulate reading and writing.
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] HXT: desperatedly trying to concat

[Steffen Schuldenzucker]

Hi.

I've got a problem with the Haskell XML Toolkit (hxt). I want to write a little 
app that performs REST requests from a certain (rather simple) XML format. 
A example procedure Call looks like testData defined below.
What I'd like to do is to transform this xml tree into a GET variable string 
using an XmlArrow. The task sounds easy, and it has to be easy, but I've been 
sitting here for about a day now, staring at my code.

It looks like this (the transformation should be done by the arrow mkGetStr):

-- Rest.hs
-- This is also on HPaste: 
http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3210#a3210

{-# LANGUAGE NoMonomorphismRestriction #-}

module Rest where

import Text.XML.HXT.Arrow
import Data.List

getParamsA = hasName param  getChildren  isElem
  (getName  (getChildren  getText))  arr2 mkGetPair

mkMethodStr = (method= ++) 
mkGetPair k v = k ++ = ++ v

getMethodA = hasName method  getChildren  getText  arr mkMethodStr

mkGetStr = isElem
(getMethodA + getParamsA) 
   . intercalate  

-- Try it with: runX (testData  mkGetStr) = print
testData = xread  constA (
methodmy.Method/method
 ++ param
 ++ foo_argFoo/foo_arg
 ++ bar_argBar/bar_arg
 ++ /param )

-- End of Rest.hs

What I get out of it is this (in ghci):

*Rest runX (testData  mkGetStr) = print
method=my.Methodfoo_arg=Foobar_arg=Bar

There is an  missing right after method=my.Method!
Why? I've tried many variants of this and they give me either this or a similar 
result or multiple results (what I don't want either).

I'd be really happy if someone could save my day and help me with this issue.

Thanks in advance,

Steffen

Neu bei WEB.DE: Kostenlose maxdome Movie-FLAT!
https://register.maxdome.de/xml/order/LpWebDe?ac=OM.MD.MD008K15726T7073a

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Character I/O

[Simon Marlow]

Judah Jacobson wrote:


Not sure if it will help, but you could take a look at what I did in Haskeline:

http://code.haskell.org/haskeline/System/Console/Haskeline/Backend/Win32.hsc


It would be nice to get some of that into the main win32 package...

Cheers,
Simon
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Peter Verswyvelen]

Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
The link you provided seems to be broken?

On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard jefferson.r.he...@gmail.comwrote:

 Read more about it on its webpage: http://vs.renci.org/jeff/buster

 Yes, it’s to solve a particular problem.  And yes, this is a rough
 draft of an explanation of how it works.  I’ve not even really
 solidified the vocabulary yet, but I have this module which couches a
 large, abstract, interactive (both with the user and the system),
 multicomponent application in terms of a bus, inputs, behaviours, and
 events.

* Time is continuous and infinite.
* An event is a static, discrete item associated with a particular time.
* The bus is the discrete view of event in time at an instant.
* A widget is an IO action that assigns events to a particular
 time based only upon sampling the outside world (other events and
 behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
 readable network socket is an widget, the mouse is an widget, the
 keyboard is an widget, a multitouch gesture engine is a widget.
* A behaviour is a continuous item — it exists for the entire
 program and for all times — which maps events on the bus to other
 events on the bus.  It is an IO action as well — where widgets only
 sample the outside world and are in a sense read only, behaviours
 encapsulate reading and writing.
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[minh thu]

It's vis instead of vs:
http://vis.renci.org/jeff/buster/

2009/4/2 Peter Verswyvelen bugf...@gmail.com:
 Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
 The link you provided seems to be broken?
 On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard jefferson.r.he...@gmail.com
 wrote:

 Read more about it on its webpage: http://vs.renci.org/jeff/buster

 Yes, it’s to solve a particular problem.  And yes, this is a rough
 draft of an explanation of how it works.  I’ve not even really
 solidified the vocabulary yet, but I have this module which couches a
 large, abstract, interactive (both with the user and the system),
 multicomponent application in terms of a bus, inputs, behaviours, and
 events.

* Time is continuous and infinite.
* An event is a static, discrete item associated with a particular
 time.
* The bus is the discrete view of event in time at an instant.
* A widget is an IO action that assigns events to a particular
 time based only upon sampling the outside world (other events and
 behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
 readable network socket is an widget, the mouse is an widget, the
 keyboard is an widget, a multitouch gesture engine is a widget.
* A behaviour is a continuous item — it exists for the entire
 program and for all times — which maps events on the bus to other
 events on the bus.  It is an IO action as well — where widgets only
 sample the outside world and are in a sense read only, behaviours
 encapsulate reading and writing.
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

Yes,sorry.  vis, not vs. http://vis.renci.org/buster

It is a bit like grapefruit's circuits, but where Grapefruit circuits
describe the flow of events from place to place, Buster never does.
Events exist for all behaviours, to be selected by name, group, or
source.  The other major difference is the |~| or beside operator,
which describes concurrent application of behaviours.

A last but somewhat minor thing is that the Event type is fairly
general, allowing for multiple data to be attached to a single event
and this data to be of many of the standard types (Int, String,
Double, ByteString, etc) as well as a user-defined type.  Of course,
such an event type could be defined for other FRP frameworks as well.

-- Jeff

On Thu, Apr 2, 2009 at 9:53 AM, minh thu not...@gmail.com wrote:
 It's vis instead of vs:
 http://vis.renci.org/jeff/buster/

 2009/4/2 Peter Verswyvelen bugf...@gmail.com:
 Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
 The link you provided seems to be broken?
 On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard jefferson.r.he...@gmail.com
 wrote:

 Read more about it on its webpage: http://vs.renci.org/jeff/buster

 Yes, it’s to solve a particular problem.  And yes, this is a rough
 draft of an explanation of how it works.  I’ve not even really
 solidified the vocabulary yet, but I have this module which couches a
 large, abstract, interactive (both with the user and the system),
 multicomponent application in terms of a bus, inputs, behaviours, and
 events.

    * Time is continuous and infinite.
    * An event is a static, discrete item associated with a particular
 time.
    * The bus is the discrete view of event in time at an instant.
    * A widget is an IO action that assigns events to a particular
 time based only upon sampling the outside world (other events and
 behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
 readable network socket is an widget, the mouse is an widget, the
 keyboard is an widget, a multitouch gesture engine is a widget.
    * A behaviour is a continuous item — it exists for the entire
 program and for all times — which maps events on the bus to other
 events on the bus.  It is an IO action as well — where widgets only
 sample the outside world and are in a sense read only, behaviours
 encapsulate reading and writing.
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe



___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

Check links...  god.  http://vis.renci.org/jeff/buster  (can you tell
I was up till 3am last night?)

On Thu, Apr 2, 2009 at 10:05 AM, Jeff Heard jefferson.r.he...@gmail.com wrote:
 Yes,sorry.  vis, not vs. http://vis.renci.org/buster

 It is a bit like grapefruit's circuits, but where Grapefruit circuits
 describe the flow of events from place to place, Buster never does.
 Events exist for all behaviours, to be selected by name, group, or
 source.  The other major difference is the |~| or beside operator,
 which describes concurrent application of behaviours.

 A last but somewhat minor thing is that the Event type is fairly
 general, allowing for multiple data to be attached to a single event
 and this data to be of many of the standard types (Int, String,
 Double, ByteString, etc) as well as a user-defined type.  Of course,
 such an event type could be defined for other FRP frameworks as well.

 -- Jeff

 On Thu, Apr 2, 2009 at 9:53 AM, minh thu not...@gmail.com wrote:
 It's vis instead of vs:
 http://vis.renci.org/jeff/buster/

 2009/4/2 Peter Verswyvelen bugf...@gmail.com:
 Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
 The link you provided seems to be broken?
 On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard jefferson.r.he...@gmail.com
 wrote:

 Read more about it on its webpage: http://vs.renci.org/jeff/buster

 Yes, it’s to solve a particular problem.  And yes, this is a rough
 draft of an explanation of how it works.  I’ve not even really
 solidified the vocabulary yet, but I have this module which couches a
 large, abstract, interactive (both with the user and the system),
 multicomponent application in terms of a bus, inputs, behaviours, and
 events.

    * Time is continuous and infinite.
    * An event is a static, discrete item associated with a particular
 time.
    * The bus is the discrete view of event in time at an instant.
    * A widget is an IO action that assigns events to a particular
 time based only upon sampling the outside world (other events and
 behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
 readable network socket is an widget, the mouse is an widget, the
 keyboard is an widget, a multitouch gesture engine is a widget.
    * A behaviour is a continuous item — it exists for the entire
 program and for all times — which maps events on the bus to other
 events on the bus.  It is an IO action as well — where widgets only
 sample the outside world and are in a sense read only, behaviours
 encapsulate reading and writing.
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe




___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[minh thu]

Funny ... I never write an url in a mail : I type it in firefox (so I
actually check it) then copy/paste it.

2009/4/2 Jeff Heard jefferson.r.he...@gmail.com:
 Check links...  god.  http://vis.renci.org/jeff/buster  (can you tell
 I was up till 3am last night?)

 On Thu, Apr 2, 2009 at 10:05 AM, Jeff Heard jefferson.r.he...@gmail.com 
 wrote:
 Yes,sorry.  vis, not vs. http://vis.renci.org/buster

 It is a bit like grapefruit's circuits, but where Grapefruit circuits
 describe the flow of events from place to place, Buster never does.
 Events exist for all behaviours, to be selected by name, group, or
 source.  The other major difference is the |~| or beside operator,
 which describes concurrent application of behaviours.

 A last but somewhat minor thing is that the Event type is fairly
 general, allowing for multiple data to be attached to a single event
 and this data to be of many of the standard types (Int, String,
 Double, ByteString, etc) as well as a user-defined type.  Of course,
 such an event type could be defined for other FRP frameworks as well.

 -- Jeff

 On Thu, Apr 2, 2009 at 9:53 AM, minh thu not...@gmail.com wrote:
 It's vis instead of vs:
 http://vis.renci.org/jeff/buster/

 2009/4/2 Peter Verswyvelen bugf...@gmail.com:
 Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
 The link you provided seems to be broken?
 On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard jefferson.r.he...@gmail.com
 wrote:

 Read more about it on its webpage: http://vs.renci.org/jeff/buster

 Yes, it’s to solve a particular problem.  And yes, this is a rough
 draft of an explanation of how it works.  I’ve not even really
 solidified the vocabulary yet, but I have this module which couches a
 large, abstract, interactive (both with the user and the system),
 multicomponent application in terms of a bus, inputs, behaviours, and
 events.

* Time is continuous and infinite.
* An event is a static, discrete item associated with a particular
 time.
* The bus is the discrete view of event in time at an instant.
* A widget is an IO action that assigns events to a particular
 time based only upon sampling the outside world (other events and
 behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
 readable network socket is an widget, the mouse is an widget, the
 keyboard is an widget, a multitouch gesture engine is a widget.
* A behaviour is a continuous item — it exists for the entire
 program and for all times — which maps events on the bus to other
 events on the bus.  It is an IO action as well — where widgets only
 sample the outside world and are in a sense read only, behaviours
 encapsulate reading and writing.
 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe





___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Peter Verswyvelen]

It seems to be a trend to use more and more IO in new FRP approaches.
Grapefruit's circuits encapsulate side effects, as does your approach

This is a big departure from the pure libs like Fran, Yampa, Reactive, ...

I wander if this is because of some fundamental problem with functional
programming when it comes to FRP?

Some people claim that IO is also pure, and I tend to agree if we can
capture the state of the real world and rewind to it somehow :)

On Thu, Apr 2, 2009 at 4:06 PM, Jeff Heard jefferson.r.he...@gmail.comwrote:

 Check links...  god.  http://vis.renci.org/jeff/buster  (can you tell
 I was up till 3am last night?)

 On Thu, Apr 2, 2009 at 10:05 AM, Jeff Heard jefferson.r.he...@gmail.com
 wrote:
  Yes,sorry.  vis, not vs. http://vis.renci.org/buster
 
  It is a bit like grapefruit's circuits, but where Grapefruit circuits
  describe the flow of events from place to place, Buster never does.
  Events exist for all behaviours, to be selected by name, group, or
  source.  The other major difference is the |~| or beside operator,
  which describes concurrent application of behaviours.
 
  A last but somewhat minor thing is that the Event type is fairly
  general, allowing for multiple data to be attached to a single event
  and this data to be of many of the standard types (Int, String,
  Double, ByteString, etc) as well as a user-defined type.  Of course,
  such an event type could be defined for other FRP frameworks as well.
 
  -- Jeff
 
  On Thu, Apr 2, 2009 at 9:53 AM, minh thu not...@gmail.com wrote:
  It's vis instead of vs:
  http://vis.renci.org/jeff/buster/
 
  2009/4/2 Peter Verswyvelen bugf...@gmail.com:
  Sounds vaguely like Grapefruit's circuits, but I could be very wrong...
  The link you provided seems to be broken?
  On Thu, Apr 2, 2009 at 3:05 PM, Jeff Heard 
 jefferson.r.he...@gmail.com
  wrote:
 
  Read more about it on its webpage: http://vs.renci.org/jeff/buster
 
  Yes, it’s to solve a particular problem.  And yes, this is a rough
  draft of an explanation of how it works.  I’ve not even really
  solidified the vocabulary yet, but I have this module which couches a
  large, abstract, interactive (both with the user and the system),
  multicomponent application in terms of a bus, inputs, behaviours, and
  events.
 
 * Time is continuous and infinite.
 * An event is a static, discrete item associated with a particular
  time.
 * The bus is the discrete view of event in time at an instant.
 * A widget is an IO action that assigns events to a particular
  time based only upon sampling the outside world (other events and
  behaviours are irrelevant to it).  e.g. a Gtk Button is a widget, a
  readable network socket is an widget, the mouse is an widget, the
  keyboard is an widget, a multitouch gesture engine is a widget.
 * A behaviour is a continuous item — it exists for the entire
  program and for all times — which maps events on the bus to other
  events on the bus.  It is an IO action as well — where widgets only
  sample the outside world and are in a sense read only, behaviours
  encapsulate reading and writing.
  ___
  Haskell-Cafe mailing list
  Haskell-Cafe@haskell.org
  http://www.haskell.org/mailman/listinfo/haskell-cafe
 
 
  ___
  Haskell-Cafe mailing list
  Haskell-Cafe@haskell.org
  http://www.haskell.org/mailman/listinfo/haskell-cafe
 
 
 
 

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

It is parametrically polymorphic in a.  And no, it's an arbitrary
decision, BUT...  it allows me and other users to define generally
useful behaviours and widgets to package with the library using the
basic types without locking down 'a'.  The EventData type looks like
this:

data Event a { ..., edata :: EData a, ... }

data EData a = EChar Char
  | EString String
  | EStringL [String]
  | EByteString ByteString
  | EByteStringL [ByteString]
  | EInt Int
  | EIntL [Int]
  | EDouble Double
  | EDoubleL [Double]
  | EBool Bool
  | EBoolL [Bool]
  | EOther a
  | EOtherL [a]

Now, given that arbitrary decision, I'd be willing to modify Event so
that it is parametric on 'a' without EData and include EData as an
example binding for 'a' if the user chooses to use it.  However, I
foresee most behaviours and widgets that are generally useful to be
dependent on this type, which is why I made it a basic part of Event.

-- Jeff

On Thu, Apr 2, 2009 at 11:05 AM, Jules Bean ju...@jellybean.co.uk wrote:
 Jeff Heard wrote:

 A last but somewhat minor thing is that the Event type is fairly
 general, allowing for multiple data to be attached to a single event
 and this data to be of many of the standard types (Int, String,
 Double, ByteString, etc) as well as a user-defined type.  Of course,
 such an event type could be defined for other FRP frameworks as well.

 That sounds the opposite of general. That sounds specific. (Int, String,
 Double, ByteString as well as a user-defined type).

 Can you explain the reason for the EDouble, EString (etc.) alternatives as
 opposed to making the event simply (parametrically) polymorphic in a ?

 Jules

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jules Bean]

Jeff Heard wrote:

It is parametrically polymorphic in a.  And no, it's an arbitrary
decision, BUT...  it allows me and other users to define generally
useful behaviours and widgets to package with the library using the
basic types without locking down 'a'.  The EventData type looks like
this:

data Event a { ..., edata :: EData a, ... }

data EData a = EChar Char
  | EString String
  | EStringL [String]
  | EByteString ByteString
  | EByteStringL [ByteString]
  | EInt Int
  | EIntL [Int]
  | EDouble Double
  | EDoubleL [Double]
  | EBool Bool
  | EBoolL [Bool]
  | EOther a
  | EOtherL [a]


Maybe I wasn't clear, and probably I'm being dense. I understand what 
you've done - I looked at the type declarations before commenting - but 
I don't understand why.


Why is it useful to be able to use basic types without locking down 'a'?

Why is it useful to have a value of type Event FooBar which, in 
apparent defiance of the FooBar parameter, actually contains a value of 
type Double?


Jules
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jules Bean]

Jeff Heard wrote:

A last but somewhat minor thing is that the Event type is fairly
general, allowing for multiple data to be attached to a single event
and this data to be of many of the standard types (Int, String,
Double, ByteString, etc) as well as a user-defined type.  Of course,
such an event type could be defined for other FRP frameworks as well.


That sounds the opposite of general. That sounds specific. (Int, String, 
Double, ByteString as well as a user-defined type).


Can you explain the reason for the EDouble, EString (etc.) alternatives 
as opposed to making the event simply (parametrically) polymorphic in a ?


Jules
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Gleb Alexeyev]

Daryoush Mehrtash wrote:

When I try to install the hubigraph I get the following error:



skip


Network/XmlRpc/Client.hs:113:23:
Not in scope: type constructor or class `ConnError'

Network/XmlRpc/Client.hs:113:51:
Not in scope: type constructor or class `ConnError'
cabal: Error: some packages failed to install:
HUBIGraph-0.1 depends on haxr-3000.1.1.2 which failed to install.
haxr-3000.1.1.2 failed during the building phase. The exception was:
exit: ExitFailure 1

Any ideas?



I've just run into this problem as well. It seems that haxr doesn't 
build with HTTP-4000, though its cabal file doesn't specify the upper bound.


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

On Thu, Apr 2, 2009 at 11:22 AM, Jules Bean ju...@jellybean.co.uk wrote:

 Maybe I wasn't clear, and probably I'm being dense. I understand what you've
 done - I looked at the type declarations before commenting - but I don't
 understand why.

 Why is it useful to be able to use basic types without locking down 'a'?

 Why is it useful to have a value of type Event FooBar which, in apparent
 defiance of the FooBar parameter, actually contains a value of type Double?

 Jules


I'm assuming everyone won't want to start from scratch in creating all
their widgets and behaviours.  A bus contains only events of type 'a',
therefore all widgets and behaviours on that bus must use events of
type 'a'.  It is possible to run multiple buses at the same time in
the same program, and even possible to have them communicate between
each other (forkIO-ing the buses and attaching some arbitrary
behaviour that takes events from bus0, translates their types and then
puts them on bus1), and so that way you could use multiple types, but
I don't see a problem with a user having to read the documentation and
understand that an Event of type a contains data that is a variant
including type a.  How is it useful?  Consider the following widgets:

commandLineArgsWidget :: Widget a
commandLineArgsWidget = getArgs =
\args - produce' Environment
  CommandLineArgsWidget
  argv
  Persistent
  [EStringL args]

environmentWidget :: Widget a
environmentWidget b = getEnvironment =
mapM_ (\(k,v) - produce' Environment EnvironmentWidget k
Persistent [EString v] b)

progNameWidget :: Widget a
progNameWidget b = getProgName =
\v - produce' Environment ProgramNameWidget ProgramName
Persistent [EString v] b

As the library stands right now, I can take these widgets and put them
in a module and include them as part of the Buster library, and they
can be used pretty arbitrarily.  I can see being more semantically
pure and changing Event a to contain data of type a instead of data of
type [EData a], in which case the type signatures would look like
this:

progNameWidget :: WIdget [EData a]

and so forth to be compatible with Bus [EData a], but I think that in
the end so many widgets will reuse the EData type that it's just as
well to make it part of the Event rather than force the user to be
explicit about it every time.  But if I'm generally disagreed with
about this, I can change it -- I'm pretty neutral about it, to be
honest.

-- Jeff
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Problem with prepose.lhs and ghc6.10.1

[Henry Laxen]

Dear Group,

I'm trying to read the paper:
Functional Pearl: Implicit Configurations
at http://www.cs.rutgers.edu/~ccshan/prepose/
and when running the code in prepose.lhs I get:
../haskell/prepose.lhs:707:0: Parse error in pattern
which is pointing at:
normalize a :: M s a = M (mod a (modulus (undefined :: s)))

The paper says it uses lexically scoped type variables.  I tried reading about
them at:
http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#scoped-type-variables

so I added -XScopedTypeVariables to my OPTIONS but I still get the same error
message.  I would really like to play with the code in the paper, but I'm stuck
at this point.  Any pointers would be appreciated.
Best wishes,
Henry Laxen


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Type families and kind signatures

[Louis Wasserman]

The following module does not compile, and I can't figure out why:
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE KindSignatures #-}

module Foo where

import Control.Monad
import Data.Maybe

class Key k where
type Map k :: * - *
empty :: Map k v
 look :: k - Map k v  - Maybe v
update :: k - (Maybe v - Maybe v) - Map k v - Map k v

instance (Key k1, Key k2) = Key (k1, k2) where
type Map (k1, k2) v = Map k1 (Map k2 v)
empty = empty
 update (k1, k2) f = update k1 (update k2 f . fromMaybe empty)
look (k1, k2) = look k1 = look k2

The compile fails with
Foo.hs:16:1:
Number of parameters must match family declaration; expected 1
In the type synonym instance declaration for `Map'
In the instance declaration for `Key (k1, k2)'

Is this a bug with type synonym families? Is there something silly I'm
missing?

Louis Wasserman
wasserman.lo...@gmail.com
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Type families and kind signatures

[Luke Palmer]

2009/4/2 Louis Wasserman wasserman.lo...@gmail.com

 The following module does not compile, and I can't figure out why:
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE KindSignatures #-}

 module Foo where

 import Control.Monad
 import Data.Maybe

 class Key k where
 type Map k :: * - *
 empty :: Map k v
  look :: k - Map k v  - Maybe v
 update :: k - (Maybe v - Maybe v) - Map k v - Map k v

 instance (Key k1, Key k2) = Key (k1, k2) where
 type Map (k1, k2) v = Map k1 (Map k2 v)


The arity of the instance has to be *exactly* the same as is declared.  So
the v is one too many parameters.  That does make your life a little more
difficult (but points to an abstraction you may not have seen :-).

I would resolve this as:

type Map (k1,k2) = Map k1 `O` Map k2

Where O is functor composition from TypeCompose on hackage.



 empty = empty
  update (k1, k2) f = update k1 (update k2 f . fromMaybe empty)
 look (k1, k2) = look k1 = look k2

 The compile fails with
 Foo.hs:16:1:
 Number of parameters must match family declaration; expected 1
 In the type synonym instance declaration for `Map'
 In the instance declaration for `Key (k1, k2)'

 Is this a bug with type synonym families? Is there something silly I'm
 missing?

 Louis Wasserman
 wasserman.lo...@gmail.com

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Type families and kind signatures

[Louis Wasserman]

Mkay.  One more quick thing -- the wiki demonstrates a place where the
original attempt worked, with a data family instead. (That is, replacing
'type' with 'data' and adjusting the instance makes this program compile
immediately.)
a) Is there a type-hackery reason this is different from data families?
b) Is there a reason this isn't made a lot clearer in the documentation?
 GHC's docs say that higher-order type families can be declared with kind
signatures, but never gives any examples -- which would make it a lot
clearer that the below program doesn't work.

Louis Wasserman
wasserman.lo...@gmail.com


On Thu, Apr 2, 2009 at 12:05 PM, Luke Palmer lrpal...@gmail.com wrote:

 2009/4/2 Louis Wasserman wasserman.lo...@gmail.com

 The following module does not compile, and I can't figure out why:
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE KindSignatures #-}

 module Foo where

 import Control.Monad
 import Data.Maybe

 class Key k where
 type Map k :: * - *
 empty :: Map k v
  look :: k - Map k v  - Maybe v
 update :: k - (Maybe v - Maybe v) - Map k v - Map k v

 instance (Key k1, Key k2) = Key (k1, k2) where
 type Map (k1, k2) v = Map k1 (Map k2 v)


 The arity of the instance has to be *exactly* the same as is declared.  So
 the v is one too many parameters.  That does make your life a little more
 difficult (but points to an abstraction you may not have seen :-).

 I would resolve this as:

 type Map (k1,k2) = Map k1 `O` Map k2

 Where O is functor composition from TypeCompose on hackage.



  empty = empty
  update (k1, k2) f = update k1 (update k2 f . fromMaybe empty)
 look (k1, k2) = look k1 = look k2

 The compile fails with
 Foo.hs:16:1:
 Number of parameters must match family declaration; expected 1
 In the type synonym instance declaration for `Map'
 In the instance declaration for `Key (k1, k2)'

 Is this a bug with type synonym families? Is there something silly I'm
 missing?

 Louis Wasserman
 wasserman.lo...@gmail.com

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe



___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Jeff Heard]

Alright, updated it to extract EData from the Event type and make it
separate.  Basically, now all type signatures

Event a
Widget a
Behaviour a

should read

Event [EData a]
Widget [EData a]
Behaviour [EData a]

for backward compatibility.

On Thu, Apr 2, 2009 at 11:53 AM, Jeff Heard jefferson.r.he...@gmail.com wrote:
 On Thu, Apr 2, 2009 at 11:22 AM, Jules Bean ju...@jellybean.co.uk wrote:

 Maybe I wasn't clear, and probably I'm being dense. I understand what you've
 done - I looked at the type declarations before commenting - but I don't
 understand why.

 Why is it useful to be able to use basic types without locking down 'a'?

 Why is it useful to have a value of type Event FooBar which, in apparent
 defiance of the FooBar parameter, actually contains a value of type Double?

 Jules


 I'm assuming everyone won't want to start from scratch in creating all
 their widgets and behaviours.  A bus contains only events of type 'a',
 therefore all widgets and behaviours on that bus must use events of
 type 'a'.  It is possible to run multiple buses at the same time in
 the same program, and even possible to have them communicate between
 each other (forkIO-ing the buses and attaching some arbitrary
 behaviour that takes events from bus0, translates their types and then
 puts them on bus1), and so that way you could use multiple types, but
 I don't see a problem with a user having to read the documentation and
 understand that an Event of type a contains data that is a variant
 including type a.  How is it useful?  Consider the following widgets:

 commandLineArgsWidget :: Widget a
 commandLineArgsWidget = getArgs =
    \args - produce' Environment
                      CommandLineArgsWidget
                      argv
                      Persistent
                      [EStringL args]

 environmentWidget :: Widget a
 environmentWidget b = getEnvironment =
    mapM_ (\(k,v) - produce' Environment EnvironmentWidget k
 Persistent [EString v] b)

 progNameWidget :: Widget a
 progNameWidget b = getProgName =
    \v - produce' Environment ProgramNameWidget ProgramName
 Persistent [EString v] b

 As the library stands right now, I can take these widgets and put them
 in a module and include them as part of the Buster library, and they
 can be used pretty arbitrarily.  I can see being more semantically
 pure and changing Event a to contain data of type a instead of data of
 type [EData a], in which case the type signatures would look like
 this:

 progNameWidget :: WIdget [EData a]

 and so forth to be compatible with Bus [EData a], but I think that in
 the end so many widgets will reuse the EData type that it's just as
 well to make it part of the Event rather than force the user to be
 explicit about it every time.  But if I'm generally disagreed with
 about this, I can change it -- I'm pretty neutral about it, to be
 honest.

 -- Jeff

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Problem with prepose.lhs and ghc6.10.1

[andy morris]

2009/4/2 Henry Laxen nadine.and.he...@pobox.com:
 Dear Group,

 I'm trying to read the paper:
 Functional Pearl: Implicit Configurations
 at http://www.cs.rutgers.edu/~ccshan/prepose/
 and when running the code in prepose.lhs I get:
 ../haskell/prepose.lhs:707:0: Parse error in pattern
 which is pointing at:
 normalize a :: M s a = M (mod a (modulus (undefined :: s)))

 The paper says it uses lexically scoped type variables.  I tried reading about
 them at:
 http://www.haskell.org/ghc/docs/latest/html/users_guide/other-type-extensions.html#scoped-type-variables

 so I added -XScopedTypeVariables to my OPTIONS but I still get the same error
 message.  I would really like to play with the code in the paper, but I'm 
 stuck
 at this point.  Any pointers would be appreciated.
 Best wishes,
 Henry Laxen

It probably needs brackets:
normalize (a :: M s a) = ...
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] ANN: Buster 0.99.1, a library for application orchestration that is not FRP

[Felipe Lessa]

On Thu, Apr 02, 2009 at 11:53:00AM -0400, Jeff Heard wrote:
 and so forth to be compatible with Bus [EData a], but I think that in
 the end so many widgets will reuse the EData type that it's just as
 well to make it part of the Event rather than force the user to be
 explicit about it every time.  But if I'm generally disagreed with
 about this, I can change it -- I'm pretty neutral about it, to be
 honest.

Why not trying something like what was done with the new extensible
extensions, using typeable existencials and casts? That way you could
put any value you want and they would all be first class citizens.

Another random idea: a phantom type could be used to be explicit about
the type of event something produces or expects, something on the
lines of

 data EData a = forall b. Typeable b = EData b
  deriving (Typeable)

 -- | Extract the data.
 extract :: EData a - a
 extract (EData d) = case cast d of
   Just x  - x
   Nothing - error extract: phantom didn't match

 -- | Carefull extract the data, returns @Nothing@ if the phantom
 --   type doesn't match.
 extractM :: EData a - Maybe a
 extractM (EData d) = cast d

 -- | Extracts any type of data from a polymorphic 'EData'.
 extractAny :: (forall a. EData a) - Maybe b
 extractAny (EData d) = cast d
 -- Is the forall above useful to prevent mistakes or not?

 -- | Unsafely casts the phantom type to another one.
 unsafeCastData :: EData a - EData b
 unsafeCastData (EData d) = EData d

Your examples would become something like

 commandLineArgsWidget :: Widget [String]
 commandLineArgsWidget = getArgs =
 \args - produce' Environment
   CommandLineArgsWidget
   argv
   Persistent
   args

 environmentWidget :: Widget String
 environmentWidget b = getEnvironment =
 mapM_ (\(k,v) - produce' Environment EnvironmentWidget k
Persistent v b)

 progNameWidget :: Widget String
 progNameWidget b = getProgName =
 \v - produce' Environment ProgramNameWidget ProgramName
 Persistent v b

where I'm assuming that you could construct the EData inside produce'
as now that's the only constructor available.  The bus could then be
polymorphic on the phantom type.  Why use phantom types at all, then?
It at least serves for documentation purposes.  Well, it is a random
idea after all :).

--
Felipe.
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Gleb Alexeyev]

Don Stewart wrote:

Please upload!!



I've run into 2 problems while trying to do this.
The first one - haxr won't build with HTTP-4000, so I had to edit 
haxr.cabal and add the upper version bound for HTTP.


The second one is puzzling me.

I've cabal-installed the package, but keep getting linking errors from 
ghci (though interactive loading of the same module from source works fine):


Prelude :m + System.Vacuum.Ubigraph
Prelude System.Vacuum.Ubigraph view 42
Loading package syb ... linking ... done.
Loading lots of packages skipped
Loading package vacuum-0.0.6 ... linking ... done.
Loading package haxr-3000.1.1.2 ... linking ... done.
Loading package vacuum-ubigraph-0.1.0.2 ... linking ... interactive: 
/home/gleb/.cabal/lib/vacuum-ubigraph-0.1.0.2/ghc-6.10.1/HSvacuum-ubigraph-0.1.0.2.o: 
unknown symbol `vacuumzmubigraphzm0zi1zi0zi2_GraphicsziUbigraph_lvl_closure'

ghc: unable to load package `vacuum-ubigraph-0.1.0.2'
Prelude System.Vacuum.Ubigraph

Non-working package is here: 
http://hackage.haskell.org/cgi-bin/hackage-scripts/package/vacuum-ubigraph-0.1.0.1.


Any hints appreciated.

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Iavor Diatchki]

Hi,
The linking problem might be due to a bug in the cabal file:  if you
have modules that are not exposed, you still need to list them in the
other-modules section.
-Iavor

On Thu, Apr 2, 2009 at 10:01 AM, Gleb Alexeyev gleb.alex...@gmail.com wrote:
 Don Stewart wrote:

 Please upload!!


 I've run into 2 problems while trying to do this.
 The first one - haxr won't build with HTTP-4000, so I had to edit haxr.cabal
 and add the upper version bound for HTTP.

 The second one is puzzling me.

 I've cabal-installed the package, but keep getting linking errors from ghci
 (though interactive loading of the same module from source works fine):

 Prelude :m + System.Vacuum.Ubigraph
 Prelude System.Vacuum.Ubigraph view 42
 Loading package syb ... linking ... done.
 Loading lots of packages skipped
 Loading package vacuum-0.0.6 ... linking ... done.
 Loading package haxr-3000.1.1.2 ... linking ... done.
 Loading package vacuum-ubigraph-0.1.0.2 ... linking ... interactive:
 /home/gleb/.cabal/lib/vacuum-ubigraph-0.1.0.2/ghc-6.10.1/HSvacuum-ubigraph-0.1.0.2.o:
 unknown symbol `vacuumzmubigraphzm0zi1zi0zi2_GraphicsziUbigraph_lvl_closure'
 ghc: unable to load package `vacuum-ubigraph-0.1.0.2'
 Prelude System.Vacuum.Ubigraph

 Non-working package is here:
 http://hackage.haskell.org/cgi-bin/hackage-scripts/package/vacuum-ubigraph-0.1.0.1.

 Any hints appreciated.

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Retargeting the ghc code generator

[Vasili I. Galchin]

Hello,

  Is there any project to retarget the GHC code generator to generate
Common Intermediate Language(CLI) in order to run on Mono or .NET? I assume
that Mondrian did precisely that.

Thanks, Vasili
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Gleb Alexeyev]

Iavor Diatchki wrote:

Hi,
The linking problem might be due to a bug in the cabal file:  if you
have modules that are not exposed, you still need to list them in the
other-modules section.


This was the problem, thanks!



___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Reverting to any old version using Darcs

[Simon Michael]

I'm learning useful things in this thread.

Ketil Malde wrote:
 I've done this once, but with the cabal dependencies, not darcs.  Thus
 the uploaded sdist was missing one of the source files, and
 consequently failed to build.

I have a pre-release make target where I test everything I can think of. 
 I think it prevents the above, am I right ?


 # run pre-release checks: cabal is happy, the code builds, tests 
pass..
 check: setversion unittest doctest haddocktest 

   cabal clean 

   cabal check 

   cabal configure 

   cabal build 

   dist/build/hledger/hledger test 21 | tail -1 | grep -q 'Errors: 0 
 Failures: 0'   |


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Type families and kind signatures

[David Menendez]

2009/4/2 Louis Wasserman wasserman.lo...@gmail.com:
 Mkay.  One more quick thing -- the wiki demonstrates a place where the
 original attempt worked, with a data family instead. (That is, replacing
 'type' with 'data' and adjusting the instance makes this program compile
 immediately.)
 a) Is there a type-hackery reason this is different from data families?

It's not type hackery. Data families are different from type families,
and the syntax for declaring instances of higher-kinded families is a
consequence of those differences.

An instance of a data family is a new type constructor, so you have to
provide the additional arguments in order to declare the data
constructors.

data family Foo a :: * - *
data instance Foo Bool a = FB a a
-- Foo Bool has kind * - *, like [], so I could make it a Functor

Instance of type families are always pre-existing type constructors.

type family Bar a :: * - *  -- Bar a must equal something of kind * - *
type instance Bar () = Maybe

 b) Is there a reason this isn't made a lot clearer in the documentation?
  GHC's docs say that higher-order type families can be declared with kind
 signatures, but never gives any examples -- which would make it a lot
 clearer that the below program doesn't work.

Here's a higher-kinded type family I've used.

type family Sig t :: * - *

class (Traversable (Sig t)) = Recursive t where
roll :: Sig t t - t
unroll :: t - Sig t t


The Traversable context wouldn't be valid if I had declared Sig t a ::
*, because type families must always be fully applied.


The difference is analogous to the difference between

type M0 a = StateT Int IO a
type M1   = StateT Int IO

Since type synonyms (like type and data families) must always be fully
applied, you can use M1 in places where you can't use M0, even though
they're effectively the same thing.

foo :: ErrorT String M1 a -- valid
bar :: ErrorT String M0 a -- not valid



-- 
Dave Menendez d...@zednenem.com
http://www.eyrie.org/~zednenem/
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Funny type signature question

[Michael Snoyman]

I've butted into this problem multiple times, so I thought it's finally time
to get a good solution. I don't even have the terminology to describe the
issue, so I'll just post the code I'm annoyed with and hope someone
understands what I mean.

import Control.Monad.Random
import System.Random

data Marital = Single | Married | Divorced
deriving (Enum, Bounded, Show)

randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
randomEnum = do
let minb = minBound
maxb = maxBound
randVal - getRandomR (fromEnum minb, fromEnum maxb)
return $ head [toEnum randVal, minb, maxb] -- if I do the obvious thing
(return $ toEnum randVal) I get funny errors

main = do
stdGen - newStdGen
let marital = evalRand randomEnum stdGen :: Marital
putStrLn $ Random marital status:  ++ show marital

Any help is appreciated. Thanks!
Michael
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Peter Verswyvelen]

The type inferer seems to struggle to find the type of minBound and
maxBound, and GHC asks to use a type annotation.
To only way I see how to add a type annotation here is to use a GHC
extension:

{-# LANGUAGE ScopedTypeVariables #-}

randomEnum :: forall a g. (Enum a, Bounded a, RandomGen g) = Rand g a
randomEnum = do
randVal - getRandomR (fromEnum (minBound::a), fromEnum (maxBound::a))
return $ toEnum randVal


It is annoying when the type inferer encounters ambiguities - you also get
this all the time when using OpenGL e.g. GL.colour - but I don't know how to
solve this without adding type annotations


On Thu, Apr 2, 2009 at 8:03 PM, Michael Snoyman mich...@snoyman.com wrote:

 I've butted into this problem multiple times, so I thought it's finally
 time to get a good solution. I don't even have the terminology to describe
 the issue, so I'll just post the code I'm annoyed with and hope someone
 understands what I mean.

 import Control.Monad.Random
 import System.Random

 data Marital = Single | Married | Divorced
 deriving (Enum, Bounded, Show)

 randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
 randomEnum = do
 let minb = minBound
 maxb = maxBound
 randVal - getRandomR (fromEnum minb, fromEnum maxb)
 return $ head [toEnum randVal, minb, maxb] -- if I do the obvious thing
 (return $ toEnum randVal) I get funny errors

 main = do
 stdGen - newStdGen
 let marital = evalRand randomEnum stdGen :: Marital
 putStrLn $ Random marital status:  ++ show marital

 Any help is appreciated. Thanks!
 Michael

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Ross Mellgren]

There's nothing connecting the Enum/Bounded used in fromEnum and min/ 
maxBound to the toEnum, as there's an Int in the middle. Annotated  
very explicitly, the type inferrer probably sees something like:



randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
randomEnum = do
let minb = (minBound :: a1)
maxb = (maxBound :: a1)
randVal - getRandomR (fromEnum minb, fromEnum maxb) -- a1 here
return $ head [toEnum randVal, minb, maxb] -- putting minb and  
maxb in the list forces the unknown a1 to be a, because lists are  
homogeneous


So you have to give it some clue what you really want.

-Ross


On Apr 2, 2009, at 2:18 PM, Peter Verswyvelen wrote:

The type inferer seems to struggle to find the type of minBound and  
maxBound, and GHC asks to use a type annotation.


To only way I see how to add a type annotation here is to use a GHC  
extension:


{-# LANGUAGE ScopedTypeVariables #-}

randomEnum :: forall a g. (Enum a, Bounded a, RandomGen g) = Rand g a
randomEnum = do
randVal - getRandomR (fromEnum (minBound::a), fromEnum  
(maxBound::a))

return $ toEnum randVal


It is annoying when the type inferer encounters ambiguities - you  
also get this all the time when using OpenGL e.g. GL.colour - but I  
don't know how to solve this without adding type annotations



On Thu, Apr 2, 2009 at 8:03 PM, Michael Snoyman  
mich...@snoyman.com wrote:
I've butted into this problem multiple times, so I thought it's  
finally time to get a good solution. I don't even have the  
terminology to describe the issue, so I'll just post the code I'm  
annoyed with and hope someone understands what I mean.


import Control.Monad.Random
import System.Random

data Marital = Single | Married | Divorced
deriving (Enum, Bounded, Show)

randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
randomEnum = do
let minb = minBound
maxb = maxBound
randVal - getRandomR (fromEnum minb, fromEnum maxb)
return $ head [toEnum randVal, minb, maxb] -- if I do the  
obvious thing (return $ toEnum randVal) I get funny errors


main = do
stdGen - newStdGen
let marital = evalRand randomEnum stdGen :: Marital
putStrLn $ Random marital status:  ++ show marital

Any help is appreciated. Thanks!
Michael

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Michael Snoyman]

Peter and Lennart,

Scoped type variables is exactly what I needed to know. Thanks for solving
this annoyance for me!

Michael

On Thu, Apr 2, 2009 at 9:18 PM, Peter Verswyvelen bugf...@gmail.com wrote:

 The type inferer seems to struggle to find the type of minBound and
 maxBound, and GHC asks to use a type annotation.
 To only way I see how to add a type annotation here is to use a GHC
 extension:

 {-# LANGUAGE ScopedTypeVariables #-}

 randomEnum :: forall a g. (Enum a, Bounded a, RandomGen g) = Rand g a
 randomEnum = do
 randVal - getRandomR (fromEnum (minBound::a), fromEnum (maxBound::a))
 return $ toEnum randVal


 It is annoying when the type inferer encounters ambiguities - you also get
 this all the time when using OpenGL e.g. GL.colour - but I don't know how to
 solve this without adding type annotations


 On Thu, Apr 2, 2009 at 8:03 PM, Michael Snoyman mich...@snoyman.comwrote:

 I've butted into this problem multiple times, so I thought it's finally
 time to get a good solution. I don't even have the terminology to describe
 the issue, so I'll just post the code I'm annoyed with and hope someone
 understands what I mean.

 import Control.Monad.Random
 import System.Random

 data Marital = Single | Married | Divorced
 deriving (Enum, Bounded, Show)

 randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
 randomEnum = do
 let minb = minBound
 maxb = maxBound
 randVal - getRandomR (fromEnum minb, fromEnum maxb)
 return $ head [toEnum randVal, minb, maxb] -- if I do the obvious
 thing (return $ toEnum randVal) I get funny errors

 main = do
 stdGen - newStdGen
 let marital = evalRand randomEnum stdGen :: Marital
 putStrLn $ Random marital status:  ++ show marital

 Any help is appreciated. Thanks!
 Michael

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe



___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Felipe Lessa]

On Thu, Apr 02, 2009 at 08:18:27PM +0200, Peter Verswyvelen wrote:
 The type inferer seems to struggle to find the type of minBound and
 maxBound, and GHC asks to use a type annotation.
 To only way I see how to add a type annotation here is to use a GHC
 extension:

 {-# LANGUAGE ScopedTypeVariables #-}

Just use 'asTypeOf'. It is defined as

 asTypeOf :: a - a - a
 asTypeOf = const

so that @asTypeOf x y == x@ but both types are constrained to be
equal.  The above function would become

 randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
 randomEnum = do
 let min = minBound; max = maxBound
 randVal - getRandomR (fromEnum min, fromEnum max)
 return $ toEnum randVal `asTypeOf` min `asTypeOf` max

Note that I use the fact that 'return' is constrained to the type
variable 'a' we want to constrain its argument, and the
'asTypeOf' constrains everything to be of the same type.

HTH,

--
Felipe.
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Michael Snoyman]

On Thu, Apr 2, 2009 at 9:51 PM, Felipe Lessa felipe.le...@gmail.com wrote:

 On Thu, Apr 02, 2009 at 08:18:27PM +0200, Peter Verswyvelen wrote:
  The type inferer seems to struggle to find the type of minBound and
  maxBound, and GHC asks to use a type annotation.
  To only way I see how to add a type annotation here is to use a GHC
  extension:
 
  {-# LANGUAGE ScopedTypeVariables #-}

 Just use 'asTypeOf'. It is defined as

  asTypeOf :: a - a - a
  asTypeOf = const

 so that @asTypeOf x y == x@ but both types are constrained to be
 equal.  The above function would become

  randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
  randomEnum = do
  let min = minBound; max = maxBound
  randVal - getRandomR (fromEnum min, fromEnum max)
  return $ toEnum randVal `asTypeOf` min `asTypeOf` max

 Note that I use the fact that 'return' is constrained to the type
 variable 'a' we want to constrain its argument, and the
 'asTypeOf' constrains everything to be of the same type.

 HTH,

 --
 Felipe.


Interesting alternative. However, I think the ScopedTypeVariables looks a
little bit cleaner. I'll keep the asTypeOf in mind for the future though.

Michael
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Peter Verswyvelen]

Ah, I did not know this asTypeOf function.
But ScopedTypeVariables also allows you to give inner functions type
signatures that reuse polymorphic type parameters of the parent scope, which
makes code clearer I think.

On Thu, Apr 2, 2009 at 8:54 PM, Michael Snoyman mich...@snoyman.com wrote:



 On Thu, Apr 2, 2009 at 9:51 PM, Felipe Lessa felipe.le...@gmail.comwrote:

 On Thu, Apr 02, 2009 at 08:18:27PM +0200, Peter Verswyvelen wrote:
  The type inferer seems to struggle to find the type of minBound and
  maxBound, and GHC asks to use a type annotation.
  To only way I see how to add a type annotation here is to use a GHC
  extension:
 
  {-# LANGUAGE ScopedTypeVariables #-}

 Just use 'asTypeOf'. It is defined as

  asTypeOf :: a - a - a
  asTypeOf = const

 so that @asTypeOf x y == x@ but both types are constrained to be
 equal.  The above function would become

  randomEnum :: (Enum a, Bounded a, RandomGen g) = Rand g a
  randomEnum = do
  let min = minBound; max = maxBound
  randVal - getRandomR (fromEnum min, fromEnum max)
  return $ toEnum randVal `asTypeOf` min `asTypeOf` max

 Note that I use the fact that 'return' is constrained to the type
 variable 'a' we want to constrain its argument, and the
 'asTypeOf' constrains everything to be of the same type.

 HTH,

 --
 Felipe.


 Interesting alternative. However, I think the ScopedTypeVariables looks a
 little bit cleaner. I'll keep the asTypeOf in mind for the future though.

 Michael


 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Funny type signature question

[Felipe Lessa]

On Thu, Apr 02, 2009 at 09:54:16PM +0300, Michael Snoyman wrote:
 Interesting alternative. However, I think the ScopedTypeVariables looks a
 little bit cleaner. I'll keep the asTypeOf in mind for the future though.

That is a matter of taste.  However 'asTypeOf' has a clear
advantage: it is Haskell 98.  This is also a matter of taste, but
I prefer not to use extensions whenever they don't bring any real
gain (e.g. sometimes you can't use 'asTypeOf', and the scoped
type variables are your only option).

--
Felipe.
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Re: ANNOUNCE: vacuum-cairo: a cairo frontend to vacuum for live Haskell data visualization

[Matt Morrow]

Very nice.

Gleb Alexeyev gleb.alex...@gmail.com wrote:
  http://hackage.haskell.org/cgi-bin/hackage-scripts/package/vacuum-ubigraph
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] .editrc

[brad clawsie]

-BEGIN PGP SIGNED MESSAGE-
Hash: SHA1

does anyone have a .editrc they can provide that allows ghci to be used
on freebsd? 

i'm not looking for anything fancy, just backspace not being broken etc

thanks
brad
-BEGIN PGP SIGNATURE-
Version: GnuPG v2.0.10 (Darwin)

iEYEARECAAYFAknVGdQACgkQxRg3RkRK91NZ4gCgm8Oktcs3sCYl6YoY6X4igZAR
IDIAn2cpF7QnI4zz4LFN1cVlzG7qSHHk
=CJXp
-END PGP SIGNATURE-
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: HXT: desperatedly trying to concat

[Steffen Schuldenzucker]

Hello again.

I finally got it myself. It was just a matter of parentheses:

See http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3229 for the corrected 
version.
Looks like what I was trying to do is not expressable via just an arrow, one 
needs a function mapping the input arrow to a new one.

I'm gonna make a big WATCH YOUR PARENTHESES! poster... Yeah, with some arrows 
on it...

Thanks for reading, anyway.

Steffen

Neu bei WEB.DE: Kostenlose maxdome Movie-FLAT!
https://register.maxdome.de/xml/order/LpWebDe?ac=OM.MD.MD008K15726T7073a

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Issue with IsFunction/Vspace in GHC 6.10.1

[Jacques Carette]

I was playing with some of Oleg's code (at end for convenience).  After 
minor adjustments for ghc 6.10.1, it still didn't work.  The error 
message is quite puzzling too, as it suggests adding exactly the 
constraint which is present...  Any ideas?


Jacques

-- Oleg's definition of a vector space class, based on IsFunction and
-- TypeCast.  See http://okmij.org/ftp/Haskell/isFunction.lhs
-- for the January 2003 message, which works in GHC 6.2.1 and 6.4
-- code below *works* in 6.8.1 AFAIK
{-# LANGUAGE EmptyDataDecls, MultiParamTypeClasses, 
FunctionalDependencies #-}

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE OverlappingInstances #-}

module Q where

class Vspace a v | v - a
   where
   (+) :: v - v - v
   (*)  :: a - v - v

instance (IsFunction v f, Vspace' f a v) = Vspace a v
 where
 (+) = doplus (undefined::f)
 (*)  = dostar (undefined::f)

class Vspace' f a v | f v - a
   where
   doplus :: f - v - v - v
   dostar :: f - a - v - v

instance Num a = Vspace' HFalse a a where
doplus _ = (+)
dostar _  = (*)
-- etc.  No problem.

instance (IsFunction v f, Vspace' f a v, Vspace a v)
   = Vspace' HTrue a (c-v) where
doplus _ f g = \x - f x + g x
dostar _ a f x = a * (f x)


test1 = (1::Int) + 2
test2 = ((\x - x + (10::Int)) + (\x - x + (10::Int))) 1
test3 = ((\x y - x + y) + (\x y - (x + y) + x)) (1::Int) (2::Int)

test4 = ((\x y - x + y) + (\x y - ((2 * x) + (3 * y
   (1::Int) (2::Int)

data HTrue
data HFalse

class IsFunction a b | a - b
instance TypeCast f HTrue = IsFunction (x-y) f
instance TypeCast f HFalse = IsFunction a f

-- literally lifted from the HList library
class TypeCast   a b   | a - b, b-a   where typeCast   :: a - b
class TypeCast'  t a b | t a - b, t b - a where typeCast'  :: t-a-b
class TypeCast'' t a b | t a - b, t b - a where typeCast'' :: t-a-b
instance TypeCast'  () a b = TypeCast a b where typeCast x = typeCast' () x
instance TypeCast'' t a b = TypeCast' t a b where typeCast' = typeCast''
instance TypeCast'' () a a where typeCast'' _ x  = x


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Issue with IsFunction/Vspace in GHC 6.10.1

[Claus Reinke]

{-# LANGUAGE ScopedTypeVariables #-}

without, the 'f's in the instance are independent.
Claus

- Original Message - 
From: Jacques Carette care...@mcmaster.ca

To: haskell-cafe@haskell.org
Sent: Thursday, April 02, 2009 10:15 PM
Subject: [Haskell-cafe] Issue with IsFunction/Vspace in GHC 6.10.1


I was playing with some of Oleg's code (at end for convenience).  After 
minor adjustments for ghc 6.10.1, it still didn't work.  The error 
message is quite puzzling too, as it suggests adding exactly the 
constraint which is present...  Any ideas?


Jacques

-- Oleg's definition of a vector space class, based on IsFunction and
-- TypeCast.  See http://okmij.org/ftp/Haskell/isFunction.lhs
-- for the January 2003 message, which works in GHC 6.2.1 and 6.4
-- code below *works* in 6.8.1 AFAIK
{-# LANGUAGE EmptyDataDecls, MultiParamTypeClasses, 
FunctionalDependencies #-}

{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE UndecidableInstances #-}
{-# LANGUAGE OverlappingInstances #-}

module Q where

class Vspace a v | v - a
   where
   (+) :: v - v - v
   (*)  :: a - v - v

instance (IsFunction v f, Vspace' f a v) = Vspace a v
 where
 (+) = doplus (undefined::f)
 (*)  = dostar (undefined::f)

class Vspace' f a v | f v - a
   where
   doplus :: f - v - v - v
   dostar :: f - a - v - v

instance Num a = Vspace' HFalse a a where
doplus _ = (+)
dostar _  = (*)
-- etc.  No problem.

instance (IsFunction v f, Vspace' f a v, Vspace a v)
   = Vspace' HTrue a (c-v) where
doplus _ f g = \x - f x + g x
dostar _ a f x = a * (f x)


test1 = (1::Int) + 2
test2 = ((\x - x + (10::Int)) + (\x - x + (10::Int))) 1
test3 = ((\x y - x + y) + (\x y - (x + y) + x)) (1::Int) (2::Int)

test4 = ((\x y - x + y) + (\x y - ((2 * x) + (3 * y
   (1::Int) (2::Int)

data HTrue
data HFalse

class IsFunction a b | a - b
instance TypeCast f HTrue = IsFunction (x-y) f
instance TypeCast f HFalse = IsFunction a f

-- literally lifted from the HList library
class TypeCast   a b   | a - b, b-a   where typeCast   :: a - b
class TypeCast'  t a b | t a - b, t b - a where typeCast'  :: t-a-b
class TypeCast'' t a b | t a - b, t b - a where typeCast'' :: t-a-b
instance TypeCast'  () a b = TypeCast a b where typeCast x = typeCast' () x
instance TypeCast'' t a b = TypeCast' t a b where typeCast' = typeCast''
instance TypeCast'' () a a where typeCast'' _ x  = x


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Looking for practical examples of Zippers

[GüŸnther Schmidt]

David, guys,

sorry, this all started with a misconception on my behalf of what a 
Zipper is and what it is good for.


In the days that followed my post this became much clearer though and I 
now realize my original question was pointless.


It seems you spotted that and yes, generalized trie is probably more 
what I'm looking for, thanks!


Günther


David Menendez schrieb:

On Mon, Mar 30, 2009 at 3:46 PM, Gü?nther Schmidt gue.schm...@web.de wrote:

Thanks Don,

I followed some examples but have not yet seen anything that would show me
how, for instance, turn a nested Map like

Map Int (Map Int (Map String Double)

into a zipped version.

That is presuming of course that this use is feasible at all.


Are you asking about the technique for navigating recursive
structures, or did you mean something having to do with the
isomorphism between Map Int (Map Int (Map String Double)) and Map
(Int,Int,String) Double?

For the latter, the term you want is generalized trie.




___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Program using 500MB RAM to process 5MB file

[lucas]

I'm relatively new to haskell so as one does, I am rewriting an
existing program in haskell to help learn the language.

However, it eats up all my RAM whenever I run the program.

http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3175#a3175

Obviously I'm doing something wrong, but without my magical FP pants I
don't know what that might be.

-- 
Lucas Hazel lu...@die.net.au


pgpCpy889Gy8E.pgp
Description: PGP signature
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Missing dependency?

[Lyle Kopnicky]

Hi folks,

Since the time package is not included in ghc-6.10.2, I installed it via
cabal. Then I tried to configure my project, and it says that the dependency
is missing. Mysterious. Can anyone explain?

l...@lwk-desktop:~/devel/vintage-basic$ ghc-pkg list
/usr/local/lib/ghc-6.10.2/./package.conf:
Cabal-1.6.0.3, HUnit-1.2.0.3, QuickCheck-1.2.0.0, array-0.2.0.0,
base-3.0.3.1, base-4.1.0.0, bytestring-0.9.1.4, containers-0.2.0.1,
directory-1.0.0.3, (dph-base-0.3), (dph-par-0.3),
(dph-prim-interface-0.3), (dph-prim-par-0.3), (dph-prim-seq-0.3),
(dph-seq-0.3), editline-0.2.1.0, filepath-1.1.0.2, (ghc-6.10.2),
ghc-prim-0.1.0.0, haddock-2.4.2, haskell-src-1.0.1.3,
haskell98-1.0.1.0, hpc-0.5.0.3, html-1.0.1.2, integer-0.1.0.1,
mtl-1.1.0.2, network-2.2.1, old-locale-1.0.0.1, old-time-1.0.0.2,
packedstring-0.1.0.1, parallel-1.1.0.1, parsec-2.1.0.1,
pretty-1.0.1.0, process-1.0.1.1, random-1.0.0.1,
regex-base-0.72.0.2, regex-compat-0.71.0.1, regex-posix-0.72.0.3,
rts-1.0, stm-2.1.1.2, syb-0.1.0.1, template-haskell-2.3.0.1,
unix-2.3.2.0, xhtml-3000.2.0.1
/home/lwk/.ghc/i386-linux-6.10.2/package.conf:
HTTP-4000.0.4, time-1.1.2.3, zlib-0.5.0.0
l...@lwk-desktop:~/devel/vintage-basic$ runhaskell Setup.hs configure
Configuring vintage-basic-1.0.1...
Setup.hs: At least the following dependencies are missing:
time =1.1
l...@lwk-desktop:~/devel/vintage-basic$

Thanks,
Lyle
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Type families and kind signatures

[Louis Wasserman]

Mkay.  I get it now.  I was under the impression that, essentially, a data
family was precisely equivalent to a type family aliasing to a separately
declared datatype.

One more question: is there any way to get the low overhead of newtypes for
particular instances of a data family?  Is this impossible?  That is, is
there any way to do something like

data family Foo a
data instance Foo Int = Bar Int -- Bar is actually a newtype

Louis Wasserman
wasserman.lo...@gmail.com


On Thu, Apr 2, 2009 at 12:47 PM, David Menendez d...@zednenem.com wrote:

 2009/4/2 Louis Wasserman wasserman.lo...@gmail.com:
  Mkay.  One more quick thing -- the wiki demonstrates a place where the
  original attempt worked, with a data family instead. (That is, replacing
  'type' with 'data' and adjusting the instance makes this program compile
  immediately.)
  a) Is there a type-hackery reason this is different from data families?

 It's not type hackery. Data families are different from type families,
 and the syntax for declaring instances of higher-kinded families is a
 consequence of those differences.

 An instance of a data family is a new type constructor, so you have to
 provide the additional arguments in order to declare the data
 constructors.

 data family Foo a :: * - *
 data instance Foo Bool a = FB a a
 -- Foo Bool has kind * - *, like [], so I could make it a Functor

 Instance of type families are always pre-existing type constructors.

 type family Bar a :: * - *  -- Bar a must equal something of kind * - *
 type instance Bar () = Maybe

  b) Is there a reason this isn't made a lot clearer in the documentation?
   GHC's docs say that higher-order type families can be declared with kind
  signatures, but never gives any examples -- which would make it a lot
  clearer that the below program doesn't work.

 Here's a higher-kinded type family I've used.

 type family Sig t :: * - *

 class (Traversable (Sig t)) = Recursive t where
roll :: Sig t t - t
unroll :: t - Sig t t


 The Traversable context wouldn't be valid if I had declared Sig t a ::
 *, because type families must always be fully applied.


 The difference is analogous to the difference between

 type M0 a = StateT Int IO a
 type M1   = StateT Int IO

 Since type synonyms (like type and data families) must always be fully
 applied, you can use M1 in places where you can't use M0, even though
 they're effectively the same thing.

 foo :: ErrorT String M1 a -- valid
 bar :: ErrorT String M0 a -- not valid



 --
 Dave Menendez d...@zednenem.com
 http://www.eyrie.org/~zednenem/ http://www.eyrie.org/%7Ezednenem/

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Retargeting the ghc code generator

[Toby Hutton]

2009/4/3 Vasili I. Galchin vigalc...@gmail.com:
 Hello,

   Is there any project to retarget the GHC code generator to generate
 Common Intermediate Language(CLI) in order to run on Mono or .NET? I assume
 that Mondrian did precisely that.

There are/were a couple of projects attempting that or to bring
Haskell to .NET in general, but with limited success.

MSR were considering it but due to qualities like purity and laziness
making it difficult they chose to bring Ocaml to .NET and came up with
F#.  http://research.microsoft.com/en-us/um/cambridge/projects/fsharp/
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Issue with IsFunction/Vspace in GHC 6.10.1

[Jacques Carette]

Claus Reinke wrote:
 {-# LANGUAGE ScopedTypeVariables #-}

 without, the 'f's in the instance are independent.
 Claus
Thanks - I discovered this (by trial-and-error) at about the same time
you sent the email. 

Is there a ticket somewhere to add a warning about this?  I expected me
'f's to be the same, and the error messages were not the least bit
enlightening.

Jacques
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Missing dependency?

[Jonathan Cast]

On Thu, 2009-04-02 at 16:13 -0700, Lyle Kopnicky wrote:
 Hi folks,
 
 Since the time package is not included in ghc-6.10.2, I installed it
 via cabal. Then I tried to configure my project, and it says that the
 dependency is missing. Mysterious. Can anyone explain?
 
 l...@lwk-desktop:~/devel/vintage-basic$ ghc-pkg list
 /usr/local/lib/ghc-6.10.2/./package.conf:
 Cabal-1.6.0.3, HUnit-1.2.0.3, QuickCheck-1.2.0.0, array-0.2.0.0,
 base-3.0.3.1, base-4.1.0.0, bytestring-0.9.1.4,
 containers-0.2.0.1,
 directory-1.0.0.3, (dph-base-0.3), (dph-par-0.3),
 (dph-prim-interface-0.3), (dph-prim-par-0.3), (dph-prim-seq-0.3),
 (dph-seq-0.3), editline-0.2.1.0, filepath-1.1.0.2, (ghc-6.10.2),
 ghc-prim-0.1.0.0, haddock-2.4.2, haskell-src-1.0.1.3,
 haskell98-1.0.1.0, hpc-0.5.0.3, html-1.0.1.2, integer-0.1.0.1,
 mtl-1.1.0.2, network-2.2.1, old-locale-1.0.0.1, old-time-1.0.0.2,
 packedstring-0.1.0.1, parallel-1.1.0.1, parsec-2.1.0.1,
 pretty-1.0.1.0, process-1.0.1.1, random-1.0.0.1,
 regex-base-0.72.0.2, regex-compat-0.71.0.1, regex-posix-0.72.0.3,
 rts-1.0, stm-2.1.1.2, syb-0.1.0.1, template-haskell-2.3.0.1,
 unix-2.3.2.0, xhtml-3000.2.0.1
 /home/lwk/.ghc/i386-linux-6.10.2/package.conf:
 HTTP-4000.0.4, time-1.1.2.3, zlib-0.5.0.0
 l...@lwk-desktop:~/devel/vintage-basic$ runhaskell Setup.hs configure
 Configuring vintage-basic-1.0.1...
 Setup.hs: At least the following dependencies are missing:
 time =1.1
 l...@lwk-desktop:~/devel/vintage-basic$ 

You need to use runhaskell Setup.hs configure --user, or else re-install
time globally (as root).

jcc


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Program using 500MB RAM to process 5MB file

[Rick R]

You could profile your app for memory usage. Then you could figure out just
what function is blowing up the mem usage and figure out how to optimize it.


http://book.realworldhaskell.org/read/profiling-and-optimization.html


2009/4/2 lu...@die.net.au

 I'm relatively new to haskell so as one does, I am rewriting an
 existing program in haskell to help learn the language.

 However, it eats up all my RAM whenever I run the program.

 http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3175#a3175

 Obviously I'm doing something wrong, but without my magical FP pants I
 don't know what that might be.

 --
 Lucas Hazel lu...@die.net.au

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe




-- 
We can't solve problems by using the same kind of thinking we used when we
created them.
   - A. Einstein
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Wishful thinking: a text editor that expands function applications into function definitions

[Duane Johnson]

So I was thinking about a killer feature for a text editor.   
Wouldn't it be neat if you could expand function calls into their  
definitions, in-place?


For example, suppose we have minus defined like so, somewhere in  
another file:



minus (a, b, c) (x, y, z) = (a - x, b - y, c - z)


Later, we make use of the function in our current context:


let p1 = (1, 2, 3)
 p2 = (4, 5, 6)
in p1 `minus` p2


By telling the editor to expand the minus, we get a temporary  
replacing of the above with:



(1 - 4, 2 - 5, 3 - 6)


Another example:


  parse s = map readLine ls


And supposing that readLine is defined somewhere else, moving the  
cursor to readLine in the line above and expanding becomes:



  parse s = map (\line - words $ dropWhile (== ' ') line)


This is all pretty standard for the kinds of things we do in Haskell  
to work it out by hand, but is there any reason the parser couldn't do  
this?  I think it would be even harder to do automatically in any  
other language.  Maybe it's already been attempted or done?


Curious,

Duane Johnson

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Wishful thinking: a text editor that expands function applications into function definitions

[Derek Elkins]

On Thu, 2009-04-02 at 18:01 -0600, Duane Johnson wrote:
 So I was thinking about a killer feature for a text editor.   
 Wouldn't it be neat if you could expand function calls into their  
 definitions, in-place?
 
 For example, suppose we have minus defined like so, somewhere in  
 another file:
 
  minus (a, b, c) (x, y, z) = (a - x, b - y, c - z)
 
 Later, we make use of the function in our current context:
 
  let p1 = (1, 2, 3)
   p2 = (4, 5, 6)
  in p1 `minus` p2
 
 By telling the editor to expand the minus, we get a temporary  
 replacing of the above with:
 
  (1 - 4, 2 - 5, 3 - 6)
 
 Another example:
 
parse s = map readLine ls
 
 And supposing that readLine is defined somewhere else, moving the  
 cursor to readLine in the line above and expanding becomes:
 
parse s = map (\line - words $ dropWhile (== ' ') line)
 
 This is all pretty standard for the kinds of things we do in Haskell  
 to work it out by hand, but is there any reason the parser couldn't do  
 this?  I think it would be even harder to do automatically in any  
 other language.  Maybe it's already been attempted or done?

See HaRe http://www.cs.kent.ac.uk/projects/refactor-fp/hare.html

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Wishful thinking: a text editor that expands function applications into function definitions

[Zachary Turner]

It seems like a neat feature, and it could just be my inexperience with
Haskell but it doesn't seem killer.  For example, why would you want to
expand readLine like that if you already have it defined?  It seems to
defeat much of the benefit of functional languages in the first place, which
is that it's so easy to reuse code by composing functions into new
functions.  I can see the case where you're passing all constants to a
function, because then supposedly inlining it might be more efficient, but I
would think the compiler would optimize most of the cases for you anyway.

One feature that I -do- think would be killer though, is the ability for the
editor to do a mouse-over tooltip of a) function definitions, and b)
arbitrary expressions.  So like in your example above, hovering the mouse
over `minus` in the expression p1 `minus` p2 would pop up a two line tooltip
that looked like this

minus :: (Num a, Num b, Num c) = (a,b,c) - (a,b,c) - (a,b,c)
minus :: first - second - (a,b,c)

Something along those lines.  It's nice to be able to see names of function
arguments without having to navigate away from the line you're editing.
This isn't the killer yet though since it's actually pretty standard for
most sufficiently advanced programming language IDEs.  The killer is that
the mouse-over event would also look one line above the function definition
for a comment.  It would then scan backward until it finds no more
comments.  It would then display that text above the function definition.
It's great having a type signature, but comments would just be icing on the
cake.

For arbitrary expressions, suppose you had the following function:

replaceItem :: [a] - (a - Bool) - a - [a]
let replaceItem xs pred = (: filter (not.pred) xs)

You then highlight the text filter (not.pred) and hover over the
highlighted text.  The mouse then pops up a tooltip that says [a] - [a].
That would be killer IMO



On Thu, Apr 2, 2009 at 7:01 PM, Duane Johnson duane.john...@gmail.comwrote:

 So I was thinking about a killer feature for a text editor.  Wouldn't it
 be neat if you could expand function calls into their definitions, in-place?

 For example, suppose we have minus defined like so, somewhere in another
 file:

  minus (a, b, c) (x, y, z) = (a - x, b - y, c - z)


 Later, we make use of the function in our current context:

  let p1 = (1, 2, 3)
 p2 = (4, 5, 6)
 in p1 `minus` p2


 By telling the editor to expand the minus, we get a temporary replacing
 of the above with:

  (1 - 4, 2 - 5, 3 - 6)


 Another example:

   parse s = map readLine ls


 And supposing that readLine is defined somewhere else, moving the cursor to
 readLine in the line above and expanding becomes:

   parse s = map (\line - words $ dropWhile (== ' ') line)


 This is all pretty standard for the kinds of things we do in Haskell to
 work it out by hand, but is there any reason the parser couldn't do this?  I
 think it would be even harder to do automatically in any other language.
  Maybe it's already been attempted or done?

 Curious,

 Duane Johnson

 ___
 Haskell-Cafe mailing list
 Haskell-Cafe@haskell.org
 http://www.haskell.org/mailman/listinfo/haskell-cafe

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Wishful thinking: a text editor that expands function applications into function definitions

[Duane Johnson]

Perhaps it wouldn't be as all-wonderful as I think, but as a new  
Haskell user, I am constantly switching back and forth between various  
definitions of things trying to compare documentation and files...


The purpose of expansion as I was explaining it is not to  
*permanently replace* what is in the text, but rather to *temporarily  
replace* it.  I imagine it kind of like a zoom in for code.  You  
could zoom in on one function, and seeing a new function that you  
don't recognize, zoom in again, and so on.  Once done, you would hit  
ESC to make it all return as it was.


BTW, I do like your suggestion of tooltip types.  That would be very  
handy!


Duane Johnson

On Apr 2, 2009, at 6:24 PM, Zachary Turner wrote:

It seems like a neat feature, and it could just be my inexperience  
with Haskell but it doesn't seem killer.  For example, why would  
you want to expand readLine like that if you already have it  
defined?  It seems to defeat much of the benefit of functional  
languages in the first place, which is that it's so easy to reuse  
code by composing functions into new functions.  I can see the case  
where you're passing all constants to a function, because then  
supposedly inlining it might be more efficient, but I would think  
the compiler would optimize most of the cases for you anyway.


One feature that I -do- think would be killer though, is the ability  
for the editor to do a mouse-over tooltip of a) function  
definitions, and b) arbitrary expressions.  So like in your example  
above, hovering the mouse over `minus` in the expression p1 `minus`  
p2 would pop up a two line tooltip that looked like this


minus :: (Num a, Num b, Num c) = (a,b,c) - (a,b,c) - (a,b,c)
minus :: first - second - (a,b,c)

Something along those lines.  It's nice to be able to see names of  
function arguments without having to navigate away from the line  
you're editing.  This isn't the killer yet though since it's  
actually pretty standard for most sufficiently advanced programming  
language IDEs.  The killer is that the mouse-over event would also  
look one line above the function definition for a comment.  It would  
then scan backward until it finds no more comments.  It would then  
display that text above the function definition.  It's great having  
a type signature, but comments would just be icing on the cake.


For arbitrary expressions, suppose you had the following function:

replaceItem :: [a] - (a - Bool) - a - [a]
let replaceItem xs pred = (: filter (not.pred) xs)

You then highlight the text filter (not.pred) and hover over the  
highlighted text.  The mouse then pops up a tooltip that says [a] - 
 [a].  That would be killer IMO




On Thu, Apr 2, 2009 at 7:01 PM, Duane Johnson  
duane.john...@gmail.com wrote:
So I was thinking about a killer feature for a text editor.   
Wouldn't it be neat if you could expand function calls into their  
definitions, in-place?


For example, suppose we have minus defined like so, somewhere in  
another file:


minus (a, b, c) (x, y, z) = (a - x, b - y, c - z)

Later, we make use of the function in our current context:

let p1 = (1, 2, 3)
p2 = (4, 5, 6)
in p1 `minus` p2

By telling the editor to expand the minus, we get a temporary  
replacing of the above with:


(1 - 4, 2 - 5, 3 - 6)

Another example:

 parse s = map readLine ls

And supposing that readLine is defined somewhere else, moving the  
cursor to readLine in the line above and expanding becomes:


 parse s = map (\line - words $ dropWhile (== ' ') line)

This is all pretty standard for the kinds of things we do in Haskell  
to work it out by hand, but is there any reason the parser couldn't  
do this?  I think it would be even harder to do automatically in any  
other language.  Maybe it's already been attempted or done?


Curious,

Duane Johnson

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe



___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Type families and kind signatures

[Manuel M T Chakravarty]

Louis Wasserman:
Mkay.  I get it now.  I was under the impression that, essentially,  
a data family was precisely equivalent to a type family aliasing to  
a separately declared datatype.


No, they are not equivalent.  You can see that as follows.  Assume,

  data family T a
  type family S a

Now, given `T a ~ T b', we know that `a ~ b'.  (We call this  
implication decomposition.)


In contrast, given `S a ~ S b' we do *not* know whether `a ~ b'.  Why  
not?  Consider the instances


  type instance S Int = Bool
  type instance S Float = Bool

Clearly, `S Int ~ S Float', but surely not `Int ~ Float'.  So,  
decomposition does not hold for type synonym families, but it does  
hold for data families.


This is actually, not really a property of type *families* alone.  It  
already distinguishes vanilla data types from vanilla type synonyms.   
We know, say, that if `Maybe a ~ Maybe b', then `a ~ b'.  However, given


  type Const a = Int

we have `Const Int ~ Const Float' (and still not `Int ~ Float').   
Definitions, such as that of `Const', are rarely used, which is why  
this issue doesn't come up much until you use type families.


One more question: is there any way to get the low overhead of  
newtypes for particular instances of a data family?  Is this  
impossible?  That is, is there any way to do something like


data family Foo a
data instance Foo Int = Bar Int -- Bar is actually a newtype


You can use

  newtype instance Foo Int = MkFoo Int

So, the instances of a data family can be data or newtype instances.,  
and you can freely mix them.


Manuel


On Thu, Apr 2, 2009 at 12:47 PM, David Menendez d...@zednenem.com  
wrote:

2009/4/2 Louis Wasserman wasserman.lo...@gmail.com:
 Mkay.  One more quick thing -- the wiki demonstrates a place where  
the
 original attempt worked, with a data family instead. (That is,  
replacing
 'type' with 'data' and adjusting the instance makes this program  
compile

 immediately.)
 a) Is there a type-hackery reason this is different from data  
families?


It's not type hackery. Data families are different from type families,
and the syntax for declaring instances of higher-kinded families is a
consequence of those differences.

An instance of a data family is a new type constructor, so you have to
provide the additional arguments in order to declare the data
constructors.

data family Foo a :: * - *
data instance Foo Bool a = FB a a
-- Foo Bool has kind * - *, like [], so I could make it a Functor

Instance of type families are always pre-existing type constructors.

type family Bar a :: * - *  -- Bar a must equal something of kind *  
- *

type instance Bar () = Maybe

 b) Is there a reason this isn't made a lot clearer in the  
documentation?
  GHC's docs say that higher-order type families can be declared  
with kind
 signatures, but never gives any examples -- which would make it a  
lot

 clearer that the below program doesn't work.

Here's a higher-kinded type family I've used.

type family Sig t :: * - *

class (Traversable (Sig t)) = Recursive t where
   roll :: Sig t t - t
   unroll :: t - Sig t t


The Traversable context wouldn't be valid if I had declared Sig t a ::
*, because type families must always be fully applied.


The difference is analogous to the difference between

type M0 a = StateT Int IO a
type M1   = StateT Int IO

Since type synonyms (like type and data families) must always be fully
applied, you can use M1 in places where you can't use M0, even though
they're effectively the same thing.

foo :: ErrorT String M1 a -- valid
bar :: ErrorT String M0 a -- not valid



--
Dave Menendez d...@zednenem.com
http://www.eyrie.org/~zednenem/

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe


___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Reverting to any old version using Darcs

[Trent W. Buck]

Nicolas Pouillard nicolas.pouill...@gmail.com writes:

 Excerpts from Peter Verswyvelen's message of Wed Apr 01 23:39:15 +0200 2009:
 [...]

 biggest problems I usually see in teams - namely forgetting to add files,
 forgetting to check in dependencies and the inability the merge after
 renames or moves -

 Have a look at the --look-for-adds flag that makes the enables the detection
 of new files.

If you were really paranoid about this, you could turn --look-for-adds
on by default in a repo or for a user, so that any darcs record would
also ask about new files.  This would probably get annoying unless you
added a bunch of entries to _darcs/prefs/boring.

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Reverting to any old version using Darcs

[Trent W. Buck]

Ketil Malde ke...@malde.org writes:

 Peter Verswyvelen bugf...@gmail.com writes:

 Forgetting to add a file can be a nasty one, since if you discover
 that too late, the original file at patch time might not exist
 anymore (how do you guys solve this? Just plain discipline I
 guess?).

 I've done this once, but with the cabal dependencies, not darcs.  Thus
 the uploaded sdist was missing one of the source files, and
 consequently failed to build.

 I suppose the best way is to test this with a separate test repository
 which you don't touch, except from pulling from your development repo
 and checking that it builds.

For what its worth, the darcs test preference performs the tests in a
completely fresh working tree that it creates ONLY using files that have
been checked in.  This helps avoid the problem of things only working
accidentally, because of uncommitted changes.

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

[Haskell-cafe] Re: Reverting to any old version using Darcs

[Trent W. Buck]

Simon Michael si...@joyful.com writes:

 I'm learning useful things in this thread.

 Ketil Malde wrote:
 I've done this once, but with the cabal dependencies, not darcs.  Thus
 the uploaded sdist was missing one of the source files, and
 consequently failed to build.

 I have a pre-release make target where I test everything I can think
 of. I think it prevents the above, am I right ?

Dunno.

  # run pre-release checks: cabal is happy, the code builds, tests
 pass..
  check: setversion unittest doctest haddocktest
cabal clean
cabal check
cabal configure
cabal build

dist/build/hledger/hledger test 21 | tail -1 | grep -q 'Errors: 0
 Failures: 0'   |

You'd also want to test

cabal haddock
cabal test
cabal copy $(TMPDIR=$PWD mktemp -dt yow.XX)# untested

IMO even if your tests aren't implemented in Setup.lhs, you should still
teach cabal test how to run them.  That helps distributors like me
automatically run the test -- i.e. you get testing for free because we
don't have to go out of our way to turn it on.

___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Program using 500MB RAM to process 5MB file

[lucas]

On Thu, Apr 02, 2009 at 07:55:07PM -0400, Rick R wrote:
 You could profile your app for memory usage. Then you could figure out just
 what function is blowing up the mem usage and figure out how to optimize it.
 
 
 http://book.realworldhaskell.org/read/profiling-and-optimization.html
 
 
 2009/4/2 lu...@die.net.au
 
  I'm relatively new to haskell so as one does, I am rewriting an
  existing program in haskell to help learn the language.
 
  However, it eats up all my RAM whenever I run the program.
 
  http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3175#a3175
 
  Obviously I'm doing something wrong, but without my magical FP pants I
  don't know what that might be.
 

I ran some profiling as suggested,

[SNIP]

total time  =8.36 secs   (418 ticks @ 20 ms)
total alloc = 3,882,593,720 bytes  (excludes profiling overheads)

COST CENTREMODULE   %time %alloc

line   PkgDb 89.7   93.5

COST CENTRE MODULE no. entries %time %alloc %time %alloc
linePkgDb  305 109771  89.7  93.3   89.7  93.3

[SNIP]

The line function is part of the file parser

line :: Parser String
line = anyChar `manyTill` newline

files' :: Parser Files
files' = line `manyTill` newline

Perhaps I should also explain the structure of the file. It's for a
simple package manager called pkgutils, used for CRUX[1]. The file
contains information for all the packages installed and is structured
as follows

package name
package version
file
file
...
file

package name
...

From profiling it shows that the memory is simple consumed by reading
in all the lines, the graph from using -p -hd shows an almost Ologn2
growth of the heap as the collection of lines grows.

Is there a better way to do this?

[1] http://crux.nu
-- 
Lucas Hazel lu...@die.net.au


pgplYxxA2pBsy.pgp
Description: PGP signature
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: [Haskell-cafe] Program using 500MB RAM to process 5MB file

[Luke Palmer]

2009/4/2 lu...@die.net.au

 I'm relatively new to haskell so as one does, I am rewriting an
 existing program in haskell to help learn the language.

 However, it eats up all my RAM whenever I run the program.

 http://hpaste.org/fastcgi/hpaste.fcgi/view?id=3175#a3175

 Obviously I'm doing something wrong, but without my magical FP pants I
 don't know what that might be.


(1) You are using plain Strings.  Those things are like 8 bytes per
character (or something, someone more knowledgeable can give a more accurate
figure).  Use bytestrings (with bytestring-utf8 if you need it) instead.

(2) You are parsing strictly, meaning you have to read the whole input file
before anything can be output.  This may be necessary for your application,
but Haskell is *very* strong with streaming applications.  Change to a lazy
parser and you will run in constant memory.

(I don't know offhand of any lazy parsing libraries, but I've heard them
discussed before, so they're somewhere)

Luke
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe