- Haskell-Cafe - Haskell.org

Cross platform method for getting the /actual/ contents of a directory
by timothyhobbs＠seznam.cz 07 Nov '12

07 Nov '12

Hello, I'm writing a function to find out if a given directory is empty. I came up with the obvious: do{ contents <- getDirectoryContents "/home/timothy/works/current/anonGraph/ empty/" ; let realContents = filter (\file -> case file of "." -> False ; ".." -> False ; _ -> True) contents in return $ case realContents of [] -> True ; _ -> False} And this works fine on linux, but I wonder. On other systems, is "." and ". ." allowed as file names? Couldn't a windows user actually end up with a file name named "." and this method would fail? Thank you Timothy

2 1

[ANNOUNCE] hashable-generics
by Clark Gaebel 07 Nov '12

07 Nov '12

Hi everybody! I have just released a handy package on Hackage that will interest you if you've ever used unordered-containers with a custom type. In order to do such a thing, you'd need to define an instance of Hashable. This process could easily be automated. And so I did. {-# LANGUAGE DeriveGeneric #-} module ThisIsPrettyNeat where import Data.Hashable.Generic import GHC.Generics data MyCoolType a = MCT0 | MCT1 (Either Int a) | MCT2 (MyCoolType a) (MyCoolType a) deriving Generic instance Hashable a => Hashable MyCoolType where hashWithSalt s x = gHashWithSalt s x {-# INLINEABLE hashWithSalt #-} and voila. You have a very performant instance of Hashable, with minimal boilerplate, no template haskell, and no subtle bugs. If you want to play with it, here it is: http://hackage.haskell.org/package/hashable-generics-1.1.6 Have fun! - Clark Oh yeah, and if anyone wants to help me figure out why it's 1.3x slower than my hand-rolled instances, that would be really helpful.

4 16

ANNOUNCE: rdf4h
by Rob Stewart 07 Nov '12

07 Nov '12

Hi, I am pleased to announce the recent release of rdf4h 1.1.0 . The Resource Description Framework (RDF) is a language for representing information about resources in the World Wide Web, and is a family of W3C specifications. RDF is a standardized machine readable data model that provides a common framework for expressing information to be exchanged between applications without loss of meaning. It is becoming a popular data-modelling language, thanks to the growing adoption of semantic web principles for publishing linked open data. This `rdf4h' is a library for working with RDF in Haskell. It includes parsers and serializers for the N-Triples and Turtle formats. It provides abilities such as RDF graph comparison, querying for triples containing a particular subject, predicate, or object, or selecting triples that satisfy an arbitrary predicate function. The library is on hackage: http://hackage.haskell.org/package/rdf4h Examples are on GitHub: https://github.com/robstewart57/rdf4h Contributions very welcome! -- Rob Stewart

1 0

Serializing with alignment
by Ben Franksen 07 Nov '12

07 Nov '12

Hi Everyone I want to implement a binary protocol that, unfortunately, has some alignment restrictions. In order to fulfill these, I need access to the "current offset" in the bytestring. The binary package does provide a function bytesRead :: Get Int64 but only for the Get monad; there is no equivalent for the Put monad. So my first question: is there a serialization library that offers something like bytesWritten :: PutM Int64 Failing that, would you think adding it to binary is a reasonable feature request? I have taken a cursory look at the implementation and it looks like this is not a matter of simply adding a missing function, but would probably need an addition to internal data structures. I could also try and wrap the PutM from binary with a StateT transformer and count the bytes myself. I will probably have to use at least a ReaderT wrapper anyway, since I have to pass the byte order as a parameter (byte order gets negotiated between client and server, it is not fixed). I was really hoping that there is some library that has built-in support for stateful serialization (alignment, byte-order, etc). Any pointers, hints, etc are much appreciated. Cheers -- Ben Franksen () ascii ribbon campaign - against html e-mail /\ www.asciiribbon.org - against proprietary attachments

2 2

Looking for a Full-time Haskell Programmer
by Doug Beardsley 06 Nov '12

06 Nov '12

I've posted this before but did not get a whole lot of responses, so here it is again: Karamaan Group, a principal investment firm based in Manhattan is looking for an outstanding software developer to develop tools for financial analysis and knowledge management. Candidates should have at least a bachelor's degree in computer science, math, or a related field and a good sense of coding style. This is a high-impact, high-visibility job opportunity where successful candidates will be entrusted with a lot of responsibility for products that have a direct effect on the P&L of the firm and influences our workflow. Karamaan Group is a small hedge fund, so the next hire will have a very direct influence on our software development and the firm as a whole. We are a growth oriented firm that values people who take a craftsman's pride in their work. We like to take a contrarian view of things, value experimenting, and use often overlooked technologies. We are looking for a candidate who shows strong analytical, organizational, and communication skills. We have a legacy Java code base that may need occasional maintenance, but for the past few years, most of our new development has been done with Haskell (with bits and pieces of a few other languages here and there). The ideal candidate would have at least some experience with Java and the related technologies used in our existing code, but since Haskell is our language of choice, we're looking for strong Haskell skills. We have a knowledge management system built on Snap, so experience with Snap or Haskell web development in general would help. Unlike most finance companies, we don't require previous experience in finance or business, but knowledge in those areas is definitely a plus, although candidates should already be able to work legally in the U.S. and be willing to move to New York City. Please send your CV and cover letter to recruitment at karamaan.com.

1 0

Problems updating cabal-install on Mac OS
by Harald Bögeholz 06 Nov '12

06 Nov '12

Hi Cafe, I just installed the brand new Haskell Platform 2012.4.0.0 for Mac OS X, 32 bit, after removing everything left over from the old one (I hope). Next I started cabal which said to me: > Downloading the latest package list from hackage.haskell.org > Note: there is a new version of cabal-install available. > To upgrade, run: cabal install cabal-install So next I did cabal install cabal-install which started working > Resolving dependencies... > Downloading Cabal-1.16.0.2... and finished with > Installing executable(s) in > /Users/bo/Library/Haskell/ghc-7.4.2/lib/cabal-install-1.16.0.1/bin > Updating documentation index /Users/bo/Library/Haskell/doc/index.html When I then tried cabal update it still said > Downloading the latest package list from hackage.haskell.org > Note: there is a new version of cabal-install available. > To upgrade, run: cabal install cabal-install I thought I just had done that. What could have gone wrong? > Haralds-iMac:~ bo$ which cabal > /Users/bo/Library/Haskell/bin/cabal > Haralds-iMac:~ bo$ ls -l `which cabal` > lrwxr-xr-x 1 bo staff 49 6 Nov 18:15 /Users/bo/Library/Haskell/bin/cabal -> ../ghc-7.4.2/lib/cabal-install-1.16.0.1/bin/cabal Now that I am writing this up I am noticing that the last thing that seems to be installed has version number 1.16.0.1, while it started out with 1.16.0.2. So on a second thought I am attaching the full log of the install. Am I doing anything wrong? Harald -- Harald Bögeholz <bo(a)ct.de> (PGP key available from servers) Redaktion c't Tel.: +49 511 5352-300 Fax: +49 511 5352-417 http://www.ct.de/ int f[9814],b,c=9814,g,i;long a=1e4,d,e,h; main(){for(;b=c,c-=14;i=printf("%04d",e+d/a),e=d%a) while(g=--b*2)d=h*b+a*(i?f[b]:a/5),h=d/--g,f[b]=d%g;} (Arndt/Haenel) Affe Apfel Vergaser /* Heise Zeitschriften Verlag GmbH & Co. KG * Karl-Wiechert-Allee 10 * 30625 Hannover * Registergericht: Amtsgericht Hannover HRA 26709 * Persönlich haftende Gesellschafterin: Heise Zeitschriften Verlag * Geschäftsführung GmbH * Registergericht: Amtsgericht Hannover, HRB 60405 * Geschäftsführer: Ansgar Heise, Dr. Alfons Schräder */

2 3

Defining a Strict language pragma
by Johan Tibell 06 Nov '12

06 Nov '12

Hi all, I would like to experiment with writing some modules (e.g. low-level modules that do a lot of bit twiddling) in a strict subset of Haskell. The idea is to remove boilerplate bangs (!) and instead declare the whole module strict. I believe this would both make code that needs to be strict more declarative (you say what you want once, instead of putting bangs everywhere), less noisy, and more predictable (no need to reason about laziness in places where you know you don't want it). The idea is to introduce a new language pragma {-# LANGUAGE Strict #-} that has the above described effect. The tricky part is to define the semantics of this pragma in terms of Haskell, instead of in terms of Core. While we also need the latter, we cannot describe the feature to users in terms of Core. The hard part is to precisely define the semantics, especially in the presence of separate compilation (i.e. we might import lazy functions). I'd like to get the Haskell communities input on this. Here's a strawman: * Every function application f _|_ = _|_, if f is defined in this module [1]. This also applies to data type constructors (i.e. the code acts if all fields are preceded by a bang). * lets and where clauses act like (strict) case statements. * It's still possible to define strict arguments, using "~". In essence the Haskell lazy-by-default with opt-out via "!" is replaced with strict-by-default with opt-out via "~". Thoughts? Cheers, Johan 1. I could see the very opposite choice be made: function applications to functions defined in other modules are also strict. We should try to think about the implications of either policy.

5 5

Announce: Haskell Platform 2012.4.0.0
by Mark Lentczner 06 Nov '12

06 Nov '12

I'm pleased to announce that Haskell Platform 2012.4.0.0<http://www.haskell.org/platform/index.html#2012.4.0.0>is now available. This release contains three new packages to the platform: - async-2.0.1.3<http://lambda.haskell.org/platform/doc/current/packages/async-2.0.1.3/doc/h…> - split-0.2.1.1<http://lambda.haskell.org/platform/doc/current/packages/split-0.2.1.1/doc/h…> - vector-0.10.0.1<http://vector-0.10.0.1http://lambda.haskell.org/platform/doc/current/packag…> The remainder of the changes are small updates to the versions of GHC (now 7.4.2) and several other packages. Installers for Windows <http://www.haskell.org/platform/windows.html>, Mac OS X <http://www.haskell.org/platform/mac.html>, and the source tar ball<http://www.haskell.org/platform/linux.html>are all now available from the site. Linux distribution packages should be available shortly. On behalf of the Haskell Platform team<http://trac.haskell.org/haskell-platform/wiki/Members> , - Mark "mzero" Lentczner, Release Manager

4 4

Call for discussion: OverloadedLists extension
by Michael Snoyman 06 Nov '12

06 Nov '12

(Prettier formatting available at: https://gist.github.com/3761252) Many of us use the OverloadedStrings language extension on a regular basis. It provides the ability to keep the ease-of-use of string literal syntax, while getting the performance and correctness advantages of specialized datatypes like ByteString and Text. I think we can get the same kind of benefit by allowing another literal syntax to be overloaded, namely lists. ## Overly simple approach The simplest example I can think of is allowing easier usage of Vector: [1, 2, 3] :: Vector Int In order to allow this, we could use a typeclass approach similar to how OverloadedStrings works: class IsList a where fromList :: [b] -> a b instance IsList Vector where fromList = V.fromList foo :: Vector Int foo = fromList [1, 2, 3] ## Flaws However, such a proposal does not allow for constraints, e.g.: instance IsList Set where fromList = Set.fromList No instance for (Ord b) arising from a use of `Set.fromList' In the expression: Set.fromList In an equation for `fromList': fromList = Set.fromList In the instance declaration for `IsList Set' Additionally, it provides for no means of creating instances for datatypes like Map, where the contained value is not identical to the value contained in the original list. In other words, what I'd like to see is: [("foo", 1), ("bar", 2)] :: Map Text Int ## A little better: MPTC A simplistic approach to solve this would be to just use MultiParamTypeClasses: class IsList input output where fromList :: [input] -> output instance IsList a (Vector a) where fromList = V.fromList foo :: Vector Int foo = fromList [1, 2, 3] Unfortunately, this will fail due to too much polymorphism: No instance for (IsList input0 (Vector Int)) arising from a use of `fromList' Possible fix: add an instance declaration for (IsList input0 (Vector Int)) In the expression: fromList [1, 2, 3] In an equation for `foo': foo = fromList [1, 2, 3] This can be worked around by giving an explicit type signature on the numbers in the list, but that's not a robust solution. In order to solve this properly, I think we need either functional dependencies or type families: ## Functional dependencies class IsList input output | output -> input where fromList :: [input] -> output instance IsList a (Vector a) where fromList = V.fromList instance Ord a => IsList a (Set a) where fromList = Set.fromList instance Ord k => IsList (k, v) (Map k v) where fromList = Map.fromList foo :: Vector Int foo = fromList [1, 2, 3] bar :: Set Int bar = fromList [1, 2, 3] baz :: Map String Int baz = fromList [("foo", 1), ("bar", 2)] ## Type families class IsList a where type IsListInput a fromList :: [IsListInput a] -> a instance IsList (Vector a) where type IsListInput (Vector a) = a fromList = V.fromList instance Ord a => IsList (Set a) where type IsListInput (Set a) = a fromList = Set.fromList instance Ord k => IsList (Map k v) where type IsListInput (Map k v) = (k, v) fromList = Map.fromList foo :: Vector Int foo = fromList [1, 2, 3] bar :: Set Int bar = fromList [1, 2, 3] baz :: Map String Int baz = fromList [("foo", 1), ("bar", 2)] ## Conclusion Consider most of this proposal to be a strawman: names and techniques are completely up to debate. I'm fairly certain that our only two choices to implement this extension is a useful way is fundeps and type families, but perhaps there's another approach I'm missing. I don't have any particular recommendation here, except to say that fundeps is likely more well supported by other compilers.

10 19

Is XMonad still developed or with a current maintainer?
by Alfredo Di Napoli 06 Nov '12

06 Nov '12

Hi guys, looking at the Darcs repo it seems that something is happening, but XMonad wasn't updated in a year on Hackage and everything seems to be still. Is XMonad still actively developed? If yes, who is the current maintainer? It would be good to have him listed in the Hackage package description, in order to contact him. Atm there is one generic email that seems not to be read very often :) Cheers, A.

4 10

ANNOUNCE: vim-hs-module-name
by Roman Cheplyaka 06 Nov '12

06 Nov '12

vim-hs-module-name is a Vim plugin that infers and inserts the Haskell module name. Please see the github page for details: https://github.com/feuerbach/vim-hs-module-name Roman

1 0

more sharing in generated code
by Peter Divianszky 06 Nov '12

06 Nov '12

Hi Joachim, > > ... > > I think one problem with this approach is that now, until "x r'" is > evaluated, you keep both r and r' alive. If r was _not_ retained by > anything else, then you are now preventing the GC from freeing it and > hence increasing the memory footprint. Good remark, this can be solved with weak pointers, although I don't know how efficient they are. ---------------------- The next version of the proposal Replace every record update r' = r { x = y } with r' = r { x = update (weak r) r' (x r) y) } in generated code if some sharing aware optimization flag is enabled. Auxilary functions: weak :: a -> Weak a -- make a weak pointer which is not followed by GC update :: Weak r -> r -> x -> x update r_old r_new x_old x_new = unsafePerformIO $ do eval x_new b <- x_old === x_new when b (replace r_new r_old) return x_new (===) :: a -> a -> IO Bool -- pointer-equality for boxed values, equality for unboxed values replace :: a -> Weak a -> IO () -- replace thunks in the heap -- do nothing if the weak pointer was gone Cheers, Peter

2 1

Re: [Haskell-cafe] Partial application in case expression rules
by Patrick Premont 06 Nov '12

06 Nov '12

I had not thought of this record syntax. But it does not perform the currying effect shown in the example; it just drops the omitted fields. Brandon Allbery <allbery.b(a)gmail.com> wrote: >On Mon, Nov 5, 2012 at 4:15 PM, Stephen Tetley <stephen.tetley(a)gmail.com>wrote: > >> There is a long extant GHC extension to elide constructor arguments >> >f (Leaf {}) = ... >> f (Node {}) = ... >> > >I don't think that's an extension, it falls out directly from how Haskell >builds records on top of ADTs and is specified in the standard as such. > See http://www.haskell.org/onlinereport/decls.html at the end of the >"Labelled Fields" section for Haskell98, or the middle of section 3.15.2 in >http://www.haskell.org/onlinereport/haskell2010/haskellch3.html#x8-490003.1… >the H'2010 version. > >-- >brandon s allbery kf8nh sine nomine associates >allbery.b(a)gmail.com ballbery(a)sinenomine.net >unix/linux, openafs, kerberos, infrastructure http://sinenomine.net

1 0

[ANNOUNCE] network-bitcoin
by Clark Gaebel 05 Nov '12

05 Nov '12

Hello Cafe, You've heard of the neat crypto-currency bitcoin[1], haven't you? Well, I've just released network-bitcoin[2] which provides Haskell bindings to the bitcoin daemon. Hopefully, this will make your bitcoin-related goals easier to achieve. Who knows, it might even make bitcoin integration for the various web frameworks a bit easier. Special thanks to Michael Hendricks who wrote the original version of network-bitcoin, which I used as a base for this release. Regards, - Clark [1] http://bitcoin.org [2] http://hackage.haskell.org/package/network-bitcoin-1.0.1

2 1

Partial application in case expression rules
by Patrick Premont 05 Nov '12

05 Nov '12

Occasionally I find it would be nice to be able to omit some or all constructor parameters from a pattern matching rule. Perhaps the compiler could put them in for you and apply them to the right hand side of the rule ? data Tree a = Leaf a| Node (Tree a) (Tree a) treeFold :: (a -> a -> a) -> Tree a -> a treeFold f = \case Leaf -> id Node -> f `on` treeFold f This could be desugared at some point to treeFold f = \case Leaf a -> id a Node a b -> (f `on` treeFold f) a b I suppose such an extension has been considered before, but I could not find such a discussion. (In http://haskell.1045720.n5.nabble.com/Partial-pattern-matching-td3087200.html the thread focused instead on case expressions over functions) Any pointers to previous discussions ? Comments ? Thank you! Patrick Prémont

3 3

How to handle exceptions in conduit?
by Hiromi ISHII 05 Nov '12

05 Nov '12

Hi, there I'm writing a program communicating with external process, which can be sometimes fail, using conduit and process-conduit package. Consider the following example, which reads paths from the config file, and passes their contents to external process, and output the results: ```exc.hs module Main where import qualified Data.ByteString.Char8 as BS import Data.Conduit import qualified Data.Conduit.Binary as BC import qualified Data.Conduit.List as LC import Data.Conduit.Process main :: IO () main = runResourceT $ BC.sourceFile "paths.dat" $$ BC.lines =$= myConduit =$= LC.mapM_ (unsafeLiftIO . BS.putStrLn) myConduit :: MonadResource m => Conduit BS.ByteString m BS.ByteString myConduit = awaitForever $ \path -> BC.sourceFile (BS.unpack path) =$= conduitCmd "./sometimes-fail" ``` ```sometimes-fail.hs module Main where import System.Random main :: IO () main = do b <- randomRIO (1,10 :: Int) if b < 9 then interact id else error "error!" ``` ```paths.dat txt/a.dat txt/b.dat txt/c.dat ...bra, bra, bra... ``` As you can see, `sometimes-fail` is a simple echoing program, but sometimes fail at random. Successful result is below: ``` $ ./exc this is a! this is b! this is c! this was d! this was e! and this is f. ``` but if `sometimes-fail` fails in some place, `exc` exits with exception like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! ``` But I want to write the program acts like below: ``` $ ./exc this is a! this is b! this is c! sometimes-fail: error! this was e! and this is f. ``` that is, ignore the exception and continue to process remaining streams. So, the question is: how to handle the exception in `myConduit` and proceed to remaining works? In `conduit` package, `Pipe` type is not an instance of `MonadBaseControl IO` so it cannot handle exceptions within it. I think this is necessary to make `ResourceT` release resources correctly. So, how to write the Conduit that ignores some kind of exceptions and proceed to remaining works? One sometimes want to ignore the invalid input and/or output and just continue to process the remaining stream. One solution is that libraries using conduit provide "failure-ignore" version for all the `Pipe`s included in the library, but I think it is too heavy solution. It is ideal that `conduit` can package provides combinator that makes exsiting `Pipe`s "failure-ignore". -- Hiromi ISHII konn.jinro(a)gmail.com

2 4

Does this have a name?
by Jacques Carette 05 Nov '12

05 Nov '12

The function > app1 f x = f >>= ($ x) or equivalently > app2 f x = join (f <*> pure x) with type Monad m => m (a -> m b) -> a -> m b ? Hoogle did not help. Jacques PS: a nice point-free version would be appreciated as well. I can easily change app1 and app2 myself to point-free with enough applications of flip, . and $, but none of those are 'nice'.

1 0

ANN: OpenGL packages update
by Jason Dagit 04 Nov '12

04 Nov '12

The updates include: * All of the newtypes in OpenGLRaw have been changed to type aliases (credit to Trevor Elliott and Mike Ledger) * OpenGLRaw's TypesInternal module has gone away * NVidia path rendering extensions have been added by "ozelis" on github This release changes OpenGLRaw to use type aliases instead of newtype wrappers for the GLfoo types, such as GLenum/GLfloat/GLdouble. Using newtypes had the following downsides: * The CPP macros to make these definitions are borrowed verbatim from GHC sources and required updates with new GHC releases in order to stay compatible. Although, it hasn't been a problem yet, it's conceivable this will conflict with supporting different versions of GHC at some point. * Optimization rules have to be written against these newtypes and forgetting them can lead to significant performance degradation or extra verbosity for people using the bindings. * You have to reach pretty deep into GHC to make it possible for the newtypes to work in the unboxed vectors provided by the vector package. This is again, another missed opportunity for high performance code. You can find the source and bug trackers for these packages here: https://github.com/haskell-opengl/ Feedback, pull requests, and bug reports are always welcome! Thanks! Jason

1 0

Help: Main: thread blocked in MVar operation
by "José A. Lopes" 04 Nov '12

04 Nov '12

Hey everyone, I changed my code I now I get the following error message Main: thread blocked indefinitely in an MVar operation Before the change, I was using the State monad with runState. Then, I changed the code to use the StateT monad transformer wrapped around IO monad and runStateT. And this change introduced the error message. BTW I am using DoRec extension, maybe it is the source of the problem, but I don't know. Here are some specs: ghc 7.4.2 mtl 2.1.1 If you need any other information please don't hesitate to ask. Any help is greatly appreciated! Cheers, José -- José António Branquinho de Oliveira Lopes Instituto Superior Técnico Technical University of Lisbon

2 2

more sharing in generated code
by Peter Divianszky 04 Nov '12

04 Nov '12

Hi, I have a question about sharing at the Haskell run-time level. Suppose we have a record update r { x = f (r x)} and suppose that most of the time f returns it's argument unchanged. I have the following questions: 1. Does the generated code for the record update build an identical record when f returns it's argument unchanged instead of sharing the old one? (I guess yes.) 2. Can we prevent building identical records? Recently I've heard about Q-combinators. Central idea: Change (f :: a -> a) to (f' :: a -> Maybe a) returning Nothing when the value didn't change. Then we can replace the record update with smarter code which preserves more sharing. My question is: Can (or could) we enable more sharing without changing the source code? Ideally the compiler would generate record update code which checks poiter-equality of the updated field value to decide whether a copy of the original record is needed or it can be shared (given an optimisation flag enabled). Thanks, Peter Background info: There was a discussion on the Agda mailing list about decreasing the Agda compiler memory-usage with more sharing[^1]. (The Agda compiler is written in Haskell.) I had the above idea and I was advised to ask about it on some Haskell mailing list. [^1]: https://lists.chalmers.se/pipermail/agda/2012/004485.html

4 6

Input Handling, Callbacks, State Machines
by Daniel Trstenjak 04 Nov '12

04 Nov '12

Hi all, I'm currently struggling in the search for a nice abstraction for the input handling of a game (it's a simple platformer with rectangular platforms). One good example is the level editor of the game. When pressing the left mouse button the creation of a new platform is started. As long as the mouse button is hold the platform can be resized by moving the mouse. When releasing the mouse button the platform is created with the current shape. The GUI library I'm using is GLFW. There're several callbacks for key, mouse button and mouse move events. Firstly I would like to be able to describe application states, like the creation of a platform or the definition of the movement of a platform. The state might add something to the current level rendering and it changes temporary the callbacks. So in the case of a platform creation, the mouse move callback would just resize the platform, the mouse button callback awaits the button release and the key callback might only allow the quitting of the current creation. Above the application states it would be nice to be able to describe the transition from one state to another. Perhaps FRP might be a solution for this. But I'm still shying away of it, because a game might have some hairy state changes and I still don't see, how FRP makes life in this regard that much easier. Any Ideas? Greetings, Daniel

3 2

haskellers.com: Keterconfig incorrect?
by Obscaenvs 04 Nov '12

04 Nov '12

Excerpt from source: "<h1>Welcome to Keter</h1><p>The hostname you have provided is not recognized.</p>". This after trying to login using Mozilla Persona: http://www.haskellers.com/auth/page/browserid/eyJhbGciOiJSUzI (Where I have shortened the string at the end) f

2 1

forall disappear from type signature
by oleg＠okmij.org 03 Nov '12

03 Nov '12

Takayuki Muranushi wrote: > Today, I encountered a strange trouble with higher-rank polymorphism. It > was finally solved by nominal typing. Was it a bug in type checker? lack of > power in type inference? > runDB :: Lens NetworkState RIB > runDB = lens (f::NetworkState -> RIB) (\x s -> s { _runDB = x }) > where f :: NetworkState -> RIB As it becomes apparent (eventually), RIB is a polymorhic type, something like type RIB = forall a. DB.DBMT (Maybe Int) IO a0 -> IO (StM (DB.DBMT (Maybe Int) IO) a0) The field _runDB has this polymorphic type. Hence the argument x in (\x s -> s { _runDB = x }) is supposed to have a polymorphic type. But that can't be: absent a type signature, all arguments of a function are monomorphic. One solution is to give lens explicit, higher-ranked signature (with explicit forall, that is). A better approach is to wrap polymorphic types like your did > newtype RIB = RIB (RunInBase (DB.DBMT (Maybe Int) IO) IO) The newtype RIB is monomorphic and hence first-class, it can be freely passed around. In contrast, polymorphic values are not first-class, in Haskell. There are many restrictions on their use. That is not a bug in the type checker. You may call it lack of power in type inference: in calculi with first-class polymorphism (such as System F and System Fw), type inference is not decidable. Even type checking is not decidable.

1 0

How to avoid T3 fonts in pdf generated with lhs2TeX?
by Andreas Abel 02 Nov '12

02 Nov '12

Hello, maybe someone has experience in publishing papers that use lhs2TeX and unicode characters with ACM, and has been in my situation before... Sheridan, who publishes for ACM, does not like T3 fonts. However, lhs2tex --agda does make use of T3 fonts via: \RequirePackage[utf8x]{inputenc} If I remove this, my unicode characters are garbled in the lhs2tex-generated code. Does anoyone know a smart workaround besides replacing all the unicode characters manually by some math symbols in the .tex file? Cheers, Andreas -- Andreas Abel <>< Du bist der geliebte Mensch. Theoretical Computer Science, University of Munich Oettingenstr. 67, D-80538 Munich, GERMANY andreas.abel(a)ifi.lmu.de http://www2.tcs.ifi.lmu.de/~abel/

3 3

Unicode case (in)stability and Haskell identifiers.
by Richard O'Keefe 02 Nov '12

02 Nov '12

I've been putting together a proposal for Unicode identifiers in Erlang (it's EEP 40 if anyone wants to look it up). In the course of this, it has turned out that there is a technical problem for languages with case-significant identifiers. Haskell 2010 report, chapter 2. http://www.haskell.org/onlinereport/haskell2010/haskellch2.html varid → (small {small | large | digit | ' })\⟨reservedid⟩ conid → large {small | large | digit | ' } small → ascSmall | uniSmall | _ ascSmall → a | b | … | z uniSmall → any Unicode lowercase letter large → ascLarge | uniLarge ascLarge → A | B | … | Z uniLarge → any uppercase or titlecase Unicode letter This is actually ambiguous: any ascSmall is also a uniSmall and any ascLarge is also a uniLarge. I take it that this is intended to mean "any Unicode xxx letter other than an ASCII one" in each case. That's not the problem. The definition currently bans Hebrew, Arabic, Chinese, Japanese, all the Indic scripts, and basically only allows Latin, Greek, Coptic, Cyrillic, Glagolitic, Armenian, arguably Georgian, and Deseret (but not Shavian). That's not the problem either. The problem is that being a Unicode lower case, upper case, or title case letter is not a stable property. Unicode annex UAX#31 guarantees that X is a well-formed case-insensitive identifier now => X will always be a well-formed case-insensitive identifier and that X is a well-formed case-sensitive identifier now => X will always be a well-formed case-sensitive identifier What it does NOT guarantee is that it will continue to be begin with the same *case* or even that a letter will continue to be classified as a letter. So it is at least technically possible for a valid Haskell 2010 varid (conid) to turn into a conid (varid) or even cease to be a legal Haskell identifier at all. Unicode standard Annex UAX#31 guarantees stability of being-an-identifier by having an exceptional set for any letter that stops being a letter to go into. For example, there are SCRIPT CAPITAL {B,E,F,H,I,L,M,P,R} characters, all of which are capital letters except for SCRIPT CAPITAL P, which is a symbol, but it's in the exception set so it's still OK to use. All of the SCRIPT CAPITAL letters were in General Category So in Unicode 1.1.5 (the earliest for which online data is available). In Unicode 2.1.8, all of them were Lu except for SCRIPT CAPITAL P, which was Ll. By Unicode 3.0.0, SCRIPT CAPITAL P was back to So. Some time later it switched over to Sm. So we've had SCRIPT CAPITAL P - not a letter (1.1.5) - is a lower case letter (2.1.8) - not a letter again (3.0.0) at least according to the on-line UnicodeData-<version>.txt files. Putting ℘ into the exceptional set means that a UAX#31 identifier may still contain it, but not so a Haskell one. There are two aspects to this instability. (1) Because Haskell hews its own line instead of tailoring UAX#31 the way Ada and Python do, Haskell cannot benefit from the UAX#31 stability guarantee. There _has_ been a character that used to be legal in a Haskell identifier that is not now. That's Haskell's problem, not Unicode's, and the Haskell community does not have to wait for anyone else to address is. (2) Even if you adopt one of the UAX#31 definitions verbatim, the case distinction Haskell needs to make is not stable. It appears that nobody who worked on UAX#31 was thinking about languages like Prolog, Erlang, Clean, Haskell, F#, or Scala, and that if the Unicode Consortium are told of the problem, they will probably be happy to add some sort of "don't break these languages" guideline. Next week I intend to submit a proposal to the Unicode consortium to consider this issue. Would anyone care to see and comment on the proposal before I send it to Unicode.org? Anyone got any suggestions before I begin to write it? For the sake of argument, suppose that we are going to stick with Xid_Start Xid_Continue* for the union of variables and atoms (which is pretty much what Ada and Python do), and the sole issue of concern is that there should be a stable way to classify such a token as "beginning with default case" or "beginning with marked case".

