- Haskell-Cafe - Haskell.org

RE: [Haskell-cafe] checking types with type families
by Simon Peyton-Jones 01 Jul '10

01 Jul '10

| Here's a concrete case I recently ran into: | | type family SomeOtherTypeFamily a | class SomeClass a where type SomeType a | instance a ~ SomeOtherTypeFamily b => SomeClass a where | type SomeType a = (b,Int) | -- (error) Not in scope: type variable `b' | | The same thing with fundeps: | | class SomeClass a b | a -> b | instance a ~ SomeOtherTypeFamily b => SomeClass a (b,Int) | -- works fine It's not the same thing at all! The code you give certainly should fail. Suppose you use fundeps thus: class C a b | a->b where op :: a -> b -> b The idiomatic way to replace this with type functions is to remove the 'b' parameter, thus: class C a where type B a op :: a -> B a -> B a Sometimes you don't want to do this. For example, you might have a bidirectional fundep. Then you can (or rather will be able to) use a superclass thus: class (B a ~ b) => C a b where type B a The superclass says that you can only instantiate this class with a second argument b that is equal to (B a). Thus you might have an instance instance C Int Bool where type B Int = Bool Meanwhile we are working hard on the new type inference engine, which will allow superclass equalities like these. Simon

1 0

dirs in Emacs/Vim in Cabal
by Chris BROWN 01 Jul '10

01 Jul '10

Dear Haskellers, I am in the process of creating a cabal HaRe and I have run into a minor problem. I have an emacs and a vim script that HaRe uses to invoke the refactorer from the two editors. In those scripts, I point HaRe to a directory containing some libraries it needs to chase the imports of the modules. Cabal installs these libraries as data files into whatever prefix the user requests at install time. However, the problem I have is that it then requires a manual user intervention to manually configure emacs/vim to point to this new directory in the 'customizable' panel of HaRe. My question is: Is it possible to allow the emacs/vim scripts that I have know where this directory is automatically? I hope someone can help, Kindest regards, Chris Brown.

2 1

functional dependencies question
by Patrick Browne 01 Jul '10

01 Jul '10

Hi, My understanding of functional dependencies is that they can be used to ensure that one type depends on another type. For example, the type of location depends could on the type of the object at that location. Consider two models 1) The location of an aircraft landing should have location of the type AirportCode, 2) The location of a car's destination should have a type CartesianCoordinate. AirportCodes should not be used as locations in 2) and CartesianCoordinates should not be used as locations in 1). Haskell class, instances, and fundeps were used to represent the above requirements. I generalized the requirement a bit, testing on a variety of types (below). Obviously, some cases are ambigous and/or conflicting and the Haskell compiler correctly flags this. Why do some cases such as 1) fail to run even if they are the only instantiation. Regards, Pat {- C:\GHC\ghc-6.8.3\bin\ghci.exe -XMultiParamTypeClasses -XFunctionalDependencies -fglasgow-exts -fallow-undecidable-instances -} class LocatedAt object location | object -> location where spatialLocation :: object -> location -- 1) Compiles but does not run instance LocatedAt Int String where spatialLocation(1)="home" -- 2) Compiles and runs OK instance LocatedAt String Int where spatialLocation("home")=1 -- 3) Compiles and runs OK, but obviously not in conjunction with 2 instance LocatedAt String String where spatialLocation("home")="home" -- 4) Compiles and runs OK instance LocatedAt Bool String where spatialLocation(True)="home" -- 5) Compiles and runs OK, but obviously not in conjunction with 2 instance LocatedAt String Bool where spatialLocation("home") = True -- 6) Not OK instance LocatedAt Float String where spatialLocation(2.3)="home" -- 7) Compiles but does not run instance LocatedAt Int Char where spatialLocation(1)='1' -- 8) Compiles and runs OK instance LocatedAt Char Int where spatialLocation('1')=1 This message has been scanned for content and viruses by the DIT Information Services E-Mail Scanning Service, and is believed to be clean. http://www.dit.ie

4 5

Newbie question about using WinGHCi
by Christopher Tauss 01 Jul '10

01 Jul '10

Hello - I just a day or so ago downloaded Hakell and am playing around with it, and I came upon this problem with WinGHCi: I am able to enter a multi-line "do" statement that works if I use brackets and semi-colon like so: Prelude> :{ Prelude| let main2 = do { Prelude| putStrLn "Please enter your name: "; Prelude| name <- getLine; Prelude| putStrLn ("Hello, " ++ name ++ ", how are you?") } Prelude| :} Prelude> main2 Please enter your name: CT Hello, CT, how are you? Prelude> Note there is no indentation. This makes sense to me because the :{ :} just take all the lines in between and make it one line. But it seems to me to be IMPOSSIBLE to input this into WinGHCi using indentation like most of the code samples seem to do. Should I just be satisfied that it works using brackets/ semi-colons? Or is there something obvious that I am missing that allows for indentation? Thanks in advance. It's issues lik this that keep me up into the depths of night. Best Regards, Chris

2 1

ANNOUNCE: HaRe, the Haskell Refactorer 0.6
by Chris BROWN 01 Jul '10

01 Jul '10

Dear Haskellers, As part of our project on Refactoring Functional Programs http://www.cs.kent.ac.uk/projects/refactor-fp/ we are pleased to announce the availability of HaRe 0.6 (also known as HaRe 28/06/2010), a snapshot of our Haskell Refactorer prototype. Apart from bug-fixes, there are major changes since HaRe 0.5 and HaRe 0.4: A number of new refactorings have been added to HaRe. Some of these include: Adding and removing fields and constructors to data-type definitions, folding and unfolding against as-patterns, merging and splitting, converting between let and where constructs, introduce pattern matching, generative folding, and a clone detection and elimination tool. We have evolved the ongoing architecture of HaRe and derived an API (documented using Haddock) for program analysis and transformation. This allows HaRe to serve as a framework for end-users to build their own refactorings or just program transformations (or analyses). HaRe is available to download directly from here: http://www.cs.kent.ac.uk/projects/refactor-fp/hare/HaRe_28062010.tar.gz You can get HaRe 0.6 and the documentation about how to build your own refactorings via: http://www.cs.kent.ac.uk/projects/refactor-fp/hare.html Please see the README.txt for build/use instructions and known issues, and let us know about any problems, bugs, suggestions or additional platforms you can confirm as working. You will need: 1. ghc-6.12.1 2. hint-0.3.2.3 (available from cabal) 3. unix/gnu tools (or cygwin tools, if on windows) 4. vim or emacs (we've tested with gvim 6.2 and with emacs 21.4) 5. If you intend on running the test suite, HUnit-1.0. Happy Refactoring! The HaRe Team (Chris Brown, Huiqing Li, Simon Thompson) Project email: refactor-fp at kent.ac.uk<http://www.haskell.org/mailman/listinfo/haskell> Background: Refactoring is the process of changing the structure of programs without changing their functionality, i.e., refactorings are meaning-preserving program transformations that implement design changes. For more details about refactoring, about our project and for background on HaRe, see our project pages. HaRe - the Haskell Refactorer: HaRe is our prototype tool supporting a collection of refactorings for Haskell 98 (see README.txt for known issues and limitations). It is implemented as a separate refactoring engine (on top of Programatica's Haskell frontend and Strafunski's generic traversal strategy library), with small scripting frontends that call this engine from either Vim or Emacs. Currently supported refactorings: Introduce Pattern Match : place cursor over pattern variable Introduce Sub pattern : place cursor over pattern variable Introduce Case Expression : place cursor over pattern variable Generative Fold : highlight expression to fold. Must have equation in comment directly before definition of highlighted expression. Clone Analysis : select from menu Clone Extraction : highlight clone from the clone class to extract, follow step-by-step instructions. Converting Let to Where : place cursor at start of identifier whose definition is to be moved Converting Where to Let : place cursor at start of identifier whose definition is to be moved. create type signatures : select from menu remove redundant declarations : highlight definition to clean up add constructor to data type : place cursor at start of data type, you'll be prompted to add the new Constructor name, followed by any Type parameters as a complete string Split a tuple : place cursor at start of top level definition that returns a tuple. Slicing based on a subexpression : highlight sub-expression to extract. Instantiate a general pattern : select a function equation and enter the new instances for each pattern in the argument set. Extract an expression : highlight an expression within a definition Convert data type to newtype : place cursor at start of data type add definition to merge : place cursor at start of definition that is to be merged merge definitions : use "add definition for merge" for each definition to be merged. then choose merge definitions from menu. fold function definition : highlight function equation to fold against. fold constant definition : highlight constant equation to fold against. convert pattern to an as pattern : highlight pattern to convert. unfold references to as patterns : place cursor over as pattern name. remove field from a data type : place cursor at start of field to remove. add field to data type : place cursor over start of constructor. enter new field name. add debug information : add trace calls to function by placing cursor at the start of the function to trace rename : place cursor at start of identifier to be renamed, you'll be prompted for a new name Lift def to top level : place cursor at start of identifier whose definition is to be moved Lift def one level : place cursor at start of identifier whose definition is to be moved Demote : place cursor at start of identifier whose definition is to be moved Introduce new def : highlight expression to be named, you'll be prompted for a new name Unfold def : place cursor at start of identifier where its definition is to be unfolded Generalise def : place cursor at start of identifier where its definition is to be unfolded Remove def : place cursor at start of identifier whose definition is to be removed Duplicate def : place cursor at start of identifier whose definition is to be duplicated, you'll be prompted for a new name Add one parameter : place cursor at start of identifier whose definition is to be modified, you'll be prompted for a new name rm one parameter : place cursor in formal parameter which is to be removed Move def to another module : place cursor at start of the identifier whose definition is to be moved, you'll be prompted for the module name Clean imports : cursor position does not matter, just choose the command from the refactor menu Make import explicit : place cursor at the start of the module name in the import declaration Add to export : place cursor at start of the identifier which is to be added to the export Remove from export : place cursor at start of the entry to be removed in the export list From concrete to abstract data type: place cursor at start of the data type name Add field names : place cursor at start of the data type name Add discriminators : place cursor at start of the data type name Add constructors : place cursor at start of the data type name Eliminate nested patterns : place cursor at start of the data type name Eliminate patterns : place cursor at start of the data type name Create an ADT module : place cursor at start of the data type name Eliminate intermediate list: cursor position does not matter, just choose the command from the menu. Caveats (see also README.txt): Please keep in mind that this is a prototype, so we do not recommend to use it on your productions sources just yet. Just play with it to get an idea of tool-supported refactoring in Haskell, and send us your feedback and bug-reports. Our goal is to develop this into a tool that many of you will find indispensable for Haskell development. Regards, The HaRe team.

