September 2010 - Haskell

Re: ANNOUNCE: countable-0.1
by Maciej Piechotka 06 Sep '10

06 Sep '10

On Mon, 2010-09-06 at 03:54 -0700, Ashley Yakeley wrote: > countable: Countable, Searchable, Finite, Empty classes. > > class Countable, for countable types > class AtLeastOneCountable, for countable types that have at least one > value > class InfiniteCountable, for infinite countable types > class Searchable, for types that can be searched over > class Finite, for finite types > class Empty, for empty types > data Nothing, an empty type > > Also includes these orphan instances: > > instance (Searchable a,Eq b) => Eq (a -> b) > instance (Finite a) => Foldable ((->) a) > instance (Finite a) => Traversable ((->) a) > instance (Show a,Finite a,Show b) => Show (a -> b) > > It turns out Searchable includes some infinite types. Specifically, > countable implements this: > > instance (Countable c,Searchable s) => Searchable (c -> s) > > using the algorithm described here: > > http://math.andrej.com/2007/09/28/seemingly-impossible-functional-programs/ > > I would welcome improvements. > > http://hackage.haskell.org/package/countable-0.1 > cabal install countable > darcs get http://code.haskell.org/countable/ > > See also this thread: > http://thread.gmane.org/gmane.comp.lang.haskell.cafe/73275 > Hmm. 1. Code formatting is very C#-like. At least for me it is hard to read the code that way (it IS matter of preference however) 2. countMaybeNext seems to need documentation. If I understand it correctly: countMaybeNext Nothing = 'minimalValue' countMaybeNext (Just x) = x + 1 Wouldn't be split it to: countNext :: a -> Maybe a initial :: Maybe a 3. Regards

1 0

ANNOUNCE: LibZip 0.1, BSD library to read and write zip archives
by Sergey Astanin 06 Sep '10

06 Sep '10

Dear Haskellers, I am glad to announce that LibZip, a major remake of Haskell bindings to libzip library, is now available [1]. As far as I know, LibZip the only non-GPL library for Haskell to manipulate zip archives (zip-archive library is GPLv2, LibZip is BSD). LibZip is also reasonably fast with large on-disk archives (more about it in the blog post, see a link below [2]). New LibZip covers almost all features of the corresponding C library: * creating, reading, updating, renaming, and deleting files in zip archives * reading and writing file and archive comments * support of various data sources: from a buffer, from a file, from another archive and from a pure function With respect to the old LibZip 0.0, there is a new monadic interface [3], more tests, examples and documentation. Users of LibZip 0.0 may still use the old API by importing Codec.Archive.LibZip.LegacyZeroZero instead of Codec.Archive.LibZip. However, the old API is deprecated and will not be supported in the future. Links: [1] Hackage page: http://hackage.haskell.org/package/LibZip [2] Blog post: http://nix-tips.blogspot.com/2010/09/libzip-01-read-and-write-zip-archives.… [3] Documentation: http://sovety.org.ru/doc/LibZip/Codec-Archive-LibZip.html Best regards, Sergey Astanin

1 0

AngloHaskell 2010 - Final Reminder + Wi-Fi Sign-Up
by Derek Wright 06 Sep '10

06 Sep '10

AngloHaskell 2010 is this week! AngloHaskell 2010 - 5th Annual Haskell Meeting in England Friday September 10th and Saturday September 11th, 2010 Microsoft Research, Cambridge, UK http://www.haskell.org/haskellwiki/AngloHaskell/2010 AngloHaskell is a free gathering of all people Haskell-related from beginners to seasoned hackers, both academic and industrial. AngloHaskell 2010 is generously hosted by Microsoft Research. As a result no charge is made for attending or speaking. Friday will be a day of talks and discussion at MSR followed by a more informal day of activities on Saturday somewhere else in Cambridge. AngloHaskell welcomes talks on all Haskell related subjects. From short comments (Functional Grit) to full presentations, all are welcome. Please add your name and the title of your talk to the wiki page (or email me and I will add it for you). If you want to attend please add your name to the wiki page, or let me know by email. Even if you can't attend you can add you name to the "Not this year, but hopefully next!" section. Wi-Fi accounts (at Microsoft Research on Friday) are available on request. The sign-up deadline is Wednesday 8th September so please sign-up on the wiki page or email me (with Full Name, Institution, Country of Residence and Email Address). Organisational discussions are on held on the #anglohaskell channel on the Freenode IRC network, feel free to drop in with questions or comments.

