September 2010 - Haskell-Cafe

Unwrapping newtypes
by Kevin Jardine 09 Sep '10

09 Sep '10

I have a generic object that I want to wrap in various newtypes to better facilitate type checking. For example, newtype Blog = Blog Obj newtype Comment = Comment Obj newtype User = User Obj Unlike Obj itself, whose internal structure is hidden in a library module, the newtype wrappings are purely to facilitate type checking. It is no secret that each is just a wrapper around Obj. It is obvious how to construct the various wrapper objects. It is not so obvious how to extract the Obj they contain in a reasonably generic way however. What I want is a getObj function that works on all of them. Of course this could work if someone using the library wrote an instance for each wrapper object: instance GetObject Blog where getObj (Blog obj) = obj but this is a pain in the neck to write for each newtype. I discovered that Foldable defines a handy toList function that extracts content from generic Foldable structures. So that I could write: toObj :: Foldable thing => thing Obj -> Obj toObj w = head $ toList w Slightly kludgy but it works. Even better, recent versions of GHC will allow you to automatically derive Foldable. Unfortunately, newtype Blog = Blog Obj deriving Foldable returns a kind error. What does work is: newtype BlogF a = Blog a deriving Foldable type Blog = BlogF Obj After having spent close to a day on this, I am a bit baffled that such a seemingly trivial problem seems so hard to do. I am wondering if I am missing something really, really obvious. Any suggestions? Or is there perhaps a more Haskelly way to place type constraints on a more generic type? Kevin

6 13

recommendations for reading list?
by David Leimbach 09 Sep '10

09 Sep '10

In my amazon shopping cart I currently have: *Conceptual Mathematics: A First Introduction to Categories<http://www.amazon.com/gp/product/052171916X/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- F. William Lawvere *Categories for the Working Mathematician (Graduate Texts in Mathematics)<http://www.amazon.com/gp/product/0387984038/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- Saunders Mac Lane *Categories and Computer Science (Cambridge Computer Science Texts)<http://www.amazon.com/gp/product/0521422264/ref=ord_cart_shr?ie=UTF8&m=ATVP…> *- R. F. C. Walters Are all 3 of these worthwhile? Any of them? I'm just trying to get a grasp on enough Category Theory to be able think more deeply about programming in general, and maybe grasp more Haskell terminology beyond the seemingly superficial meanings I understand today. Thanks! Dave

5 6

Re: ANNOUNCE: GotoT-transformers version 1.0
by oleg＠okmij.org 09 Sep '10

09 Sep '10

Antoine Latter wrote: > To recover from my overly complex previous post, here is a much simply > goto based on existing monad transformers: > > goto :: Monad m => ContT r m r -> ContT r m a > > goto (ContT m) = ContT $ \_ -> > > m return That is precisely how continuations were discovered (as John Reynolds documents, continuations have been discovered and rediscovered multiple times). The paper Continuations: A Mathematical Semantics for Handling Full Jumps Christopher Strachey and Christopher P. Wadsworth http://www.ling.ohio-state.edu/research/groups/commies/past/autumn2009/stra… first published in 1974 and republished in Higher-Order and Symbolic Computation, 13, 135-152, 2000 starts with the following sentence: The purpose of this paper is to explain a method of giving the mathematical semantics of a programming language which includes a very general form of jump (goto statement). The cited goto expression above appears, in mathematical notation, as the second equation on p. 143 of the paper. Labels are considered next. The paper is still a good read. One can literally implement the language of the paper, by reading domain equations as the implementation of a monad. Incidentally, Note 1 of the paper anticipated delimited continuations.

1 0

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

08 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

3 9

interesting type families problem
by Gábor Lehel 08 Sep '10

08 Sep '10

