November 2009 - Haskell-Cafe

Emacs: Haskell snippets for YASnippet
by Daniel Schüssler 04 Nov '09

04 Nov '09

Hi List, this is rather trivial, but maybe someone else finds these useful: darcs get http://code.haskell.org/~daniels/haskell-snippets/ Especially the LANGUAGE ones have saved me quite some typing :) Additions welcome. Usage: If not already installed, get YASnippet: http://code.google.com/p/yasnippet/ and put this into your .emacs: (load-file "some-path/haskell-snippets.el") to expand a snippet, just enter the macro string (these are listed in the haskell-snippets.el file) and press <tab>. If the snippet has holes, press <tab> again to jump to the next hole. Greetings, Daniel

3 4

ANN: fdo-notify 0.1, a client for the Desktop Notifications protocol
by Max Rabkin 04 Nov '09

04 Nov '09

Haskellers, I present to you fdo-notify, a client library for FreeDesktop.org's Desktop Notifications protocol. This is the DBUS protocol served by NotifyOSD and other notifications systems, which allows a wide variety of applications to present notifications to the user in a uniform way. The library should not require knowledge of DBus or the Desktop Notifications protocol itself, at least once fully documented (there should be enough haddocumentation for basic use already). Hackage: http://hackage.haskell.org/package/fdo-notify Mercurial: http://bitbucket.org/taejo/fdo-notify/ Basic notifications and updated/replacement notifications are supported. Images are not yet supported (adding support should be easy, but which Image type? Is there a de facto standard imaging library like the Python Imaging Library?) and nor are signals. Signals allow an application to be informed when some action is taken on the notification (NotifyOSD doesn't support actions, but other implementations might). The library is released under the 3-clause BSD license, but depends on the dbus-core and dbus-client libraries which are GPLed. I hope you find this library useful. Regards, Max

1 0

Fwd: [Haskell-cafe] What's the deal with Clean?
by Alberto G. Corona 04 Nov '09

04 Nov '09