2 1

[Security] Put haskell.org on https
by Niklas Hambüchen 02 Nov '12

02 Nov '12

(I have mentioned this several times on #haskell, but nothing has happened so far.) Are you aware that all haskell.org websites (hackage, HaskellWiki, ghc trac) allow unencrypted http connections only? This means that everyone in the same Wifi can potentially - read you passwords for all of these services - abuse your hackage account and override arbitrary packages (especially since hackage allows everybody to override everything) I propose we get an SSL certificate for haskell.org. I also offer to donate that SSL certificate (or directly create it using my Startcom account). Niklas

17 34

[solved] forall disappear from type signature
by Takayuki Muranushi 02 Nov '12

02 Nov '12

Today, I encountered a strange trouble with higher-rank polymorphism. It was finally solved by nominal typing. Was it a bug in type checker? lack of power in type inference? or lack of my understanding? I'll submit this in hope that it will at least result in better GHC error message some day: My following code https://github.com/sugoi/sugoi/blob/0aec19b29274ddb7c5ae46b9b733e91bae0790b… > runDB :: Lens NetworkState RIB > runDB = lens (f::NetworkState -> RIB) (\x s -> s { _runDB = x }) > where f :: NetworkState -> RIB Didn't typecheck with following error: Sugoi/Types.hs:38:15: Couldn't match expected type `RIB' with actual type `DB.DBMT (Maybe Int) IO a0 -> IO (StM (DB.DBMT (Maybe Int) IO) a0)' Expected type: NetworkState -> RIB Actual type: NetworkState -> DB.DBMT (Maybe Int) IO a0 -> IO (StM (DB.DBMT (Maybe Int) IO) a0) In the first argument of `lens', namely `(f :: NetworkState -> RIB)' In the expression: lens (f :: NetworkState -> RIB) (\ x s -> s {_runDB = x}) How come an expression `(f :: NetworkState -> RIB)' is not of type NetworkState -> RIB ? When I changed the definition of runDB as follows, > runDB = lens (\NetworkState{_runDB = x} -> x) (\x s -> s { _runDB = x }) The source of error was more clear: Expected type: DB.DBMT (Maybe Int) IO a1 -> IO (StM (DB.DBMT (Maybe Int) IO) a1) Actual type: DB.DBMT (Maybe Int) IO a -> IO (StM (DB.DBMT (Maybe Int) IO) a) So, ghc couldn't unify these two types. By using the nominal typing, namely > - type RIB = RunInBase (DB.DBMT (Maybe Int) IO) IO > + newtype RIB = RIB (RunInBase (DB.DBMT (Maybe Int) IO) IO) the problem was solved. Always grateful to haskell-cafe from being there, -- Takayuki MURANUSHI The Hakubi Center for Advanced Research, Kyoto University http://www.hakubi.kyoto-u.ac.jp/02_mem/h22/muranushi.html

1 0

Haskell Weekly News: Issue 249
by Daniel Santa Cruz 02 Nov '12

02 Nov '12

Welcome to issue 249 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of October 21 to October 27, 2012. Quotes of the Week * johnw: ah terminology, just when you think you know something, they redefined "know"... * lispy: The crappy thing about using partial fun*** Exception: Pattern match failure * shachaf: This Useful Information information brought to you by: ghci, and: the letter t * edwardk: i should have picked a better name to minimize confusion cmccann: huh. that's not something I ever expected to hear edwardk say * beaky: why did they settle on bitshiftrightassign (>>=) for monadic bind? Top Reddit Stories * Why is this simple text processing program so much slower than in dynamic languages? Domain: honza.ca, Score: 64, Comments: 189 On Reddit: [1] http://goo.gl/jW5ow Original: [2] http://goo.gl/pPzIb * Fay slides Domain: fay-lang.org, Score: 50, Comments: 42 On Reddit: [3] http://goo.gl/0UM4T Original: [4] http://goo.gl/h8iZE * Haskell for all: "Hello, core!" Domain: haskellforall.com, Score: 48, Comments: 6 On Reddit: [5] http://goo.gl/qXRd2 Original: [6] http://goo.gl/9cBeo * Haskell job opening at Functor AB Domain: alpmestan.com, Score: 35, Comments: 5 On Reddit: [7] http://goo.gl/hQmoa Original: [8] http://goo.gl/ASA9c * Enemy of the Mutable State Domain: ozonehouse.com, Score: 32, Comments: 10 On Reddit: [9] http://goo.gl/Wn3Yv Original: [10] http://goo.gl/r18by * Gloss(ish) and Fay: An Example Domain: zelda.designacourse.com, Score: 29, Comments: 7 On Reddit: [11] http://goo.gl/rtR9Y Original: [12] http://goo.gl/1cF0z * Yesodweb: Future work to improve the performance of Warp Domain: yesodweb.com, Score: 25, Comments: On Reddit: [13] http://goo.gl/0YF64 Original: [14] http://goo.gl/fq7ds * (a,b,c,d) as sugar for (a,(b,(c,d))) ? Domain: self.haskell, Score: 23, Comments: 37 On Reddit: [15] http://goo.gl/cc30R Original: [16] http://goo.gl/cc30R * Using Cloud Haskell in HPC Cluster Domain: malcodigo.blogspot.com.es, Score: 23, Comments: On Reddit: [17] http://goo.gl/LxmqY Original: [18] http://goo.gl/ycmZr * Haskell Platform 2012.4.0.0 release candidates Domain: trac.haskell.org, Score: 23, Comments: 3 On Reddit: [19] http://goo.gl/B4MNc Original: [20] http://goo.gl/Q4fHP Top StackOverflow Questions * Concrete example showing that monads are not closed under composition (with proof)? votes: 24, answers: 3 Read on SO: [21] http://goo.gl/sys7F * Why is there no IO transformer in Haskell? votes: 15, answers: 2 Read on SO: [22] http://goo.gl/04Xc7 * Is it possible to make GHC optimize (deforest) generic functions such as catamorphisms? votes: 14, answers: 1 Read on SO: [23] http://goo.gl/f4ZlU * Confused by the meaning of the 'Alternative' type class and its relationship to other type classes votes: 13, answers: 5 Read on SO: [24] http://goo.gl/RXNuV * How to add fields that only cache something to ADT? votes: 13, answers: 0 Read on SO: [25] http://goo.gl/FjLlX * How to reliably compare runtime of Haskell and C? votes: 10, answers: 1 Read on SO: [26] http://goo.gl/R7whA * Currying Product Types votes: 10, answers: 3 Read on SO: [27] http://goo.gl/7gxIS * Modular Program Design - Combining Monad Transformers in Monad Agnostic functions votes: 9, answers: 2 Read on SO: [28] http://goo.gl/8rh1B * Is there a nicer way to apply a function to both elements of a pair in a list than a list comprehension? votes: 9, answers: 3 Read on SO: [29] http://goo.gl/JF3p5 * How unpacking strict fields goes together with polymorphism? votes: 9, answers: 1 Read on SO: [30] http://goo.gl/58MuT Until next time, Daniel Santa Cruz References 1. http://honza.ca/2012/10/haskell-strings 2. http://www.reddit.com/r/haskell/comments/120h6i/why_is_this_simple_text_pro… 3. http://fay-lang.org/fay-talk/ 4. http://www.reddit.com/r/haskell/comments/11yrpi/fay_slides/ 5. http://www.haskellforall.com/2012/10/hello-core.html 6. http://www.reddit.com/r/haskell/comments/11vuzz/haskell_for_all_hello_core/ 7. http://alpmestan.com/posts/2012-10-23-haskell-job-opening-at-functor.html 8. http://www.reddit.com/r/haskell/comments/11yf8c/haskell_job_opening_at_func… 9. http://www.ozonehouse.com/mark/enemy/ 10. http://www.reddit.com/r/haskell/comments/125zt0/enemy_of_the_mutable_state/ 11. http://zelda.designacourse.com/codeworld.html 12. http://www.reddit.com/r/haskell/comments/126vdk/glossish_and_fay_an_example/ 13. http://www.yesodweb.com/blog/2012/10/future-work-warp 14. http://www.reddit.com/r/haskell/comments/11w7wv/yesodweb_future_work_to_imp… 15. http://www.reddit.com/r/haskell/comments/11ysa5/abcd_as_sugar_for_abcd/ 16. http://www.reddit.com/r/haskell/comments/11ysa5/abcd_as_sugar_for_abcd/ 17. http://malcodigo.blogspot.com.es/2012/10/using-cloud-haskell-in-hpc-cluster… 18. http://www.reddit.com/r/haskell/comments/122m6y/using_cloud_haskell_in_hpc_… 19. http://trac.haskell.org/haskell-platform/wiki/ReleaseCandidates 20. http://www.reddit.com/r/haskell/comments/124kje/haskell_platform_2012400_re… 21. http://stackoverflow.com/questions/13034229/concrete-example-showing-that-m… 22. http://stackoverflow.com/questions/13056663/why-is-there-no-io-transformer-… 23. http://stackoverflow.com/questions/13099203/is-it-possible-to-make-ghc-opti… 24. http://stackoverflow.com/questions/13080606/confused-by-the-meaning-of-the-… 25. http://stackoverflow.com/questions/13098448/how-to-add-fields-that-only-cac… 26. http://stackoverflow.com/questions/13009728/how-to-reliably-compare-runtime… 27. http://stackoverflow.com/questions/13080074/currying-product-types 28. http://stackoverflow.com/questions/13007123/modular-program-design-combinin… 29. http://stackoverflow.com/questions/13022720/is-there-a-nicer-way-to-apply-a… 30. http://stackoverflow.com/questions/13098375/how-unpacking-strict-fields-goe…

1 0

Comparing Haskell and Darcs
by Henk-Jan van Tuyl 01 Nov '12

01 Nov '12

L.S., I just found a site that compares o.a. Haskell to other languages[0] and Darcs to other version control systems[1]: Hammer principle. Haskell scores quite good, Darcs could do better. Regards, Henk-Jan van Tuyl [0] http://hammerprinciple.com/therighttool/items/haskell [1] http://hammerprinciple.com/versioncontrol/items/darcs -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

Deriving settings from command line, environment, and files
by David Thomas 01 Nov '12

01 Nov '12

Is there a library that provides a near-complete solution for this? I looked around a bit and found many (many!) partial solutions on hackage, but nothing that really does it all. In coding it up for my own projects, however, I can't help but feel like I must be reinventing the wheel. What I want is something that will process command line options (this seems to be where most packages are targetted), environment variables, and settings files (possibly specified in options), and override/default appropriately. Did I miss something? If not, I'd like to see about fixing the situation, but very much want to avoid the whole "There were X libraries that didn't quite do it right; now there's X+1!" thing. Are there any opinions as to which of the many libraries is likely the best starting point if I'm going to contribute to one of them?

3 2

Looking for advice on modelling a 3-way merge (with varying strategies)
by Oliver Charles 01 Nov '12

01 Nov '12

Hello, I'm currently trying to implement a way 3 way merge, that is dispatched on type. Essentially, I want to be able to say "I have this large data type which is a product of various other types - here's how to merge it". By 3 way merge, I mean that I have a 'new' value, a 'current' value and a 'common ancestor' value. So far I have: import Control.Applicative import Data.Monoid newtype Merge a = Merge { runMerge :: Either [String] a } instance Functor Merge where fmap f a = Merge $ fmap f $ runMerge a instance Applicative Merge where pure = Merge . Right (Merge (Right f)) <*> (Merge (Right a)) = Merge $ Right $ f a (Merge (Right _)) <*> (Merge (Left c)) = Merge $ Left $ c (Merge (Left c)) <*> (Merge (Left c')) = Merge $ Left $ c <> c' (Merge (Left c)) <*> _ = Merge $ Left $ c ok :: a -> Merge a ok = pure failMerge :: String -> Merge a failMerge x = Merge $ Left [x] So far so good, so I can add my first merge strategy: mergeEq :: Eq a => String -> a -> a -> a -> Merge a mergeEq lbl new current ancestor | current == new = ok new | current == ancestor = ok new | new == ancestor = ok current | otherwise = failMerge lbl And we can make use of this to build more complicated merge strategies: data Person = Person { name :: String, surname :: String } deriving (Show) mergeEqOn :: Eq a => (b -> a) -> String -> b -> b -> b -> Merge a mergeEqOn l lbl n c a = mergeEq lbl (l n) (l c) (l a) mergePerson :: Person -> Person -> Person -> Merge Person mergePerson new current ancestor = Person <$> mergeEqOn name "name" new current ancestor <*> mergeEqOn surname "surname" new current ancestor >>> runMerge $ mergePerson Person { name="Steve", surname="Bobman" } Person { name="Joe", surname="Obman" } Person { name="oe", surname="Obman" } Left ["name"] >>> runMerge $ mergePerson Person { name="Steve", surname="Bobman" } Person { name="Joe", surname="Obman" } Person { name="Joe", surname="Obman" } Right (Person {name = "Steve", surname = "Bobman"}) Everything does exactly what I want, but it doesn't smell as good as I expect from Haskell. Firstly, all my primitives or operations take 3 arguments that have to be threaded in a very specific pattern. If I accidently call mergeEq ancestor current new, I've ran things in the wrong order and I'm Gonna Have a Bad Time. So that's no good. Secondly, is there a better way of labelled parts of a merge? I suspect not, as at some point I need a human readable display, but I did wonder about using a lens as a label, and then mapping lenses to human readable names later -- but that will require a bit of newtyping in order to provide the Eq instance, or maybe i make a HumanLens type which is a lens and a name?). Finally, I'm currently a little obsessed with the idea of building applicatives from the composition or product of other applicatives - can I use this trick here? I initially used 'Compose ((,) [String]) Maybe a' but this means it's possible to have (["Conflicts"], Just "But success!"), which is nonsense. I'd love to hear your thoughts! - ocharles

1 0

Haskell User Group Hamburg (Germany) - Meeting Thursday November 8th 2012
by Stefan Schmidt 01 Nov '12

01 Nov '12

Hello cafe, there's an upcomming meeting of the Haskell user group Hamburg next week on Thursday, November 8th. We'll start 19:00 at the fortytools GmbH in Hamburg (Georgsplatz 10, 20099 Hamburg). We don't have a program or talk yet. Maybe we'll discuss our experiences from the last ICFP and the Haskell Symposium. If you are interested to join us, have a look at our doodle (only in german) http://www.doodle.com/gvdsbsyfz7a7427g Be careful: the Google Maps link in the Doodle may direct you to the old address. Georgsplatz 10, 20099 Hamburg is the new one. Further announcements will be made via Twitter, so you may want to follow https://twitter.com/hug_hh.

1 0

ANNOUNCE: btree-concurrent
by Johan Brinch 31 Oct '12

31 Oct '12

Greetings Haskellers, We are pleased to announce this new package, featuring a concurrent b-tree developed as part of our master's thesis on backup systems. The package features code related to STM, caching, QuickCheck and of course concurrency and parallelism. And it's also on Hackage: http://hackage.haskell.org/package/btree-concurrent In case the build fails on Hackage and the documentation doesn't work, it's also available here: http://hindsight.dk/doc/html/btree-concurrent Credits to Thomas Conway of Melbourne University, for discussions related to the implementation, and to our supervisor Ken Friis Larsen of University of Copenhagen. And now, the description of the package: ===== A backend agnostic, concurrent BTree with relaxed balance[1] written in Haskell using a mix of IO operations and pure STM. Although the code does work, it is neither production-ready nor complete. Features include: * Caching: While nodes are periodically saved on persistent storage (e.g. disk) they are cached in-memory during operations. * Live flushing: It is possible to save the current version of the tree to disk and run modifying operations at the same time. The nodes are updated buttom-up to ensure a valid tree in the case of a crash. * Backend agnosticism: A simple API is used as an abstraction for the persistent storage. * Verification: The test-suite uses QuickCheck to compare the trees behaviour to that of Data.Map. Deficients include: * Memory greedy. Nodes are not stored in a compact fashion and are constantly being serialised/deserialised. * findMin and findMax are incomplete and may fail (see the TODO for details). * The implementation does not parallelise well. [1] B-trees with relaxed balance, K. S. Larsen & R. Fagerberg, Parallel Processing Symposium, 1995. Proceedings., 9th International -- Johan Brinch & Morten Brøns-Pedersen

2 2

ANNOUNCE: plat
by Miguel Mitrofanov 31 Oct '12

31 Oct '12

My current project at work has a web interface. Therefore I needed an HTML templating library. I've tried several and found them all unsatisfactory. Most of them generate Haskell code from templates (with Template Haskell or a separate utility), and I don't like metaprogramming; and recompiling the program every time you make a small change in the template kinda defeats the purpose. Other libraries make it PITA to implement basic things, like iterating over an array. So, I'm proud to announce the first release of another template library: plat-0.1.0.1 (http://hackage.haskell.org/package/plat) An example of what it does. If your data looks like do "name" =: "Mac's tools" "staff" =: [ do "index" =: "1" "name" =: "Alice" , do "name" =: "Bob" "index" =: "2" "bad" =: True , do "index" =: "3" "name" =: "Nicolás" ] and your template is List of employees at @name: @staff[person @person.index@.. @person.name@{@!person.bad (going to be fired)@|@}@ @]@# There won't be an empty line in the result Then the result you get would be this: List of employees at Mac's tools: 1. Alice 2. Bob (going to be fired) 3. Nicolás Keep in mind, that it's actually a string template library, and the resulting string doesn't have to be valid HTML, or any HTML at all. I haven't benchmarked this library - since I intended to use it for web interface in an program which won't be released outside, speed was not in my priorities; but I'll work on that in future versions. Also, templates are supposed to be in UTF-8, as I've successfully forgot all about other encodings. So, if you want binary templates, I'm afraid, this library is not for you.

1 0

Safe lens?
by Greg Fitzgerald 31 Oct '12

31 Oct '12

Why are getters from the 'lens' package unsafe? Is there a subset like Data.Label.Pure from 'fclabels' that can be imported safely? $ cat a.hs {-# LANGUAGE Safe #-} import Control.Lens.Getter main = print 123 $ runghc a.hs a.hs:3:1: Control.Lens.Getter: Can't be safely imported! The module itself isn't safe. Thanks, Greg

5 10

ANNOUNCE: network-house
by Niklas Hambüchen 30 Oct '12

30 Oct '12

In absence of a library that easily parses network packages from recorded raw data (not sockets), I have taken the network stack from the House project and put it into a separate package, network-house. http://hackage.haskell.org/package/network-house This library allows you to parse Ethernet, TCP, UDP, IPv4, IPv6, ICMP, DHCP and TFTP packages from raw data (e.g. recorded traffic). I have left the source code almost unmodified (apart from the relocation of one module and a few necessary LANGUAGE pragmas). As House development itself seems dormant, I invite you to collaborate on the network stack on https://github.com/nh2/network-house. If you would like to contribute, these are the things it definitely needs: * A ByteString interface (it currently works on UArrays). If you know what the most performant way is to convert a UArray to a ByteString, please let me know. * Some examples how to use it * Haddock documentation and code cleanup * Somebody should ask the original authors if they would like to relax the license from GPL to BSD. Cheers Niklas

1 0

Optimal line length for haskell
by Rustom Mody 30 Oct '12

30 Oct '12

There was a recent discussion on the python list regarding maximum line length. It occured to me that beautiful haskell programs tend to be plump (ie have long lines) compared to other languages whose programs are 'skinnier'. My thoughts on this are at http://blog.languager.org/2012/10/layout-imperative-in-functional.html. Are there more striking examples than the lexer from the standard prelude? [Or any other thoughts/opinions :-) ] Thanks, Rusi

16 26

GHC maintenance on Arch
by timothyhobbs＠seznam.cz 30 Oct '12

30 Oct '12

Hello, Who is in charge of the ghc and haskell packages on Arch linux? The current system isn't working. Arch linux tends to update packages very quickly. For ghc, always having the latest ghc isn't a good thing. At least if you actually want to get some work done. A majority of the time the latest GHC is unusable. This is because the packages in hackage simply don't keep up. With the current ghc version(7.6.1) even some basic packages in hackage are not upgraded yet. Right now, a large number of other haskell related packages are in the arch repos. Other than gtk2hs, I think these packages are pointless duplications. In the other cases, it has been my experience that it is simpler to maintain these packages through cabal rather than through pacman. Support for these packages in Arch should probably be dropped. If you want to get work done in Arch with haskell, you should only install ghc and cabal-install(right now, you'll have to search the Internet for the old binaries, because the arch repos usually don't keep the old versions around). Then you should add these packages to "IgnorePkg =" in pacman.conf this way things won't break every couple of months. You can then choose to upgrade when you wish. I hope that someone who is involved with the haskell Arch stuff reads this. The current model needs to be rethought. Linux should be sane by default, but I've lost many many hours learning that arch's relationship with haskell is not so :( Probably the best solution would be to make Arch automatically keep two versions of ghc around at any given time. Thank you for your time, Timothy Hobbs

12 18

TAP 2013: 1st Call for Papers
by Achim D. Brucker 30 Oct '12

30 Oct '12

(Apologies if you receive this announcement multiple times. We also apologize for resending the first call for papers, the original announcement contained an incorrect URL to easychair.) **************************************************** *** *** *** TAP 2013 *** *** *** *** Abstract submission: January 25, 2013 *** *** Paper submission: February 1, 2013 *** **************************************************** *** TAP 2013 solicits both full papers and *** *** (industrial) experience/tool papers *** *** in combining proofs and (security) testing *** **************************************************** CALL FOR PAPERS 7th INTERNATIONAL CONFERENCE ON TESTS AND PROOFS (TAP 2013) http://www.spacios.eu/TAP2013 Budapest, Hungary, June 17-21, 2013 The TAP conference is devoted to the synergy of proofs and tests, to the application of techniques from both sides and their combination for the advancement of software quality. Testing and proving seem to be contradictory techniques: once you have proved your program to be correct then additional testing seems pointless; on the other hand, when such a proof in not feasible, then testing the program seems to be the only option. This view has dominated the research community since the dawn of computer science, and has resulted in distinct communities pursuing the seemingly orthogonal research areas. However, the development of both approaches has lead to the discovery of common issues and to the realization of potential synergy. Perhaps, use of model checking in testing was one of the first signs that a counterexample to a proof may be interpreted as a test case. Recent breakthroughs in deductive techniques such as satisfiability modulo theories, abstract interpretation, and interactive theorem proving, have paved the way for new and practically effective methods of powering testing techniques. Moreover, since formal, proof-based verification is costly, testing invariants and background theories can be helpful to detect errors early and to improve cost effectiveness. Summing up, in the past few years an increasing number of research efforts have encountered the need for combining proofs and tests, dropping earlier dogmatic views of incompatibility and taking instead the best of what each of these software engineering domains has to offer. The TAP conference aims to bring together researchers and practitioners working in the converging fields of testing and proving, and will offer a generous allocation of papers, panels and informal discussions. Topics of interest cover theory definitions, tool constructions and experimentations, and include (other topics related to TAP are welcome): - Bridging the gap between concrete and symbolic techniques, e.g. using proof search in satisfiability modulo theories solvers to enhance various testing techniques - Transfer of concepts from testing to proving (e.g., coverage criteria) and from proving to testing - Program proving with the aid of testing techniques - New problematics in automated reasoning emerging from specificities of test generation - Verification and testing techniques combining proofs and tests - Generation of test data, oracles, or preambles by deductive techniques such as: theorem proving, model checking, symbolic execution, constraint logic programming - Model-based testing and verification - Generation of specifications by deduction - Automatic bug finding - Debugging of programs combining static and dynamic analysis - Formal frameworks - Tool descriptions and experience reports - Case studies combining tests and proofs - Domain specific applications of testing and proving to new application domains such as validating security protocols, vulnerability detection of programs, security Important Dates: ================ Abstract submission: January 25, 2013 Paper submission: February 1, 2013 Notification: March 3, 2013 Camera ready version: April 5, 2013 TAP conference: June 17-21, 2013 Program Chairs: =============== Margus Veanes (Microsoft Research, USA) Luca Vigano` (University of Verona, Italy) Program Committee: ================== TBA Submission: =========== Please submit your papers via easychair https://www.easychair.org/conferences/?conf=tap2013 (submission page to be opened in due time) TAP 2013 will accept two types of papers: - Research papers: full papers with at most 16 pages in LNCS format (pdf), which have to be original, unpublished and not submitted elsewhere. - Short contributions: work in progress, (industrial) experience reports or tool demonstrations, position statements; an extended abstract with at most 6 pages in LNCS format (pdf) is expected. Subject to final approval by Springer, accepted papers will be published in the Springer LNCS series and will be available at the conference. The contents of previous TAP proceedings is available at: http://www.informatik.uni-trier.de/~ley/db/conf/tap/ -- Dr. Achim D. Brucker, SAP AG, SAP Research Vincenz-Priessnitz-Str. 1, D-76131 Karlsruhe, Phone: +49 6227 7-52595 http://www.brucker.ch

1 0

[Off-topic] How unimportant it is whether submarines can swim (EWD1056)
by Henk-Jan van Tuyl 30 Oct '12

30 Oct '12

L.S., I thought you might be interested to know, that I have translated one of prof. Edsger W. Dijkstra's writings to English[0]. I will submit this translation to the E. W. Dijkstra Archive of the University of Texas[1]. Some of the highlights: - can submarines swim? - redefining mathematics - something unimaginably unimaginable - a baby faster than fighter jets Regards, Henk-Jan van Tuyl [0] http://members.chello.nl/hjgtuyl/computing/EWD1056.html [1] http://www.cs.utexas.edu/users/EWD/welcome.html -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

5 5

Teaching Haskell @ MOOCs like Coursera or Udacity
by niket 30 Oct '12

30 Oct '12

I am a novice in Haskell but I would love to see the gurus out here teaching Haskell on MOOCs like Coursera or Udacity. Dr Martin Odersky is doing it for Scala here: https://www.coursera.org/course/progfun I would love to see Haskell growing on such new platforms! Regards, Niket

7 9

Segment Tree based Set
by Tony Morris 30 Oct '12

30 Oct '12

Hi, I was wondering if anyone knows of a package implementing a fast lookup for an element in ranges. For example, this operation: Ord a => a -> [(a, a)] -> Bool ...can be implemented: \a rs -> let s = Set.fromList rs in a `member` s This is not particularly efficient. A segment tree seems like a more appropriate data structure to store the ranges. Does such a library exist? -- Tony Morris http://tmorris.net/

5 6

Empirically comparing strict vs. lazy evaluation
by Kristopher Micinski 30 Oct '12

30 Oct '12

Hello Haskellers! I wonder if you know of benchmarks that attempt to compare, empirically, lazy vs. eager evaluation. Pointers to papers and/or code would be most appreciated. Our group (at UMD) is working on a paper that develops some technology for lazy programs, and we would like to choose benchmarks for evaluating it that span the gamut of computations that perform well when done lazily, vs. those that do not perform as well when evaluated lazily. Then we want to look at the best case and worst case for our technology WRT laziness, and see how it stacks up. Thanks in advance for any ideas you have! Kris Micinski

1 0

ICFP 2013: Call for workshops and co-located events
by David Van Horn 29 Oct '12

29 Oct '12

CALL FOR WORKSHOP AND CO-LOCATED EVENT PROPOSALS ICFP 2013 18th ACM SIGPLAN International Conference on Functional Programming September 22 - 28, 2013 Boston, Massachusetts, USA http://icfpconference.org/icfp2013/ The 18th ACM SIGPLAN International Conference on Functional Programming will be held in Boston, Massachusetts on September 22-28, 2013. ICFP provides a forum for researchers and developers to hear about the latest work on the design, implementations, principles, and uses of functional programming. Proposals are invited for workshops (and other co-located events, such as tutorials) to be affiliated with ICFP 2013 and sponsored by SIGPLAN. These events should be more informal and focused than ICFP itself, include sessions that enable interaction among the attendees, and foster the exchange of new ideas. The preference is for one-day events, but other schedules can also be considered. The workshops are scheduled to occur on September 22-24 (the three days before ICFP) and September 28 (the day after ICFP). ---------------------------------------------------------------------- Submission details Deadline for submission: December 7, 2012 Notification of acceptance: January 7, 2013 Prospective organizers of workshops or other co-located events are invited to submit a completed workshop proposal form in plain text format to the ICFP 2013 workshop co-chairs (Patrik Jansson and Sam Tobin-Hochstadt), via email to icfp13-workshops(a)ccs.neu.edu by December 7, 2012. (For proposals of co-located events other than workshops, please fill in the workshop proposal form and just leave blank any sections that do not apply.) Please note that this is a firm deadline. Organizers will be notified if their event proposal is accepted by January 7, 2013, and if successful, depending on the event, they will be asked to produce a final report after the event has taken place that is suitable for publication in SIGPLAN Notices. The proposal form is available at: http://www.icfpconference.org/icfp2013/icfp13-workshops-form.txt Further information about SIGPLAN sponsorship is available at: http://acm.org/sigplan/sigplan_workshop_proposal.htm ---------------------------------------------------------------------- Selection committee The proposals will be evaluated by a committee comprising the following members of the ICFP 2013 organizing committee, together with the members of the SIGPLAN executive committee. Workshop Co-Chair: Patrik Jansson (Chalmers University of Technology) Workshop Co-Chair: Sam Tobin-Hochstadt (Northeastern University) General Chair : Greg Morrisset (Harvard University) Program Chair: Tarmo Uustalu (Tallinn University of Technology) ---------------------------------------------------------------------- Further information Any queries should be addressed to the workshop co-chairs (Patrik Jansson and Sam Tobin-Hochstadt), via email to icfp13-workshops(a)ccs.neu.edu

1 0

hsql-mysql encoding issues
by Johannes Waldmann 29 Oct '12

29 Oct '12

Hi. I am using hsql-(mysql-)1.8.2 When compiled with ghc-7.6, the resulting executable does not seem to be able to read strings from the DB correctly (umlauts do "vanish") while it worked with hsql-(mysql-)1.8.1 and ghc-7.4. the mysql server says (show variables) | character_set_client | latin1 | | character_set_connection | latin1 | | character_set_database | latin1 | | character_set_filesystem | binary | | character_set_results | latin1 | | character_set_server | latin1 | | character_set_system | utf8 | hsql is using type String all over the place, while it should be ByteString? Internally, Database.HSQL.Types.SqlBind uses Foreign.C.String.peekCStringLen . Did the behaviour of this function change? hsql is quite old, but so is my application. Assuming I find the time to rewrite my code (not likely) - what DB binding should I rather be using? Thanks - J.W.

3 4

foldr (.) id
by Greg Fitzgerald 29 Oct '12

29 Oct '12

Hi Haskellers, I've recently found myself using the expression: "foldr (.) id" to compose a list (or Foldable) of functions. It's especially useful when I need to map a function over the list before composing. Does this function, or the more general "foldr fmap id", defined in a library anywhere? I googled and hoogled, but no luck so far. Thanks, Greg

10 13

Maximum bipartite matching: 24 lines
by Stefan Klinger 29 Oct '12

29 Oct '12

Hello. I have written a function that calculates maximum cardinality matchings on bipartite graphs. It's only 24 lines of code. It seems (tested, not proven) to run faster, use less memory, and scale better than using MaxFlow from FGL with constant weight and additional source and sink nodes. But it's not as good as Hopcroft–Karp would be. Attached is the module MaxMatching which also contains extensive documentation of the rationale behind its design. I would hope to get any feedback on this: What do you think about the approach? Did I oversee anything? Do you know of any other purely functional solution to this problem? Just as an exmaple, run `ghci MaxMatching.lhs` and then use matching $ S.fromList [(1,'a'),(1,'b'),(2,'a'),(2,'c'),(3,'b')] to calculate a maximum cardinality matching of the graph shown below. 1---a Note the somewhat awkward type of the matching \ / function, returning a Map instead of a Set, with the X edges being backwards! / \ 2 b matching :: (Ord b, Ord a) => S.Set (a, b) -> M.Map b a \ / X On my machine, it takes less than 2s on 10k edges / \ or 225 nodes. 3 c Comments are welcome! Thank you! Stefan -- Stefan Klinger o/klettern /\/ bis zum send plaintext only - max size 32kB - no spam \ Abfallen http://stefan-klinger.de

3 3

non-uniform recursive Trie
by Kazu Yamamoto 29 Oct '12

29 Oct '12

Hello cafe, I'm now studying Trie in Okasaki's "Purely Functional Data Structure". Attached is the program in its appendix. I cannot understand how to use "empty", "look" and "bind". For instance, if I type 'look "" empty', I got an error: > look "" empty <interactive>:2:1: No instance for (FiniteMap m0 [Char]) arising from a use of `look' Possible fix: add an instance declaration for (FiniteMap m0 [Char]) In the expression: look "" empty In an equation for `it': it = look "" empty I have no idea how to determine the parameter 'm'. Suggestions would be appreciated. --Kazu {-# LANGUAGE MultiParamTypeClasses, FlexibleInstances #-} class FiniteMap m k where empty :: m k v look :: k -> m k v -> Maybe v bind :: k -> v -> m k v -> m k v data Trie m ks v = Trie (Maybe v) (m (Trie m ks v)) instance FiniteMap m k => FiniteMap (Trie (m k)) [k] where empty = Trie Nothing empty look [] (Trie b _) = b look (k:ks) (Trie _ m) = look k m >>= look ks bind [] x (Trie _ m) = Trie (Just x) m bind (k:ks) x (Trie b m) = Trie b (bind k t' m) where t = case look k m of Just a -> a Nothing -> empty t' = bind ks x t

