- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Some thoughts on Type-Directed Name
by Anthony Clayden 31 Jan '12

31 Jan '12

> There is an effort underway to make Haskell's Records > better. The discussion is ongoing on the ghc-users mail > list, ... > in the direction of making the most minimal changes > possible to achieve some simple record name-spacing. > > Thanks, > Greg Weber Thank you Greg, Yes I know, and I have been trying to follow along (intermittently). Thank you for your attempts to marshall the discussion. What would really, really help me is for someone to have a look at the 'solution' I posted to the difficulties SPJ saw with the SORF approach. (I ref'd it in my reply to Steve.) It seemed from my testing to address the needs. Since I got it working in GHC 7.2.1, there's a good chance it will need only "minimal changes" to implement (I'm thinking mostly syntactic sugar) -- providing of course that it is workable and generalisable enough. It could possibly benefit from some of the new Kind-level stuff in 7.4.1 (that SPJ used, but wasn't available to me at the time). I keep trying to make the time to write up the full proposal on the Wiki. I see it as a 'tweak' to SORF. Given that I'm supposed to have a day job, I'm reluctant to make time until/unless someone else double-checks whether I'm barking up the wrong tree. Anthony

2 1

Need advice: Haskell in Web Client
by dokondr 30 Jan '12

30 Jan '12

**Bardur Arantsson wrote: >On 01/26/2012 11:16 AM, dokondr wrote: >> Ideally, I would be happy to be able to write in Haskell a complete >> front-end / GUI, so it could be compiled to different back-ends: Javascript >> to run in the Browser and also a standalone app. >> In Python world this is already done with Pyjamas (http://pyjs.org/) - "a >> Rich Internet Application (RIA) Development Platform for both Web and >> Desktop." >> Also from Pyjamas site: >> Pyjamas "... contains a Python-to-Javascript compiler, an AJAX framework >> and a Widget Set API. >> Pyjamas Desktop is the Desktop version of Pyjamas >> Pyjamas Desktop allows the exact same python web application source code to >> be executed as a standalone desktop application (running under Python) >> instead of being stuck in a Web browser." >> >> Architecture diagram >> http://pyjs.org/wiki/pyjamasandpyjamasdesktop/ >> >> I wonder if somebody works on similar Haskell "Rich Internet Application >> (RIA) Development Platform" ? >> Any ideas, comments on implementation of such system in Haskell? What >> existing Haskell GUI libraries can be used for a desktop GUI, etc.? >> > >Well, it's basically just proof-of-concept at the moment, and it's not >really usable for real applications at the moment, but there is > > http://hackage.haskell.org/package/dingo-core-0.1.0 > http://hackage.haskell.org/package/dingo-widgets-0.1.0 > http://hackage.haskell.org/package/dingo-example-0.1.0 > >The basic client<->server communication, server-side state handling, >etc. is there, but it's missing a couple of things before it could be >used for real apps: There's no real security, and there are *very* few >widgets. The few widgets that exist at the moment are also probably >lacking a few operations. On the plus side, it's should be pretty easy >to create new widgets. > >You can get a feel for how the thing looks from an application >programmer's perspective by looking at the source for the example. Looks neat, thanks! If I got this write, in dingo all web page content is created by running Haskell on the server side in run-time and then sending generated html + js to the client (browser). I am looking for the opposite - when client does more work running Javascript generated by Haskell in advance, the approach that Pyjamas use ( http://pyjs.org/) with Python to Javascript compilation.

1 0

ANN: bytestring-lexing 0.3.0
by wren ng thornton 30 Jan '12

30 Jan '12

-------------------------------------------- -- bytestring-lexing 0.3.0 -------------------------------------------- The bytestring-lexing package offers efficient reading and packing of common types like Double and Integral types. -------------------------------------------- -- Administrative Changes (since 0.2.1) -------------------------------------------- * Change of maintainer. Don Stewart handed maintainership of the package over to myself when I voiced interest. * Change of repo type. The old repo for the package used Darcs-1 style patches. I've converted the repository to Darcs-2 hashed. This means that the new repository cannot exchange patches with the old Darcs-1 repo (or any other Darcs-2 conversions that may be floating around out there). So anyone who's interested in contributing should scrap their local copies and get the new repo. -------------------------------------------- -- Code Changes (since 0.2.1) -------------------------------------------- * Added Data.ByteString.Lex.Integral which provides efficient implementations for reading and packing/showing integral types in ASCII-compatible formats including decimal, hexadecimal, and octal. * The readDecimal function in particular has been highly optimized. The new version is wicked fast[1] and perfectly suitable for hot code locations like parsing headers for HTTP servers like Warp. In addition, attention has been paid to ensuring that parsing is efficient for larger than native types like Int64 on 32-bit systems (including 64-bit OS X), as well as Integer. The optimization of this function was done in collaboration with Erik de Castro Lopo, Vincent Hanquez, and Christoph Breitkopf following a blog post by Erik[2] and ensuing discussion on Reddit[3] [1] A Criterion report is available for 64-bit Intel OS X running 32-bit GHC 6.12.1: http://code.haskell.org/~wren/bytestring-lexing/test/bench/readDecimal.html The benchmark is included in the repo and has also been run on 64-bit GHC 7 systems, which differ primarily in not showing slowdown for Int64 vs Int (naturally). If you're curious about the different implementations: * readIntBS / readIntegerBS --- are the readInt and readInteger functions in Data.ByteString * readDecimalOrig (correct) --- was my original implementation, prior to collaboration with Erik, Vincent, and Christoph. * readIntegralMH (buggy) --- or rather a non-buggy version very much like it, is the implementation currently used in Warp. * readDecimal (current) --- is the current implementation used in this package. [2] http://www.mega-nerd.com/erikd/Blog/CodeHacking/Haskell/read_int.html [3] http://www.reddit.com/r/haskell/comments/otwxe/benchmarking_and_quickchecki… -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/bytestring-lexing Darcs: http://community.haskell.org/~wren/bytestring-lexing Haddock (Darcs version): http://community.haskell.org/~wren/bytestring-lexing/dist/doc/html/bytestri… -- Live well, ~wren

2 3

ANN: pointless fun
by wren ng thornton 29 Jan '12

29 Jan '12

-------------------------------------------- -- pointless-fun 1.1.0 -------------------------------------------- The pointless-fun package offers some common point-free combinators (common for me at least). -------------------------------------------- -- Long Description -------------------------------------------- * Perhaps the most useful is that it packages up Matt Helige's classic multicomposition trick[1]. These combinators allow you to easily modify the types of a many-argument function with syntax that looks like giving type signatures. For example, > foo :: A -> B -> C > > albert :: A -> X > beth :: B -> Y > carol :: C -> Z > > bar :: X -> Y -> Z > bar = foo $:: albert ~> beth ~> carol I've found this to be especially helpful for defining non-derivable type class instances for newtypes since it both abstracts away the plumbing and also makes explicit what you mean. * Other prevalent combinators include, ** (.:) for binary composition: > (f .: g) x y = f (g x y) > -- or, > f .: g = curry (f . uncurry g) This is the same as the common idiom @(f .) . g@ but more easily extended to multiple uses, due to the fixity declaration. ** (.!) for function composition which calls the right-hand function eagerly; i.e., making the left-hand function strict in its first argument. > (f .! g) x = f $! g x This defines the composition for the sub-category of strict Haskell functions. If the 'Functor' class were parameterized by the domain and codomain categories (e.g., a regular @Functor f@ would be @CFunctor (->) (->) f@ instead) then this would allow us to define functors @CFunctor (->) (!->) f@ where @fmap f . fmap g = fmap (f .! g)@. [1] http://matt.immute.net/content/pointless-fun -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/pointless-fun Darcs: http://community.haskell.org/~wren/pointless-fun Haddock (Darcs version): http://community.haskell.org/~wren/pointless-fun/dist/doc/html/pointless-fun -- Live well, ~wren

2 3

Reminder Munich Haskell Meeting
by Heinrich Hördegen 29 Jan '12

29 Jan '12

Dear all, just to remind you: Tomorrow, Monday 30. Jan 2012, Haskellers meet in Munich. Check out the details and click the button, if you plan to join: http://www.haskell-munich.de/dates See you, Heinrich -- -- hoerdegen(a)funktional.info www.funktional.info --

1 0

ANN: data-or
by wren ng thornton 29 Jan '12

29 Jan '12

-------------------------------------------- -- data-or 1.0.0 -------------------------------------------- The data-or package offers a data type for non-exclusive disjunction. This is helpful for things like a generic merge function on sets/maps which could be union, mutual difference, etc. based on which 'Or' value a function argument returns. Also useful for non-truncating zips (cf. 'zipOr') and other cases where you sometimes want an 'Either' and sometimes want a pair. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://code.haskell.org/~wren/ Hackage: http://hackage.haskell.org/package/data-or Darcs: http://community.haskell.org/~wren/data-or Haddock (Darcs version): http://community.haskell.org/~wren/data-or/dist/doc/html/data-or -- Live well, ~wren

1 0

Named captures in regex-pcre?
by Ilya Portnov 29 Jan '12

29 Jan '12

Hi haskell-cafe. Is there a way to get named captures from regex using regex-pcre (or maybe other PCRE-package)? For example, I want to write something like let result = "ab 12 cd" =~ "ab (?P<number>\d+) cd" :: SomeCrypticType and then have namedCaptures result == [("number", "12")]. I do not see somewhat similar in regex-pcre documentation. It parses such regexs fine, and captures work, but i do not see way to get _named_ captures. WBR, Ilya Portnov.

3 2

Re: [Haskell-cafe] Natural Transformations and fmap
by Janis Voigtländer 28 Jan '12

28 Jan '12

Ryan Ingram wrote: > However, the type of natural transformations comes with a free theorem, for > example > > concat :: [[a]] -> [a] > > has the free theorem > > forall f :: a -> b, f strict and total, fmap f . concat = concat . fmap > (fmap f) > > The strictness condition is needed; consider > > broken_concat :: [[a]] -> [a] > broken_concat _ = [undefined] > f = const () > > fmap f (broken_concat []) = fmap f [undefined] = [()] > broken_concat (fmap (fmap f) []) = broken_concat [] = [undefined] > > The 'taming selective strictness' version of the free theorem generator[1] > allows removing the totality condition on f, but not the strictness > condition. > > But in the case of concat, you can prove a stronger theorem: > > forall f :: a -> b, fmap f . concat = concat . fmap (fmap f) > > My suspicion is that this stronger theorem holds for all strict and total > natural transformations, but I don't know how to go about proving that > suspicion. I'm a hobbyist mathematician and a professional programmer, not > the other way around:) > > ... > > [1]http://www-ps.iai.uni-bonn.de/cgi-bin/polyseq.cgi There is an analogous approach to the "taming selective strictness" version of the free theorem generator where it is general recursion that is tamed. In that setting, you then get free theorems like that for concat without either strictness or totality side conditions. It is really very similar, indeed the "taming selective strictness" work takes over and develops further the much earlier "taming general recursion" ideas. The original source for the latter is: http://dblp.uni-trier.de/rec/bibtex/conf/esop/LaunchburyP96 Just nobody ever bothered to implement it in a tool. (Well, actually, such an implementation is essentially hidden inside the counterexample generator http://www-ps.iai.uni-bonn.de/cgi-bin/exfind.cgi) Best, Janis. -- Jun.-Prof. Dr. Janis Voigtländer http://www.iai.uni-bonn.de/~jv/ mailto:jv@iai.uni-bonn.de

1 0

Something's weird about System.Directory.removeDirectoryRecursive
by John Millikin 28 Jan '12

28 Jan '12

http://hackage.haskell.org/packages/archive/directory/1.1.0.1/doc/html/Syst… The documentation says that removeDirectoryRecursive follows symlinks. However, the implementation doesn't (in most cases, see below). ------------------------------------------------------------------------------------------------------------ $ mkdir test-removeDirectoryRecursive $ cd test-removeDirectoryRecursive $ mkdir a b $ touch a/a.txt b/b.txt $ ln -s $PWD/b a/ $ ln -s $PWD/b/b.txt a/ $ ls -l a total 8.2k -rw-rw-r-- 1 john john 0 2012-01-27 23:33 a.txt lrwxrwxrwx 1 john john 65 2012-01-27 23:33 b -> /home/john/test-removeDirectoryRecursive/b lrwxrwxrwx 1 john john 71 2012-01-27 23:34 b.txt -> /home/john/test-removeDirectoryRecursive/b/b.txt # OK, a/ has a normal file and two symlinks in it. Let's recursively remove a/ and see what happens. $ ghci Prelude> import System.Directory Prelude System.Directory> removeDirectoryRecursive "a" Prelude System.Directory> Leaving GHCi. $ ls -l a b ls: cannot access a: No such file or directory b: total 0 -rw-rw-r-- 1 john john 0 2012-01-27 23:33 b.txt # a/ was removed -- good! # # b/ and its contents are untouched, good, but goes against the docs ------------------------------------------------------------------------------------------------------------ Now, there is one case where this function *will* follow symlinks. However, I believe it is a bug because it produces odd behavior: ------------------------------------------------------------------------------------------------------------ $ sudo mkdir a [sudo] password for john: $ sudo ln -s $PWD/b a/ $ ls -l a b a: total 4.1k lrwxrwxrwx 1 root root 65 2012-01-27 23:38 b -> /home/john/test-removeDirectoryRecursive/b b: total 0 -rw-rw-r-- 1 john john 0 2012-01-27 23:33 b.txt # Now a/ has a symlink, which cannot be deleted, because its containing directory is read-only to the current user. $ rm a/b rm: remove symbolic link `a/b'? y rm: cannot remove `a/b': Permission denied # What happens if removeDirectoryRecursive is called now? $ ghci Prelude> import System.Directory Prelude System.Directory> removeDirectoryRecursive "a" *** Exception: a/b: removeDirectory: permission denied (Permission denied) Prelude System.Directory> Leaving GHCi. $ ls -l a b a: total 4.1k lrwxrwxrwx 1 root root 65 2012-01-27 23:38 b -> /home/john/test-removeDirectoryRecursive/b b: total 0 # a/ is untouched, but b/ has been emptied! ------------------------------------------------------------------------------------------------------------ So what is the expected behavior of this function? What should it do in the presence of symlinks? IMO, the function should be documented as *not* following symlinks, and the directory check should be changed so that it returns False for symlink-to-directory.

1 0

Natural Transformations and fmap
by Ryan Ingram 28 Jan '12

28 Jan '12

I've been playing around with the relationship between monoids and monads (see http://www.jonmsterling.com/posts/2012-01-12-unifying-monoids-and-monads-wi… http://blog.sigfpe.com/2008/11/from-monoids-to-monads.html) and I put together my own implementation which I'm quite happy with, that you can see at http://hpaste.org/56903 ; relying only on the extensions RankNTypes, TypeOperators, NoImplicitPrelude, ScopedTypeVariables; At the end of that paste, I prove the three Haskell monad laws from the functor laws and "monoid"-ish versions of the monad laws, but my proofs all rely on a property of natural transformations that I'm not sure how to prove; given type m :-> n = (forall x. m x -> n x) class Functor f where fmap :: forall a b. (a -> b) -> f a -> f b -- Functor identity law: fmap id = id -- Functor composition law fmap (f . g) = fmap f . fmap g Given Functors m and n, natural transformation f :: m :-> n, and g :: a -> b, how can I prove (f . fmap_m g) = (fmap_n g . f)? Is there some more fundamental law of natural transformations that I'm not aware of that I need to use? Is it possible to write a natural transformation in Haskell that violates this law? -- ryan

5 8