4 11

zlib or digest package installation
by Daniel Kahlenberg 30 Jun '10

30 Jun '10

Hi, when installing pandoc package, which has digest somewhere in dependencies the usual cabal install stucks because zlib.h is missing, so I explicitly installed zlib package first, then installing digest (can also replace that directly with pandoc here) with the --extra-include-dirs parameter set: Prelude System.Cmd> > rawSystem "cabal" ["install", "digest", "-v3", "--user", "-- > build-log=d:/temp/log/build-$$pkgid-$$compiler-msys.log", "--reinstall", "--data > dir=$$prefix/haskell-pkgdata", "--extra-include-dirs=C:\\Users\\daniel\\AppData\ > \Roaming\\cabal\\zlib-0.5.2.0\\ghc-6.12.1\\include"] Is there something to improve in one of the packages cabal file to overcome the need to explicitly specify the header file locations of already installed packages or is that a consequence of not installing them as developer packages simply, so i. e. to have the header file zlib.h at the specified location is more a bonus to have in that situation? Greetz Daniel

3 2

Haskell Bangalore
by C K Kashyap 30 Jun '10

30 Jun '10

Hi, I was wondering if it would be a good idea for the folks interested in Haskell in Bangalore to get together. Especially if there are folks at EGL, perhaps we could just meet up at pyramid. I've been trying to learn Haskell for a while and currently am trying to work through SPJ's "implementation of Functional Programming languages". It would be good to bounce off ideas (in person) with like minded folks. -- Regards, Kashyap

4 3

Kate: Haskell and Literate Haskell syntax files
by Nicolas Wu 30 Jun '10

30 Jun '10

Dear all, I've just finished implementing a complete rewrite of the Haskell and Literate Haskell files for Kate. This improves the previous version in many ways: * Operators are now supported (++, !, >>=, and any other combination of legal operator characters) * Special symbols are recognised (=>, <-, ->, ::, ..) * Unicode support for →, ←, ∷, ‥,⇒, ∀, ∃ * Support for qualified module functions (List.sort, etc) * Support for qualified module types * Refactored Literate Haskell using IncludeRules * Support for literate code (using > and \begin{code} \end{code}) * Support for literate specifications (using < and \begin{spec} \end{spec}) You can find the most recent snapshot in my github repository [1], and examples of highlighted syntax using these files at my website [2]. Please let me know if there are any further improvements you can think of, Nick [1] http://github.com/zenzike/kate-haskell [2] http://zenzike.com

1 0

Re: [Haskell] Second draft of the Haskell 2010 report available
by Henk-Jan van Tuyl 30 Jun '10

30 Jun '10

On Tue, 29 Jun 2010 17:01:54 +0200, Simon Marlow <marlowsd(a)gmail.com> wrote: > Comments on the draft report are welcome, before I finalise this and > sign off on Haskell 2010. Subsection 12.3, "Language extensions", mentions the FFI as a language extension, but FFI is now part of the standerd; the same goes for the "extensions" mentioned at the end of the subsection. Regards, Henk-Jan van Tuyl -- http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html --

2 1

whine and solution about programmers not respecting documentations
by Albert Y.C.Lai 30 Jun '10

30 Jun '10

Some docs are in a miserable state of being incomplete. And then some programmers are in a miserable state of not respecting docs when the docs are complete. Why should anyone expect deleteBy (>=) 5 [0..10] to accomplish anything meaningful, if he/she respects the written docs? Today someone on #haskell expected it to accomplish something meaningful, even something mind-reading. The said person has been around for more than a year, not eligible for the "newbie" excuse. The said person is just the tip of an iceberg. The doc of deleteBy states: "The deleteBy function behaves like delete, but takes a user-supplied equality predicate." A precondition is that the user-supplied predicate is an equality predicate. (>=) is not an equality predicate, be it in the layperson sense of "it isn't analogous to (==)" or the mathematical sense of "it isn't an equivalence relation". If you respect the precondition or the authors of the doc, you should just never use deleteBy (>=) 5 [0..10], much less expect any meaningful result. I propose this solution: For each of deleteBy, groupBy, unionBy... we can usually conceive at least two implementations, behaving pretty much the same (answer, speed, space) when given an equivalence relation (modulo some rare concern when the equivalence relation has assymetric strictness properties), but behaving different when not, and their code sizes are pretty much the same. With more imagination and allowing some code bloat, perhaps we can conceieve more implementations. But two suffices, really. I propose that at each minor version of base, someone picks an implementation randomly. Here is a more radical, less labour-intensive solution, if you don't mind a judicious, correctness-preserving use of unsafePerformIO: at the first invocation of the process lifetime, pick an implementation randomly. The result frustrates people who disrespect the docs. My purpose is exactly that. The goal is to give people an incentive to not disrepect the docs. (If you think this is a nasty "stick, not carrot" incentive, on first thought I would agree. On second thought, it is not adding a stick, it is just removing a carrot. Programmer's carrot means his/her code "works" consistently. When deleteBy (>=) "works" consistently, you are giving out undeserved free carrots --- incentive to write more wrong code. I am proposing to remove undeserved free carrots.)

12 22

Call for comments: neither package
by Michael Snoyman 30 Jun '10

30 Jun '10

Hi all, I'll admit, the original idea for this package was something to place in ACME ;). However, it's goal is to solve a real problem: the lack of good instances on the Either type. As a brief summary, Either has no Applicative or Monad instances in the base library, has 2 reasonable definitions for Applicative, and there are conflicting orphan instances in the mtl and transformers packages. Also, the ErrorT transformer in those two packages introduces a superclass constraint many people would like to avoid. neither supplies three datatypes: AEither, MEither and MEitherT. AEither provides the Monoid version of the Applicative instance, MEither is the monadic version, and MEitherT is a monad transformer. The package provides instances for both the transformers and mtl libraries for MonadTrans, MonadIO and MonadCatchIO. The code is up on github[1], let me know what you think. Michael [1] http://github.com/snoyberg/neither

6 8

specifying package name in ghci import?
by Michael Vanier 29 Jun '10

29 Jun '10

Hi, Quick question about ghci: when I do this at the prompt: ghci> :m +Control.Monad.Cont I get Ambiguous module name `Control.Monad.Cont': it was found in multiple packages: mtl-1.1.0.2 monads-fd-0.0.0.1 Is there any way to fix this from within ghci (i.e. not involving mucking with ghc-pkg)? What I have in mind might be e.g. ghci> :m + "mtl" Control.Monad.Cont or something similar. Thanks, Mike

2 1

Re: [Haskell-cafe] Call for comments: neither package
by Antoine Latter 29 Jun '10

29 Jun '10

It looks like good work, but I would be hesitent about depending on a package which pulled in both mtl and tranformers. Maybe that's just superstition - I haven't tried it. Antoine On Jun 28, 2010 5:51 PM, "Michael Snoyman" <michael(a)snoyman.com> wrote: Hi all, I'll admit, the original idea for this package was something to place in ACME ;). However, it's goal is to solve a real problem: the lack of good instances on the Either type. As a brief summary, Either has no Applicative or Monad instances in the base library, has 2 reasonable definitions for Applicative, and there are conflicting orphan instances in the mtl and transformers packages. Also, the ErrorT transformer in those two packages introduces a superclass constraint many people would like to avoid. neither supplies three datatypes: AEither, MEither and MEitherT. AEither provides the Monoid version of the Applicative instance, MEither is the monadic version, and MEitherT is a monad transformer. The package provides instances for both the transformers and mtl libraries for MonadTrans, MonadIO and MonadCatchIO. The code is up on github[1], let me know what you think. Michael [1] http://github.com/snoyberg/neither _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe(a)haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe

3 4

MonadCatchIO and bracket.
by Carl Howells 29 Jun '10

29 Jun '10

While working this weekend on the Snap web framework, I ran into a problem. Snap implements MonadCatchIO, so I thought I could just use bracket to handle resource acquisition/release in a safe manner. Imagine my surprise when bracket simply failed to run the release action sometimes. I quickly determined the times when it doesn't run are when Snap's monadic short-circuiting is used. I dug into the source of bracket (in the transformers branch, though the mtl branch has the same behavior in these cases, with slightly different code), and the reason why quickly became obvious: -- | Generalized version of 'E.bracket' bracket :: MonadCatchIO m => m a -> (a -> m b) -> (a -> m c) -> m c bracket before after thing = block $ do a <- before r <- unblock (thing a) `onException` after a _ <- after a return r When monadic short-circuiting applies, the "_ <- after a" line gets completely ignored. In discussions with #haskell on this topic, it quickly became clear that for any monad transformer that can affect control flow, the definition of bracket in MonadCatchIO doesn't keep the guarantee provided by bracket in Control.Exception, which is that the "after" action will be run exactly once. Because of that, I think bracket needs to be a class function. Furthermore, I think it needs to be a new class, ie class MonadCatchIO m => MonadBracketIO m where bracket :: m a -> (a -> m b) -> (a -> m c) -> m c This would allow its definition in cases where it makes sense (Snap or MaybeT IO), but it could be left out in cases where it doesn't make sense, like ListT IO, even though MonadCatchIO makes sense there. Carl Howells

4 3

Physical equality
by José Romildo Malaquias 29 Jun '10

29 Jun '10

Is there in Haskell a non monadic function of type a -> a -> Bool which test for physical equality of two values? It would return True if only if both values are the same object in memory. For instance: value1 = "good" value2 = "good" eq value1 value2 => False value1 = "good" value2 = value1 eq value1 value2 => True Romildo

5 4

Space leak with unsafePerformIO
by Henning Thielemann 29 Jun '10

29 Jun '10

Attached is a program with a space leak that I do not understand. I have coded a simple 'map' function, once using unsafePerformIO and once without. UnsafePerformIO has a space leak in some circumstances. In the main program I demonstrate cases with and without space leak. Without space leak the program writes a file to the disk until it is full. Any idea? The original problem is a function that is compiled by LLVM and shall be applied to a list in a mapAccumL manner.

2 3

Construction of short vectors
by Alexey Khudyakov 28 Jun '10

28 Jun '10

Hello, cafe I have question about vector package. Currently I'm playing with data types which are isomorphic to vectors of fixed length. Think about vector in N-dimensional space, list of parameters to function R^n → R, set of measurements with uncertainties, etc. They have different semantics but exactly the same representation and it's often advantageous to think about them as N-dimensional vectors. Then constructor like one below arise naturally. And I don't know how to write them properly. It's possible to use fromList but then list could be allocated which is obviously wasteful. > vector2 :: Double -> Double -> Vec2D > vector2 x y = ... > -- Vec2D is some wrapper around Vector data type Another question is there any specific problems with short vectors? They could be just 2 elements long. I mean performance problems

5 8

Why this doesn't type checked
by Victor Nazarov 28 Jun '10

28 Jun '10

I've allways found code like > -- maxBound (undefined :: Int) a bit strange as any usage of undefined is. Being Ruby on Rails developer I've personally found that one of the main Rails motos is being as readable as possible. Code must be as close to english as possible. Embeded DSLs like rspec are made mostly to made specs as close to english as possible. Having this in my mind I've decided that this code should be rewritten without undefined being mentioned. But I need some type signature and it should mention Int type. So I've got an idea about what I've called "fantom type functions". So wee need type families for it to work. > {-# LANGUAGE TypeFamilies #-} > module Main where > > import Data.Word I want the code I've mentioned to be rewrited as something like > -- maxBound :: MaxBoundOf Int As it is much more readable: "I want maxBound with the type of MaxBound Of Int". So here is the implementation of class Sizeable that implements sizeof operation. Which is type-indexed like maxBound is. sizeof returns number of bytes that occupy type when serialized to some binary stream. > class Sizeable sizeable > where type Sizeof sizeable > sizeof :: Sizeof sizeable We should like to make a default type but GHC still doesn't support it. > -- type Sizeof sizeable = Int Instances for all basic types > instance Sizeable Int > where sizeof = 4 Even without defaults we get type safety in these instances > type Sizeof Int = Int > instance Sizeable Word8 > where sizeof = 1 > type Sizeof Word8 = Int > > instance Sizeable Word16 > where sizeof = 2 > type Sizeof Word16 = Int > > instance Sizeable Word32 > where sizeof = 4 > type Sizeof Word32 = Int > > instance Sizeable Word64 > where sizeof = 8 > type Sizeof Word64 = Int The annoyance is the need to instantiate Sizeof type family every time. It will disappear once associated types' defaults will be implemented in GHC. What we get with this instances is following code. > main = > do print (sizeof :: Sizeof Word16) Let's try it. $ runhaskell this.lhs this.lhs:78:14: Couldn't match expected type `Int' against inferred type `Sizeof sizeable' NB: `Sizeof' is a type function, and may not be injective In the first argument of `print', namely `(sizeof :: Sizeof Word16)' In the expression: print (sizeof :: Sizeof Word16) In the expression: do { print (sizeof :: Sizeof Word16) } What can I do with this code to make it type-check? -- Victor Nazarov