I'm bad at expositions so I'll just lead with the code: {-# LANGUAGE EmptyDataDecls, TypeFamilies #-} data True :: * data False :: * class TypeValue a where type ValueTypeOf a :: * value :: ValueTypeOf a instance TypeValue True where type ValueTypeOf True = Bool value = True instance TypeValue False where type ValueTypeOf False = Bool value = False main = print (value :: ValueTypeOf True) (In case this is initially confusing, there are entirely distinct type-level and value-level True and False involved which merely share a name. The idea is to take type-level 'values' and reflect them down to the corresponding value-level, er, values.) Which results in the following error message: Couldn't match expected type `Bool' against inferred type `ValueTypeOf a' NB: `ValueTypeOf' is a type function, and may not be injective In the first argument of `print', namely `(value :: ValueTypeOf True)' In the expression: print (value :: ValueTypeOf True) In the definition of `main': main = print (value :: ValueTypeOf True) This is strange and vaguely amusing to me. I get that type functions are not injective, but I can't figure out how it applies to this situation. Obviously if I had written `print (value :: Bool)` it would rightly complain that there could be any number of instances which map to Bool, and how in the world should it know which one I meant. But it seems like in this case the compiler knows everything it needs to know. And it even manages to deduce, from the exact same expression (`print` isn't giving it any extra information), that it's simultaneously a Bool and not necessarily a Bool. Is this "supposed" to work? If not, why not? -- Work is punishment for failing to procrastinate effectively.

3 4

ANNOUNCE: text 0.8.0.0, fast Unicode text support
by Bryan O'Sullivan 08 Sep '10

08 Sep '10

New in this release: - Substantial performance improvements. - Bug fixes, and better quality assurance via automated QuickCheck and HPC tests and coverage. - An even nicer API than before. The text library provides an efficient packed, immutable Unicode text type (both strict and lazy), with a powerful loop fusion optimization framework. The 'Text' type represents Unicode character strings, in a time and space-efficient manner. This package provides text processing capabilities that are optimized for performance critical use, both in terms of large data quantities and high speed. The text package provides character-encoding, type-safe case conversion via whole-string case conversion functions. It also provides a range of functions for converting Text values to and from ByteStrings, using several standard encodings (see the text-icu package for a much larger variety of encoding functions). Efficient locale-sensitive support for text I/O is also supported. http://www.serpentine.com/blog/2010/09/01/major-version-of-the-haskell-text…

8 17

ANNOUNCE: Grempa 0.1.0, Embedded grammar DSL and LALR parser generator
by Olle Fredriksson 08 Sep '10

08 Sep '10

Hello everyone, I'm pleased to announce the first release of Grempa: A library for expressing programming language grammars in a form similar to BNF, which is extended with the semantic actions to take when a production has been parsed. The grammars are typed and are to be be used with the LALR(1) parser generator, also part of the library, which can generate a parser for the language either at compile time using Template Haskell, producing fast parsers with no initial runtime overhead, or dynamically, which has the initial overhead of generating the parser, but can be used for example when the grammar depends on an input. Here is a small example (from Ex1 in the examples directory) of what a grammar may look like: data E = Plus E E | Times E E | Var | ... expr :: Grammar Char E expr = do rec e <- rule [ Plus <@> e <# '+' <#> t , id <@> t ] t <- rule [ Times <@> t <# '*' <#> f , id <@> f ] f <- rule [ id <@ '(' <#> e <# ')' , Var <@ 'x' ] return e The corresponding BNF grammar is the following: E ::= E + T | T T ::= T * F | F F ::= ( E ) | x Generating a parser from the grammar is simple: parseExpr :: Parser Char E parseExpr = $(mkStaticParser expr [|expr|]) There are a few other examples in the examples directory of the package, most notably a grammar and parser for a simple functional language similar to Haskell. It is possible to generate random input strings and their expected outputs for grammars written using Grempa which makes it possible to test the generated parsers with QuickCheck. The package and documentation (should be up soon) can be found here: http://hackage.haskell.org/package/Grempa-0.1.0 Please get in touch with me if you have any comments, issues, questions, bug reports or would like to contribute to the project. I would love to get some more people involved in the project, as there are many areas of the library that could be improved. Thanks to Daniel Gustafsson and everyone else at Chalmers Uni for valuable input and getting me into Haskell (respectively). Regards, Olle Fredriksson

3 4

ANNOUNCE: grammar-combinators 0.1 (initial release): A parsing library of context-free grammar combinators
by Dominique Devriese 08 Sep '10

08 Sep '10

The grammar-combinators library is a parsing library employing a novel grammar representation with explicit recursion. The library features much of the power of a parser generator like Happy or ANTLR, but with the library approach and most of the benefits of a parser combinator library. Grammars and grammar algorithms are defined in a functional style. The library currently has the following features: * Grammar specified completely in Haskell using an elegant syntax * Grammar algorithms implemented in a functional style (no fresh identifiers), with elegant and meaningful types. * Multi-backend: use the same grammar with a Packrat, Parsec or UUParse parser * Grammar transformations: use left-recursive grammars directly thanks to a powerful grammar transformation library, featuring the left-corner left-recursion removal transform, a uniform version of the classic Paull left-recursion removal, and various smaller transformations (dead-branch removal, dead non-terminal removal, consecutive epsilon combination, selective unfolding etc.). * Grammar utility functions: printing of grammars, FIRST-set calculation, reachability analysis of non-terminals, etc. * Compile-time transformations (using Template Haskell), given a suitable definition of the grammar. This is currently limited to a certain set of transformations. The library is currently not intended for mainstream use. Its API is relatively stable, but performance needs to be looked at further. We are submitting a paper about the ideas behind this library to PADL 2011. A draft is linked on the project's website. More information: * Project website: http://projects.haskell.org/grammar-combinators/ * Tutorial: http://projects.haskell.org/grammar-combinators/tutorial.html * Hackage: http://hackage.haskell.org/package/grammar-combinators All comments welcome! Dominique PS. The documentation on hackage currently doesn't build because of (seemingly) a Hackage dependency problem during the build [1]. Compiling and generating the documentation locally should work fine. A version of the docs is available on the project's webpage as a temporary replacement [2]. Footnotes: [1] http://www.haskell.org/pipermail/libraries/2010-September/014168.html [2] http://projects.haskell.org/grammar-combinators/docs/index.html

3 6

Re: ghc HEAD
by Johannes Waldmann 08 Sep '10

08 Sep '10

Yuras Shumovich <shumovichy <at> gmail.com> writes: > http://hackage.haskell.org/trac/ghc/ticket/3910 So what is the magic "link-time flag to en/disable the RTS options"? It seems it would be needed for all things multi-core, since you'd want to modify +RTS -Nx J.W.

6 5

Re: [Haskell-cafe] Re: Crypto-API is stabilizing
by Thomas DuBuisson 08 Sep '10

08 Sep '10

On Sat, Sep 4, 2010 at 3:23 AM, Heinrich Apfelmus <apfelmus(a)quantentunnel.de> wrote: >>> A better reason is the data structure has >>> no way to implement generateKeyPair. > > That's a non-problem: each algorithm (RSA, DSA, ...) implements a > function with the same type as generateKeyPair . Compare > > rsa :: RangomGen g => BitLength -> g -> ((Key,Key), g) > > vs > > ((k1 :: RSA, k2), g') = generateKeyPair g > > You always have to write down the name of the algorithm ("RSA") when > using generateKeyPair , so you may as well drop it entirely. That simply isn't true. What if you have a key exchange in which the ephemeral key is of the same type as your signing key? Slightly contrived example: buildAgreementMessage :: (Monad m, CryptoRandomGen g, ASymetricCipher k) => g -> k -> m (B.ByteString,g) buildAgreementMessages g k = do (e,g') <- liftM eitherToFail (buildAsymKey g `asTypeOf` k) let eBS = encode e msg = runPut (putByteString agreementHeader >> putWord16be (B.length eBS) >> putByteString eBS) return msg

2 2