2 2

Building all possible element combinations from N lists.
by dokondr 28 Oct '12

28 Oct '12

Hi all, I am looking for the algorithm and code better then the one I wrote (please see below) to solve the problem given in the subject. Unfortunately I finally need to implement this algorithm in Java. That's why I am not only interested in beautiful Haskell algorithms, but also in the one that I can without much pain implement in procedural PL like Java :( {-- Build all possible element combinations from N lists. Valid combination consists of k <= N elements. Where each element of a single combination is taken from one of the N lists. When building combination any list can give only one element for this combination. In other words you can not take more then one element from one and the same list when building current combination. Thus combinations between elements from the same input list are not allowed. Yet when building next combination you can use any of the lists again. Order of elements in combinaton does not matter. For example: input = [ [["a"],["b"]], [["1"],["2"]], [["<"],[">"]] ] output = [ ["a"],["b"],["1"],["2"], ["a","1"],["a","2"],["b","1"],["b","2"], ["<"],[">"], ["a","<"],["a",">"],["b","<"],["b",">"], ["1","<"],["1",">"],["2","<"],["2",">"], ["a","1","<"],["a","1",">"],["a","2","<"],["a","2",">"], ["b","1","<"],["b","1",">"],["b","2","<"],["b","2",">"] ] (see bigger example at the end of the code) Current implementation is based on the idea of using combinations accumulator. After first run accumulator contains: 1) All elements from the first two lists. These two lists are taken from the input list of lists. The elements of these first two lists are put in accumulator as is. For example: ["a"],["b"],["1"],["2"] 2) All combinations of these elements: ["a","1"],["a","2"],["b","1"],["b","2"] Note: Combinations between elements from the same input list are not allowed Next, on each run we add combinations built from accumulator elements together with next list taken from the input list of list. --} input = [ [["a"],["b"]], [["1"],["2"]], [["<"],[">"]], [["X"],["Y"]] ] addAll :: [[[a]]] -> [[a]] addAll [] = [] addAll (x:[]) = x addAll (x:y:[]) = accum x [y] addAll inp = accum (initLst inp) (restLst inp) initLst inp = fstLst ++ sndLst ++ (addLst fstLst sndLst) where fstLst = inp !! 0 sndLst = inp !! 1 restLst inp = (tail . tail) inp accum :: [[a]] -> [[[a]]] -> [[a]] accum xs (r:rs) = accum (xs ++ r ++ addLst xs r) rs accum xs _ = xs addLst :: [[a]] -> [[a]] -> [[a]] addLst (x:xs) ys = addOne x ys ++ addLst xs ys addLst _ [] = [] addLst [] _ = [] addOne :: [a] -> [[a]] -> [[a]] addOne x (y:ys) = [x ++ y] ++ addOne x ys addOne x [] = [] {-- For example: input = [ [["a"],["b"]], [["1"],["2"]], [["<"],[">"]], [["X"],["Y"]] ] output = [ ["<"],[">"], ["a"],["b"],["1"],["2"], ["a","1"],["a","2"],["b","1"],["b","2"], ["a","<"],["a",">"],["b","<"],["b",">"], ["1","<"],["1",">"],["2","<"],["2",">"], ["a","1","<"],["a","1",">"],["a","2","<"],["a","2",">"], ["b","1","<"],["b","1",">"],["b","2","<"],["b","2",">"], ["X"],["Y"], ["a","X"],["a","Y"],["b","X"],["b","Y"], ["1","X"],["1","Y"],["2","X"],["2","Y"], ["a","1","X"],["a","1","Y"],["a","2","X"],["a","2","Y"], ["b","1","X"],["b","1","Y"],["b","2","X"],["b","2","Y"], ["<","X"],["<","Y"],[">","X"],[">","Y"], ["a","<","X"],["a","<","Y"],["a",">","X"],["a",">","Y"], ["b","<","X"],["b","<","Y"],["b",">","X"],["b",">","Y"], ["1","<","X"],["1","<","Y"],["1",">","X"],["1",">","Y"], ["2","<","X"],["2","<","Y"],["2",">","X"],["2",">","Y"], ["a","1","<","X"],["a","1","<","Y"],["a","1",">","X"],["a","1",">","Y"], ["a","2","<","X"],["a","2","<","Y"],["a","2",">","X"],["a","2",">","Y"], ["b","1","<","X"],["b","1","<","Y"],["b","1",">","X"],["b","1",">","Y"], ["b","2","<","X"],["b","2","<","Y"],["b","2",">","X"],["b","2",">","Y"] ] --}

4 6

Gaussian Distribution
by Frank Recker 28 Oct '12

28 Oct '12

Hi, at work, I often need the values the cumulative distribution function of the Gaussian distribution. The code for this function in haskell, erlang and perl and the corresponding mathematical paper can be found at git://github.com/frecker/gaussian-distribution.git . Regards, Frank

1 0