5 5

building a patched ghc
by braver 28 Jun '10

28 Jun '10

How do I get the latest 6.12 source and cherry-pick selected patches from the trunk, e.g. Simon's GC fixes? The wiki says that you get the head with darcs get --lazy http://darcs.haskell.org/ghc and the 6.12 with darcs get --lazy http://darcs.haskell.org/ghc-6.12/ghc Since the trunk is big enough, I wonder if 6.12 a subset of it and can be obtained from it? The tags are not informative. If I get the branch, how will I be able to get the patches from the head, once they're separate repos? -- Alexy

2 2

The mother of all functors/monads/categories
by Max Bolingbroke 28 Jun '10

28 Jun '10

I'm wondering if someone can cast some light on a pattern I've come across, which I'm calling the "mother of all X" pattern after Dan Piponi's blog post (http://blog.sigfpe.com/2008/12/mother-of-all-monads.html) Edward Kmett has also explored these ideas here: http://www.mail-archive.com/haskell-cafe@haskell.org/msg57738.html Preliminaries === Q: What is the "mother of all X", where X is some type class? A: It is a data type D such that: 1. There exist total functions: > lift :: X d => d a -> D a > lower :: X d => D a -> d a 2. And you can write a valid instance: > instance X D With *no superclass constraints*. 3. (We may also add the constraint that D is somehow the "smallest such" data type, but I don't know in exactly what sense I mean this). So the "mother of all X" is a data type that somehow encodes all of the functions that the X type class gives you. An example is in order! Example 1: Yoneda is the mother of all Functors === The code in this example and the next one is shamelessly stolen from the category-extras package (thanks Edward!). Here is the data type: > -- flip fmap :: forall a. f a -> (forall b. (a -> b) -> f b) > newtype Yoneda f a = Yoneda { runYoneda :: forall b. (a -> b) -> f b } And the injections. As it turns out, we don't need the Functor constraint on the lowerYoneda call: > liftYoneda :: Functor f => f a -> Yoneda f a > liftYoneda f = Yoneda (flip fmap f) > > lowerYoneda :: Yoneda f a -> f a > lowerYoneda f = runYoneda f id Finally, we can write the Functor instance. Notice that we don't need to make use of the Functor instance for f: all of the methods of Functor f have been somehow encoded into the Yoneda data type! > instance Functor (Yoneda f) where > fmap f m = Yoneda (\k -> runYoneda m (k . f)) Note that we can also write an instance (Y f => Y (Yoneda f)) for any Functor subclass Y. But (Yoneda f) is not the mother of all Y, because we will need the Y f constraint to do so. Here is an example: > instance Applicative f => Applicative (Yoneda f) where > pure = liftYoneda . pure > mf <*> mx = liftYoneda (lowerYoneda mf <*> lowerYoneda mx) Why is (Yoneda f) interesting? Because if I take some expression whose type is quantified over any superclass of Functor, and we want to run it with Functor instantiated to some F, if we instead run it with Functor instantiated to (Yoneda f) and then use lowerYoneda, we will automatically get guaranteed fmap fusion. Example 2: Codensity is the mother of all Monads === Data type: > -- (>>=) :: forall a. m a -> (forall b. (a -> m b) -> m b) > newtype Codensity m a = Codensity { runCodensity :: forall b. (a -> m b) -> m b } Isomorphism. We need Monad constraints on both ends now: > liftCodensity :: Monad m => m a -> Codensity m a > liftCodensity m = Codensity ((>>=) m) > > lowerCodensity :: Monad m => Codensity m a -> m a > lowerCodensity m = runCodensity m return Instances: > instance Functor (Codensity f) where > fmap f m = Codensity (\k -> runCodensity m (k . f)) > > instance Applicative (Codensity f) where > pure x = Codensity (\k -> k x) > mf <*> mx = Codensity (\k -> runCodensity mf (\f -> runCodensity mx (\x -> k (f x)))) > > instance Monad (Codensity f) where > return = pure > m >>= k = Codensity (\c -> runCodensity m (\a -> runCodensity (k a) c)) Again, using (Codensity m) where you used m before can yield a performance improvement, notably in the case of free monads. See http://haskell.org/haskellwiki/Performance/Monads or http://wwwtcs.inf.tu-dresden.de/~voigt/mpc08.pdf. Example 3: Wotsit is the mother of all Categories === I don't actually know what the right name for this data type is, I just invented it and it seems to work: > -- (>>>) :: forall a b. t a b -> (forall c. t b c -> t a c) > newtype Wotsit t a b = Wotsit { runWotsit :: forall c. t b c -> t a c } Isomorphism: > liftWotsit :: Category t => t a b -> Wotsit t a b > liftWotsit t = Wotsit ((>>>) t) > > lowerWotsit :: Category t => Wotsit t a b -> t a b > lowerWotsit t = runWotsit t id And finally the instance: > instance Category (Wotsit t) where > id = Wotsit id > t1 . t2 = Wotsit (runWotsit t2 . runWotsit t1) This is *strongly* reminiscent of normalisation-by-evaluation for monoids (reassociation realised by assocativity of function application), which is not surprising because Category is just a monoid. There is probably some connection between NBE and Yoneda (e.g. "Normalization and the Yoneda embedding", but I can't get access to this paper electronically). Conclusion === So I have a lot of questions about this stuff: 1. Is there a way to mechanically derive the "mother of all X" from the signature of X? Are these all instances of a single categorical framework? 2. Is there a mother of all idioms? By analogy with the previous three examples, I tried this: > -- (<**>) :: forall a. i a -> (forall b. i (a -> b) -> i b) > newtype Thingy i a = Thingy { runThingy :: forall b. i (a -> b) -> i b } But I can't see how to write either pure or <*> with that data type. This version seems to work slightly better: > newtype Thingy i a = Thingy { runThingy :: forall b. Yoneda i (a -> b) -> i b } Because you can write pure (pure x = Thingy (\k -> lowerYoneda (fmap ($ x) k))). But <*> still eludes me! 3. Since (Codensity m) enforces >>= associativity, perhaps it can be used to define correct-by-construction monads in the style of operational or MonadPrompt? Any insight offered would be much appreciated :-) Cheers, Max

8 17

ANN: bitspeak 0.0.1
by Maurício CA 28 Jun '10

28 Jun '10

Hi, all, bitspeak is a small proof of concept application that allows writing text using only two commands (yes/no, 1/2, top/down etc.). It is intended to show how people with disabilities similar to Stephen Hawking's (i.e., good cognitive hability, but very few movements) can write text. http://hackage.haskell.org/package/bitspeak http://bitbucket.org/mauricio/bitspeak/wiki/Home Best, Maurício

15 19

A little jewel on sigfpe's blog
by Günther Schmidt 27 Jun '10

27 Jun '10

Hello, I just discovered this little jewel on Dan Piponi's blog. http://blog.sigfpe.com/2010/03/partial-ordering-of-some-category.html I'm just posting the link so that it doesn't get overlooked, would be a real shame. Günther

1 0

Core packages and locale support
by Roman Cheplyaka 27 Jun '10

27 Jun '10

While ghc 6.12 finally has proper locale support, core packages (such as unix) still use withCString and therefore work incorrectly when argument (e.g. file path) is not ASCII. Is someone already working on this? If it's just a matter of time and manpower I can help but I need some guidance from authority. -- Roman I. Cheplyaka :: http://ro-che.info/ "Don't let school get in the way of your education." - Mark Twain

7 36

Emacs script to align Haskell import list
by Christopher Done 26 Jun '10

26 Jun '10

I whipped up a little Emacs script to align the import lines in the current buffer. I am using it in my projects and have experienced no problems. It's good at keeping within 80 columns. http://gist.github.com/453933 I've pasted it as a gist on Github so that anyone can edit it, gists also provide a simple revision history and comment support. Please feel free to contribute some tweaks and fixes. I'll then see about merging this into haskell-mode in some fashion. It doesn't handle multiple line explicit imports as I have a personal rule that any explicit import list with more than a few symbols should be changed to an "as X" import, as an addition to tibbe's style guide.[1] I haven't decided on a recommended keybinding. I'm considering a context-dependent binding of C-c C-. that indents the import list when you are on an import line. [1]: http://github.com/tibbe/haskell-style-guide

1 1

Re: [Haskell-cafe] Huffman Codes in Haskell
by John Lato 26 Jun '10

26 Jun '10

> From: Max Rabkin <max.rabkin(a)gmail.com> > > This seems like an example of list-chauvinism -- what Chris Okasaki > calls a communal blind spot of the FP community in Breadth-First > Numbering: Lessons from a Small Exercise in Algorithm Design -- > http://www.eecs.usma.edu/webs/people/okasaki/icfp00.ps > Thanks for sharing; this was an interesting (and short!) read. I would like to see other Haskeller's responses to this problem. I'll restate it here hoping to get replies from those who haven't read the paper yet: Assume you have a type of labeled binary trees: data Tree a = E | T a (Tree a) (Tree a) and you are to produce a function bfnum :: Tree a -> Tree Int that performs a breadth-first numbering of the tree (starting with 1), preserving the tree structure. How would you implement bfnum? (If you've already read the paper, what was your first answer?) For the record, my solution doesn't rely on any other data structures or laziness AFAICT, and I think it would fit into the Level-Oriented category of solutions. John

6 9

Haskell Web Framework for newbies?
by Giuseppe Luigi Punzi 26 Jun '10

26 Jun '10

Hi all, At the moment, I'm learning haskell and I would like to use the things I'm learning under web. I would like to mount a local web server, but I would like to test some things in my VPS in 1&1 with CentOs 5, but this, in a near future. For the moment, my doubt is, wich is the haskell web framework more easy to learn for newbies? Cheers.

1 0

Re: [Haskell-cafe] Manual Type-Checking to provide Read instances for GADTs. (was Re: [Haskell-cafe] Read instance for GATD)
by Edward Kmett 26 Jun '10

26 Jun '10

I've obtained permission to repost Gershom's slides on how to deserialize GADTs by typechecking them yourself, which are actually a literate haskell source file, that he was rendering to slides. Consequently, I've just pasted the content below as a literate email. -Edward Kmett - Deserializing strongly typed values (four easy pieces about typechecking) Gershom Bazerman - prior art: Oleg (of course) http://okmij.org/ftp/tagless-final/course/course.html ...but also Stephanie Weirich http://www.comlab.ox.ac.uk/projects/gip/school/tc.hs = Ahem... \begin{code} {-# LANGUAGE DeriveDataTypeable, ExistentialQuantification, FlexibleContexts, FlexibleInstances, FunctionalDependencies, GADTs, RankNTypes, ScopedTypeVariables #-} \end{code} = ahem. \begin{code} import Data.Typeable import Data.Maybe import Control.Monad.Error import Control.Applicative import qualified Data.Map as M import Unsafe.Coerce \end{code} = A simple ADT. \begin{code} data SimpleExpr = SOpBi String SimpleExpr SimpleExpr | SOpUn String SimpleExpr | SDbl Double | SBool Bool deriving (Read, Show, Typeable) \end{code} Yawn. = An awesome GADT! \begin{code} data Expr a where EDbl :: Double -> Expr Double EBool :: Bool -> Expr Bool EBoolOpBi :: BoolOpBi -> Expr Bool -> Expr Bool -> Expr Bool ENumOpBi :: NumOpBi -> Expr Double -> Expr Double -> Expr Double ENumOpUn :: NumOpUn -> Expr Double -> Expr Double deriving Typeable data NumOpBi = Add | Sub deriving (Eq, Show) data NumOpUn = Log | Exp deriving (Eq, Show) data BoolOpBi = And | Or deriving (Eq, Show) \end{code} The GADT is well typed. It cannot go wrong. - It also cannot derive show. = But we can write show... \begin{code} showIt :: Expr a -> String showIt (EDbl d) = show d showIt (EBool b) = show b showIt (EBoolOpBi op x y) = "(" ++ show op ++ " " ++ showIt x ++ " " ++ showIt y ++ ")" showIt (ENumOpBi op x y) = "(" ++ show op ++ " " ++ showIt x ++ " " ++ showIt y ++ ")" showIt (ENumOpUn op x) = show op ++ "(" ++ showIt x ++ ")" \end{code} = And eval is *much nicer*. It cannot go wrong --> no runtime typechecks. \begin{code} evalIt :: Expr a -> a evalIt (EDbl x) = x evalIt (EBool x) = x evalIt (EBoolOpBi op expr1 expr2) | op == And = evalIt expr1 && evalIt expr2 | op == Or = evalIt expr2 || evalIt expr2 evalIt (ENumOpBi op expr1 expr2) | op == Add = evalIt expr1 + evalIt expr2 | op == Sub = evalIt expr1 - evalIt expr2 \end{code} = But how do we write read!? read "EBool False" = Expr Bool read "EDbl 12" = Expr Double The type being read depends on the content of the string. Even worse, we want to read not from a string that looks obvious to Haskell (i.e. a standard showlike instance) but from something that looks pretty to the user -- we want to *parse*. So we parse into our simple ADT. Then we turn our simple ADT into our nice GADT. - But how? How do we go from untyped... to typed? [And in general -- not just into an arbitrary GADT, but an arbitrary inhabitant of a typeclass.] [i.e. tagless final, etc] = Take 1: Even if we do not know what type we are creating, we eventually will do something with it. So we paramaterize our typechecking function over an arbitrary continuation. \begin{code} mkExpr :: (forall a. (Show a, Typeable a) => Expr a -> r) -> SimpleExpr -> r mkExpr k expr = case expr of SDbl d -> k $ EDbl d SBool b -> k $ EBool b SOpUn op expr1 -> case op of "log" -> k $ mkExpr' (ENumOpUn Log) expr1 "exp" -> k $ mkExpr' (ENumOpUn Exp) expr1 _ -> error "bad unary op" SOpBi op expr1 expr2 -> case op of "add" -> k $ mkExprBi (ENumOpBi Add) expr1 expr2 "sub" -> k $ mkExprBi (ENumOpBi Sub) expr1 expr2 \end{code} = Where's the typechecking? \begin{code} mkExpr' k expr = mkExpr (appCast $ k) expr mkExprBi k expr1 expr2 = mkExpr' (mkExpr' k expr1) expr2 appCast :: forall a b c r. (Typeable a, Typeable b) => (c a -> r) -> c b -> r appCast f x = maybe err f $ gcast x where err = error $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} ... We let Haskell do all the work! = Hmmm... the continuation can be anything. So let's just make it an existential constructor. \begin{code} data ExprBox = forall a. Typeable a => ExprBox (Expr a) appExprBox :: (forall a. Expr a -> res) -> ExprBox -> res appExprBox f (ExprBox x) = f x tcCast :: forall a b c. (Typeable a, Typeable b) => Expr a -> Either String (Expr b) tcCast x = maybe err Right $ gcast x where err = Left $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} Now we can delay deciding what to apply until later. Typecheck once, execute repeatedly! = One more trick -- monadic notation lets us extend the context of unpacked existentials to the end of the do block \begin{code} retBox x = return (ExprBox $ x, typeOf x) typeCheck :: SimpleExpr -> Either String (ExprBox, TypeRep) typeCheck (SDbl d) = retBox (EDbl d) typeCheck (SBool b) = retBox (EBool b) typeCheck (SOpBi op s1 s2) = case op of "add" -> tcBiOp (ENumOpBi Add) "sub" -> tcBiOp (ENumOpBi Sub) "and" -> tcBiOp (EBoolOpBi And) "or" -> tcBiOp (EBoolOpBi Or) where tcBiOp constr = do (ExprBox e1, _) <- typeCheck s1 (ExprBox e2, _) <- typeCheck s2 e1' <- tcCast e1 e2' <- tcCast e2 retBox $ constr e1' e2' \end{code} = So that's fine for *very* simple expressions. How does it work for interesting GADTs? (like, for example, HOAS)? (The prior art doesn't demonstrate HOAS -- it uses DeBruijn.) = Our simple world \begin{code} type Ident = String type TypeStr = String data STerm = SNum Double | SApp STerm STerm | SVar Ident | SLam Ident TypeRep STerm \end{code} Note.. terms are Church style -- each var introduced has a definite type. Determining this type is left as an exercise. = Over the rainbow in well-typed land. \begin{code} data Term a where TNum :: Double -> Term Double TApp :: Term (a -> b) -> Term a -> Term b TLam :: Typeable a => (Term a -> Term b) -> Term (a -> b) TVar :: Typeable a => Int -> Term a deriving Typeable \end{code} Wait! DeBrujin (TVar) *and* HOAS (TLam)! The worst of both worlds. Don't worry. In the final product all TVars are eliminated by construction. Exercise to audience: rewrite the code so that TVar can be eliminated from the Term type. = Show and eval... \begin{code} showT :: Int -> Term a -> String showT c (TNum d) = show d showT c (TApp f x) = "App (" ++ showT c f ++ ") (" ++ showT c x ++ ")" showT c (TLam f) = "Lam " ++ ("a"++show c) ++ " -> " ++ (showT (succ c) $ f (TVar c)) showT c (TVar i) = "a"++show i runT :: Term a -> Term a runT (TNum d) = (TNum d) runT (TLam f) = (TLam f) runT (TApp f x) = case runT f of TLam f' -> runT (f' x) runT (TVar i) = error (show i) \end{code} = The existential \begin{code} data TermBox = forall a. Typeable a => TermBox (Term a) appTermBox :: (forall a. Typeable a => Term a -> res) -> TermBox -> res appTermBox f (TermBox x) = f x \end{code} = The typechecker returns a box *and* a typeRep. Cast is the usual trick. \begin{code} retTBox :: Typeable a => Term a -> Either String (TermBox, TypeRep) retTBox x = return (TermBox $ x, typeOf x) type Env = M.Map Ident (TermBox, TypeRep) trmCast :: forall a b c. (Typeable a, Typeable b) => Term a -> Either String (Term b) trmCast x = maybe err Right $ gcast x where err = Left $ "Type error. Expected: " ++ show (typeOf (undefined::a)) ++ ", Inferred: " ++ show (typeOf (undefined::b)) \end{code} = \begin{code} typeCheck' :: STerm -> Env -> Either String (TermBox, TypeRep) typeCheck' t env = go t env 0 where go (SNum d) _ idx = retTBox (TNum d) go (SVar i) env idx = do (TermBox t, _) <- maybe (fail $ "not in scope: " ++ i) return $ M.lookup i env retTBox $ t \end{code} Nums and vars are easy. = App and Lam... less so. \begin{code} go (SApp s1 s2) env idx = do (TermBox e1, tr1) <- go s1 env idx (TermBox e2, _) <- go s2 env idx TermBox rt <- return $ mkTerm $ head $ tail $ typeRepArgs $ head $ typeRepArgs $ tr1 -- TypeReps have their... drawbacks. e1' <- trmCast e1 retTBox $ TApp e1' e2 `asTypeOf` rt go (SLam i tr s) env idx = do TermBox et <- return $ mkTerm tr (TermBox e, _) <- go s (M.insert i (TermBox (TVar idx `asTypeOf` et),tr) env ) (idx + 1) retTBox $ TLam (\x -> subst (x `asTypeOf` et) idx e) \end{code} = How does mkTerm work? \begin{code} mkTerm :: TypeRep -> TermBox mkTerm tr = go tr TermBox where go :: TypeRep -> (forall a. (Typeable a) => Term a -> res) -> res go tr k | tr == typeOf (0::Double) = k (TNum 0) | typeRepTyCon tr == arrCon = go (head $ typeRepArgs tr) $ \xt -> go (head $ tail $ typeRepArgs tr) $ \y -> k (TLam $ \x -> const y (x `asTypeOf` xt)) arrCon = typeRepTyCon $ typeOf (undefined::Int -> String) \end{code} Same principle -- but can build arrows directly. Doing so requires staying cps... I think. = And this is how we get rid of the DeBruijn terms. \begin{code} subst :: (Typeable a) => Term a -> Int -> Term b -> Term b subst t i trm = go trm where go :: Term c -> Term c go (TNum d) = (TNum d) go (TApp f x) = TApp (go f) (go x) go (TLam f) = TLam (\a -> go (f a)) go (TVar i') | i == i' = either error id $ trmCast t | otherwise = (TVar i') \end{code} Q: Now you see why DeBruijn is handy -- substitution is otherwise a pain. = But note -- all functions must be monotyped. This is the simply typed lambda calculus. How do we represent TLam (\a -> a)? The masses demand HM polymorphism. - Take 4: A damn dirty hack. = All hacks begin with Nats. \begin{code} data Z = Z deriving (Show, Typeable) data S a = S a deriving (Show, Typeable) \end{code} = typeCheck is almost the same. \begin{code} typeCheck'' :: STerm -> Env -> Either String (TermBox, TypeRep) typeCheck'' t env = go t env 0 where go :: STerm -> Env -> Int -> Either String (TermBox, TypeRep) go (SNum d) _ idx = retTBox (TNum d) go (SVar i) env idx = do (TermBox t, _) <- maybe (fail $ "not in scope: " ++ i) return $ M.lookup i env retTBox $ t \end{code} = \begin{code} go (SApp s1 s2) env idx = do (TermBox e1, tr1) <- go s1 env idx (TermBox e2, _) <- go s2 env idx TermBox rt <- unifyAppRet e1 e2 e1' <- unifyAppFun e1 e2 retTBox $ TApp e1' e2 `asTypeOf` rt go (SLam i tr s) env idx = do TermBox et <- return $ mkTerm' $ tr (TermBox e, _) <- go s (M.insert i (TermBox (TVar idx `asTypeOf` et),tr) env) (idx + 1) retTBox $ TLam (\x -> subst (x `asTypeOf` et) idx e) \end{code} It looks like we just factored on the nasty arrow code. = mkTerm is almost the same... we just extended it to deal with Nats. \begin{code} mkTerm' :: TypeRep -> TermBox mkTerm' tr = go tr TermBox where go :: TypeRep -> (forall a. (Typeable a) => Term a -> res) -> res go tr k | tr == typeOf (0::Double) = k (TNum 0) | tr == typeOf Z = k (TVar 0 :: Term Z) | typeRepTyCon tr == succCon = go (head $ typeRepArgs tr) $ \t -> k $ succTerm t | isArr tr = go (head $ typeRepArgs tr) $ \xt -> go (head $ tail $ typeRepArgs tr) $ \y -> k (TLam $ \x -> const y (x `asTypeOf` xt)) | otherwise = error $ show tr succCon = typeRepTyCon $ typeOf (S Z) succTerm :: Typeable b => Term b -> Term (S b) succTerm _ = TVar 0 \end{code} = Some utilities \begin{code} isArr :: TypeRep -> Bool isArr x = typeRepTyCon x == (typeRepTyCon $ typeOf (undefined::Int -> String)) splitArrCon :: TypeRep -> Either String (TypeRep, TypeRep) splitArrCon x | isArr x = case typeRepArgs x of [a,b] -> Right (a,b) _ -> Left $ "Expected function, inferred: " ++ show x | otherwise = Left $ "Expected function, inferred: " ++ show x \end{code} = Give an arrow term we unify it with its argument... and return a witness. \begin{code} unifyAppRet :: forall a b. (Typeable a, Typeable b) => Term a -> Term b -> Either String TermBox unifyAppRet x y = do tr <- unifyAppTyps (head $ typeRepArgs $ typeOf x) (head $ typeRepArgs $ typeOf y) return $ mkTerm' tr \end{code} = Yes. Actual unification. (although this is unification of a type template, so at least it is local) \begin{code} unifyAppTyps :: TypeRep -> TypeRep -> Either String TypeRep unifyAppTyps trf trx = do (fl,fr) <- splitArrCon trf env <- go M.empty fl trx subIt env fr where -- go yields a substitution environment. go :: M.Map String TypeRep -> TypeRep -> TypeRep -> Either String (M.Map String TypeRep) go env x y | isFree x = case M.lookup (show x) env of Just x' -> if x' == y then return env else Left (error "a") Nothing -> return $ M.insert (show x) y env | isArr x = do (lh,rh) <- splitArrCon x (lh',rh') <- splitArrCon y env' <- go env lh lh' go env' rh rh' | otherwise = if x == y then return env else Left (error "b") \end{code} = \begin{code} -- subIt applies it subIt :: M.Map String TypeRep -> TypeRep -> Either String TypeRep subIt env x | isFree x = case M.lookup (show x) env of Just x' -> return x' Nothing -> Left (error "c") | isArr x = do (lh,rh) <- splitArrCon x lh' <- subIt env lh rh' <- subIt env rh return $ mkTyConApp arrCon [lh',rh'] | otherwise = return x succCon = typeRepTyCon $ typeOf (S Z) zCon = typeRepTyCon $ typeOf Z isFree x = typeRepTyCon x `elem` [zCon, succCon] arrCon = (typeRepTyCon $ typeOf (undefined::Int -> String)) \end{code} = And now, we just have to convince GHC that they unify! \begin{code} unifyAppFun :: forall a b c. (Typeable a, Typeable b, Typeable c) => Term a -> Term b -> Either String (Term c) unifyAppFun x y = do unifyAppTyps (head $ typeRepArgs $ typeOf x) (head $ typeRepArgs $ typeOf y) return $ unsafeCoerce x \end{code} = Problem solved. On Fri, Jun 25, 2010 at 2:03 PM, Edward Kmett <ekmett(a)gmail.com> wrote: > It turns out that defining Read is somewhat tricky to do for a GADT. > > Gershom Bazerman has some very nice slides on how to survive the process by > manual typechecking (much in the spirit of Oleg's meta-typechecking code > referenced by Stephen's follow up below) > > He presented them at hac-phi this time around. > > I will check with him to see if I can get permission to host them somewhere > and post a link to them here. > > -Edward Kmett > > > On Fri, Jun 25, 2010 at 5:04 AM, <corentin.dupont(a)ext.mpsa.com> wrote: > >> >> Hello Haskellers, >> >> I'm having trouble writing a Read Instance for my GATD. >> Arg this GATD!! It causes me more problems that it solves ;) >> Especially with no automatic deriving, it adds a lot of burden to my code. >> >> >data Obs a where >> > ProposedBy :: Obs Int -- The player that proposed the tested >> rule >> > Turn :: Obs Turn -- The current turn >> > Official :: Obs Bool -- whereas the tested rule is official >> > Equ :: (Eq a, Show a, Typeable a) => Obs a -> Obs a -> Obs >> Bool >> > Plus :: (Num a) => Obs a -> Obs a -> Obs a >> > Time :: (Num a) => Obs a -> Obs a -> Obs a >> > Minus :: (Num a) => Obs a -> Obs a -> Obs a >> > And :: Obs Bool -> Obs Bool -> Obs Bool >> > Or :: Obs Bool -> Obs Bool -> Obs Bool >> > Not :: Obs Bool -> Obs Bool >> > Konst :: a -> Obs a >> >> >> > instance Read a => Read (Obs a) where >> > readPrec = (prec 10 $ do >> > Ident "ProposedBy" <- lexP >> > return (ProposedBy)) >> > +++ >> > (prec 10 $ do >> > Ident "Official" <- lexP >> > return (Official)) >> > (etc...) >> >> Observable.lhs:120:8: >> Couldn't match expected type `Int' against inferred type `Bool' >> Expected type: ReadPrec (Obs Int) >> Inferred type: ReadPrec (Obs Bool) >> >> >> Indeed "ProposedBy" does not have the same type that "Official". >> Mmh how to make it all gently mix altogether? >> >> >> Best, >> Corentin >> >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >> > >