1 0

Re: ANNOUNCE: countable-1.0
by Nicolas Pouillard 06 Sep '10

06 Sep '10

On Mon, 06 Sep 2010 03:46:18 -0700, Ashley Yakeley <ashley(a)semantic.org> wrote: > countable: Countable, Searchable, Finite, Empty classes. > > class Countable, for countable types > class AtLeastOneCountable, for countable types that have at least one > value > class InfiniteCountable, for infinite countable types > class Searchable, for types that can be searched over > class Finite, for finite types > class Empty, for empty types > data Nothing, an empty type > > Also includes these orphan instances: > > instance (Searchable a,Eq b) => Eq (a -> b) > instance (Finite a) => Foldable ((->) a) > instance (Finite a) => Traversable ((->) a) > instance (Show a,Finite a,Show b) => Show (a -> b) Could you put these instances in a dedicated module? In the same vein I would like to have a newtype wrapper over functions were intention is to be used extensionally. Nice package BTW! -- Nicolas Pouillard http://nicolaspouillard.fr

1 0

ANNOUNCE: secure-sockets version 1.0
by David Anderson 06 Sep '10

06 Sep '10

Hi, I'm happy to announce the first release of secure-sockets, a library which aims to simplify the task of communicating securely between two authenticated peers. -------------------------------------------- -- What it is -------------------------------------------- The API mimicks that of Network.Socket, and introduces the additional notion of peer identity, which is distinct from the endpoint address (host and port). Connections can only be established between two peers who know and expect to be communicating with each other. Transport security is implicitly taken care of: an established Network.Secure.Connection implies that each end of the connection successfully authenticated to the other, and that they have setup strong encryption for your data. -------------------------------------------- -- What it isn't -------------------------------------------- The library leans towards the "zero configuration" end of the spectrum, and basically Just Works. This means that if you know exactly what you want and need for the cipher, authentication algorithm, key type and length, key exchange protocol, HMAC algorithm, rekeying intervals, random number source... Then secure-sockets is not for you. If on the other hand you just want to replace your current cleartext "cipher" and faith-based "authentication" code with something that gives you a good chance of being secure (see caveats in docs), without diving into the rich madness that is full blown SSL, then you might want to take a look. This library assumes that both ends of a connection are using it. The goal of secure-sockets is not to allow you to connect to any SSL-enabled server, or to speak a particular standard flavor of authentication protocol. Internally, secure-sockets uses SSL to achieve its goals, so you might get lucky if you do it just right, but that is an implementation detail. The library is designed to help you easily secure communications between two programs whose implementation you control, not between you and anything out there. -------------------------------------------- -- Links -------------------------------------------- Homepage: http://secure-hs.googlecode.com/ Hackage page: http://hackage.haskell.org/package/secure-sockets Bug tracker: http://code.google.com/p/secure-hs/issues/list Code repository: https://secure-hs.googlecode.com/hg -------------------------------------------- -- Thanks -------------------------------------------- I'd like to thank my employer, Google. Not only did they not get mad at the idea that I might want to hack on Haskell during working hours (as my "20% project"), they also made it very painless for me to open source this code when the time came. -------------------------------------------- -- Questions? -------------------------------------------- Questions, comments, suggestions and patches can be filed in the issue tracker, emailed directly to me, or thrown out on haskell-cafe. Hope you find this code useful! - Dave

1 0

ANNOUNCE: stringsearch 0.3.1, fast searching, splitting and replacing of ByteStrings
by Daniel Fischer 02 Sep '10

02 Sep '10

