- Haskell-Cafe - Haskell.org

using FlexibleInstances and OverlappingInstances
by TP 07 Apr '12

07 Apr '12

Hello, In a module I am writing, I would like to use FlexibleInstances and OverlappingInstances. But I get errors, so I am trying to reproduce the problems on a smaller program: -------------------------------------------- {-# LANGUAGE FlexibleInstances, OverlappingInstances #-} data Foo = Foo Int deriving ( Show ) instance Show [Foo] where show [] = "[0]" show l = map show l main = do let l = [ Foo 1, Foo 2 ] print l -------------------------------------------- The first error I obtain is: -------------------------------------------- test_overlappinginstances.hs:7:19: Couldn't match expected type `Char' with actual type `[Char]' Expected type: a0 -> Char Actual type: a0 -> String In the first argument of `map', namely `show' In the expression: map show l -------------------------------------------- Where does this "Char" come from? How to solve this problem? The second error is: -------------------------------------------- test_overlappinginstances.hs:11:5: Overlapping instances for Show [Foo] arising from a use of `print' Matching instances: instance Show a => Show [a] -- Defined in GHC.Show instance [overlap ok] Show [Foo] -- Defined at test_overlappinginstances.hs:5:10-19 -------------------------------------------- The overlap is ok ("overlap ok" does not appear if not using the pragma OverlappingInstances), so it should work? Thanks in advance, TP

2 2

Conduits and Unix Pipes
by Clark Gaebel 07 Apr '12

07 Apr '12

Has anyone built an adapter between unix pipes and conduits? Something like: upipe2conduit :: String -> Conduit Char Char let someLines = "hello\nworld" nLines <- (read . runResourceT $ sourceList someLines $= upipe2conduit "wc -l" $$ consume) :: Integer If this has been done, is it on hackage? Thanks, - clark

2 2

Haskell integration with C/C++ (GSOC)
by Sutherland, Julian 07 Apr '12

07 Apr '12

Hey Guys, I'm Julian, I am reaching the end of my second year as a JMC (Joint Mathematics and Computer science) Student at Imperial College London and I'd like to apply to GSOC for a project involving Haskell and I just wanted to run my idea past the community. I've already talked about this on the haskell-soc IRC channel (I go by the pseudonym "julek"). What I would like to do is to improve the integration of C/C++ with Haskell, particularly in calling Haskell from C/C++. Currently ghc is able to generate stubs to export functions whose arguments are simple types such as CInts into C/C++. The stub generated is always in an extern "C" clause due to the fact that ghc does not as yet implement the C++ calling conventions as defined in the "The Haskell 98 Foreign Function Interface 1.0" (http://www.cse.unsw.edu.au/~chak/haskell/ffi/ffi.pdf) So a first step would be to implement this calling convention to bring it up to speed with the above referenced report. This shouldn't be too hard and mostly involves implementing C++ name mangling conventions. Next, I would like to extend the stub generation so as to be able to deal with more complex types. The type systems in C++ and Haskell have many analogous syntaxes that can be easily exploited to provide strong compatibility and interoperability between the two languages. For example a simple type such as: data Foo = A | B Could be implemented as an enum in C/C++: enum Foo {A, B}; More advanced types that take arguments such as: data Tree = Node Left Right | Leaf Could be converted to a struct in C/C++: struct Tree { struct Tree* left; struct Tree* right; }; Types that have functions that act on them such as: data IntContainer = IntContainer Int getInt :: IntContainer -> Int getInt (IntContainer a) = a could have these functions automatically converted to C/C++: struct IntContainer { int a; }; extern int getInt_hs(IntContainer a); This also opens up the possibility of exploiting C/C++ name mangling conventions, to allow the _hs postfix I'm suggesting here to be eliminated. Haskell classes: class Arithmetic a where (+) :: a -> a -> a (*) :: a -> a -> a (-) :: a -> a -> a (/) :: a -> a -> a could be implemented using C++ functions with virtual members: class Monad { public: virtual Monad add(Monad a, Monad b); virtual Monad mult(Monad a, Monad b) virtual Monad neg(Monad a, Monad b); virtual Monad div(Monad a, Monad b); } All types of single/multiple instancing (i.e. either directly or through requirements of instances) would be implemented using single/multiple inheritance. Obviously, this example is rather contrived due to the conversion of the function names. The fact that the rules that govern function naming in Haskell are much more permissive than those of C/C++ might cause compatibility issues. This can be worked around by implementing a similar syntax to that currently used for function imports by the FFI. E.g..: foreign export ccall "bind" >>= :: CInt -> CInt Similar to: foreign import ccall "f" func :: CInt -> CInt The latter is the current syntax for imports. The name given for the export would be checked for legality in the namespace of the target language. Alternatively this could be done in an automated manner using some naming conventions as well as operator polymorphism, but this would probably sacrifice ease of use. Finally polymorphic Haskell functions/types can be implemented in C++ using templates. I would like to extend ghc to implement enhanced C/C++ stub generation using the methods described above as well as to generate Haskell stubs which describe the Haskell CType equivalents of the Haskell types defined, functions for conversion between the two and function stubs to convert the types, run the Haskell function and convert back as required. On top of this I'd like to write C/C++ libraries for dealing with most of the standard Haskell types such as Maybe, Either, etc... Finally, I'd like to work on ironing out any bugs that remain in the RTS when it is used in "multilingual" situations, as well as improving it's performance in this situation. I found an example of such a bug, which I will test further before reporting it. It seems to be the opposite of the following bug: http://hackage.haskell.org/trac/ghc/ticket/5594 i.e. the stdout buffer isn't always correctly flushed when calling C/C++ in a program whose main is written in Haskell. For example, when running the code: main.hs: module Main where import Foreign.C.Types import System.IO foreign import ccall "inc" c_inc :: CInt -> CInt main :: IO () main = do putStr "Enter n: " -- hFlush stdout s <-getLine putStrLn . show . c_inc . read $ s inc.c: int inc(int i) __attribute__ ((const)); int inc(int i) { return i + 1; } Built with Makefile: all: gcc -c -o inc.o inc.c ghc --make -main-is Main main.hs inc.o -o test rm *.hi *.o The output comes out as: [julek@cryptid inc]$ ./test 2 Enter n: 3 But when the " hFlush stdout" line is commented back in, the output is: [julek@cryptid inc]$ ./test Enter n: 2 3 which is correct, but the extra line shouldn't be necessary. I am currently using ghc 7.4.1 which is the newest version, so this is a current bug. I have had a look for such a bug being reported and have found no such report. I'll look into this further before reporting it, but I am fairly certain this is a bug in the RTS. As part of this project, I would fix this bug (if it is still around when I start) as well as looking for other ones in this area. I think that extending ghc to the level required by "The Haskell 98 Foreign Function Interface 1.0" specification and above would reap significant benefit to the Haskell community. The improved integration into C/C++ would open the door for this to happen for several other languages and would make Haskell more widespread. Many Haskell beginners are daunted by the falsely perceived complexity of working with Haskell IO and monads, but love using the massive advantages that the paradigm gives in a non monadic context. Due to this, simplifying the interoperability between Haskell and C/C++ would enable many of these users to stick around for longer and perhaps encourage them to eventually look deeper into the language. This would make the size of the community grow and make the use of Haskell more widespread, potentially reaping benefits for the community at large. I believe this could be implemented within the time frame given for GSOC. Hope you like the ideas presented here and hopefully I'll be accepted into the Haskell summer of code! If anybody has any opinions on the implementability/usefulness of this and/or criticism of the idea, please inform me and I'll be happy to discuss it! Looking forward to hearing from you! Thanking you in advance. Kind regards, Julian Sutherland

7 7

Subscriber-only lists as Maintainer contacts of Cabal packges
by Joachim Breitner 07 Apr '12

07 Apr '12

Dear Cabal authors, if your package is team maintained and you put in a mailing list as the “Maintainer” contact of your package, that is in general a good thing. But if you do so, please make sure the list is not set to subscriber only; it is an unreasonable burden to subscribe for people who just want to send you one question, and possibly have to contact dozends of different package authors, e.g. as a distribution packager. Thanks, Joachim (Who really thinks that using the subscriber-only setting of mailman as an anti-spam-measure is an abuse of the feature, and that mailman should offer a “non-subscribers get a bounce that allows them to approve the message themselves“ feature which would give the same spam protection but much less hassle for the users.) -- Joachim "nomeata" Breitner Debian Developer nomeata(a)debian.org | ICQ# 74513189 | GPG-Keyid: 4743206C JID: nomeata(a)joachim-breitner.de | http://people.debian.org/~nomeata

2 1

Testing Concurrent Programs
by satvik chauhan 06 Apr '12

06 Apr '12

How do you test concurrent programs in which you actually have to test over all possible interleaving schedules by the scheduler . Is this possible to do with quickcheck . Thanks , Satvik

1 0

Re: [Haskell-cafe] thread killed
by Gregory Collins 05 Apr '12

05 Apr '12

+haskell-cafe, oops On Thu, Apr 5, 2012 at 11:04 AM, Gregory Collins <greg(a)gregorycollins.net>wrote: > On Wed, Apr 4, 2012 at 10:09 PM, tsuraan <tsuraan(a)gmail.com> wrote: > >> > It's hard to rule Snap timeouts out; try building snap-core with the >> > "-fdebug" flag and running your app with "DEBUG=1", you'll get a spew of >> > debugging output from Snap on stderr. >> >> Heh, that was quite a spew. I normally get the exceptions tens of MB >> into files that are hundreds of MB, and I sometimes don't get them at >> all, so printing out the entire request body was a bit slow :) After >> commenting out some of the more talkative debug statements, I got the >> exception to happen, and it looks generally like this: >> > > I think I might know what your problem is. You're accepting file uploads > using handleMultipart, yes? Snap kills uploads that are going too slow, > otherwise you would be vulnerable to slowloris ( > http://ha.ckers.org/slowloris/) DoS attacks. What's probably happening > here is that you're doing slow work inside the "Iteratee IO a" handler you > pass to that function, which makes Snap think the client is trickling bytes > to you. If that's the case, either finish the iteratee more quickly and do > the slow work back in the Snap handler (preferable), or disable the minimum > upload rate guard (although that's not recommended on a server talking to > the public internet.) > > G > -- > Gregory Collins <greg(a)gregorycollins.net> > -- Gregory Collins <greg(a)gregorycollins.net>

3 3

Re: [Haskell-cafe] Is this a correct explanation of FRP?
by Paul Liu 05 Apr '12

05 Apr '12

On Thu, Apr 5, 2012 at 4:30 AM, Ertugrul Söylemez <es(a)ertes.de> wrote: > Paul Liu <ninegua(a)gmail.com> wrote: > >> > This isn't switching. It's selection. If fullTime decides to be >> > productive, then alterTime acts like fullTime. Otherwise it acts >> > like halfTime. If both inhibit, then alterTime inhibits. This >> > allows for a much more algebraic description of reactive systems. >> >> AFRP can do this through ArrowChoice. Maybe you can explain the >> concept of "inhibition" in more detail? >> >> I fail to grasp why this is making switches obsolete. The idea of >> switch is to completely abandoning the old state. See the broken >> pendulum example. > > Some of this can be done through ArrowChoice. The difference is > comparable to why server parts form a monoid in Happstack. You don't > have to decide when a server part reaches a request. You let the server > part decide itself. In other words ArrowChoice forces you to deal with > events in the application itself: > > -- Library code: > x = x' > y = y' > > -- Application code: > proc inp -> do > r <- request -< () > if p r > then x -< inp > else y -< inp > > Signal inhibition allows the component wires themselves to deal with the > events and you as the higher level programmer to just stick the wires > together: > > -- Library code: > x = proc inp -> do requireReq -< (); x' -< inp > y = y' > > -- Application code: > x <|> y I'm curious as to how this plays out with the usual arrow compositions. How does x *** y behave when x inhibits? what about z >>> x? This cannot replace switching though, since the structure of your arrows cannot change dynamically, while with switches it can. -- Regards, Paul Liu

1 0

Fail-back monad
by Alberto G. Corona 05 Apr '12

05 Apr '12

Hi Haskellers. In my package MFlow [1] I program an entire web navigation in a single procedure. That happened in the good-old WASH web application framework. The problem is the back button in the Browser. To go back in the code to the previous interactions when the data input does not match the expected because the user pressed the back button one or more times, i came across this Monad specimen,: that solves the problem. data FailBack a = BackPoint a -- will go back to this point | NoBack a . -- Normal outcome | GoBack -- "exception":: must go to the last backPoint newtype BackT m a = BackT { runBackT :: m (FailBack a ) } -- this monad nas a loop instance Monad m => Monad (BackT m) where fail _ = BackT $ return GoBack return x = BackT . return $ NoBack x x >>= f = BackT $ loop where loop = do v <- runBackT x case v of NoBack y -> runBackT (f y) -- business as usual BackPoint y -> do z <- runBackT (f y) case z of GoBack -> loop -- if x was a backpoint, then redirects the flow to this backpoint other -> return other GoBack -> return GoBack --propagate the signal back This monad does not perform exploration of alternatives as is the case of MonadPlus instances. It does not perform the kind of backtracking of "nondeterministic" three navigations in the Prolog style. It just go back to the last point where the computation can restart again in a sequence of actions. In this example: liftBackPoint f= BackT $ f >>= \x -> return $ BackPoint x test= runBackT $ do lift $ print "will not return back here" liftBackPoint $ print "will return here" n2 <- lift $ getLine lift $ print "second input" n3 <- lift $ getLine if n3 == "back" then fail "" else lift $ print $ n2++n3 Whenever the second input is "back" The procedure will go back to where liftBackPoint is. Otherwise, it will return the concatenation of the two inputs. If the underlying monad is an instance of MonadState, it can transport the state that caused the failure to the backpoint. Are there something similar? May it be functionally equivalent to something simpler or with more grounds? I looked at some exception monads out there, but they did not seems to share the same idea [1] http://haskell-web.blogspot.com.es/2012/02/web-application-server-with-stat…

3 6

Re: [Haskell-cafe] Fail-back monad
by oleg＠okmij.org 05 Apr '12

05 Apr '12

Alberto G. Corona wrote about a monad to set a checkpoint and be able to repeatedly go to that checkpoint and re-execute the computations following the checkpoint. http://haskell-web.blogspot.com.es/2012/03/failback-monad.html The typical example is as follows. > test= runBackT $ do > lift $ print "will not return back here" > liftBackPoint $ print "will return here" > n2 <- lift $ getLine > lift $ print "second input" > n3 <- lift $ getLine > if n3 == "back" > then fail "" > else lift $ print $ n2++n3 Let us first consider a slightly simplified problem, with a different signature for liftBackPoint. Rather than writing do liftBackPoint $ print "will return here" other_computation we will write do backPoint $ do lift $ print "will return here" other_computation In that case, backPoint will be implemented with the Exception or Error monad. For example, > backPoint :: Monad m => > ErrorT SomeException m a -> ErrorT SomeException m a > backPoint m = catchError m handler > where > handler e | Just RestartMe <- fromException e = backPoint m > handler e = throwError e -- other errors propagate up We designate one exception RestartMe as initiating the restart from the checkpoint. Other exceptions will propagate as usual. Obviously, if we are in IO or some MonadIO, we could use the regular exception-handling facilities: throw/catch. Suppose however that marking of the checkpoint should be a single action rather that exception-like handling form. Then we need the continuation monad: > type BackT r m a = ContT r (ErrorT SomeException m) a > > backPointC :: Monad m => ContT e (ErrorT SomeException m) () > backPointC = ContT (\k -> backPoint (k ())) (we have re-used the earlier backPoint). Incidentally, the continuation monad will be faster than BackT in the original article. Attentive reader must have noticed that backPointC is shift in disguise. Here is the complete code. > {-# LANGUAGE DeriveDataTypeable #-} > > module BackT where > > import Control.Monad.Trans > import Control.Monad.Error > import Control.Monad.Cont > import Control.Exception > import Data.Typeable > > > data RestartMe = RestartMe deriving (Show, Typeable) > instance Exception RestartMe > instance Error SomeException > > -- Make a `restartable' exception > -- (restartable from the beginning, that is) > -- We redo the computation once we catch the exception RestartMe > -- Other exceptions propagate up as usual. > > -- First, we use ErrorT > > backPoint :: Monad m => > ErrorT SomeException m a -> ErrorT SomeException m a > backPoint m = catchError m handler > where > handler e | Just RestartMe <- fromException e = backPoint m > handler e = throwError e -- other errors propagate up > > test1 = runErrorT $ do > lift $ print "will not return back here" > backPoint $ do > lift $ print "will return here" > n2 <- lift $ getLine > lift $ print "second input" > n3 <- lift $ getLine > if n3 == "back" > then throwError (toException RestartMe) > else lift $ print $ n2++n3 > > -- Obviously we can use error handling in the IO monad... > > -- Suppose we don't want backPoint that takes monad as argument. > -- We wish backPoint that is a simple m () action. > > -- We will use Cont monad then: That is, we use Cont + Error Monad > -- We reuse the old backPoint > > type BackT r m a = ContT r (ErrorT SomeException m) a > > backPointC :: Monad m => ContT e (ErrorT SomeException m) () > backPointC = ContT (\k -> backPoint (k ())) > > abort e = ContT(\k -> e) > > test2 :: BackT r IO () > test2 = do > liftIO $ print "will not return back here" > backPointC -- This line differs > liftIO $ print "will return here" -- (and the indentation on here) > n2 <- liftIO $ getLine > liftIO $ print "second input" > n3 <- liftIO $ getLine > if n3 == "back" > then abort $ throwError (toException RestartMe) > else liftIO $ print $ n2++n3 > > test2r = runErrorT $ runContT test2 return

2 2

Yesod 1.0 Release Candidate
by Michael Snoyman 05 Apr '12

05 Apr '12

Hi everyone, I'd like to announce the availability of the Yesod 1.0 release candidate. The code is available on Hackage now, so you should be able to install with a simple `cabal update && cabal install yesod` to get up-and-running. If you've been installing from Github or Yackage, you'll probably have the smoothest ride by wiping out your ~/.ghc and ~/.cabal/packages/cabal-src folders, and disabling Yackage as a remote repo in ~/.cabal/config. We're setting a release date of next Monday, April 9. That's when we'll be posting an official release announcement and releasing a new version of yesod-platform. At this point, the code is well tested and usable (in fact, it *is* in production use on multiple sites), but we wanted to give everyone one last chance to hammer away at the code. One of the goals with this release is to try to start pushing Haskell and Yesod to the masses (i.e., we're going to fail to avoid success at all costs). We're going to be trying to demonstrate the advantages Haskell provides over other solutions out there. I think this is the kind of effort that we can all work on together as a community. If anyone's interested in helping out with promoting, please be in touch. Michael

1 0

lhs2TeX: automatic line wrap within code blocks?
by david.mihola 05 Apr '12

05 Apr '12

Hello, I am currently using lhs2TeX for the first time and have encountered a problem which I am unable to solve myself: Some code lines are too long to fit into a single line of the output (PDF) file and thus go off the right edge of the page. Consider the following example: ------------------------------------- \documentclass{article} \usepackage[utf8]{inputenc} %include polycode.fmt %options ghci \begin{document} Our encrypted message: \begin{code} cyphertext = "rlkmlj, zlnift ekblvke pqc elvm if pzlp gblrk, akrlomk zk zle lfpiriglpke pzlp, if pzk flpojlb rcojmk cs knkfpm, morz qcobe ak pzk rcfeorp cs nkjriftkpcjiu, bklnkm pzk ljdv ofekj gjkpkfmk cs jlimift jkrjoipm lfe rlnlbjv" \end{code} Our decryption function: \begin{code} decrypt = id \end{code} The original message was: \eval{decrypt cyphertext} \end{document} ------------------------------------- Converting this to .tex with lhs2TeX and to .pdf with pdflatex produces a PDF in which both instances of the cyphertext go off the right edge of the page. Is there any way to tell lhs2TeX to allow/force line wrap within code blocks and eval-statements? Thank you very much for any help! David P.S.: I have only found one prior discussion of my question (http://tex.stackexchange.com/questions/15048/how-to-typeset-a-multiline-tex…) but to my understanding no real answer came out of that. -- View this message in context: http://haskell.1045720.n5.nabble.com/lhs2TeX-automatic-line-wrap-within-cod… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

3 2

thread killed
by tsuraan 05 Apr '12

05 Apr '12

What sorts of things can cause a thread to get an asynchronous "thread killed" exception? I've been seeing rare, inexplicable "thread killed" messages in my Snap handlers for a long time, but they aren't from Snap's timeout code. I recently upgraded to ghc 7.4.1, and that caused the kills to happen a lot more often, but also gave me some traceback capabilities. I tracked the most common kills down to cryptohash's Crypto.Hash.Tiger.update function, but that's about as pure a FFI function can be, so I don't know how that would be causing anything weird to happen. I also sometimes get the kills in the Tiger.finalize function, and I get other ones in functions that I haven't been able to track down yet. Given that the thread kills aren't from Snap's timeout code (they happen in under a second, and I have snap's timeouts turned to an insanely high value), what sort of other things cause ThreadKilled exceptions? Thanks for any help; this is really driving me mad :-/

4 9

Haskell Weekly News: Issue 221
by Daniel Santa Cruz 05 Apr '12

05 Apr '12

Welcome to issue 221 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of March 25 to 31, 2012. Quotes of the Week * Tekmo: Now I have a monoid in the category of problems. * hpc: atomically the whole thing * BMeph (in "announcer voice"): In a world, where orphan instances collide, one language holds the key to successful compilation, in our time. * thoughtpolice: if there is a question, edwardk probably has the answer * danharaj: All I have to do is remove me from the program and it works. * anonymous: Caveat implementor. * ski: 'getLine :: IO String' is a recipe for how to interact with the world to acquire a `String' ski: the recipe is not the cake Top Reddit Stories * My Thesis is Finally Complete! "Elm: Concurrent FRP for functional GUIs" Domain: self.haskell, Score: 74, Comments: 31 On Reddit: [1] http://goo.gl/yw2P9 Original: [2] http://goo.gl/yw2P9 * ANNOUNCE: Happstack 7! (Haskell Web Framework) Domain: happstack.com, Score: 51, Comments: 26 On Reddit: [3] http://goo.gl/kwcc7 Original: [4] http://goo.gl/wBBsu * pipes-like conduit Domain: yesodweb.com, Score: 49, Comments: 84 On Reddit: [5] http://goo.gl/nu4Tl Original: [6] http://goo.gl/hWaCj * SIMD Support for the vector library Domain: ghc-simd.blogspot.co.uk, Score: 45, Comments: 6 On Reddit: [7] http://goo.gl/m0PI8 Original: [8] http://goo.gl/NDq2j * Replacing Cabal Domain: yesodweb.com, Score: 40, Comments: 7 On Reddit: [9] http://goo.gl/ulv2o Original: [10] http://goo.gl/86NLW * Summarizing the conduit questions Domain: yesodweb.com, Score: 33, Comments: 13 On Reddit: [11] http://goo.gl/lkLgF Original: [12] http://goo.gl/uK25n * I love `RWST r w s (IO a) ` to ease the transition from imperative programming. Am I cheating? Domain: self.haskell, Score: 31, Comments: 53 On Reddit: [13] http://goo.gl/xq2Jn Original: [14] http://goo.gl/xq2Jn * FRP - Three principles for bidirectional GUI elements Domain: apfelmus.nfshost.com, Score: 30, Comments: 11 On Reddit: [15] http://goo.gl/AFbXE Original: [16] http://goo.gl/xd4Yf * haskell-src-exts-1.12.0: supports the new quasi-quoter syntax Domain: haskell.org, Score: 28, Comments: 6 On Reddit: [17] http://goo.gl/u6ZDx Original: [18] http://goo.gl/XTzJO * Why GADTs are awesome: implementing System F using HOAS Domain: github.com, Score: 25, Comments: 7 On Reddit: [19] http://goo.gl/IG14P Original: [20] http://goo.gl/62iLX * Reactive-banana: new major release Domain: apfelmus.nfshost.com, Score: 24, Comments: 3 On Reddit: [21] http://goo.gl/XYXvm Original: [22] http://goo.gl/u3PAz Top StackOverflow Questions * Does Haskell require a garbage collector? votes: 40, answers: 7 Read on SO: [23] http://goo.gl/hDNT4 * Can you recognize an infinite list in a Haskell program? [closed] votes: 20, answers: 5 Read on SO: [24] http://goo.gl/TcJHt * Confusion regarding a passage in the “Kinds and some type-foo” section of learnyouahaskell.com votes: 12, answers: 1 Read on SO: [25] http://goo.gl/ldKbM * Haskell: Correct practice to specify version in source? votes: 7, answers: 2 Read on SO: [26] http://goo.gl/eUr6X * How to count the number of times a fuction was called, the FP way votes: 7, answers: 2 Read on SO: [27] http://goo.gl/OLNxy * how to translate Haskell into Scalaz? votes: 7, answers: 2 Read on SO: [28] http://goo.gl/1ep62 * In which languages is function abstraction not primitive votes: 7, answers: 7 Read on SO: [29] http://goo.gl/aZG5w * Is it possible to debug pattern matching in a Haskell function? votes: 6, answers: 3 Read on SO: [30] http://goo.gl/qIpDw * Generate cabal file with dependencies on foreign libs votes: 5, answers: 2 Read on SO: [31] http://goo.gl/mRz1o * Is there a monadic version of Arbitrary to use with QuickCheck? votes: 5, answers: 2 Read on SO: [32] http://goo.gl/1IOg4 Until next time, Daniel Santa Cruz References 1. http://www.reddit.com/r/haskell/comments/rkyoa/my_thesis_is_finally_complet… 2. http://www.reddit.com/r/haskell/comments/rkyoa/my_thesis_is_finally_complet… 3. http://www.happstack.com/C/ViewPage/1 4. http://www.reddit.com/r/haskell/comments/rjtwt/announce_happstack_7_haskell… 5. http://www.yesodweb.com/blog/2012/03/pipes-like-conduit 6. http://www.reddit.com/r/haskell/comments/reft1/pipeslike_conduit/ 7. http://ghc-simd.blogspot.co.uk/2012/03/simd-support-for-vector-library.html 8. http://www.reddit.com/r/haskell/comments/reyn9/simd_support_for_the_vector_… 9. http://www.yesodweb.com/blog/2012/04/replacing-cabal 10. http://www.reddit.com/r/haskell/comments/rnd2b/replacing_cabal/ 11. http://www.yesodweb.com/blog/2012/03/summarizing-conduit-questions 12. http://www.reddit.com/r/haskell/comments/rhs0y/summarizing_the_conduit_ques… 13. http://www.reddit.com/r/haskell/comments/rd2t5/i_love_rwst_r_w_s_io_a_to_ea… 14. http://www.reddit.com/r/haskell/comments/rd2t5/i_love_rwst_r_w_s_io_a_to_ea… 15. http://apfelmus.nfshost.com/blog/2012/03/29-frp-three-principles-bidirectio… 16. http://www.reddit.com/r/haskell/comments/rj4l1/frp_three_principles_for_bid… 17. http://www.haskell.org/pipermail/haskell-cafe/2012-March/100421.html 18. http://www.reddit.com/r/haskell/comments/rfn3g/haskellsrcexts1120_supports_… 19. https://github.com/DanBurton/Blog/blob/master/Literate%20Haskell/SystemF.lhs 20. http://www.reddit.com/r/haskell/comments/rk0uf/why_gadts_are_awesome_implem… 21. http://apfelmus.nfshost.com/blog/2012/03/25-frp-banana-0-5.html 22. http://www.reddit.com/r/haskell/comments/rd35t/reactivebanana_new_major_rel… 23. http://stackoverflow.com/questions/9952602/does-haskell-require-a-garbage-c… 24. http://stackoverflow.com/questions/9889347/can-you-recognize-an-infinite-li… 25. http://stackoverflow.com/questions/9892814/confusion-regarding-a-passage-in… 26. http://stackoverflow.com/questions/9857710/haskell-correct-practice-to-spec… 27. http://stackoverflow.com/questions/9920129/how-to-count-the-number-of-times… 28. http://stackoverflow.com/questions/9941199/how-to-translate-haskell-into-sc… 29. http://stackoverflow.com/questions/9944159/in-which-languages-is-function-a… 30. http://stackoverflow.com/questions/9949494/is-it-possible-to-debug-pattern-… 31. http://stackoverflow.com/questions/9857597/generate-cabal-file-with-depende… 32. http://stackoverflow.com/questions/9863451/is-there-a-monadic-version-of-ar…

1 0

Is this a correct explanation of FRP?
by Peter Minten 04 Apr '12

04 Apr '12

Hi, I've been trying to get my head around Functional Reactive Programming by writing a basic explanation of it, following the logic that explaining something is the best way to understand it. Am I on the right track with this explanation? Greetings, Peter Minten P.S. Sorry about the long mail, the explanation ended up a little longer than I originally expected. :) Document (with markdown formatting) follows: --8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<--8<-- This is an attempt to explain Functional Reactive Programming (FRP) enough to give a reader with no previous exposure to FRP an intuition what FRP is about. After reading this you should hopefully understand enough of FRP to understand the [reactive-banana](http://www.haskell.org/haskellwiki/Reactive-banana) examples. FRP has certain terms such as behavior, event and time-varying that can be confusing for people unfamiliar with it. I'll avoid these terms at first and will focus on spreadsheets and a generalization of spreadsheet cells (which I will call boxes). Later, once the most important concepts are explained, reactive-banana syntax will be introduced along with an example that demonstrates how to work with behaviors and events in reactive-banana. Finally some theory about time-varying functions and how events and behaviors can be implemented using pure functions by making time explicit should provide the necessary background to understand reactive-banana's haddock comments. The version of reactive-banana used here is [0.5.0.0](http://hackage.haskell.org/package/reactive-banana-0.5.0.0). Reactive Programming for the Masses: The Spreadsheet ==================================================== Spreadsheets are something we all (for certain values of we) know about. Let's talk about a typical, simplified, spreadsheet. We have a list of products that we sell and want to compute their price with the Value Added Tax (VAT) added. We might have cells A1 to A10 contain the raw prices of our products and cell B1 contain the current VAT rate (say 19 for a 19% VAT). In cells C1 to C10 we'd like to see the prices including VAT. In cell C1 we'd have a formula: `=A1*(1+B1/100)`, in cell C2 `=A2*(1+B1/100)`, etc. So if A1 contains $100 C1 would contain $119. But what if the government, in it's eternal quest to reduce the budget deficit, raises the VAT rate? We'd adjust cell B1, just change it to 20. And like magic all the C cells are updated. Though this may seem mundane what we've just seen is actually a very good example of reactive programming. We didn't tell the C cells to update; they updated on their own because a value they depend on changed. >From Cells to Boxes: Generalizing the Spreadsheet ================================================= Spreadsheets are nice, but if we want to truly get a feel for FRP we'll have to think beyond them. If we look at a spreadsheet at an abstract level it pretty much consists of cells of two types: value cells (`19`) and formula cells (`=A1*(1+B1/100)`). Let's lose the reference to spreadsheets and talk about boxes. Say, for now, that there are two kinds of boxes: formula boxes and value boxes. Both support a "get" operation that returns a value. Value boxes additionally support a "set" operation that sets the value. Formula boxes can contain any kind of pure function. They can also refer to the values of other boxes (both formula and value boxes). Value boxes don't have a function inside them, they have a value. The translation of our VAT spreadsheet would be something like a formula box *fIncl1* containing the expression `get(vExcl1) * (1 + get(vVat) / 100)`. This expression uses two value boxes: *vExcl1* and *vVat*. We could also write *fIncl1* using a helper formula box *fVat*. Let *fVat* have the formula `1 + get(vVat) / 100` and *fIncl1* have the formula `get(vExcl1) * get(vVat)`. I'll use `:=` for this kind of definition, the `:=` is there to remind you that this isn't Haskell. It's important to note that any kind of value may be put into value boxes, including IO actions and functions. Try doing this with a spreadsheet: `fIncls := [get(ve) * get(vVat) | ve <- vExcls]`. Or this: `fIncl1 := apply(get(vVatFunc), get(vExcl1))`. If you're wondering why I'm not using Haskell syntax, it's to focus on the meaning of boxes rather than what the functions and combinators mean. That said, this pseudo-imperative syntax is on its way out as it's getting too clunky (that `apply` function is really just ugly). For a quick peek ahead the last few examples would be something like this in reactive-banana: fIncls = map (\ve -> (*) <$> ve <*> fVat) vExcls fIncl1 = fVatFunc <*> vExcl1 Events ====== Let's say we want to build the worlds worst synthesizer. We have 7 buttons: "a", "b", "c", "d", "e", "f" and "g". Our output is generated by sampling a box twice per second and playing the frequency in the box until the next sample is taken. This can't be expressed with the crude formula and value boxes system we've had so far. There is no way to express key presses in that system, a key press isn't like changing a value, it's something that occurs on a specific point in time but after it occurs it's forgotten (your keyboard doesn't remember key strokes, at least mine doesn't). In this new system we'll forget about formula boxes and value boxes and introduce event boxes. Event boxes are like formula boxes in that they can refer to the value of other boxes. Event boxes can also react to events. Events can be thought of like signals in something like D-Bus. Multiple things (event boxes) can listen to them and do something once a specific event is fired (triggered). Every event has a value associated with it. Sometimes the value isn't important because the fact that the event has occurred is what's interesting but often we do want to know the value. Events come in streams. When we say event box *b1* changes to the value of event *e1* when it receives that event we're actually saying that whenever an event from the stream of events we colloquially call *e1* comes *b1* changes to the value of that event. Yes, that's confusing so I'll try to be precise. Just remember that when I refer to something like *e1* when defining an event box it's always to a stream of events, never a specific event. If you're puzzled by the stream just think of it as an acknowledgement that a certain kind of event can occur multiple times. It actually goes a lot deeper than that, involving those confusing `[(t, e)]` types, but for now just remembering that a kind of event can occur multiple times with possibly different values is good enough. Events have values and we can use that to chose to do something only for events with some value. So not only can we determine which streams of events we'll do something with when defining an event box, we can also determine for what values of events we'll do something. For example if we have an event that directly sets our synthesizer frequency we can apply a filter that only allows events with frequencies that are pleasant to the human ear. Some Reactive-Banana syntax =========================== Expressing event handling with the pseudo-code I've used before is tricky and gets near impossible soon. So it's a good thing that once you've understood or at least got a basic idea of the concepts of event streams and event boxes the syntax of reactive-banana starts to make sense. In this section I'll explain the most fundamental functions and operators. If you're reading the [reactive-banana 0.5 haddocks](http://hackage.haskell.org/package/reactive-banana-0.5.0.0) there are a few things to keep in mind. The first is that what I've called an event box in the previous section is called a Behaviour in reactive-banana. To avoid confusion I'll stop using the term event box from here on. In the reactive-banana haddocks you'll find a lot of references to time-varying functions and lists involving time variables. Just ignore those, they're important but we'll get to them later. As a general rule just ignore what you don't understand. You'll also notice a `t` parameter on the `Event` and `Behavior` types. It's basically similar to the `s` parameter for `STRef`, it's a trick to use the type system to prevent constructs that would result in undefined or incorrect behavior. Just ignore it. For understanding the next sections you'll need to know about a basic subset of reactive-banana which I'll explain here. First up: event streams. Events ------ Event streams are represented by the type Event in reactive-banana. The type `Event t Int` means a stream of events carrying Int values. There are three basic things you can do with just event streams. You can transform the events in them, you can filter in events in them and you can combine the event streams. Transforming an event stream means changing the values carried by the events in them. As this is *Functional* Reactive Programming the streams themselves are not changed. When you transform a stream you create a new stream. Whenever an event in the old stream is fired an event in the new stream is also fired, but with a different value. Transforming an event stream is done primarily by good old fmap. The expression ``show `fmap` eInt`` (or with the (`<$>`) operator `show <$> eInts`) with *eInt* having the type `Event t Int` creates a new event stream of the type `Event String` with the int in every event in the original stream being a string in the new stream. To replace the value of an event (if the event doesn't carry a useful value) just use (`<$`): `"MOO!" <$ eWhatever` causes every value in the stream eWhatever to be replaced by MOO!. Like (`<$>`) this is an operator from Control.Applicative. Filtering is done using the `filterE` function. When you filter an event stream you create a new event stream with the same associated values but which doesn't contain all the events from the original stream. To only deal with events with positive integers you can create a filtered stream using ``filterE (>= 0) eInt``. Combining event streams creates a new event stream with all the events from both streams. So if you combine *eOne* and *eTwo* into *eThree* there will be an event in *eThree* for every event in *eOne* and for every event in *eTwo*. Combining is done with the union function: ``eThree = eOne `union` eTwo``. Beware however that when events come in at the same time things can get a little tricky, you'd have to wonder in what order the events are processed. Reactive-banana contains several functions to handle simultaneous events. For the purpose of this document we'll do the easiest thing and ignore simultaneous events. In real world code you would need to think about it. Behaviors --------- To create a behavior (event box) in reactive-banana you'll typically use one of two functions: `stepper` and `accumB`. Both work with an initial value and an event stream. The difference is that when an event occurs `stepper` changes the value of the behavior to the value in the event while `accumB` applies the function in the event to the value of the behavior. eNewVal :: Event t Int bSet :: Behavior t Int bSet = stepper 0 eNewVal eUpdater :: Event t (Int -> Int) bUpdated :: Behavior t Int bUpdated = accumB 0 eUpdater The expression `bSet = stepper 0 eNewVal` creates a behavior named *bSet* with initially value 0. Once an event from the *eNewVal* stream comes in the value of *bInt* changes to the value in that event. So if an event comes in with value 2 the value of bSet becomes 2. On the other hand the expression `bUpdated = accumB 0 eUpdater` makes *bUpdated* a behavior with initially the value 0 but which gets updated (modified) whenever an event comes in. If an event comes in with value (+1) (a slice, so `\x -> x + 1`) and the current value of *bUpdated* is 1 the new value becomes 2. That's basically it for behaviors. Well, there's a third way to create behaviors: using `pure`. To create a behavior with the value 1 which doesn't change at all use `pure 1`. In case you didn't know, for applicative functors (which behaviors are) `pure` is what `return` is for monads. To create a behavior that's depends on old behaviors (`f3 := get(f1) + get(f2)` in our old formula box syntax) we have to use applicative functor functions in reactive-banana. There is unfortunately no option to use monad syntax. To express that the value of *b3* is the sum of the value of *b1* and the value of *b2* we write: `b3 = (+) <$> b1 <*> b2`. Example: The Worlds Worst Synthesizer ===================================== Now for an example. We'd like to create a synthesizer. The synthesizer will use our keyboard for input, which we notice through a stream of events called *eKey* with as associated value a Char containing the key that was pressed. Something outside our program (and scope of discussion) samples the behavior *bNote* every 100ms and plays the tone currently in there until the next sample time. To avoid getting caught up in music theory (read: I'm lazy and can't be bothered to look up tone frequencies) the note to play is expressed as an algebraic data type. type Octave = Int data Pitch = PA | PB | PC | PD | PE | PF | PG data Note = Note Octave Pitch -- Type signature for the key event, it comes from outside our -- system. eKey :: Event t Char You'll notice the octave. To change the octave we'll use the '-' and '+' keys. To set the pitch we'll use the 'a'..'g' keys on the keyboard. Never mind that it's really annoying to play with those keys as they're scattered all over the keyboard, this is about the FRP logic not practicality. Those chars in the *eKey* event stream need to be translated to pitches. Here's one way to do that. ePitch :: Event t Pitch ePitch = (PA <$ filterE (=='a') eKey) `union` (PB <$ filterE (=='b') eKey) `union` ... (PG <$ filterE (=='g') eKey) The "trouble" here is that we're filtering the stream multiple times, not very efficient. Here's a better way. table = [('a', PA), ('b', PB), ..., ('g', PG)] ePitch = filterJust $ (\e -> lookup e table) <$> eKey The `filterJust` function is a simple helper in reactive-banana. It filters out `Nothing` events and returns the value inside the `Just` constructor for `Just` events. To get *ePitch* we first look up the characters in the translation table and then remove all events who's chars aren't in the table, removing the `Just` wrapper from events who's chars are in the table at the same time. The *bNote* behavior will not use these events directly, instead *bOctave* and *bPitch* will each store part of the note and *bNote* will combine the information. eOctUp, eOctDown :: Event t Char eOctUp = filterE (=='+') eKey eOctDown = filterE (=='-') eKey bOctave :: Behavior t Octave bOctave = accumB 0 $ ((+1) <$ eOctUp) `union` ((subtract 1) <$ eOctDown) bPitch :: Behavior t Pitch bPitch = stepper PC ePitch bNote :: Behavior t Note bNote = Note <$> bOctave <*> bPitch If you understand what's going on here you should have a basic idea of what FRP is in practice. There are of course considerations in the real world that we've skipped over here, such as how to get the keyboard event and how to play the sounds. To get a better idea of what FRP in the real world looks take a look at the [reactive-banana examples](http://www.haskell.org/haskellwiki/Reactive-banana/Examples), they should be easy to follow. When following those examples you'll come across the (`<@`) and (`<@>`) operators. I'll give a short introduction here to make it easier to understand the examples. The (`<@`) operator is used like this: `e2 = b1 <@ e1`, if an event in stream *e1* comes in the value of that event is replaced in the *e2* stream by whatever value is in *b1* at the time. The (`<@>`) operator is used in much the same way, but it doesn't replace the value from *e1* outright but uses it to compute a new value. bOne :: Behavior t Int bOne = pure 1 bPlusOne :: Behavior t (Int -> Int) bPlusOne = pure (+1) eAlwaysOne, ePlusOne :: Event t Int eAlwaysOne = bOne <@ eWhatever ePlusOne = bPlusOne <@> eInt Time-varying values and functions ================================= If you've read about FRP before you're likely to have come across the term "time-varying function". This sounds difficult, but once you understand the basics of behaviors and events it's really no big deal. Here's the clue: a behavior contains a value, but the value can change. Therefore at different points in time a behavior can have different values. So we could say that a behavior has a value that varies in time. We could also throw away the concept of boxes and say a behavior *is* a value that varies in time. This is more correct, those boxes are helpful as teaching concepts but once we talk directly about time they are no longer needed. So, a time-varying value is simply a behavior as behaviors can have different values at different points in time. A time-varying function is also just a behavior, one where the value is a function (functional programming 101: the clue to every riddle is that functions are values). To go further down the rabbit hole a time-varying value can actually be thought of as a function by making time explicit. If a behavior has value 1 up to the 30th's second and from that point forward value 2 we could express the behavior as: `\t -> if t < 30 then 1 else 2`. This is important: by making time explicit we can reason about behaviors as if they were pure functions. While in practice we're dealing with applicative functors (or in other libraries monads or arrows) we can think of behaviors as pure functions. Real world behaviors aren't as simple as from 30 seconds onwards change to value 2. They interact with events. So to express such behaviors as pure functions events need to be expressed in a way that works for pure functions. This is where the `[(t,e)]` type comes in. We can see events as a list of values at certain points in time, for example `[(10, 1), (20, 2), (30, 3)]` for events that occur on second 10, 20 and 30 with values 1, 2 and 3 respectively. When viewing events in such a way it becomes easy to create a behavior that changes to whatever value was last: type Time = Int stepped :: [(Time, Int)] -> Time -> Int stepped es t = case takeWhile (\(t', _) -> t' <= t) es of [] -> 0 xs -> snd (last xs) For once this is actually runnable code. If we invoke it as `stepped [(10,1),(20,1),(30,1)] 2` the result is 0, if we invoke it as `stepped [(10,1),(20,1),(30,1)] 12` the result is 1, as expected. Stepped sounds a lot like stepper and we can create that function by making a few small adjustments. type Time = Int stepper :: a -> [(Time, a)] -> (Time -> a) stepper d es = \t -> case takeWhile (\(t', _) -> t' <= t) es of [] -> d xs -> snd (last xs) If you understand this bit, why behaviors and events can be expressed by making time explicit you have a good intuition of what FRP is. Good luck on your endeavors in FRP land.

6 12

GSOC Proposal 2012 : HDBC
by pranjal pandit 04 Apr '12

04 Apr '12

Hi, I would like to work on improving the HDBC as a GSOC project 2012. I have a previous working experience with Django and its ORM and I had a look at Amnesia (http://amnesia.sourceforge.net/user_manual/manual.html) which is a SQL database interface for Erlang. Few of the features of both include: 1 ) Database operation are supported through Language Native types. 2 ) Direct table creation from native language constructs. (models.py in Django and *tablename*.hrl in Amnesia) I would like to make developement in HDBC so that all Database interactions are made through Haskell Native data type. For eg - In using Erlang Database interface through Amnesia on would write (Quoting example from Amnesia Documentation) populate() -> {ok, Pid} = amnesia:open(sales), %% adding customer {ok, Cust1} = amnesia:add_new (Pid, #customer {customer_code = 102341, name = "John", address = "XXXXX", email = "john@xxx"}), %% adding product {ok, P1} = amnesia:add_new (Pid, #product { product_code = "001", description = "CPU Intel", price = 231.10 }), %% now let's add an order for customer "Cust2" {ok, Order} = amnesia:add_new (Pid, #orders { order_number = 30, order_date = {2008, 7, 17}, customer = Cust1 }), Here each Erlang record (#customer, #product and #orders) are responsible for different Database Tables. So writing the first statement inserts into database and return an object Cust1 that can be used late down the line to create an order table object. In Django through Python one would have written: customer = Customer.objects.create(customer_code=102341, name = "John", address = "XXXXX", email = "john@xxx" ) order = Orders.objects.create(order_number = 30, order_date = {2008, 7, 17}, customer = customer) Writing everything through Language type increases more readability inside the code. Additionally this helps in abstracting the logic in code from the underlying SQL being executed. In addition to the support for select, insert, update queries the my work would extend support for Joins, aggregations etc all in Haskell Native Types. I would also like to work to handle the database queries from wire formats/ binaries instead of strings as is the case currently. I would like to close down these two features as a GSOC project during the summer of 2012 and I would your feedback on the same. -- Regards Pranjal Pandit Don't communicate by sharing memory; share memory by communicating.

3 2

Conduits: Is Source a valid instance of Monad?
by Aristid Breitkreuz 04 Apr '12

04 Apr '12

Hi all, As you may have noticed, Michael Snoyman has been working on an alternative approach to I/O, called conduits. You can find it here: https://github.com/snoyberg/conduit When looking at the Source type (explained here: http://www.yesodweb.com/blog/2011/12/conduits) I noticed that they seem to behave "like lists", and naturally wondered if I could write a Monad instance for them. But first, let's have a brief look at the definition of Source: data SourceResult a = Open a | Closed data PreparedSource m a = PreparedSource { sourcePull :: ResourceT m (SourceResult a) , sourceClose :: ResourceT m () } newtype Source m a = Source { prepareSource :: ResourceT m (PreparedSource m a) } ResourceT deals with resource acquisition and releasing (making sure that all resources are released), and provides a an abstraction over IORef/STRef. For our purposes here, ResourceT is probably close enough to IO. So now the question again is, can we write a Monad instance for this? I have been able to write join (concatenate) and return (a source with a single non-repeated) element. https://gist.github.com/1525471 I _think_ it behaves properly like a Monad, but I'm not quite sure, and neither was Michael. Greg Weber then suggested bringing the question to this forum. What made the question difficult for me is that this would be a stateful Monad transformer, so I'm not quite sure how to test the Monad laws properly. There's a second part to this question: If Source turns out not to be a Monad, is it possibly a ZipList-like Applicative? And either way, which is more useful: The list-like or the ziplist-like instances (of Applicative/Monad)? Thank you, Aristid

4 4

GSOC Proposal 2012 : HDBC
by Greg Weber 04 Apr '12

04 Apr '12

Hi Pranjal, We are glad you are interested in the GSoC. Please take a look at persistent: http://www.yesodweb.com/book/persistent It performs queries and serialization based on Haskell records. It also uses native drivers rather than HDBC. I created a proposal outline [1] and there is a student submission for it [2] [1] http://hackage.haskell.org/trac/summer-of-code/ticket/1605 [2] http://hackage.haskell.org/trac/summer-of-code/ticket/1605 Let me know if you are interested in that or need help coming up with a proposal Thanks, Greg Weber

1 0

mueval leaving behind tmp files
by Johannes Waldmann 04 Apr '12

04 Apr '12

The following program prints Right ("test","Bool","True") as it should, but it leaves behind in /tmp two files (name is a long string of digits) and an empty directory (name is ghcNNNNN_N). ... and it deletes the input file (/tmp/Main.hs). That's not nice. Ideally, I would want to read input from a String (instead of the file), and not write to disk at all. But cleaning up properly would be OK as a work-around. import Language.Haskell.Interpreter import Mueval.Interpreter import Mueval.ArgsParse main = do writeFile "/tmp/Main.hs" "test = True" result <- runInterpreter $ interpreter $ Options { timeLimit =1, modules =Just ["Prelude"], expression ="test" , loadFile ="/tmp/Main.hs", user="what", printType =True , extensions =False,namedExtensions = [] , noImports =False, rLimits =False, help=True } print result ghc --version The Glorious Glasgow Haskell Compilation System, version 7.4.1 ghc-pkg list| egrep 'mueval|hint' hint-0.3.3.4 mueval-0.8.1.1 uname -a Linux octopus 3.0.0-16-generic #29-Ubuntu SMP Tue Feb 14 12:48:51 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux

2 2

GSoC proposal: Units for GHC
by Nils Schweinsberg 04 Apr '12

04 Apr '12

Hi Haskell-Cafe & GHC-users! I'm looking to apply for the GSoC and since I've worked on GHC before I'd like to continue to do so. My proposal would be something that tempted me (as a physics student) for a while: Units for Haskell/GHC. This project has been suggested for a long time on the GHC wiki, and there is already a lot of work done for other languages like ML, F# etc[1]. I have tried to implement e.g. the unification algorithm from the "Types for Units-of-Measure in F#" talk[2] for an abstract syntax tree[3] and it was pretty much straight forward. As I see it, the project would consist of: 1.) Find appropriate rules/algorithms for unit analysis. Most (if not all?) of this should be covered in those papers/talks on [1]. 2.) Applying the rules to the Haskell syntax tree used in GHC. I have approximately 3 years of experience with Haskell, I worked for the database research group[4] at the University of Tübingen (Germany) on the Database Supported Haskell[5] library. I've done most of the coding for the monad comprehension[6] extension, which has been added to the latest GHC release version. I'm already quite familiar with the GHC internals of the compiler/typechecker, and even though I'd have to look up how exactly type interference etc. works in GHC (as I've only *used* it, but never tried to understand/modify it) I'm confident that the work on GHC itself should be doable in the given timeframe. So my questions would be: Do you think this is a appropriate GSoC project? What should I include in the application/project proposal? Anything else? Opinions, suggestions? I realize that I'm kind of late and probably should have written this email a long time ago. But there are still 2 days left for the student application and hopefully I'll get some good feedback by then. - Nils [1]: http://research.microsoft.com/en-us/um/people/akenn/units/index.html [2]: http://research.microsoft.com/en-us/um/people/akenn/units/MLWorkshop2008.pdf [3]: https://github.com/mcmaniac/units/blob/master/src/Unification.hs [4]: http://db.inf.uni-tuebingen.de/team [5]: http://hackage.haskell.org/package/DSH [6]: http://db.inf.uni-tuebingen.de/files/giorgidze/haskell2011.pdf

3 3

Re: [Haskell-cafe] GSoC proposal: Units for GHC
by George Giorgidze 04 Apr '12

04 Apr '12

Implementing this proposal in GHC, as opposed to the library-only approach, would allow for generation of much more useful and user friendly error messages. I believe this aspect is important when it comes to type systems supporting physical units. Cheers, George > This sounds pretty cool and useful. How much of this can be implemented in a library and how much of this would need to be supported on a compiler level? Ideally, most of this would be solved on the library level.

1 0

ANNOUNCE: fast-tags-0.0.1
by Evan Laforge 04 Apr '12

04 Apr '12

A while back I was complaining about the profusion of poorly documented tags generators. Well, there is still a profusion of poorly documented tags generators... I was able to find 5 of them. So, that said, here's my contribution to the problem: fast-tags, haskell tag generator #6. Why not use one of the other 5? Two of them use haskell-src which means they can't parse my code. Two more use haskell-src-exts, which is slow and fragile, breaks on partially edited source, and doesn't understand hsc. Then there's the venerable hasktags, but it's buggy and the source is a mess. I fixed a bug where it doesn't actually strip comments so it makes tags to things inside comments, but then decided it would be easier to just write my own. fast-tags is fast because it has a parser that's just smart enough to pick out the tags. It can tagify my entire 300 module program in about a second. But it's also incremental, so it only needs to do that the first time. I have vim's BufWrite autocommand bound to updating the tags every time a file is written, and it's fast enough that I've never noticed the delay. It understands hsc directly (that's trivial, just ignore the # lines) so there's no need to run hsc2hs before tagifying. The result is tags which are automatically up to date all the time, which is nice. If people care about lhs and emacs tags then it wouldn't be hard to support those too, and at that point I could replace hasktags and we'd be back down to 5 again. But I'm not even sure anyone uses hasktags, since surely someone would have noticed that comment bug. Anyway, it's been working great for me for a couple weeks so I uploaded it to hackage: http://hackage.haskell.org/package/fast-tags

5 9

A Modest Records Proposal
by Gershom B 03 Apr '12

03 Apr '12

The records discussion has been really complicated and confusing. But I have a suggestion that should provide a great deal of power to records, while being mostly[1] backwards-compatible with Haskell 2010. Consider this example: data A a = A{a:a, aa::a, aaa :: a -> A (a -> a)} data B a = B{aaa :: a -> A (a -> a), a :: A} Now what is the type of this? aaaa aaaaa a aa = aaaaa{a = a, aaa = aa} Using standard Haskell typeclasses this is a difficult question to answer. The types of aaaa for A and B do not unify in an obvious way. However, while they are intensionally quite distinct, they unify trivially extensionally. The obvious thing to do is then to extend the type system with extensional equality on record functions. Back when Haskell was invented, extensional equality was thought to be hard. But purity was thought to be hard too, and so were Monads. Now, we know that function existentionality is easy. In fact, if we add the Univalence Axiom to GHC[2], then this is enough to get function existensionality. This is a well-known result of Homotopy Type Theory[3], which is a well-explored approach that has existed for at least a few years and produced more than one paper[4]. Homotopy Type Theory is so sound and well understood that it has even been formalized in Coq. Once we extend GHC with homotopies, it turns out that records reduce to mere syntactic sugar, and there is a natural proof of their soundness (Appendix A). Furthermore, there is a canonical projection for any group of fields (Appendix B). Even better, we can make "." into the identity path operator, unifying its uses in composition and projection. In fact, with extended (parenthesis-free) section rules, "." can also be used to terminate expressions, making Haskell friendly not only to programmers coming from Java, but also to those coming from Prolog! After some initial feedback, I'm going to create a page for the Homotopy Extensional Records Proposal (HERP) on trac. There are really only a few remaining questions. 1) Having introduced homotopies, why not go all the way and introduce dependent records? In fact, are HERP and Dependent Extensional Records Proposal (DERP) already isomorphic? My suspicion is that HERP is isomorphic, but DERP is not. However, I can only get away with my proof using Scott-free semantics. 2) Which trac should I post this too? Given how well understood homotopy type theory is, I'm tempted to bypass GHC entirely and propose this for haskell-prime. 3) What syntax should we use to represent homotopies? See extend discussion in Appendix C. HTH HAND, Gershom [1] To be precise, 100% of Haskell 2010 programs should, usually, be able to be rewritten to work with this proposal with a minimal set of changes[1a]. [1a] A minimal set of changes is defined as the smallest set of changes necessary to make to a Haskell 2010 program such that it works with this proposal. We can arrive at these changes by the following procedure: 1) Pick a change[1b]. 2) Is it minimal? If so keep it. 3) are we done? If not, make another change. [1b] To do this constructively, we need an order. I suggest the lo mein, since noodles give rise to a free soda. [2] I haven't looked at the source, but I would suggest putting it in the file Axioms.hs. [3] http://homotopytypetheory.org/ [4] http://arxiv.org/ *Appendix A: A Natural Proof of the Soundness of HERP Take the category of all types in HERP, with functions as morphisms. Call it C. Take the category of all sound expressions in HERP, with functions as morphisms. Call it D. Define a full functor from C to D. Call it F. Define a faithful functor on C and D. Call it G. Draw the following diagram. F(X)----F(Y) | | | | | | G(X)----G(Y) Define the arrows such that everything commutes. *Appendix B: Construction of a Canonical Projection for Any Group of Fields. 1) Take the fields along the homotopy to an n-ball. 2) Pack them loosely with newspaper and gunpowder. 3) Project them from a cannon. In an intuitionistic logic, the following simplification is possible: 1) Use your intuition. *Appendix C: Homotopy Syntax Given that we already are using the full unicode set, what syntax should we use to distinguish paths and homotopies? At first, I thought we could avoid providing any syntax for homotopies at all. Haskell is a language with type inference, so we should just be able to infer paths and homotopies behind the scenes by adding homotopies to the type system. That's a very nice answer in theory. But in the real world, when we're writing code that solves actual problems, theoretical niceties break down. What if a user wants to use a nonstandard homotopy? Why should we stop them just because we're too lazy to come up with a good syntax? I then realized that we keep running out of syntax because we've limited ourselves to unicode. Instead, I propose we add a potentially infinite universe of identifiers: youtube videos. For example, the higher inductive type for a circle can be written as: homotopyType http://www.youtube.com/watch?v=dQw4w9WgXcQ where Base ::: http://www.youtube.com/watch?v=dQw4w9WgXcQ Loop ::: http://www.youtube.com/watch?v=J---aiyznGQ Base Base Note that the urls do not use SSL. For portability reasons, I propose that SSL only be enabled as an optional extension.

8 9

(no subject)
by Mark Snyder 02 Apr '12

02 Apr '12

<a href="http://dreadscottart.com/mynewwebsite/wp-content/plugins/extended-comment-o…"> http://dreadscottart.com/mynewwebsite/wp-content/plugins/extended-comment-o…</a>

1 0

Regarding simple xml string parser code review
by rajendra prasad 02 Apr '12

02 Apr '12

Hi, I am trying to fetch the values under tags in an xml string given the tag string and xml string. Actually, I don't want to use xml parser since I need to parse very small xml strings. Also, I dont want to use anything else other than haskell platform. I wrote some routines and want to know whether there is any better option available. Please review them and the comments will be highly appreciated. please find routines posted at http://hpaste.org/66357 Thanks in advance. Regards, Rajendra

1 0

Towards a single, unified API for incremental data processing
by John Millikin 02 Apr '12

02 Apr '12

There are currently several APIs for processing strict monoidal values as if they were pieces of a larger, lazy value. Some of the most popular are based on Oleg's left-fold enumerators, including the "iteratee", "enumerator", "iterIO". Other choices include "comonads", "conduits", and "pipes". Despite having various internal implementations and semantics, these libraries generally export a similar-looking API. This is a terrible duplication of effort, and it causes dependant packages to be strongly tied to the underlying implementation. I propose that a new package, "tzinorot", be written to provide a single API based on Data.List. It should be pretty easy to use, requiring only a few common extensions to the type system. For example, the enumerator package's 'mapM' function could be generalized for use in tzinorot through a few simple modifications to the type signature: ---------- -- enumerator mapM mapM :: Monad m => (ao -> m ai) -> Enumeratee ao ai m b -- tzinorot mapM mapM :: (Monad m, Tzinorot t, ListLike l1 a1, ListLike l2 a2) => (l1 a1 -> m (l2 a2)) -> t Void s (TzinorotItems (l1 a1)) (TzinorotItems (l2 a2)) m r ---------- To make it easier to install and use the tzinorot package, it will depend on all of its supported implementations (iteratee, enumerator, conduits, pipes, etc), and use Michael Snoyman's "cabala" tool to manage dependency versions. See the cabala announcement for details on use: http://www.yesodweb.com/blog/2012/04/replacing-cabal

2 1

ANN: acme-http
by Jeremy Shaw 01 Apr '12

01 Apr '12

Hello, As we all know, the true measure of performance for a web server is the classic PONG test. And, so the Happstack team is pleased to announce the release of the new acme-http server! hackage: http://hackage.haskell.org/package/acme-http source: http://patch-tag.com/r/stepcut/acme-http When testing on my laptop with +RTS -N4 using the classic PONG test: $ httperf --hog -v --server 127.0.0.1 --port 8000 --uri / --num-conns=1000 --num-calls=1000 --burst-length=20 --rate=1000 acme-http delivered 221,693.0 req/s, making it the fastest Haskell web server on the planet. By comparison, warp delivered 51,346.6 req/s on this machine. The secret to acme-http's success is that it large avoids doing anything not required to win the PONG benchmark. It does not support timeouts, it does not check quotas, it assumes the client is HTTP 1.1, it does not catch exceptions, and it responds to every single request with PONG. The goal of acme-http is two fold: 1. determine the upper-bound on Haskell web-server performance 2. push that upper bound even higher In regards to #1, we have now established the current upper limit at 221,693.0 req/s. In regards to #2, I believe acme-http will be useful as a place to investigate performance bottlenecks. It is very small, only 250 lines of code or so. And many of those lines deal with pretty-printing, and other non-performance related tasks. Additionally, it works in the plain IO monad. It does not use conduits, enumerators, pipes, or even lazy IO. As, a result, it should be very easy to understand, profile, and benchmark. In providing such a simple environment and avoiding as much extra work as possible we should be able to more easily answer questions like "Why is so much RAM required?", "What is limiting the number of connections per second", etc. As we address these issues in acme-http, we can hopefully bring solutions back to practical frameworks, or to the underlying GHC implementation itself. If performance tuning is your thing, I invite you to check out acme-http and see if you can raise the limit even higher! - jeremy

2 2

Re: [Haskell-cafe] hint and type synonyms
by Claude Heiland-Allen 01 Apr '12

01 Apr '12

Hi Daniel, cafe, On 31/03/12 17:47, Daniel Gorín wrote: > Could you provide a short example of the code you'd like to write but gives you problems? I'm not able to infer it from your workaround alone... This problem originally came up on #haskell, where Rc43 had a problem making a library with a common module that re-exports several other modules: http://hpaste.org/66281 My personal interest is somewhat secondary, having not yet used hint in a real project, but code I would like to write at some point in the future is much like the 'failure' below, unrolled it looks like: main = (print =<<) . runInterpreter $ do setImports ["Prelude"] interpret "1/5" (as :: Rational) -- fails Having to remember that Rational is defined as type Rational = Ratio Integer and that Ratio is defined in Data.Ratio and then to add that to the setImports list is a little inconvenient: main = (print =<<) . runInterpreter $ do setImports ["Prelude", "Data.Ratio" ] interpret "1/5" (as :: Rational) -- works But for my own purposes this is probably much saner in the long run than my newtype wrapping approach below. However, this is not always possible: supposing Ratio itself was defined as a type synonym of Ratio2, and Ratio2 was not exported. Perhaps this is what Rc43 was experiencing, but I shouldn't speculate, as this is all getting a bit theoretical - I should try out hint in the real world to see if this problem makes things impractical for me - sorry for the noise! Thanks, Claude > Thanks, > Daniel > > > On Mar 31, 2012, at 6:19 PM, Claude Heiland-Allen wrote: > >> Hi all, >> >> What's the recommended way to get hint[0] to play nice with type synonyms[1]? >> >> A problem occurs with in scope type synonyms involving types not in scope. >> >> I came up with this after looking at the source[2], but it makes me feel ill: >> >> --8<-- >> -- hint and type synonyms don't play nice >> module Main where >> >> import Language.Haskell.Interpreter >> >> import Data.Typeable as T >> import Data.Typeable.Internal >> import GHC.Fingerprint.Type >> >> main = failure>> success >> >> test t = (print =<<) . runInterpreter $ do >> setImports [ "Prelude" ] >> interpret "1/5" t >> >> failure = test (as :: Rational) >> -- Left (WontCompile [GhcError {errMsg = "Not in scope: type constructor or class `Ratio'"}]) >> >> success = test (as :: Q) >> -- Right (1 % 5) >> >> newtype Q = Q Rational >> >> instance Show Q where >> show (Q a) = show a >> showsPrec n (Q a) = showsPrec n a >> >> instance Typeable Q where >> typeOf _ = TypeRep (Fingerprint 0 0) (T.mkTyCon "Rational") [] >> --8<-- >> >> Thanks, >> >> >> Claude >> >> [0] http://hackage.haskell.org/package/hint >> [1] http://www.haskell.org/onlinereport/decls.html#type-synonym-decls >> [2] http://hackage.haskell.org/packages/archive/hint/0.3.3.4/doc/html/src/Hint-… >> >> _______________________________________________ >> Haskell-Cafe mailing list >> Haskell-Cafe(a)haskell.org >> http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1

Re: [Haskell-cafe] Google Summer of Code - Lock-free data
by John Lato 01 Apr '12

01 Apr '12

Slightly related: I think it would be interesting to compare a Disruptor-based concurrency communications mechanism and compare it to e.g. TChans 1. Disruptor - http://code.google.com/p/disruptor/ > From: Ryan Newton <rrnewton(a)gmail.com> > >> I think so. Atomically reading and writing a single memory location >>> (which CAS does) is just a very simple transaction. But using a CAS >>> instruction should be more efficient, since STM has to maintain a >>> transaction log and commit transactions, which creates some overhead. >>> >> >> Ah, I see. In that case, it may be worthwhile to implement the CAS >> instruction in terms of STM as well and measure the performance difference >> this makes for the final data structure. After all, STM is a lot more >> compositional than CAS, so I'd like to know whether the loss of >> expressiveness is worth the gain in performance. > > > There's one annoying hitch with doing apples-to-apples comparisons here. > > The problem is that CAS falls short of being a hardware-accelerated version > of a simple transaction (read TVar, (==) against expected value, > conditionally update TVar), because CAS is based on pointer equality rather > than true equality. (eq? rather than equal? for any Schemers out there.) > > For this reason our "Fake" version of CAS -- for older GHCs and for > performance comparison -- has to use reallyUnsafePointerEquality#: > > > http://hackage.haskell.org/packages/archive/IORefCAS/0.2/doc/html/Data-CAS-… > > But we do provide a "CASable" type class in that package which is precisely > for comparing the performance of: > > - Hardware CAS > - Fake CAS -- atomicModifyIORef + ptrEquality > - Foreign CAS -- gcc intrinsic + function call

3 2

get a string representation (show) of a function argument
by TP 01 Apr '12

01 Apr '12

Hi, I don't known the advanced features and extensions of GHC at all. Look at the following program: ---------------- f :: Integer -> Integer -> IO Integer f a b = do print $ "first argument=" ++ (show a) print $ "second argument=" ++ (show b) print $ a+b return (a+b) main = do k <- f 3 5 f 2 k ---------------- It yields: ---------------- "first argument=3" "second argument=5" 8 "first argument=2" "second argument=8" 10 10 ---------------- I am wondering if there is any means to get "f 3 5" instead of "8" in the output of this program. My idea would be to write some generic test function: I give it an expression (probably a function call) and the expected result (as a string), and then: * it should check that the obtained result is identical to the expected one. * it should also print the expression that yielded the first argument of the test function (i.e. the function call), under an understandable form (show). This is the feature that is missing to my mind in some test suites: for example in HUnit, it is not automatic: in the first argument of assertEqual, we may give a string corresponding to the executed command, see the documentation of Test.HUnit: test1 = TestCase (assertEqual "for (foo 3)," (1,2) (foo 3)) > runTestTT tests # Failure in: 0:test1 for (foo 3), expected: (1,2) but got: (1,3) Cases: 2 Tried: 2 Errors: 0 Failures: 1 So, we have duplication of code: "foo 3". On the other hand, I guess that the needed features to do that are not possible in Haskell (related to some kind of metaprogramming), but I prefer to ask people about that. Thanks in advance, TP

2 1

ANNOUNCE: fix-imports 1.0.0
by Evan Laforge 31 Mar '12

31 Mar '12

I just uploaded a new version to hackage. This improves the heuristics for guessing the right module quite a bit, and adds a local config file where you can prioritize or de-prioritize packages or module prefixes. It's also a bit faster. >From the hackage description: A small standalone program to manage the import block of a haskell program. It will try to add import lines for qualified names with no corresponding import, remove unused import lines, and sort the import block according to some heuristic you can define. This only works for qualified imports! Unqualified imports are left untouched. It's most convenient if bound to an editor key. Recent major changes: version 1.0.0 Change name from FixImports to fix-imports, which is more unixy. Change ghc-pkg parsing from String to Text. It's noticeably faster. Add a more flexible system for prioritizing imports. When there are several possibilities for a module name, they are all given to a single function to decide. The config file moved from fix-imports-priority to .fix-imports and can now specify sort orders for packages and modules by prefix. Make -i includes for non-existent dirs ignored instead of causing an error.

1 0

hint and type synonyms
by Claude Heiland-Allen 31 Mar '12

31 Mar '12

Hi all, What's the recommended way to get hint[0] to play nice with type synonyms[1]? A problem occurs with in scope type synonyms involving types not in scope. I came up with this after looking at the source[2], but it makes me feel ill: --8<-- -- hint and type synonyms don't play nice module Main where import Language.Haskell.Interpreter import Data.Typeable as T import Data.Typeable.Internal import GHC.Fingerprint.Type main = failure >> success test t = (print =<<) . runInterpreter $ do setImports [ "Prelude" ] interpret "1/5" t failure = test (as :: Rational) -- Left (WontCompile [GhcError {errMsg = "Not in scope: type constructor or class `Ratio'"}]) success = test (as :: Q) -- Right (1 % 5) newtype Q = Q Rational instance Show Q where show (Q a) = show a showsPrec n (Q a) = showsPrec n a instance Typeable Q where typeOf _ = TypeRep (Fingerprint 0 0) (T.mkTyCon "Rational") [] --8<-- Thanks, Claude [0] http://hackage.haskell.org/package/hint [1] http://www.haskell.org/onlinereport/decls.html#type-synonym-decls [2] http://hackage.haskell.org/packages/archive/hint/0.3.3.4/doc/html/src/Hint-…

1 0

New in haskell for old-timers?
by Mats Rauhala 31 Mar '12

31 Mar '12

I ended up discussing in university with the person next to me about Haskell. He's an old-timer who's even been to conferences, but it's a long time since he's looked at Haskell. He asked me to write "what's new in Haskell", but I'm not too experienced myself. I didn't realize asking how long it's been for him, but he mentioned about new fronts in optimizing compilers and specifically mentioned a compiler that could compile to legible C. I've been following Haskell only for a couple of years, so my intuition tells me that he means `-fvia-c`, and I mentioned to him that it's about to be deprecated and replaced with the llvm back-end. I also mentioned hackage, but he hadn't heard of it. He mentioned that he'd like to use Haskell for his master's thesis, but we got a interrupted when he said what it was about. Formal something or other. I trust you fellow Haskellers have better understanding of the time frame, and can think of something interesting new features, libraries, communities etc. that's since been emerged. I ask you to give me something interesting to give him and reinstate his interest. -- Mats Rauhala MasseR

6 6

for = flip map
by Johannes Waldmann 30 Mar '12

30 Mar '12

Good: we have mapM, and we have forM ( = flip mapM ) . Sure this is just a convenience, and indeed "forM xs $ \ x -> do ..." is quite handy, especially if "xs" is really small, and "..." is some larger expression. Bad: we have map, but we are missing: for ( = flip map ) . The function is very convenient, for the same reasons as above. I can't remember how often I typed "for = flip map" in a source file. I never put this definition in a module either, since the import statement would be longer than the definition. So, I'm all for "for" . In Data.List? In the Prelude? (Should put it right next to "map".) - J.W.

8 9

ANN: Happstack 7
by Jeremy Shaw 30 Mar '12

30 Mar '12

We are pleased to announce the release of Happstack 7! Happstack is a fast, modern, web application framework written in Haskell. Please check out the brand new happstack.com website to read about what is new in Happstack 7, and what we are planning for Happstack 8, and what makes Happstack great! http://www.happstack.com/ - jeremy

3 3

blog software in Haskell?
by Ketil Malde 30 Mar '12

30 Mar '12

Hi, I just upgraded my server, and set up everything again. Except wordpress, as 1) I'm not too fond of its user interface, and 2) it's a big pile of PHP, difficult to keep updated, and basically a disaster waiting to happen (and in fact, it was hacked at one point). Before I enable it again, is there any alternatives I should consider? Preferably written in Haskell, of course, but other suggestions welcome as well. -k -- If I haven't seen further, it is by standing in the footprints of giants

5 6

Re: [Haskell-cafe] a code that cannot compile with or without NoMonomorphismRestriction
by Denis Moskvin 30 Mar '12

30 Mar '12

f :: (Show a, Ord b) => (a -> String, b -> b -> Bool) f = let commond_definitions = undefined in let f1 = id.show f2 x = (< x) in (f1, f2) > From: Ting Lei <tinlyx(a)hotmail.com> > To: <haskell-cafe(a)haskell.org> > Cc: > Date: Wed, 28 Mar 2012 23:42:30 -0700 > Subject: [Haskell-cafe] a code that cannot compile with or without > NoMonomorphismRestriction > Hi > > I have met a piece of code that cannot be compiled whether I add or remove > the NoMonomorphismRestriction flag (as of GHC 7.0.4, Haskell platform > 2011.4.0.0). > I have extracted a minimal example below: > > > > {-# LANGUAGE NoMonomorphismRestriction #-} > (f1, f2) = > let commond_definitions = undefined in > let f1 = id.show > f2 x = (< x) > in > (f1, f2) > > I needed this format because there are many shared definitions in > common_definitions for f1 and f2, and I want to keep them local. > > If I compile them with NoMonomorphismRestriction, I get: > > D:\work\test.hs:7:8: > Ambiguous type variable `a0' in the constraint: > (Show a0) arising from a use of `f1' > Possible cause: the monomorphism restriction applied to the following: > f1 :: a0 -> String (bound at D:\work\hsOcaml\test.hs:2:2) > Probable fix: give these definition(s) an explicit type signature > In the expression: f1 > In the expression: (f1, f2) > In the expression: > let > f1 = id . show > f2 x = (< x) > in (f1, f2) > D:\work\test.hs:7:12: > Ambiguous type variable `a1' in the constraint: > (Ord a1) arising from a use of `f2' > Possible cause: the monomorphism restriction applied to the following: > f2 :: a1 -> a1 -> Bool (bound at D:\work\hsOcaml\test.hs:2:6) > Probable fix: give these definition(s) an explicit type signature > In the expression: f2 > In the expression: (f1, f2) > In the expression: > let > f1 = id . show > f2 x = (< x) > in (f1, f2) > Failed, modules loaded: none. > > If I comment out > -- {-# LANGUAGE NoMonomorphismRestriction #-} > I get: > > D:\work\hsOcaml\test.hs:4:17: > Ambiguous type variable `a0' in the constraint: > (Show a0) arising from a use of `show' > Possible cause: the monomorphism restriction applied to the following: > f1 :: a0 -> String (bound at D:\work\hsOcaml\test.hs:2:2) > Probable fix: give these definition(s) an explicit type signature > or use -XNoMonomorphismRestriction > In the second argument of `(.)', namely `show' > In the expression: id . show > In an equation for `f1': f1 = id . show > D:\work\hsOcaml\test.hs:7:12: > Ambiguous type variable `a1' in the constraint: > (Ord a1) arising from a use of `f2' > Possible cause: the monomorphism restriction applied to the following: > f2 :: a1 -> a1 -> Bool (bound at D:\work\hsOcaml\test.hs:2:6) > Probable fix: give these definition(s) an explicit type signature > or use -XNoMonomorphismRestriction > In the expression: f2 > In the expression: (f1, f2) > In the expression: > let > f1 = id . show > f2 x = (< x) > in (f1, f2) > Failed, modules loaded: none. > > Can anyone show me why this does not work and how to fix it (e.g. by > adding type signature as the error message suggested)? > I tried to add type signature by couldn't figure out the right way of > doing it. > > Thanks in advance! > > Ting Denis Moskvin

1 0

DHD >>= UHac: Register by April 1 for the DHD
by Sean Leather 30 Mar '12

30 Mar '12

DHD >>= UHac will be held from Friday, April 20, to Sunday, April 22, 2012. The Dutch HUG Day (DHD) is on the first day. The Utrecht Hackathon (UHac) follows the DHD on Friday and continues through the weekend. http://www.haskell.org/haskellwiki/DHD_UHac *Please register for the DHD by Sunday, April 1.* Our sponsor for the DHD, Ordina, will use the registration to prepare the (free!) lunch and venue. If you're coming only to UHac and not the DHD, you can register by April 19. http://www.haskell.org/haskellwiki/DHD_UHac/Register See you in Utrecht! The Organizers: Sean Leather Jurriën Stutterheim Jurriaan Hage

1 0

How helpful is h-99 (and should we complete the missing ones)?
by Ziyao Wei 30 Mar '12

30 Mar '12

Hi all, I am new at Haskell, but I am trying to learn as much as possible. While learning, I noticed that h-99 (the 99 Haskell problems) are highly recommended on haskell.org. However, the answers to the 99 problems are not finished, and some of the answers are not really Haskell-ish. So here's my question: how useful is h-99 (are they overrated as learning tools)? I find myself solve most of them in a "from the scratch" fashion (e.g., no Monad, no Applicative, no Functor aside from List and a few Maybe). Some of them are paper-worthy, for example the prime problems. I hope some guru-level Haskeller could do away the missing few, and maybe dive deeper into the surface to produce more insights (like the knights travel page or the sieve paper, which are both beautiful). And of course, if anyone could tell me how to learn Haskell without treating it as just another functional language, I'd be very grateful:) Thanks, Ziyao

1 0

winhugs interrupts
by Doug McIlroy 29 Mar '12

29 Mar '12

On windows I have long used hugs under cygwin, but hugs doesn't get along well with cygwin's latest terminal emulator. So I switched to winhugs. Small problem that looms big: how do you interrupt an interminable expression evaluation in winhugs? Doug

2 1

Re: [Haskell-cafe] adding the elements of two lists
by Doug McIlroy 29 Mar '12

29 Mar '12

> Date: Tue, 27 Mar 2012 11:03:54 +1300 > From: "Richard O'Keefe" <ok(a)cs.otago.ac.nz> > Subject: Re: [Haskell-cafe] adding the elements of two lists > To: <jerzy.karczmarczuk(a)unicaen.fr> > Cc: haskell-cafe(a)haskell.org > > And *that* is why I stopped trying to define instance Num t => Num [t]. > If "I KNEW that the length of the lists is ... fixed ..." then the type > wasn't *really* [t], but some abstract type that happened to be implemented > as [t], and that abstract type deserved a newtype name of its own. > > Naming the type > - makes the author's intent clearer to readers > - lets the compiler check it's used consistently > - lets you have instances that don't match instances for > other abstract types that happen to have the same implementation > - provides a natural place to document the purpose of the type > - gives you a way to enforce the intended restrictions > all for zero run-time overhead. Quite taken by this manifesto for high style and morality, I resolved to do right by some old code, of which I had been quite proud: www.cs.dartmouth.edu/~doug/powser.html. Sadly, the exercise took some bloom off the rose. What the code gained in honesty and safety, it lost in beauty and readability. Here's the contrast, seen in overloading arithmetic to handle addition and multiplication of power series. --------- without newtype toSeries f = f : repeat 0 -- coerce scalar to series instance Num a => Num [a] where (f:fs) + (g:gs) = f+g : fs+gs (f:fs') * gs@(g:gs') = f*g : fs'*gs + (toSeries f)*gs' --------- with newtype newtype Num a => PS a = PS [a] deriving (Show, Eq) fromPS (PS fs) = fs -- extract list toPS f = PS (f : repeat 0) -- coerce scalar to series instance Num a => Num (PS a) where (PS (f:fs)) + (PS (g:gs)) = PS (f+g : fs+gs) (PS (f:fs)) * gPS@(PS (g:gs)) = PS $ f*g : fromPS ((PS fs)*gPS + (toPS f)*(PS gs)) The code suffers a pox of PS. When one goes on to introduce efficiencies and generalize to handle finite series (polynomials), it only gets worse. One unpleasant technical problem: the deriving clause is almost useless--one can't print or detect equality of infinite objects. For output one must apply something like (take 10 . fromPS). Yet this modest package would likely pose problems if it were combined with others in a grander suite for automated mathematics. What to do? I think I might write the package without newtype, and then wrap it in PS for export in hopes of exploiting the advantages of both styles.

4 3

Mathematics and Statistics libraries
by Ben Jones 29 Mar '12

29 Mar '12

I am a student currently interested in participating in Google Summer of Code. I have a strong interest in Haskell, and a semester's worth of coding experience in the language. I am a mathematics and cs double major with only a semester left and I am looking for information regarding what the community is lacking as far as mathematics and statistics libraries are concerned. If there is enough interest I would like to put together a project with this. I understand that such libraries are probably low priority, but if anyone has anything I would love to hear it. Thanks for reading, -Benjamin

10 11

a code that cannot compile with or without NoMonomorphismRestriction
by Ting Lei 29 Mar '12

29 Mar '12

Hi I have met a piece of code that cannot be compiled whether I add or remove the NoMonomorphismRestriction flag (as of GHC 7.0.4, Haskell platform 2011.4.0.0).I have extracted a minimal example below: {-# LANGUAGE NoMonomorphismRestriction #-} (f1, f2) = let commond_definitions = undefined in let f1 = id.show f2 x = (< x) in (f1, f2) I needed this format because there are many shared definitions in common_definitions for f1 and f2, and I want to keep them local. If I compile them with NoMonomorphismRestriction, I get: D:\work\test.hs:7:8: Ambiguous type variable `a0' in the constraint: (Show a0) arising from a use of `f1' Possible cause: the monomorphism restriction applied to the following: f1 :: a0 -> String (bound at D:\work\hsOcaml\test.hs:2:2) Probable fix: give these definition(s) an explicit type signature In the expression: f1 In the expression: (f1, f2) In the expression: let f1 = id . show f2 x = (< x) in (f1, f2)D:\work\test.hs:7:12: Ambiguous type variable `a1' in the constraint: (Ord a1) arising from a use of `f2' Possible cause: the monomorphism restriction applied to the following: f2 :: a1 -> a1 -> Bool (bound at D:\work\hsOcaml\test.hs:2:6) Probable fix: give these definition(s) an explicit type signature In the expression: f2 In the expression: (f1, f2) In the expression: let f1 = id . show f2 x = (< x) in (f1, f2) Failed, modules loaded: none. If I comment out -- {-# LANGUAGE NoMonomorphismRestriction #-} I get: D:\work\hsOcaml\test.hs:4:17: Ambiguous type variable `a0' in the constraint: (Show a0) arising from a use of `show' Possible cause: the monomorphism restriction applied to the following: f1 :: a0 -> String (bound at D:\work\hsOcaml\test.hs:2:2) Probable fix: give these definition(s) an explicit type signature or use -XNoMonomorphismRestriction In the second argument of `(.)', namely `show' In the expression: id . show In an equation for `f1': f1 = id . showD:\work\hsOcaml\test.hs:7:12: Ambiguous type variable `a1' in the constraint: (Ord a1) arising from a use of `f2' Possible cause: the monomorphism restriction applied to the following: f2 :: a1 -> a1 -> Bool (bound at D:\work\hsOcaml\test.hs:2:6) Probable fix: give these definition(s) an explicit type signature or use -XNoMonomorphismRestriction In the expression: f2 In the expression: (f1, f2) In the expression: let f1 = id . show f2 x = (< x) in (f1, f2) Failed, modules loaded: none. Can anyone show me why this does not work and how to fix it (e.g. by adding type signature as the error message suggested)?I tried to add type signature by couldn't figure out the right way of doing it. Thanks in advance! Ting

4 4

Re: [Haskell-cafe] adding the elements of two lists
by Doug McIlroy 29 Mar '12

29 Mar '12

> From: "Richard O'Keefe" <ok(a)cs.otago.ac.nz> > Date: Thu, 29 Mar 2012 16:34:46 +1300 > > On 29/03/2012, at 3:08 PM, Doug McIlroy wrote: > > --------- without newtype > > > > toSeries f = f : repeat 0 -- coerce scalar to series > > > > instance Num a => Num [a] where > > (f:fs) + (g:gs) = f+g : fs+gs > > (f:fs') * gs@(g:gs') = f*g : fs'*gs + (toSeries f)*gs' > > > > --------- with newtype > > > > newtype Num a => PS a = PS [a] deriving (Show, Eq) > > > > fromPS (PS fs) = fs -- extract list > > toPS f = PS (f : repeat 0) -- coerce scalar to series > > > > instance Num a => Num (PS a) where > > (PS (f:fs)) + (PS (g:gs)) = PS (f+g : fs+gs) > > (PS (f:fs)) * gPS@(PS (g:gs)) = > > PS $ f*g : fromPS ((PS fs)*gPS + (toPS f)*(PS gs)) > > Try it again. > > newtype PS a = PS [a] deriving (Eq, Show) > > u f (PS x) = PS $ map f x > b f (PS x) (PS y) = PS $ zipWith f x y > to_ps x = PS (x : repeat 0) > > ps_product (f:fs) (g:gs) = whatever > > instance Num a => Num (PS a) > where > (+) = b (+) > (-) = b (-) > (*) = b ps_product > negate = u negate > abs = u abs > signum = u signum > fromInteger = to_ps . fromInteger > > I've avoided defining ps_product because I'm not sure what > it is supposed to do: the definition doesn't look commutative. You have given the Hadamard product--a construction with somewhat esoteric properties. The product I have in mind is the ordinary mathematical product that one meets in freshman calculus. The distributive law yields this symmetric formulation (f:fs) * (g:gs) = f*g : (toSeries f)*gs + fs*(toSeries g) + (0 : fs*gs) The version I gave is an optimization (which I learned from Jerzy). For more explanation see www.cs.dartmouth.edu/~doug/powser.html. I like the lifting functions b and u, but they don't get one very far. The product is where the PS pox begins to bite badly. I would welcome a perspicuous formulation of that using newtype. Incidentally, a more efficient way to write the symmetric product is (f:fs) * (g:gs) = f*g : zipWith (f*) gs + zipWith fs (*g) + (0 : fs*gs) toSeries and zipWith appear in the formulas because Haskell overloading won't let one use the multiplication symbol for both series*series and scalar*series. One might also invent a distinct operator for the purpose. Coercion with toSeries strikes me as the least jarring of these approaches. zipWith suffers from mixing levels of abstraction--it signifies not the idea of multiplication, but the algorithm. A new operator would suffer both from unfamiliarity and lack of commutativity. > > > The code suffers a pox of PS. > > But it doesn't *need* to. > >

1 0

adding the elements of two lists
by TP 29 Mar '12

29 Mar '12

Hello, My primary problem may be reduced to adding elements of two lists: [1,2,3] + [4,5,6] = [5,7,9] My first idea was to declare a list of Int as an instance of Num, and define (+) in the correct way. However, it seems it is not possible to do that: ------------------- instance Num [Int] where l1 + l2 = .... ------------------- Why? It seems it is necessary to do: ------------------ newtype ListOfInt = ListOfInt { getList :: [Int] } deriving (Show, Eq) instance Num ListOfInt where l1 + l2 = ... ------------------- Am I correct? Is it the best way to do that? Now, what is the most usual way to implement l1+l2? I have just read about applicative functors, with which I can do: ------------------- import Control.Applicative let l1 = [1,2,3] let l2 = [4,5,6] print $ getZipList $ (+) <$> ZipList l1 <*> ZipList l2 [5,7,9] ------------------- Is it the correct way to do that? I have tried: ------------------- instance Num ListOfInt where l1 + l2 = ListOfInt $ getZipList $ (+) <$> ZipList (getList l1) <*> ZipList (getList l2) ------------------- Isn't it too much complicated? Thanks TP

9 18

Haskell Weekly News: Issue 220
by Daniel Santa Cruz 29 Mar '12

29 Mar '12

Welcome to issue 220 of the HWN, an issue covering crowd-sourced bits of information about Haskell from around the web. This issue covers the week of March 18 to 24, 2012. Quotes of the Week * shachaf: Type classes are a scary story that you tell new Haskellers so they can go to sleep at night. * acowley: Parametric polymorphism is the inspiring story you tell them to get them riled up and raring to go. It's like Braveheart for programmers. * monochrom: the purpose of types is to ban more programs * rostayob: I was a type constructor, then I took an arrow in the kind * shachaf: @let otherfoolish = not otherwise * flebron: Monoidal objects in the monoidal category of endofunctors on a category. I took a small detour through tensor products to understand monoidal categories better, with one example of such a product. mauke: I have no idea what you just said * weexplat: starts a proposal to replace launchMissiles with atomicDestroyBiosphere * monochrom: rumour: SPJ will write a thick book "A New Science of Kind" * JonathanShapiro: [on abandoning BitC] "And I *still* don't believe in monads. :-)" Top Reddit Stories * Starting the Mezzo Haskell Book Domain: yesodweb.com, Score: 58, Comments: 28 On Reddit: [1] http://goo.gl/pOSlR Original: [2] http://goo.gl/ecy4O * First patches for iPhone cross compiler against GHC head Domain: haskell.org, Score: 55, Comments: 27 On Reddit: [3] http://goo.gl/OOAai Original: [4] http://goo.gl/p7C3L * Retrospective thoughts on BitC by its author, and why type classes didn't work for him Domain: coyotos.org, Score: 44, Comments: 22 On Reddit: [5] http://goo.gl/0sL80 Original: [6] http://goo.gl/5pCp2 * Google Summer of Code 2012 - Haskell.org is participating Domain: haskell.org, Score: 42, Comments: 11 On Reddit: [7] http://goo.gl/9EwzD Original: [8] http://goo.gl/XqcUJ * Conduits vs. Pipes. Using Void as an Input or Output type can reduce the number of concepts (source, sink, conduit) from 3 to 1 (pipe). Domain: twanvl.nl, Score: 34, Comments: 50 On Reddit: [9] http://goo.gl/bc8RB Original: [10] http://goo.gl/eb7oz * Announcing conduit 0.3 Domain: yesodweb.com, Score: 33, Comments: 9 On Reddit: [11] http://goo.gl/JrgV0 Original: [12] http://goo.gl/OsDl7 * Haskell for embedded domain-specific languages (Functional Programming eXchange 2012) Domain: skillsmatter.com, Score: 31, Comments: 4 On Reddit: [13] http://goo.gl/pSREX Original: [14] http://goo.gl/1azVh * Domain theory course Domain: cs.nott.ac.uk, Score: 31, Comments: 5 On Reddit: [15] http://goo.gl/5VHyG Original: [16] http://goo.gl/o2pRC * ANNOUNCE: options, an easy-to-use command-line option parser Domain: self.haskell, Score: 29, Comments: 21 On Reddit: [17] http://goo.gl/s6ktw Original: [18] http://goo.gl/s6ktw * A Case Study in Creating Rich Internet Apps in Haskell (Silk at FP eXchange 2012) Domain: skillsmatter.com, Score: 22, Comments: 18 On Reddit: [19] http://goo.gl/ZdtDq Original: [20] http://goo.gl/Ta2HQ * It just occurred to me that (lift .) defines a functor... Domain: self.haskell, Score: 22, Comments: 15 On Reddit: [21] http://goo.gl/GMzPt Original: [22] http://goo.gl/GMzPt Top StackOverflow Questions * Haskell platform: nested functions and optimization votes: 15, answers: 2 Read on SO: [23] http://goo.gl/nreIr * newtype with RankNTypes votes: 14, answers: 2 Read on SO: [24] http://goo.gl/UT9DV * Pattern Matching - Prolog Vs Haskell votes: 13, answers: 4 Read on SO: [25] http://goo.gl/3hZV1 * How does this definition of ArrowLoop.loop work? votes: 13, answers: 2 Read on SO: [26] http://goo.gl/ocSCM * Data.Set : does it always know best? votes: 12, answers: 2 Read on SO: [27] http://goo.gl/NUjkB * Building a histogram with haskell, many times slower than with python votes: 11, answers: 3 Read on SO: [28] http://goo.gl/kbh5i * What is the scope of let when used without in? votes: 11, answers: 2 Read on SO: [29] http://goo.gl/bNwna * Strange "half to even" rounding in different languages [closed] votes: 11, answers: 3 Read on SO: [30] http://goo.gl/lnPch * Practical reasons for Сhurch Encoding votes: 10, answers: 1 Read on SO: [31] http://goo.gl/xYoef * Can the FFI deal with arrays? If so, how? votes: 9, answers: 3 Read on SO: [32] http://goo.gl/d4R3H Until next time, Daniel Santa Cruz References 1. http://www.yesodweb.com/blog/2012/03/start-mezzo-haskell 2. http://www.reddit.com/r/haskell/comments/r9xdq/starting_the_mezzo_haskell_b… 3. http://www.haskell.org/pipermail/iphone/2012-March/000120.html 4. http://www.reddit.com/r/haskell/comments/r3ge7/first_patches_for_iphone_cro… 5. http://www.coyotos.org/pipermail/bitc-dev/2012-March/003300.html 6. http://www.reddit.com/r/haskell/comments/rbk7z/retrospective_thoughts_on_bi… 7. http://www.haskell.org/pipermail/haskell-cafe/2012-March/100247.html 8. http://www.reddit.com/r/haskell/comments/r5h81/google_summer_of_code_2012_h… 9. http://twanvl.nl/blog/haskell/conduits-vs-pipes 10. http://www.reddit.com/r/haskell/comments/rbgvz/conduits_vs_pipes_using_void… 11. http://www.yesodweb.com/blog/2012/03/announcing-conduit-0-3 12. http://www.reddit.com/r/haskell/comments/r6wdh/announcing_conduit_03/ 13. http://skillsmatter.com/podcast/scala/haskell-for-embedded-domain-specific-… 14. http://www.reddit.com/r/haskell/comments/r22d6/haskell_for_embedded_domains… 15. http://www.cs.nott.ac.uk/~gmh/domains.html 16. http://www.reddit.com/r/haskell/comments/r250h/domain_theory_course/ 17. http://www.reddit.com/r/haskell/comments/rbpmb/announce_options_an_easytous… 18. http://www.reddit.com/r/haskell/comments/rbpmb/announce_options_an_easytous… 19. http://skillsmatter.com/podcast/home/silkapp-a-case-study-in-creating-rich-… 20. http://www.reddit.com/r/haskell/comments/r1xey/a_case_study_in_creating_ric… 21. http://www.reddit.com/r/haskell/comments/raxsk/it_just_occurred_to_me_that_… 22. http://www.reddit.com/r/haskell/comments/raxsk/it_just_occurred_to_me_that_… 23. http://stackoverflow.com/questions/9757515/haskell-platform-nested-function… 24. http://stackoverflow.com/questions/9779301/newtype-with-rankntypes 25. http://stackoverflow.com/questions/9780779/pattern-matching-prolog-vs-haske… 26. http://stackoverflow.com/questions/9856342/how-does-this-definition-of-arro… 27. http://stackoverflow.com/questions/9755851/data-set-does-it-always-know-best 28. http://stackoverflow.com/questions/9772098/building-a-histogram-with-haskel… 29. http://stackoverflow.com/questions/9777399/what-is-the-scope-of-let-when-us… 30. http://stackoverflow.com/questions/9829769/strange-half-to-even-rounding-in… 31. http://stackoverflow.com/questions/9806729/practical-reasons-for-hurch-enco… 32. http://stackoverflow.com/questions/9854782/can-the-ffi-deal-with-arrays-if-…

1 0

Can't install snap (problem with syb)
by Michael Iles 29 Mar '12

29 Mar '12

I uninstalled ghc, removed my ~/.cabal directory, reinstalled ghc, then tried to install snap. I get: $ cabal install snap Resolving dependencies... Downloading syb-0.3.6... <command line>: cannot satisfy -package Cabal-1.14.0: Cabal-1.14.0-0338b6f52e6e6a56054371a110e1d79e is unusable due to missing or recursive dependencies: directory-1.1.0.2-8957520ced1fb19160c3a6126dcccfaa process-1.1.0.1-91185c964ab744c1f3cbca1863d2ba45 (use -v for more information) cabal: Error: some packages failed to install: aeson-0.6.0.0 depends on syb-0.3.6 which failed to install. snap-0.8.0.2 depends on syb-0.3.6 which failed to install. syb-0.3.6 failed during the configure step. The exception was: ExitFailure 1 Any ideas? Mike.

5 6

Re: [Haskell-cafe] [Haskell] ANNOUNCE: haskell-src-exts-1.13.0
by dag.odenhall＠gmail.com 28 Mar '12

28 Mar '12

On 28 March 2012 21:05, Jurriaan Hage <J.Hage(a)uu.nl> wrote: > > Our first year students will be very unhappy to hear this. Wait, what?

2 1

ANNOUNCE: haskell-src-exts-1.13.0
by Niklas Broberg 28 Mar '12

28 Mar '12

Fellow Haskelleers, I'm pleased to announce the release of haskell-src-exts-1.13.0! * On hackage: http://hackage.haskell.org/package/haskell-src-exts * Via cabal: cabal install haskell-src-exts * Darcs repo: http://code.haskell.org/haskell-src-exts It's been a *very short* while since the last update before this, and another (smallish) major release it is. Sorry about that (especially to Neil who was quick to update). The main update of this release is to add support for DoAndIfThenElse, which means haskell-src-exts at long last is compliant with Haskell2010. This is also the cause for the backwards-incompatible change: default parse mode is now to use Haskell2010 mode. In particular this means that NPlusKPatterns is no longer recognized by default. No old code using haskell-src-exts should fail to compile (unless really unlucky with clashing imports from L.H.E.Extension), but it may now fail to work on some Haskell98-compliant source files. Changelog: 1.12.0 --> 1.13.0 =============== * Add extensions DoAndIfThenElse and NPlusKPatterns to Language.Haskell.Exts.Extensions. * DoAndIfThenElse is now supported, at long last, making HSE compatible with Haskell2010 * Introduce haskell98 and haskell2010 extension groups, exported from Language.Haskell.Exts.Extensions. * Backwards-incompatible change: default parse mode is now to use haskell2010, which means the following features are recognized by default: DoAndIfThenElse, PatternGuards, ForeignFunctionInterface, EmptyDataDecls. NPlusKPatterns is no longer recognized by default. Cheers, /Niklas

1 0

ghci can't load file whose name contains non-ASCII chars?
by Johannes Waldmann 28 Mar '12

28 Mar '12

I must be making some obvious mistake here, but I'm not seeing it. The file name contains O-umlaut, and the OS handles it fine, but ghci does not like it (although it accepts umlauts in the contents of the file (UTF-8) e.g., as a module name) $ cat fÖÖbar.hs main = print $ product [1..100] $ ghci fÖÖbar.hs GHCi, version 7.4.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. <no location info>: can't find file: f??bar.hs Failed, modules loaded: none. this is on a standard ubuntu install (11.10 and 11.04) with $ locale LANG=en_US.UTF-8 LANGUAGE= LC_CTYPE="en_US.UTF-8" ... $ ghc --version The Glorious Glasgow Haskell Compilation System, version 7.4.1 $ uname -a Linux octopus 3.0.0-16-generic #29-Ubuntu SMP Tue Feb 14 12:48:51 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux

3 2

Re: [Haskell-cafe] Mathematics and Statistics libraries
by Vivian McPhail 28 Mar '12

28 Mar '12

Date: Sun, 25 Mar 2012 17:54:11 +0400 > From: Aleksey Khudyakov <alexey.skladnoy(a)gmail.com> > Subject: Re: [Haskell-cafe] Mathematics and Statistics libraries > To: haskell-cafe(a)haskell.org > Message-ID: <4F6F2383.6070404(a)gmail.com> > Content-Type: text/plain; charset=ISO-8859-1; format=flowed > > On 25.03.2012 14:52, Tom Doris wrote: > > Hi Heinrich, > > And of course data visualization. Only library I know of is Chart[1] but > I don't like API much. > There is the plot[1] library which provides for updateable plots from GHCi REPL and has a gnuplot-like interface. I wrote it for this very reason, a mathematics/statistics development environment. It uses Data.Vector.Storable, which provides for compatability with both statistics and hmatrix packages (as well as hstatistics). > > I think talking about data frames is a bit pointless unless we specify > what is data frame. Basically there are two representations of tabular > data structure: array of tuples or tuple of arrays. If you want first go > for Data.Vector.Vector YourData. If you want second you'll probably end > up with some HList-like data structure to hold arrays. > > Matrices from hmatrix are easily converted to rows or columns of Data.Vector.Storable and can be sliced and otherwise manipulated. [1] http://hackage.haskell.org/package/plot<%20%20[1]%20http://hackage.haskell.org/package/plot> Vivian

2 1