2 1

Why my program runs out of memory?
by Vladimir Ch. 25 Jun '10

25 Jun '10

I'm trying to solve this problem: http://projecteuler.net/index.php?section=problems&id=44, and my program runs out of memory. I was wondering where I have a space leak, I thought that this program doesn't accumulate any data structures (i.e. should use constant memory): CODE BEGINS -- returns list of pairs (i, j) of indices, for which differences (gen j - gen i) -- increase, provided that gen has the following property: -- gen (i+1) - gen i > gen i - gen (i - 1) incDiffPairs gen = iterate next (0, 1) where next (i, j) = if (i == 0) || gen (j+1) - gen j < gen j - gen (i - 1) then (j, j + 1) else (i - 1, j) -- returns ith pentagonal number pentagonal i = let n = i + 1 in n * (3 * n - 1) `div` 2 -- tests if a number is pentagonal isPentagonal x = let d = 24 * x + 1 in isSquare d && (1 + sqrti d) `mod` 6 == 0 result44 = head [(pentagonal j - pentagonal i, (i, j)) | (i, j) <- incDiffPairs pentagonal, isPentagonal (pentagonal j - pentagonal i), isPentagonal (pentagonal j + pentagonal i)] CODE ENDS

2 2

Fwd: signficant improvements to the containers package
by Don Stewart 25 Jun '10