Changes vs. 0.3.0: - fixed a space leak in the splitting of lazy ByteStrings Changes of the 0.3 series vs. 0.2.*: - improved performance of the searching functions - new functionality: - breaking of ByteStrings at the first occurrence of a substring - splitting a ByteString at each occurrence of a substring - replacing all occurrences of a substring with another string Where bytestring provides the same functionality (Data.ByteString.breakSubstring, Data.ByteString.findSubstrings), the implementations in stringsearch are typically much faster. By default, stringsearch uses an enhanced Boyer-Moore algorithm to locate a pattern, but it also provides other algorithms which may be better in special cases (Knuth-Morris-Pratt; DFA).

1 0

ANN: mute-unmute-0.2.0.0
by Krzysztof Skrzętnicki 01 Sep '10

01 Sep '10

* Hello! I'm pleased to announce a small utility program I wrote recently. Today I pushed version 0.2.0.0 of mute-unmute to Hackage, from with you can cabal-install it right now (following the usual 'update' step). What it does? It's simple: it will mute the sound when you lock your screen and unmute it back again when you unlock it. Why anyone would need such program? Well, this is a little bit more complicated. I work in "open space" kind of office. It can get quite noisy there. I often sit with headphones on, but when I walk away from my desk I put them down and lock my screen. Here comes uncomfortable moment: when I remove my headphones suddenly people around me who doesn't use their headphones now start to hear the music I listen to. And they don't always like it, so I manually mute the sound to make happy. But now, instead of doing this task by hand I have a program do it for me :-) Unfortunately this kind of programs tend to be pretty much platform specific. Current version supports the recent versions of Gnome and KDE, but needs ALSA. It's quite common setup, but if you happen to have a different one you can easily hack the code (it's very straightforward) and send me patches. Patches are always welcome. The source repo is on Github and released versions are on Hackage: Github: http://github.com/Tener/mute-unmute <http://github.com/Tener/mute-unmute#> Hackage: http://hackage.haskell.org/package/mute-unmute Example use: ~/ mute-unmute # first session, it will ask for configuration options mute-unmute: Creating config directory... mute-unmute: Mute config is missing... Mute sound card and press RETURN mute-unmute: Unmute config is missing... Unmute sound card and press RETURN mute-unmute: Session: UnixAbstract {addrPath = "/tmp/dbus-1tB1AEUcgg", addrGuid = Just "19ec85e3778816ad38a77bbf0000003f"} mute-unmute: Connected mute-unmute: Handler added: [MatchType Signal,MatchInterface "org.gnome.ScreenSaver",MatchMember "ActiveChanged",MatchPath "/org/gnome/ScreenSaver"] mute-unmute: Handler added: [MatchType Signal,MatchInterface "org.freedesktop.ScreenSaver",MatchMember "ActiveChanged",MatchPath "/ScreenSaver"] ^C ~/ mute-unmute # remembers previous options which can be changed by calling with --store switch mute-unmute: Session: UnixAbstract {addrPath = "/tmp/dbus-1tB1AEUcgg", addrGuid = Just "19ec85e3778816ad38a77bbf0000003f"} mute-unmute: Connected mute-unmute: Handler added: [MatchType Signal,MatchInterface "org.gnome.ScreenSaver",MatchMember "ActiveChanged",MatchPath "/org/gnome/ScreenSaver"] mute-unmute: Handler added: [MatchType Signal,MatchInterface "org.freedesktop.ScreenSaver",MatchMember "ActiveChanged",MatchPath "/ScreenSaver"] mute-unmute: Message {mType = Signal, mFlags = [NoReplyExpected], mSerial = 31, mPath = Just "/org/gnome/ScreenSaver", mInterface = Just "org.gnome.ScreenSaver", mMember = Just "ActiveChanged", mErrorName = Nothing, mReplySerial = Nothing, mDestination = Nothing, mSender = Just ":1.19", mBody = [Variant (True) {- b -}]} mute-unmute: Lock screen mute-unmute: Message {mType = Signal, mFlags = [NoReplyExpected], mSerial = 32, mPath = Just "/org/gnome/ScreenSaver", mInterface = Just "org.gnome.ScreenSaver", mMember = Just "ActiveChanged", mErrorName = Nothing, mReplySerial = Nothing, mDestination = Nothing, mSender = Just ":1.19", mBody = [Variant (False) {- b -}]} mute-unmute: Unlock screen ^C * You can get usage information with --help switch: *~/ mute-unmute --help *mute-unmute --store ask for mute and unmute configurations --store-mute ask for mute configuration --store-unmute ask for unmute configuration -d --daemon wait for screensaver state changes -h, -? --help show help There isn't much more I can say. I hope you find the program at least educational (as a simple example of DBus usage) if not useful. Best regards, Krzysztof Skrzętnicki