Artyom. I know what uniqueness means. What I meant is that the context in which uniqueness is used, for imperative sequences: (y, s')= proc1 s x (z, s'')= proc2 s' y ..... is essentially the same sequence as if we rewrite an state monad to make the state explicit. When the state is the "world" state, then it is similar to the IO monad. An state monad forces a single use of the implicit state variable too (unless you pass it trough the next step without changes. That can be done in Clean too. 2009/11/4 Artyom Shalkhakov <artyom.shalkhakov(a)gmail.com> Hello, > > 2009/11/4 Alberto G. Corona <agocorona(a)gmail.com>: > > The code executed by uniqueness types is somehow similar to the internal > > code executed in a state monad (or in the case of IO, the IO monad). The > > main difference is that the pairs of results (state, value) are > explicitly > > written in Clean by the programmer and the type sytem assures that the > > order of executions makes sense at compile time, whereas in the case of > the > > state monad the sequence of instructions is lazily assembled at runtime > in > > the first step and executed in a second step. So there is a little more > > overhead in haskell but the code is higher level. > > Am I right? > > I would rather say: code with uniqueness types allows for safe > destructive updates. > > In Clean, a variable of unique type is ensured to have only one > reference to it, at any time (that's why it's called "uniqueness > typing"). So you can't write the code like this > > > f(x) + f(x) > > where f : *a -> int (x is of unique type), because x is clearly > referenced two times here. What to do? Let f yield another reference > to x! That also means that the old reference is not usable any more, > since you have new one. f becomes: > > > f : *a -> (int, *a) > > and the code looks very familiar: > > > let (a, x') = f(x) > > (b, x'') = f(x') > > in a + b > > The function f can use destructive updates under the hood though it > doesn't violate referential transparency. I bet you can you see why. > > I'd say that call-by-need is orthogonal to uniqueness typing. > > Cheers, > Artyom Shalkhakov. >

3 3

Re: How to optimize the performance of a code in Haskell?
by Kalman Noel 04 Nov '09

04 Nov '09

(I take it you accidently wrote to fa.haskell, which is just a mirror of -cafe and -beginners, so I'm cc-ing the Café with a full quote.) Masayuki Takagi: > I'm writing fluid simulation programs with SPH(Smoothed particle > hydrodynamics) in Haskell and C++. (The purpose that I write in two > languages is to make a workflow that first i write in Haskell for > rapid prototyping and accuracy then rewrite in C++ for performance.) > > I've compared them in performance. Then, although I have already done > optimization with profiler, the Haskell code is 20 times slower than > the C++ code. > > I think the performance of the Haskell code is so slow that there can > be room for optimization. I'm happy if the Haskell code work 3 times > slower than the C++ code at worst. > > How can I make the Haskell code faster? > What information should I refer? > > The codes are here: > http://kamonama.sakura.ne.jp/sph/20091101/sph.hs.zip > http://kamonama.sakura.ne.jp/sph/20091101/sph.cpp > > To run the code in Haskell: > $ ghc --make -O sph.hs > $ ./sph 300 > (300 is the time step to be conputed) > > To run the code in C++: > $ g++ -O2 -o sph sph.cpp > $ ./sph 300 > (300 is the time step to be conputed) > > thanks > I've not looked at the code, but you'll want ghc to do better optimizations than -O. -O2 is what you should use in general. Also, number-crunching often profits from -fexcess-precision.

2 1

multi-line regex
by Michael Mossey 04 Nov '09

04 Nov '09

I have some very simple regex-matching needs, and Text.Regex.Posix will work fine, EXCEPT I need to match multi-line patterns, and/or find all occurrences of text that may occur several times on different lines. So I need to turn on some kind of flag. Can someone show me how to do that? I have worked the examples in RWH so I basically know how to run the thing.

4 5

ANN: haskell-src-exts-1.3.0
by Niklas Broberg 04 Nov '09

04 Nov '09

Fellow Haskelleers, I'm pleased to announce the release of haskell-src-exts-1.3.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 Version 1.3.0 is a new major release, following the PVP, as it contains a few backwards-incompatible changes, making the 1.2.x branch a very short parenthesis in history. There are two main new things in 1.3.0: fixity application is now handled uniformly regardless of which AST you use, simple or annotated, and the parser now supports multiple modules in the same source file. haskell-src-exts-1.3.0: ==================== * The *.Fixity modules now export the same Fixity type (incidentally the one previously used by the simple un-annotated parsing) and the same helper functions. If you've done all your Fixity handling using the helper functions (infix_, infixl_, infixr_), or if you've only used fixities for the un-annotated AST, you're safe. Only if you've manually created values of the annotated Fixity type will you need to pay attention. * A new entry point in the parser allows multiple modules to be parsed from the same source file ( parseModules[With[Mode|Comments]] ). * SpecialCon is now an instance of Pretty (don't ask me why it wasn't before). * fromParseResult now displays the filename in case of a failed parse. * A few bug fixes to the exact-printer (that not many seem to be using just yet). Please help me test and report! Grab a darcs version, put your source files in the Test/examples dir, and go cabal test (in the top dir). Any failing cases not due to CPP or literate source files (for the exact-printer), please report to the trac: http://trac.haskell.org/haskell-src-exts Cheers, /Niklas

2 1

IORefs and weak pointers
by Patai Gergely 04 Nov '09

04 Nov '09

Hello all, I wanted to create a weak pointer with an IORef as the key and something else as the value, but I saw no way to do it through the API provided. After some experimentation I came up with the following abomination for a solution: myWeakRef (IORef (STRef r)) v f = IO $ \s -> case mkWeak# r v f s of (# s', w #) -> (# s', Weak w #) This works perfectly when the code is compiled both with and without optimisations, but ghci chokes on it with an internal error. So my question is if I can expect this to work at least this much in the long run, or is it a hopelessly fragile hack? Gergely -- http://www.fastmail.fm - Same, same, but different...

3 5

Re: [Haskell-cafe] Best Editor In Windows
by Tom.Amundsen 04 Nov '09

04 Nov '09

Nathan P. Campos wrote: > > Hello, > I'm very new at Haskell, i'm reading a book and starting, but i want to > know which is the best editor for development under Windows, because now > i'm using Notepad++(That i use to develop in C++). > > Thanks, > Nathan Paullino Campos > If you use emacs, check out http://www.haskell.org/haskell-mode/ -- View this message in context: http://www.nabble.com/Best-Editor-In-Windows-tp25908187p25917670.html Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

11 18

Gauss Elimination -> More Clean2Haskell
by Philippos Apolinarius 04 Nov '09

04 Nov '09

I am keeping with my project of translating programs from Clean to Haskell. As far as arrays go, I don't understand well how to use them in Haskell. Therefore, I will appreciate if somebody can find time to check the program below, and make suggestions to improve it. My Haskell program is about 4 times slower than the Clean version. It would be great if one could reduce the execution time by half, approaching to the speed of Clean and Scheme. Here are the constraints: 1 --- The program must be implemented using arrays. Update must be done in place, in order to minimize use of the garbage collector. I have used Data.Array.IO, but I guess that Data.Array.ST is better. Is it easy to rewrite the program in order to use DataArray.ST? 2 -- I liked very much the forM_ monad. I wonder if there is an accumulating monad that play the role of a program like leftSide. 3 -- Clean program almost double its speed, if one uses strictness annotations. Is it possible to use similar anotations for Haskell? Here is how I compiled the program: ghc -O2 gel.hs --make In order to run the program with 2000 equations, type gel.exe 2000 +RTS -sstderr The program will create a linear system with 2000 equations so that all elements of the solution is equal to 1. It prints 20 elements of the solution. Here is the program: {- File: gel.hs Compilation: ghc -O2 gel.hs --make Run: time gel.exe 2000 -} import Control.Monad import Data.Array.IO import System.IO import System.Random import System (getArgs) prtSol i n1 arr | i < 1= return () prtSol i n1 arr= do b <- readArray arr (i, n1) putStr ((show b)++" ") prtSol (i-1) n1 arr fillArray xs s (i, n) (j, m) arr | i > n= return () fillArray xs s (i,n) (j, m) arr | i==n && j>m= do writeArray arr (i, j) s return () fillArray xs s (i, n) (j, m) arr | j > m = do writeArray arr (i, j) s fillArray xs 0.0 (i+1, n) (1, m) arr fillArray (val:xs) s (i, n) (j, m) arr= do writeArray arr (i, j) val fillArray xs (s+val) (i, n) (j+1, m) arr sLU arr n= sIJ 2 1 2 n arr sIJ i j k n arr | i > n = return () sIJ i j k n arr | k > n = sIJ (i+1) i (i+1) n arr sIJ i j k n arr = do im <- pmax (j+1) j swap j im 1 a <- readArray arr (k, j) forM_ [j..n+1] $ \l -> do ajj <- readArray arr (j, j) ajl <- readArray arr (j, l) akl <- readArray arr (k, l) writeArray arr (k, l) (akl-a*(ajl/ajj)) sIJ i j (k+1) n arr where pmax line imax | line > n = return imax pmax line imax = do alj <- readArray arr (line, j) aij <- readArray arr (imax, j) if (abs alj)> (abs aij) then pmax (line+1) line else pmax (line+1) imax swap r s q | q>n+1 = return () swap r s q | r==s = return () swap r s q = do arq <- readArray arr (r,q) asq <- readArray arr (s,q) writeArray arr (s,q) arq writeArray arr (r,q) asq swap r s (q+1) leftSide acc i j n arr | j>n= return acc leftSide acc i j n arr = do v <- readArray arr (j, n+1) a <- readArray arr (i, j) leftSide (acc-v*a) i (j+1) n arr solvit i n arr | i<1= return () solvit i n arr= do a <- readArray arr (i, i) acc <- readArray arr (i, n+1) v <- leftSide acc i (i+1) n arr writeArray arr (i, n+1) (v/a) solvit (i-1) n arr rnList :: (Double, Double) -> IO [Double] rnList r=getStdGen>>=(\x->return(randomRs r x)) dims [input] = (read input, read input) dims _ = (1000, 1000) main = do xs <- rnList (1.0,1000.0) args <- getArgs let (n, m)= dims args arr <- newArray_ ((1,1),(n,m+1)) :: IO (IOUArray (Int, Int) Double) fillArray xs 0.0 (1,n) (1,m) arr sLU arr n solvit n n arr prtSol (min 20 n) (n+1) arr print "Done" __________________________________________________________________ Be smarter than spam. See how smart SpamGuard is at giving junk email the boot with the All-new Yahoo! Mail. Click on Options in Mail and switch to New Mail today or register for free at http://mail.yahoo.ca

4 3

Fwd: [Haskell-cafe] What's the deal with Clean?
by Alberto G. Corona 04 Nov '09

04 Nov '09

The code executed by uniqueness types is somehow similar to the internal code executed in a state monad (or in the case of IO, the IO monad). The main difference is that the pairs of results (state, value) are explicitly written in Clean by the programmer and the type sytem assures that the order of executions makes sense at compile time, whereas in the case of the state monad the sequence of instructions is lazily assembled at runtime in the first step and executed in a second step. So there is a little more overhead in haskell but the code is higher level. Am I right? 2009/11/4 wren ng thornton <wren(a)freegeek.org> > Stephen Tetley wrote: > >> 2009/11/3 Andrew Coppin <andrewcoppin(a)btinternet.com>: >> >> As far as I can tell, Clean is to Haskell as C is to Pascal. I.e., Clean >>> is >>> notionally very similar to Haskell, but with lots of added clutter, >>> complexity and general ugliness - but it's probably somehow more >>> machine-efficient as a result. >>> >>> (All of which makes the name "Clean" rather ironic, IMHO.) >>> >> >> OUuch - you really could put it the other way round. >> > > Part of this really comes down to how one feels about the monads vs > uniqueness types argument. It's a silly argument to have since the ideas are > orthogonal and only really intersect at IO, but there's history there which > lead to the current state of things. > > Sometimes in Haskell I've thought about how uniqueness typing would make > something faster, but in general all the plumbing associated with it in > Clean makes me feel like I'm writing systems-level code (i.e. C, asm) > instead of using a high-level language. The extra plumbing really makes it > feel dirtier to work with. That doesn't mean Clean is bad, but I think it > does contribute to the "cluttered" feeling Haskellers get. > > But as I said, it's a silly argument and folks should use whichever gives > them warm fuzzies. I also have a vague unnameable distaste whenever working > with Python, and rather enjoy working with Perl. Nobody's perfect :) > > -- > Live well, > ~wren > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

2 1