25 Jun '10

Some people might be quite excited by Milan's work on significant performance improvements to the containers package... ----- Forwarded message from Milan Straka <fox(a)ucw.cz> ----- Date: Thu, 24 Jun 2010 07:45:50 +0200 From: Milan Straka <fox(a)ucw.cz> To: Don Stewart <dons(a)galois.com> Cc: Claus Reinke <claus.reinke(a)talk21.com>, libraries(a)haskell.org Subject: Re: Map folds in containers: why no worker/wrapper split? > > Data.Map is the way it is for historical reasons. It needs a dedicated > performance maintainer to do detailed benchmarking and static analysis. I did quite a lot of benchmarking, strictness analysis and performance improvements to the containers package recently, see the draft of my paper http://fox.ucw.cz/papers/containers/containers.pdf. Next week I will start finalizing the patches and submit them. The 'not generating a worker/wrapper' issue is one of several on my radar, so this should be resolved. Cheers, Milan ----- End forwarded message -----

7 12

Read instance for GATD
by corentin.dupont＠ext.mpsa.com 25 Jun '10

25 Jun '10

Hello Haskellers, I'm having trouble writing a Read Instance for my GATD. Arg this GATD!! It causes me more problems that it solves ;) Especially with no automatic deriving, it adds a lot of burden to my code. >data Obs a where > ProposedBy :: Obs Int -- The player that proposed the tested rule > Turn :: Obs Turn -- The current turn > Official :: Obs Bool -- whereas the tested rule is official > Equ :: (Eq a, Show a, Typeable a) => Obs a -> Obs a -> Obs Bool > Plus :: (Num a) => Obs a -> Obs a -> Obs a > Time :: (Num a) => Obs a -> Obs a -> Obs a > Minus :: (Num a) => Obs a -> Obs a -> Obs a > And :: Obs Bool -> Obs Bool -> Obs Bool > Or :: Obs Bool -> Obs Bool -> Obs Bool > Not :: Obs Bool -> Obs Bool > Konst :: a -> Obs a > instance Read a => Read (Obs a) where > readPrec = (prec 10 $ do > Ident "ProposedBy" <- lexP > return (ProposedBy)) > +++ > (prec 10 $ do > Ident "Official" <- lexP > return (Official)) > (etc...) Observable.lhs:120:8: Couldn't match expected type `Int' against inferred type `Bool' Expected type: ReadPrec (Obs Int) Inferred type: ReadPrec (Obs Bool) Indeed "ProposedBy" does not have the same type that "Official". Mmh how to make it all gently mix altogether? Best, Corentin