2 1

ANN: Hayoo! 2.1
by "Timo B. Hübel" 01 Sep '10

01 Sep '10

Hi, We are pleased to announce the next major release 2.1 of Hayoo!, the Haskell API search engine with find-as-you-type and suggestions. Visit Hayoo! here: http://holumbus.fh-wedel.de/hayoo What's new? Thanks to Uwe Schmidt, we have completely revamped the indexer, which now also crawls package information from Hackage. Hence, Hayoo! now searches package names, package categories, package descriptions etc., too, and shows you some package results along with the functions found (some of you may have noticed this already, since this is live for testing purposes since a few months). For example, this will find you all packages in the category "Algorithms" that will do something with "sat": category:algorithms sat This will find you some strict datastructures (i.e. synopsis contains "strict" and category contains "data"): synopsis:strict category:data As we now have package information present in the search index, the algorithm for ranking the results has been adjusted to mainly depend on reverse package dependencies. Nevertheless, we are still trying to optimize this. The new indexer also supports incremental index updates, which made a rebuild of the whole infrastructure around it possible. This way, we are now able to provide daily index updates. Useful figures about the current index are shown below the query input field. Additionally, we have made some optimizations and performance improvements. This allowed us to leverage the restrictions on the query length and hence it is now possible to search for any single character (try searching for "s"). In the result display, the whole function description is now included and its formatting is preserved. Internally, the HTML rendering part has been completely rewritten, which hopefully allows for faster adoption of new features. Please let us know about any issues or suggestions. Especially some opinions about how to integrate the package information in the result display would be appreciated. Thanks, Timo

1 0

Three new implementations of multi-prompt delimited control
by oleg＠okmij.org 01 Sep '10

01 Sep '10