3 2

ANN: ForSyDe DSL v3.1
by Seyed Hosein Attarzadeh Niaki 25 Jun '10

25 Jun '10

Dear All, A new version of the ForSyDe DSL is uploaded to the Hackage database. "The ForSyDe (Formal System Design) methodology has been developed with the objective to move system design to a higher level of abstraction and to bridge the abstraction gap by transformational design refinement. This library provides ForSyDe's implementation as a Haskell-embedded Domain Specific Language (DSL). For more information, please see ForSyDe's website: http://www.ict.kth.se/forsyde/." In addition to compatibility with base 4 and GHC 6.10.x, the new version provides more freedom for declaration of process functions (e.g., support for when and let blocks). BR/ Hosein Attarzadeh

1 1

ANN: parameterized-data library v0.1.4
by Seyed Hosein Attarzadeh Niaki 25 Jun '10

25 Jun '10

Dear Haskell developers, A new version of the parameterized-data library providing fixed-sized vectors (based on the type-level library) is pushed into the repository and uploaded to the Hackage database. This is only a minor update to fix the compatibility issues with base 4, GHC>=6.10 and cabal-install (not backward compatible). Bests, Hosein Attarzadeh

1 1

RE: [Haskell-cafe] proposal: HaBench, a Haskell Benchmark Suite
by Andy Georges 25 Jun '10

25 Jun '10

Hi Simon et al, I've picked up the HaBench/nofib/nobench issue again, needing a decent set of real applications to do some exploring of what people these days call split-compilation. We have a framework that was able to explore GCC optimisations [1] -- the downside there was the dependency of these optimisations on each other, requiring them to be done in certain order -- for a multi-objective search space, and extended this to exploring a JIT compiler [2] for Java in our case -- which posed its own problems. Going one step further, we'd like to explore the tradeoffs that can be made when compiling on different levels: source to bytecode (in some sense) and bytecode to native. Given that LLVM is quicly becoming a state-of-the-art framework and with the recent GHC support, we figured that Haskell would be an excellent vehicle to conduct our exploration and research (and the fact that some people at our lab have a soft spot for Haskell helps too). Which brings me back to benchmarks. Are there any inputs available that allow the real part of the suite to run for a sufficiently long time? We're going to use criterion in any case given our own expertise with rigorous benchmarking [3,4], but since we've made a case in the past against short running apps on managed runtime systems [5], we'd love to have stuff that runs at least in the order of seconds, while doing useful things. All pointers are much appreciated. Or if any of you out there have (recent) apps with inputs that are open source ... let us know. -- Andy [1] COLE: Compiler Optimization Level Exploration, Kenneth Hoste and Lieven Eeckhout, CGO 2008 [2] Automated Just-In-Time Compiler Tuning, Kenneth Hoste, Andy Georges and Lieven Eeckhout, CGO 2010 [3] Statistically Rigorous Java Performance Evaluation, Andy Georges, Dries Buytaert and Lieven Eeckhout, OOPSLA 2007 [4] Java Performance Evaluation through Rigorous Replay Compilation, Andy Georges, Lieven Eeckhout and Dries Buytaert, OOPSLA 2008 [5] How Java Programs Interact with Virtual Machines at the Microarchitectural Level, Lieven Eeckhout, Andy Georges, Koen De Bosschere, OOPSLA 2003

5 6

How does one get off haskell?
by Günther Schmidt 25 Jun '10

25 Jun '10

Hi list, I'm facing a really tough problem. About 3 years ago I stopped doing freelance and quite nicely paid projects in Java, PHP and C#. Now I'm dire straits, again, and need to get back into the project market which seems to have picked up again, quite a lot of projects out there and it looks like I could ask again for decent rates. (I personally call them compensation because I never ever enjoyed doing Java etc. but the money was good.) Anyway the problem is that I am totally reluctant to code in anything else but haskell. It has always been a problem to me getting up early in the morning, taking a train to work and coming back in the evening totally exhausted. But I think I could manage that again, at least for 3 or 6 months and then my bank account will be fine again and I can take it easy for another year or so. But this time all this is much harder. I really cannot see myself writing such huge amounts of code over and over again not doing much, well you know the story. BTW this is not meant as a fun post, I'm actually quite serious, ie. I need money, only way of getting it is doing Java, C# or PHP. So how does one get off haskell? Are there people in similar situations that have managed? How did you do it? Günther

27 35

AusHac2010, the first Australian Haskell Hackathon is growing near, and we need you!
by Alex Mason 25 Jun '10

25 Jun '10

AusHac2010 will be held from the 16th to the 18th of July at UNSW, where we'll be working on various haskell projects such as: The LLVM backend for GHC (I'm going to see if we can somehow get in contact with David T during the hackathon so we can discuss what can be done) A Generic graph class The Accelerate and Repa libraries for fast array computations Hubris, the Ruby-Haskell bridge (Mark's done some really awesome work here, but I'm sure could use some help) Leksah, the Haskell IDE written in Haskell MPI bindings, to either bring the previous package alive from its bitrotten state, or create a new one from scratch A Notification library for things like Growl and libnotify A Library re-builder, extending haskell-updater for use with cabal-install, Arch, etc. If you can come for any of the days we'll be hacking, we'd love to see you! But you'll need to sign up first (so you can get access to the UNSW wireless network). If you're not sure if you can make it, sign up anyway, you're not obliged to come, but mark yourself as only possibly being able to come. The signup page can be found at: Sign up!: [http://axman6.wufoo.com/forms/aushac-2010-sign-up-20/] See the AusHac2010 wiki page [http://www.haskell.org/haskellwiki/AusHac2010] for more details on what we'll be doing, and various other details. We've already got 20-30 people coming hopefully, but the more we have the better. If you've already signed up using the previous form, you we still need you to fill out this new 2.0 version of the sign up form If you have questions, please feel free to email me or Ivan (our addresses are the reply-to addresses for this email... I hope), or talk to us (Axman6, ivanm) on #haskell. Cheers, Alex Mason

1 0

Re: [Haskell-cafe] Question regarding deepseq (Control.DeepSeq)
by Frank Moore 25 Jun '10

25 Jun '10

Daniel, >This means *when meanOver2 is evaluated*, then evaluate (mean as). >Binding it in a let is lazy, so it won't be evaluated until it's needed >(for printing in this case). >Also note that (mean as) is a Double, so deepseq is just seq in this case >(but I suppose this is just a boiled down example and you also want to time >computations with results where deepseq does strictly more than seq). Thanks for the help, I think I understand now. This is indeed a boiled down example. I have some data that I am trying to compute in parallel, and I want to control how much evaluation to force. To do this, I was trying to use NFData and deepseq, since I thought bang patterns were a little clunky (but maybe they are less clunky than forcing evaluations with seq and deepseqs). Are there best practices for keeping track of which variables are bound where, when writing a complex program? >There are two standard ways to achieve what you want, >1. > let meanOver2 = ... > end <- meanOver2 `deepseq` getCurrentTime >2. put {-# LANGUAGE BangPatterns #-} at the top of the file and write > let !meanOver2 = ... > end <- getCurrentTime >The bang on meanOver2 means "evaluate this expression now (to weak head >normal form, i.e. to the outermost constructor)". Sometimes for me, whnf is not quite enough. For example, if I have a newtype P (with type constructor P) that is a for Map M Int. Is NFData and deepseq the way to do this, or should I be trying to implement my own Strategy along the lines of rwhnf in Control.Parallel.Strategies? >Another thing, for timing computations, wall-clock time is not appropriate, >better use >System.CPUTime.getCPUTime >to get only the CPU-time the process took, and not also what your browser >or whatever used in the meantime. Thanks for the tip. Frank > On Thu, Jun 24, 2010 at 9:38 PM, Daniel Fischer <daniel.is.fischer(a)web.de> wrote: >> >> On Friday 25 June 2010 02:57:31, Frank Moore wrote: >> > Hello Haskellers, >> > >> > I am new to programming in Haskell and I am having trouble understanding >> > exactly when statements become evaluated. My goal is to try and measure >> > how long a computation takes without having to use a show function. The >> > code I am trying to use is below (taken in part from RWH chapter 25) >> > >> > ---------------------------------- >> > import Data.List (foldl') >> > import Data.Time.Clock (diffUTCTime, getCurrentTime) >> > import Control.DeepSeq (deepseq) >> > >> > mean :: [Double] -> Double >> > mean xs = s / fromIntegral n where >> > (n,s) = foldl' k (0,0) xs >> > k (n,s) x = n `seq` s `seq` (n+1,s+x) >> > >> > main = do >> > let as = [1..1e7] :: [Double] >> > start <- getCurrentTime >> > let meanOver2 = deepseq (mean as) `seq` (mean as) / fromIntegral 2 >> >> This means *when meanOver2 is evaluated*, then evaluate (mean as). >> Binding it in a let is lazy, so it won't be evaluated until it's needed >> (for printing in this case). >> Also note that (mean as) is a Double, so deepseq is just seq in this case >> (but I suppose this is just a boiled down example and you also want to time >> computations with results where deepseq does strictly more than seq). >> >> There are two standard ways to achieve what you want, >> >> 1. >> let meanOver2 = ... >> end <- meanOver2 `deepseq` getCurrentTime >> >> 2. put {-# LANGUAGE BangPatterns #-} at the top of the file and write >> >> let !meanOver2 = ... >> end <- getCurrentTime >> >> The bang on meanOver2 means "evaluate this expression now (to weak head >> normal form, i.e. to the outermost constructor)". >> >> > end <- getCurrentTime >> > putStrLn (show (end `diffUTCTime` start)) >> > putStrLn (show meanOver2) >> > ------------------------------------- >> >> Another thing, for timing computations, wall-clock time is not appropriate, >> better use >> >> System.CPUTime.getCPUTime >> >> to get only the CPU-time the process took, and not also what your browser >> or whatever used in the meantime. >> >> > >> > My understanding of deepseq was that it evaluates (mean as) completely >> > before continuing, and then the show would not take any time, but >> >> No, it evaluates (mean as) completely *when meanOver2 is demanded*, not >> before. >> >> > instead all the time is spent in the show meanOver2 function. I feel >> > like I am missing something fundamental here. Any suggestions? Thanks >> > for your help. >> > >> > Frank >> > > > > -- > Dr. W. Frank Moore > H. C. Wang Assistant Professor > Department of Mathematics, Cornell University > 310 Malott Hall, Ithaca NY 14853-4201, USA > > Office: Malott 587, Phone: +1 607 255 4030 > Email: frankmoore(a)math.cornell.edu -- Dr. W. Frank Moore H. C. Wang Assistant Professor Department of Mathematics, Cornell University 310 Malott Hall, Ithaca NY 14853-4201, USA Office: Malott 587, Phone: +1 607 255 4030 Email: frankmoore(a)math.cornell.edu

1 0

Question regarding deepseq (Control.DeepSeq)
by Frank Moore 25 Jun '10

25 Jun '10

Hello Haskellers, I am new to programming in Haskell and I am having trouble understanding exactly when statements become evaluated. My goal is to try and measure how long a computation takes without having to use a show function. The code I am trying to use is below (taken in part from RWH chapter 25) ---------------------------------- import Data.List (foldl') import Data.Time.Clock (diffUTCTime, getCurrentTime) import Control.DeepSeq (deepseq) mean :: [Double] -> Double mean xs = s / fromIntegral n where (n,s) = foldl' k (0,0) xs k (n,s) x = n `seq` s `seq` (n+1,s+x) main = do let as = [1..1e7] :: [Double] start <- getCurrentTime let meanOver2 = deepseq (mean as) `seq` (mean as) / fromIntegral 2 end <- getCurrentTime putStrLn (show (end `diffUTCTime` start)) putStrLn (show meanOver2) ------------------------------------- My understanding of deepseq was that it evaluates (mean as) completely before continuing, and then the show would not take any time, but instead all the time is spent in the show meanOver2 function. I feel like I am missing something fundamental here. Any suggestions? Thanks for your help. Frank

4 4

Tiger compiler: variable escaping analysis phase
by José Romildo Malaquias 25 Jun '10

25 Jun '10

Hello. I have been teaching an introductory course on compiler construction to our undergraduates students using Appel's "Modern Compiler Implementation in Java". There are also versions of the book in ML and C. The books explain how to write a compiler for the Tiger programming language. Now I want to implement a Tiger compiler in Haskell. The lexer and parser (built with the help of alex and happy) and the type checker are already working. Next step is implementing a variable escape analysis phase, needed for the intermediate code generator. The objective of this phase is to find out if each variable escapes or not. In general an escaping variable should be allocated in the stack frame (in memory). Non escaping variables may be allocated in the stack frame or in a register. Generally, a variable escapes if it is passed by reference, its address is taken (using C's & operator, for instance), or it is accessed from a nested function. Only the last is possible with Tiger. The approach adopted by Appel in his books is easy: a muttable field in the abstract syntax of variable declarations, of for expressions, and of function formal parameters, which introduce new variables, is used to collect the escaping information of the variable. In the ML version of the book this is a reference to boolean (bool ref). Initially, in a conservative approach, the reference is initialized to true. In the variable escaping analysis phase of the compiler, a function findEscape looks for escaping variables and record this information in the escape fields of the abstract syntax. To do this the entire abstract syntax tree is traversed looking for escaping uses of every variable, and, when found, the field is set to true. findEscape uses a symbol table to accomplish its work, binding variable names to a reference to boolean (the same reference used in the abstract syntax tree). When processing a variable declaraction, for instance, it inserts the variable name into the symbol table, binding it to its escaping field. When processing an expression which is a simple variable, if the variable occurs in a nested function, its binding in the symbol table is set to true. This reflects directly in the abstract syntax tree of the variable declaration, as the escape field in the variable declaration and the binding in the symbol table are the same reference to bool. I am look for good ways to implement the variable escaping analysis phase in Haskell, which is a pure language. I see two alternatives: 1) adopt the same approach as Appel used in his ML version of the compiler: use a mutable reference in the IO monad (Data.IORef) to hold the variable escaping information, and write everything inside the IO monad 2) build a new abstract syntax tree with updated information regarding variable escaping The second option is more elegant in my point of view, but would be much less efficient than the first one. So I want to know what advices Haskell programmers has to me about implementing this phase of the Tiger compiler in Haskell. Regards, Romildo -- Computer Science Department Universidade Federal de Ouro Preto, Brazil

5 10

When the unknown is unknown
by Martin Drautzburg 24 Jun '10

24 Jun '10

Hello all, I am currently playing with Paul Hudak's Euterpea (a music program, formely called Haskore) and I am trying to teach it about rhythm. I said that a rhythm is a series of Moments (or Beats), each expressed as fractions of a bar. But each Moment also has volume. So I could model rhythm as Pairs of (Moment, Volume). However I certanly do not want to specify both the Moments and the Volume, but rather compute one from the other. Often the Moments are known and I need to compute the Volumes, but this is not always the case. I might as well start with the volume and compute the moments. The latter would be particularly interesting when trying to find rhythms which are suitable for certain lyrics. In that case I must even be prepared to find more than one series-of-moments which "fit" to the given series-of-volumes. There are countless other problems like this, e.g. when trying to match harmony, melody and tension. In that case I even have three variables and I may want to specify tension first, then melody and have the harmony computed. At first glance this looks like a Prolog-like problem to me. I could say that certain things are always true for [(Moment, Volume)] and let an inference engine figure out the options which are still in consideration. From which angle would you approach problems like this? Should I get my hands on a prolog-in-haskel implementation (which indeed seems to exist)? Or should I roll my own poor-man's prolog? Or is this a constraint-satisfaction-problem? Or is there even a more straight-forward more haskellish pattern, which solves such problems? Any pointers would be much appreciated. -- Martin

3 4

Continuations and coroutines
by Yves Parès 24 Jun '10

24 Jun '10

Hello, I saw on the haskell wikibook that coroutines could be implemented by using continuations : http://en.wikibooks.org/wiki/Haskell/Continuation_passing_style#Example:_co…, the section is empty) Since I'm actually learning the wonders of continuations, I just wonder : how ?

5 7

ANN: statechart-0.0.0
by Tom Hawkins 24 Jun '10

24 Jun '10

Statechart [1] is a program that compiles Rhapsody [2] statechart diagrams [3] into C. Rhapsody is a UML <cough, choke, gag...> tool from IBM intended for embedded systems development. If you use Rhapsody, and its code generator makes your eyes bleed, statechart may provide some relief. -Tom [1] http://hackage.haskell.org/package/statechart [2] http://www-01.ibm.com/software/rational/products/rhapsody/developer/ [3] http://en.wikipedia.org/wiki/State_diagram#Harel_statechart

1 0

Unknown symbol: __fixunsdfdi
by Michael Snoyman 24 Jun '10

24 Jun '10

Hi all, I'm trying to get some code to compile on Windows, and have run into an unknown symbol. Has anyone else run into an unknown __fixunsdfdi? I'm using GHC 6.12.3. I'm trying to use my persistent-sqlite package. To reproduce, cabal install persistent-sqlite and then try running the example program[1]. Thanks, Michael [1] http://github.com/snoyberg/persistent/raw/ef31e6ddece659b1b8240756a1a47360f…

1 0

Network of GUI Controls - using MonadFix?
by Günther Schmidt 24 Jun '10

24 Jun '10

Hello list, let's say I would like to create 4 buttons where any one button can respond to a click and notify every other button. Ie. where the 1st button is wired with the 2nd, the 2nd with the 3rd ... and the 4th button with the 1st. In short I would like these buttons to be connected as in a cyclic list. Is that something that MonadFix is meant to be used for? Günther

3 2

Haddock Problem
by Dominic Steinitz 24 Jun '10

24 Jun '10

..\ThirdParty\Haskell_Platform\2010.1.0.0\bin\haddock.exe BackendC\Core.hs haddock.exe: can't find a package database at E:\ghc\ghc-6.12.1lib\package.conf.d But if I do haddock --help there is no option to set the package database and I don't even have an E: drive. I'm on windows in case that wasn't obvious and we have a custom package database which we point e.g. ghc and cabal at. Can someone tell me what I am doing wrong? Many thanks, Dominic.

4 14

Re: Installing Haskell on OSX
by Giuseppe Luigi Punzi 24 Jun '10

24 Jun '10