The monadic framework for delimited continuations described in the paper by Dybvig, Peyton Jones and Sabry (JFP 2007) has found many applications, for example, fair backtracking search, final zippers, direct-style web programming, direct-style code generation, and probabilistic programming. The extensive experience suggested improvements in efficiency and, mainly, programmer's convenience. The three new libraries are novel implementations of the enhanced framework. Prompts, for instance, can now be bound to top-level identifiers and do not have to be passed around explicitly or through the extra Reader monad. The new libraries benefited from the experience of implementing delimited control on several platforms. All three libraries provide monad transformers, with basic operations to capture and reinstall delimited continuations: pushPrompt, shift, shift0, control, takeSubCont/pushSubCont. All three libraries support multiple, typed prompts. All three libraries are quite distinct from the original implementation in Dybvig, Peyton Jones, Sabry's paper. For instance, none of the new libraries use unsafeCoerce. All three implementations are derived from the specification of delimited control: from the reduction semantics or from the definitional interpreter. The new libraries differ in -- performance -- ease of understanding -- constraints on the base monad or the prompt types -- flavors of prompts and support for global prompts The libraries are named CCRef, CCExc and CCCxe. The complete code of the libraries along with the regression test suite are publicly available at http://okmij.org/ftp/continuations/CCmonad/ The directory includes sample code (Generator1.hs and Generator2.hs), implementing generators like those of Python. A more extensive example is the porting of the LogicT library (of fair backtracking monad transformers), from the old CC implementation to CCExc/CCCxe: http://okmij.org/ftp/Haskell/LogicT.tar.gz One of the sample applications of LogicT, of a computer playing 5x5 tic-tac-toe against itself, was used as a macro-benchmark of the libraries. The end of the file TicTacToe.hs summarizes the results. The new libraries are faster (so the reader who may wish to play will have less time to think). The library CCRef is closest to the interface of Dybvig, Peyton Jones and Sabry. CCRef is derived from the definitional interpreter using the implementation techniques described and justified in the FLOPS 2010 paper. The monad transformer CC implemented by CCRef requires the base monad to support reference cells. In other words, the base monad must be a member of the type class Mutable: that is, must be IO, ST, STM or their transformer. CCRef adds to the original interface the frequently used function abortP as a primitive. As one may notice from their names, the libraries CCExc and CCCxe are closely related. CCCxe is derived as a CPS version of CCExc. CCCxe is sometimes more efficient; it is always less perspicuous. Both libraries provide the identical interface and are interchangeable. It seems that CCExc is faster at delimited control but imposes more overhead on the conventional code; CCCxe is dual. It pays to use CCCxe in code with long stretches of determinism punctuated by fits and restarts. We now explain new features of CCExc. It is the most direct implementation of the bubble-up (bottom-up) reduction semantics of multi-prompt delimited control, described on PDF page 57 of http://okmij.org/ftp/gengo/CAG-talk.pdf Unlike all other implementations of delimited control in Haskell, CCExc is _not_ based on the continuation monad. Rather, the monad of CCExc is an extension of the Error monad: a monad for restartable exceptions. CCExc offers not one monad transformer but a family (CC p), parameterized by the prompt flavor p. The library defines several prompt flavors; the users are welcome to define their own. Prompt flavors are inherently like exception flavors (the FLOPS 2010 paper even calls prompts `exception types' or `exception envelopes'). Control.Exception defines singular global exceptions such as BlockedOnDeadMVar. There are global exceptions like ErrorCall, parameterized by the error string. There are closed global variants, such as ArithException, with the fixed number of alternatives. There are also open variants, SomeException, with any number of potential alternatives. Users may define their own exception types, whose visibility may be restricted to a module or a package. Finally, one may even generate distinct expression types dynamically, although that is seldom needed. The libraries CCExc and CCCxe support all these flavors. On one end is the prompt flavor (PS w). There is only one prompt of that flavor, which is globally defined and does not have to be passed around. The monad transformer (CC (PS w)) then is the monad transformer for regular, single-prompt delimited continuations, for the answer-type w. Danvy/Filinski test, which looks in Scheme as > (display (+ 10 (reset (+ 2 (shift k (+ 100 (k (k 3)))))))) appears as follows in Haskell: > test5 = (print =<<) . runCC $ > incr 10 . pushPrompt ps $ > incr 2 . shiftP ps $ \sk -> incr 100 $ sk =<< (sk 3) where > incr :: Monad m => Int -> m Int -> m Int > incr n = ((return . (n +)) =<<) [A reader might wish to try to predict the result of test5.] The global identifier ps is defined in CCExc. One should read the operator (=<<), the flipped bind, as a ``call-by-value application'', akin to the application in CBV languages such as Scheme. That is, "f =<< e" is the application that first evaluates the argument e, performing its effects. The value is passed to f, which is evaluated in turn. The application "sk 3" is an optimized version of "sk =<< (return 3)". The appearance of print tells us that test5 is the IO computation. If we rather had the result of test5 as a pure value (an integer), we merely need to pass the result of the runCC expression to runST. The file Generator1.hs shows one example of using PS; the file SRReifT.hs of the LogicT is a larger example. The file Generator2.hs demonstrates why we may need more than one prompt (perhaps with different types). The library offers several flavors of multiple prompts: closed unions (P2) and open unions (PP, PM, PD). The open unions are like SomeException. The prompt flavor PD carries an extra integer identifier to further distinguish prompts of the same type. It becomes possible therefore to dynamically generate an arbitrary number of PD prompts, which was required in Dybvig, Peyton Jones and Sabry's framework. We close by juxtaposing the Python code that uses generators to traverse a binary tree in-order >>> def inorder(t): ... if t: ... for x in inorder(t.left): ... yield x ... yield t.label ... for x in inorder(t.right): ... yield x with the corresponding Haskell code (excerpted from Generator1.hs) > in_order :: (Monad m) => Tree -> CC (P m Label) m () > in_order Leaf = return () > in_order (Node label left right) = do > in_order left > yield label > in_order right In Python, 'yield' is a keyword and generators are built-in. In Haskell, yield is a regular, small, user-defined function, and generators are programmed-in.

1 0