Sorry for my ignorance but..why install with +universal? i didn't use this in any port. Sudish Joseph <sudish(a)gmail.com> wrote: >Hi, > >I ran into one problem worth mentioning while recompiling gtk and its >dependencies as universal libraries using macports: the pango port >refused to build with +universal (it fails when trying to merge the >i386 & x86_64 libs). The pango-devel port does work with one small >tweak as described at https://trac.macports.org/ticket/22801. > >Essentially, I had to comment out the "PortGroup muniversal 1.0" line >in the Portfile to get a working universal library for pango. > >-Sudish > >On Mon, Jun 21, 2010 at 5:09 AM, Giuseppe Luigi Punzi ><glpunzi(a)lordzealon.com> wrote: >> I died in more dependencies. One, ige-mac-integration. To avoid possible problems I uninstall all ports last night to reinstall full gtk2 with quartz. >> >> For now, i'm solving all of this and I hope to get it working this night. >> >> Sudish Joseph <sudish(a)gmail.com> wrote: >> >>>Antoine Latter <aslatter(a)gmail.com> writes: >>>> On Sun, Jun 20, 2010 at 12:53 PM, Giuseppe Luigi Punzi Ruiz >>>> <glpunzi(a)lordzealon.com> wrote: >>>>> Hi again, >>>>> >>>>> Yes, you are right, but now, "cabal install leksah" I get: >>>>> >>> >>>[...] >>> >>>>> Undefined symbols: >>>>> "_iconv_close", referenced from: >>>>> _hs_iconv_close in libHSbase-4.2.0.0.a(iconv.o) >>>>> "_iconv_open", referenced from: >>>>> _hs_iconv_open in libHSbase-4.2.0.0.a(iconv.o) >>>>> "_iconv", referenced from: >>>>> _hs_iconv in libHSbase-4.2.0.0.a(iconv.o) >>>>> ld: symbol(s) not found >>> >>>> This one is a bummer, and I see it all the time when I try to build a >>>> package linked against macports. >>> >>>This is caused by the two libiconv's in the system being >>>ABI-incompatible, sadly. The ghc pkg available for download from >>>haskell.org is linked against the system /usr/lib/libiconv.dynlib, which >>>has iconv_open() as a function. Macports has GNU libiconv which >>>#defines iconv_open to libiconv_open() in /opt/local/include/iconv.h. >>> >>>This then blows up as above when linking against other libraries in >>>macports - the linker pulls in GNU libiconv which lacks the symbols >>>needed as you see above. >>> >>>One workaround is to link GHC itself against the macports version of >>>libiconv (and libgmp) and have cabal-install link all subsequent >>>libraries against macports. I did just that this weekend and now have a >>>working threadscope using the Quartz backend for gtk2, which is very >>>nice (no need to run the X server). >>> >>>Recipe for reproducing this build is included below (and I can also >>>provide the resulting ghc-6.12.3 pkg file if needed). >>> >>>Another possible option is to use Homebrew to install gtk2 and other >>>dependencies. Homebrew prefers to use the system-provided libraries and >>>will not pull in GNU libiconv, so this should work with the existing GHC >>>pkg in theory. I didn't pursue this since the homebrew 'gtk+' package >>>didn't seem to have the option to use Quartz instead of X11 as its >>>backend. >>> >>>Steps for linking the ghc runtime against macports: >>> >>>- Specify EXTRA_CABAL_CONFIGURE_FLAGS in mk/build.mk as mentioned at >>> the bottom of http://www.haskell.org/ghc/download_ghc_6_12_3.html >>> >>> EXTRA_CABAL_CONFIGURE_FLAGS = --extra-include-dirs=/opt/local/include \ >>> --extra-lib-dirs=/opt/local/lib >>> >>>- Use the --with-iconv-* and --with-gmp-* flags when configuring ghc. >>> >>> ./configure --with-iconv-includes=/opt/local/include \ >>> --with-iconv-libraries=/opt/local/lib \ >>> --with-gmp-includes=/opt/local/include \ >>> --with-gmp-libraries=/opt/local/lib >>> >>>- This produces a GHC runtime and libraries linked against macports: >>> >>> % otool -L ghc >>> ghc: >>> /opt/local/lib/libncurses.5.dylib (compatibility version 5.0.0, current version 5.0.0) >>> /usr/lib/libSystem.B.dylib (compatibility version 1.0.0, current version 125.2.0) >>> /opt/local/lib/libiconv.2.dylib (compatibility version 8.0.0, current version 8.0.0) >>> /opt/local/lib/libgmp.10.dylib (compatibility version 11.0.0, current version 11.1.0) >>> >>> % nm HSbase-4.2.0.2.o | fgrep iconv >>> 001ff7f0 T _hs_iconv >>> 001ff7e0 T _hs_iconv_close >>> 001ff800 T _hs_iconv_open >>> U _libiconv >>> U _libiconv_close >>> U _libiconv_open >>> >>> ghc and included libraries use the macports libiconv, so linking >>> against other libraries in macports (gtk2!) will work. >>> >>>- Have cabal-install use macports as well for packages it installs by >>> editing ~/.cabal/config and setting: >>> >>> extra-include-dirs: /opt/local/include >>> extra-lib-dirs: /opt/local/lib >>> >>>- This gives, for e.g., threadscope linked against macports: >>> >>> % otool -L ~/.cabal/bin/threadscope | egrep '(gtk|iconv)' >>> /opt/local/lib/libgtk-quartz-2.0.0.dylib (compatibility version 2001.0.0, current version 2001.1.0) >>> /opt/local/lib/libiconv.2.dylib (compatibility version 8.0.0, current version 8.0.0) >>> >>>- Note that since the ghc runtime is still in 32-bit i386 mode, we >>> need universal versions of most libraries in macports. Recent >>> versions of macports (1.9 for sure, maybe 1.8) make it simple to >>> switch from an x86_64 library to a universal one: >>> >>> % port install gtk2 +universal >>> >>> This will recompile gtk2 and *all* dependent libraries as universal >>> libraries which is exactly what you need. You can then eliminate any >>> inactive 64-bit libraries with: >>> >>> % port -f uninstall inactive >>> >>>> Here's the last thread about with, with more links and discussion: >>>> >>>> http://thread.gmane.org/gmane.comp.lang.haskell.general/18064/ >>>> >>>> The response by Jean-Marie Gaillourdet has worked for me in the past. >>>> >>>> Antoine >>> >>>Thanks for that link, I didn't think of overriding libiconv on a >>>per-package basis. >>> >>>-Sudish >>

3 7

Relating generated asm to Core
by Rami Mukhtar 24 Jun '10

24 Jun '10

Hi, Can anyone tell me a way to identify the generated assembly (as found in the intermediate files produced by GHC) corresponding to a particular fragment of Core code. Thanks, Rami ________________________________ The information in this e-mail may be confidential and subject to legal professional privilege and/or copyright. National ICT Australia Limited accepts no liability for any damage caused by this email or its attachments.

3 2

Accounting Engine in Haskell
by Amiruddin Nagri 24 Jun '10

24 Jun '10

My current project is about making an accounting engine that handles all the journal entries, transactions, portfolios etc. The communication with the engine is based on simple protocol, the things to be taken care of in the order are consistency, handling large data(performance) and availability. I came across a video lecture by Simon Peyton Jones where he gives an example from Financial domain (derivatives etc) to explain how haskell is being used and the advantages provided. I am interested in knowing if Haskell will be the right fit for my project. My requirements are transactional nature, which I believe is one of the strengths of functional programming, also handling large data set and being available. there is no such requirement for partitioning of data and the application is going to be centrally hosted on a single server. AFAIK OCaml and other functional languages are heavily used in financial domain, some of the reason are same as features I am looking for. I wanted some insight as to how Haskell is going to help me with my project. Also there has been some concerns because of lazy evaluation in Haskell and memory leaks associated with it. http://jlouisramblings.blogspot.com/2010/04/haskell-vs-erlang-for-bittorent… Also, if you have any suggestions of the choice of programming language, we have been looking into other functional languages like Scala and Clojure. But we have not dig deep on the performance aspects of these languages, if someone can shed a light on the pros- cons of these languages, it will help us very much to come to a decision. -Regards, Amir

6 6

offtopic - installing archlinux as a domU
by Michael Litchard 24 Jun '10

24 Jun '10

I know some haskell people out there have done what I am trying to do, and I hope you can help me out. I've got access to a debian server which is running a Xen Hypervisor 3.0.3 I believe. I would like to install archlinux as a paravirtual machine (or HVM if I must) in order to get a more supportive haskell environment than my current OS. Could someone point me to some updated documentation on this process? Much thanks. Michael Litchard

1 0

Haskell Weekly News?
by aditya siram 24 Jun '10

24 Jun '10

Hi all, I haven't seen a "Haskell Weekly News" in a while. Is there anything I can do to help? -deech

9 16

In other words is there a good place to post stuff like the following?
by caseyh＠istar.ca 23 Jun '10

23 Jun '10

-- Algorithms From: "Selected Papers on Design of Algorithms", Donald Knuth, 2010 -- Chapter 10 Addition Machines -- Haskell version by Casey Hawthorne -- Note this is only a skeleton of the chapter, -- so as to wet your interest to buy the book. -- Addition Machine -- The only operations allowed are the following: -- read x -- x <- y -- x <- x + y -- x <- x - y -- if x >= y -- write x -- Can all functional versions be tail recursive? ----------------------------------------------------------------------- ----------------------------------------------------------------------- -- Modulus -- Assuming without loss of generality x>=0 and y>0, -- since one can use various identities for other cases. -- Performs floor(x/y) subtractions. modulusNaive x y | x >= y = modulusNaive (x-y) y | otherwise = x -- Can we do better? -- Uses a doubling procedure to subtract larger multiplies of y. -- Bounded by O(log(x/y))^2 modulusByDoubling x y | x >= y = helper y y | otherwise = x where helper w z | x < z = helper z z+z | otherwise = modulusByDoubling (x-w) y -- Can we do better? -- Want bounded by O(log(x/y)). -- Addition Machine, so cannot divide by 2. -- Implicitly use the Fibonacci representation of floor(x/y) -- instead of its the binary representation. -- F0 = 0; F1 = 1; Fn = F(n-1) + F(n-2), n >=2 -- Every nonnegative integer n can be uniquely represented in the form -- n = F(m1) + F(m2) + ... + F(mt), m1 >> m2 >> ... >> mt >> 0 -- where t >= 0 and m >> m' means that m - m' >= 2 -- If n > 0 this representation can be found by choosing m1 such that -- F(m1) <= n < F(m1+1) ----------------------------------------------------------------------- -- Furthermore Fibonacci numbers grow exponentially, -- about 69% as fast as powers of 2. -- They have been used as power-of-2 analogs in a variety of algorithms. ----------------------------------------------------------------------- modulusFib x y | x >= y = helper x y y | otherwise = x where helper x y z | x < z = helper x z y+z | otherwise = helper2 x y z helper2 x y z | x >= y = helper2 (x-y) y z | y > z = helper2 x (z-y) y | otherwise = x

2 1