- Haskell-Cafe - Haskell.org

Books on Haskell
by PR Stanley 17 May '07

17 May '07

Hi, Is Graham Hutton's book on Haskell Programming a good text for FP beginners? Paul

2 1

problem with implicit parameter
by Eric 16 May '07

16 May '07

Hi there, I've written the following program putchr = putChar ?d main = do { c <- getChar ; putchr with ?d = c} which I try to compile with ghc --make -fimplicit-params myprogram However I keep getting the following error: myprogram.hs:5:17: parse error on input `=' What's wrong? E.

3 2

Re: ANNOUNCE: Harpy -- run-time code generation library
by apfelmus 16 May '07

16 May '07

[Relocated to haskell-cafe] Dirk Kleeblatt wrote: > apfelmus wrote: >> Note that even currently, your operations cannot be strict in the >> address a label refers to because this may be determined later than the >> first use of the label. In other words, your example code >> >> fac = do > [...] >> (1) jmp loopTest > [...] >> (2) loopTest @@ cmp ecx (0 :: Word32) > [...] >> already shows that the function jmp that generates a jmp-instruction may >> not be strict in the position it jumps to as the address behind loopTest >> is only known later at line (2). > > When generating code for (1), the label loopTest is used as an index > into a map, to see whether there's a code position associated with it. > If it is, the code position is used to compute the jump offset for the > jmp instruction, if not (as in this example), a dummy value is placed in > the code buffer, and Harpy remembers this position to be patched later > on. At (2), the label is defined, and this leads to patching all > instructions that have been emitted before this definition. > > So, yes, the code position is only used after the definition of the > label. But the "look up in a map"-part makes the jmp operation strict in > the label parameter. Ah, I slowly get what you mean. In short, the point is that you're reinventing lazy evaluation because you're writing directly to a memory buffer and writing a raw _|_ is impossible. So, you invent a scheme to delay the evaluation of the _|_ until they are defined. With raw writing, we indeed have the strictness writeByte buf _|_ = _|_ which implies jmp _|_ = _|_ I thought that you'd simply store the instructions in a list/monoid like the Builder-Monoid from Data.Binary with the effect that jmp _|_ /= _|_ as monadic action although it stores _|_ as instruction. Lazy evaluation then takes care of filling the _|_-instructions with content in times of need. Here's an illustration with a fictional robodog toy assembly language import Control.Monad.RWS type Address = Int data Dogcode = Bark | Bite | Jump Address data CodeGen a = RWS () [Dogcode] Address a emitDogcode :: Dogcode -> CodeGen Address emitDogcode c = x <- get tell c put (x+1) return x jump :: Label -> CodeGen Address jump = emitDogcode . Jump bark, bite :: CodeGen Address bark = emitDogcode Bark bite = emitDogcode Bite generateDogCode :: CodeGen a -> CodeBuffer generateDogCode c = let (_,instructionCount, code) = runRWST c () 0 in ... whatever to do with a list of instructions ... Now, you magically get recursive do-notation without lifting a finger because RWS is already an instance of MonadFix. For example, the following works out of the box pluto :: CodeGen Address pluto = mdo bark jump loop bite loop <- bark bark jump loop (The return value of type Address encapsulated in the monad is the line number of the last instruction of pluto.) If you really want to directly write to a memory buffer, I think that you can still use lazy evaluation to fill in the _|_ by emitting a "jump PATCHME" dummy instruction and build a stack (f.i. of type [Address]) of addresses. The stack takes the role of the map you currently use, I think that a stack is enough. The addresses therein may well be _|_. After having written all instructions into the buffer, all the _|_ are resolved and you can patch the "PATCHME"s in a second pass over the buffer. However, because of omnipresent lazy evaluation, it is unclear whether "directly" writing to a buffer instead of first building a monoid does give a speed/space advantage. So, your current approach may well be slower than a naïve "first (difference) list, then raw memory" approach. > We could omit the map, and just remember where to patch the code, but > then we'd need to call explicitly some function after code generation > that does the patching. We had implemented this, but found the current > solution easier to use, since backpatching is completely automatic and > hidden from the user. Huh, I thought that runCodeGen would do an additional backpatch pass as transparently? >> I also think that having liftIO in the CodeGen-monad is plain wrong. I >> mean, CodeGen is a monad that generates code without any execution >> taking place. The execution part is already handled by runCodeGen. >> Having liftIO means that arbitrary Haskell programs can be intertwined >> with assembly generation and I doubt that you want that. > > Feel free to doubt, but this is exactly what we want. :-) > > Also, note that runCodeGen runs the code _generation_, executing the > generated code is done _within_ the CodeGen monad via the functions > generated by callDecl (or the predefined functions in the Harpy.Call > module). This is even more intertwined, but intentional. Huh? That means that code gets executed during it's own generation? But why do you mix separate concerns? I don't see what use this is besides being an opportunity to mess up. > Of course, again a different design is possible, making runCodeGen > return a binary code object, that can be called from the IO monad. But > then, the user has to care about releasing code buffers, and not to have > unevaluated closures having code pointers to already released run-time > generated code. Huh, why does the user have to care? Shouldn't wrapping the raw memory block into a Foreign.ForeignPtr do the job? Regards, apfelmus

2 2

Type class help please
by Adrian Hey 16 May '07

16 May '07

Hello, Here's a simple module I'm playing about with.. {-# OPTIONS_GHC -fglasgow-exts #-} module Test(GT(..)) where -- GT class -- class Ord key => GT map key | map -> key where assocsAscending :: map a -> [(key,a)] -- Just 1 of many methods -- Instances of GT are instances of Eq -- instance (GT map key, Eq a) => Eq (map a) where map1 == map2 = assocsAscending map1 == assocsAscending map2 When I compile it I get this error.. Test.hs:9:0: Variable occurs more often in a constraint than in the instance head in the constraint: GT map key (Use -fallow-undecidable-instances to permit this) In the instance declaration for `Eq (map a)' But I can't see any problem here. If map and key are collectively instances of GT, and the fundep in GT fixes the type of key if type of map is known, and GT class has Ord constraint on key (and IIRC Ord class has an Eq constraint so key is a known instance of Eq), then why is this undecidable? Anyway, if I compile with -fallow-undecidable-instances I get this error instead.. Test.hs:10:16: Overlapping instances for Eq [(key, a)] arising from use of `==' at Test.hs:10:16-59 Matching instances: instance (Eq a) => Eq [a] -- Defined in GHC.Base instance (GT map key, Eq a) => Eq (map a) -- Defined at Test.hs:9:0 In the expression: (assocsAscending map1) == (assocsAscending map2) In the definition of `==': == map1 map2 = (assocsAscending map1) == (assocsAscending map2) In the definition for method `==' .. but I don't understand what that means (or to be more precise, what it seems to be saying makes no sense to me, so it's probably saying something else :-) How can my new instance overlap with the old (ghc) instance unless [] is also an instance of GT for some key type (which it isn't). Could someone explain? If I try making key a type arg of map (with no -fallow-undecidable-instances ).. {-# OPTIONS_GHC -fglasgow-exts #-} module Test(GT(..)) where -- GT class -- class Ord key => GT map key | map -> key where assocsAscending :: map key a -> [(key,a)] -- key is type arg of map -- Instances of GT are instances of Eq -- instance (GT map key, Eq a) => Eq (map key a) where map1 == map2 = assocsAscending map1 == assocsAscending map2 .. then I don't get the first error "Variable occurs more often in a constraint than in the instance head". But I still get the second ("Overlapping instances.."). But I don't really want to do this anyway as it as AFAICS it defeats the object of using the fundep in GT class. I also don't really understand why this second form should be decidable (presumably), whereas the first isn't. What extra information does the second provide that isn't already provided by the fundep in the first? If I also use the -fallow-overlapping-instances flag then both forms of this module compile, but with the warning.. Warning: orphan instances: instance [overlap ok] base:GHC.Base.Eq [.] = $f1 I'd be grateful if someone could take the time to explain what's going on here and (if possible) what I can or should do to get this code to compile (preferably without using undecidable or overlapping anything). Thanks -- Adrian Hey

2 2

Higher order types via the Curry-Howard correspondence
by Gaal Yahas 16 May '07

16 May '07

What do higher-order types like lists mean when viewed through the Curry-Howard correspondence? I've been wondering about this for a while. The tutorials ask me to consider id :: forall a. a -> a (.) :: forall a b c. (b -> c) -> (a -> b) -> (a -> c) These represent theorems in a logical calculus, with the variables a, b, c denoting propositions. In the case of the composition function, the proposition (a -> c) may be deduced if (b -> c) and (a -> b) obtain, and so on. (I've obviously skimmed some details.) We know the function e :: a -> b diverges because there is no way to deduce b from a with no other premises; the only value that satisfies this is bottom -- and so on. But what does the following mean? map :: (a -> b) -> [a] -> [b] Since the empty list inhabits the type [b], this theorem is trivially a tautology, so let's work around and demand a non-trivial proof by using streams instead: data Stream a = SHead a (Stream a) sMap :: (a -> b) -> Stream a -> Stream b What is the object "Stream a" in logic? What inference rules may be applied to it? How is "data Stream" introduced, and what about variant constructors? -- Gaal Yahas <gaal(a)forum2.org> http://gaal.livejournal.com/

9 14

openBinaryFile
by Eric 15 May '07

15 May '07

Hello all, Does anyone have some sample code for reading and writing to binary files? E.

2 1

readline crashes in Emacs buffer on Windows
by Gleb Alexeyev 15 May '07

15 May '07

Hello Cafe! I asked about this problem on IRC channel but with little luck. The problem boils down to the following: readline crashes on any input if the calling program runs in the Emacs buffer. To reproduce this bug, load the code below into ghci using haskell-mode and run main. >import System.Console.Readline > >main = do readline "prompt" > putStrLn "You cannot see this, because I've crashed. Amen" I'm running Windows 2003 Server, GHC-6.6, Emacs 22.0.50.1.

1 0

Problem with finalizers
by Ivan Tomac 15 May '07

15 May '07

Why does the finalizer in the following code never get called unless I explicitly call finalizeForeignPtr fptr? Even adding System.Mem.performGC made no difference. The code was compiled with ghc --make -fffi -fvia-c Test.hs Ivan -------------------- Test.hs ------------------------ module Main where import Foreign.Ptr import Foreign.ForeignPtr import Foreign.Marshal.Utils import System.Mem foreign import ccall safe "ctest.h &ctest" ctestPtr :: FunPtr (Ptr Int -> IO ()) test :: Int -> IO () test i = with i test' where test' ptr = do fptr <- newForeignPtr ctestPtr ptr putStrLn "test" -- finalizeForeignPtr fptr main = do putStrLn "before test..." test 33 putStrLn "after test..." performGC --------------------- ctest.h ---------------------- #include <stdio.h> static inline void ctest( int *i ) { printf( "finalizer called with: %d\n", *i ); }

3 5

Code layout in Emacs' haskell-mode
by Christopher L Conway 15 May '07

15 May '07

I am new to Haskell---and also to languages with the off-side rule--and working my way through Hal Daume's tutorial. I'm a little confused by the support for code layout in Emacs' haskell-mode. Is it buggy, or am I doing something wrong. For example, here's the "Hello, world" example from the tutorial, with the indentation induced by pounding Tab in haskell-mode. test.hs: module Test where import IO main = do putStrLn "Hello, world" Prelude> :l test [1 of 1] Compiling Test ( test.hs, interpreted ) test.hs:12:0: parse error on input `main' In emacs, every line but the one with "where" reports "Sole indentation". With "where", I have the option of having it flush left or indented four spaces; "import" wants to be two spaces in from "where". Moving where doesn't change the error. But if I manually move import flush left (which is the way it's shown in the tutorial, BTW): module Test where import IO main = do putStrLn "Hello, world" Prelude> :l test [1 of 1] Compiling Test ( test.hs, interpreted ) Ok, modules loaded: Test. I have a similar problem with the layout of if-then-else... num.hs: module Num where import IO main = do putStrLn "Enter a number: " inp <- getLine let n = read inp if n == 0 then putStrLn "Zero" else putStrLn "NotZero" Prelude> :l num [1 of 1] Compiling Num ( num.hs, interpreted ) num.hs:11:2: parse error (possibly incorrect indentation) Again, if I hit tab on the "then" or "else" lines, emacs reports "Sole indentation". But if I manually change the indentation, it works. module Num where import IO main = do putStrLn "Enter a number: " inp <- getLine let n = read inp if n == 0 then putStrLn "Zero" else putStrLn "NotZero" Prelude> :l num [1 of 1] Compiling Num ( num.hs, interpreted ) Ok, modules loaded: Num. This is particularly weird because if-then-else doesn't always act this way: exp.hs: module Exp where my_exponent a n = if n == 0 then 1 else a * my_exponent a (n-1) Prelude> :l exp [1 of 1] Compiling Exp ( exp.hs, interpreted ) Ok, modules loaded: Exp. I suppose this might have something to do with the do-notation... Does haskell-mode support code layout? Are there conventions I need to know about to make it behave properly? I have haskell-mode version 2.1-1 installed from the Ubuntu feisty repository. Thanks, Chris

5 5

instance monad problem
by Veer Singh 15 May '07

15 May '07

Hello, I am trying to learn haskell , but i am struggling with types , its been around 7 days , it will be very kind if some explain it why this error , i think this is the only stumbling block . I am looking for the comparison on why similar code works , while other code not . I get this error on ghci : {- `a' is not applied to enough type arguments Expected kind `*', but `a' has kind `* -> *' In the type `SS a' In the type `(Monad a) => {Monad (SS a)}' In the instance declaration for `Monad (SS a)' -} Here is the very small code with comments: data SS a = SS a Int data Maybe1 a = Nothing1 | Just1 a instance Monad Maybe1 where (Just1 x) >>= f = f x --^^ this loads fine in ghci -- where as this instance (Monad a)=> Monad (SS a) where (SS x y) >>= f = f (x y) --^^ does not work , so whats the difference , both have type parameters -- something similar works like this : instance (Eq a)=>Eq (SS a) where (SS x y) == (SS b c) = (y == c) && (x == b) Thanks

3 2

Re: [Haskell-cafe] Limits of deduction
by Matthew Brecknell 15 May '07

15 May '07

Roberto Zunino: > Yes, you are right, I didn't want to involve type classes and assumed > 3::Int. A better example would be: > > polyf :: Int -> a -> Int > polyf x y = if x==0 then 0 > else if x==1 then polyf (x-1) (\z->z) > else polyf (x-2) () > > Here, passing both () and (\z->z) _does_ make inference fail. Alternatively, type inference succeeds in rejecting an illegal program [1,2]. :-) So I think we need to be a little more precise about exactly what is undecideable in this example. Yes, the explicit type signature you've given is valid, and the Hindley-Milner type inference algorithm is not able to assign that type without an explicit signature. But that doesn't make Hindley-Milner type inference undecideable. On the contrary, Hindley-Milner type inference is deliberately designed to be decideable. To achieve that, it assumes monomorphic types in certain identifiable contexts, and therefore rejects some functions for which valid types exist. So I think the point you were making is that the problem of inferring the types of all functions for which valid types exist is, in general, undecideable. Hindley-Milner inference ensures decideability by choosing a somewhat less general (but still useful) problem. For what it's worth (not much), it might be possible to invent a decideable type inference which could infer types for a slightly larger set of functions (including polyf), by automatically generalising the types of arguments which are not inspected. Of course, doing so would presuppose the decideability of the subproblem of identifying unused arguments, and achieving that would undoubtedly require certain restrictions on the subproblem definition, analogous to the ones employed by Hindley-Milner. [1] http://haskell.org/onlinereport/decls.html#sect4.1.4 [2] http://haskell.org/onlinereport/decls.html#sect4.5

1 0

Limits of deduction
by Andrew Coppin 15 May '07

15 May '07

Suppose I have you the source code to some arbitrary function that takes a list and returns another list. It is possible to determine whether the function always examins the entire input list? Or would that be equivilent to solving the Halting Problem? (Last time I checked, the Halting Problem is unsolvable.)

9 14

How to decrease ghc link time
by Georg Sauthoff 14 May '07

14 May '07

Hi, well, I work with a Haskell project which I regulary compile with ghc. I am a bit unhappy with the link time of the project (i.e. the time ghc needs to link everyting). The project consinst of ~60 Haskell and ~25 foreign files. Some parts of the project are organized like a 'cluster', i.e. the foreign part has only one function, which is used from Haskell-Code. What could I do to improve the link time? Does some concept of 'Packages' exists in Haskell, which helps with the link time? If someone does it before, does it help to link against shared foreign libraries instead of static ones (if this is possible)? Best regards Georg

2 3

CUFP
by Simon Peyton-Jones 14 May '07

14 May '07

The CUFP website is working again now. http://cufp.galois.com/ Thanks for pointing it out. Simon

1 0

More mystery with existentials and fundeps
by Matthew Sackman 14 May '07

14 May '07

Hi, > {-# OPTIONS_GHC -fglasgow-exts #-} > > class F a b | b -> a where > > data G :: * -> * where > GC :: (F a b) => a -> G b > > foo :: (F a b) => G b -> a > foo g = case g of > (GC a) -> a I may be being dumb, but I think this should work. Any value of G using the GC constructor will be able to define a from G b given F a b due to the functional dependency. In the above 'case' statement version I get: Couldn't match expected type `a' (a rigid variable) against inferred type `a1' (a rigid variable) `a' is bound by the type signature for `foo' at Test.lhs:10:11 `a1' is bound by the pattern for `GC' at Test.lhs:12:12-15 In the expression: a In a case alternative: (GC a) -> a In the expression: case g of (GC a) -> a > foo2 :: (F a b) => G b -> a > foo2 g = let (GC a) = g in a And this 'let' statement version explodes with: My brain just exploded. I can't handle pattern bindings for existentially-quantified constructors. In the binding group for (GC a) In a pattern binding: (GC a) = g In the expression: let (GC a) = g in a In the definition of `foo2': foo2 g = let (GC a) = g in a So is this a missing feature of GHC or am I (more likely) utterly mistaken about what should be possible here? Many thanks, Matthew

1 1

Disadvantages of de Bruijn indicies?
by Neil Mitchell 14 May '07

14 May '07

Hi, de Bruijn indicies look quite nice, and seem to eliminate a lot of complexity when dealing with free variables: http://en.wikipedia.org/wiki/De_Bruijn_index So I was wondering, are they suitable for use in a compiler? If so, what are their disadvantages/advantages? Is there any particular reason that GHC (as an example) doesn't use them in its Core? I'm trying to decide if I should use them in my compilers data type - and would like some recommendations before I start. Thanks Neil

7 9

hash of a lazy bytestring?
by David Roundy 14 May '07

14 May '07

I was just contemplating hashes, and it occurred to me that it would be nice to be able to compute the hash of a lazily constructed bytestring and lazily consume its output without requiring the whole string to ever be in memory. Or in general, it'd be nice to be able to perform two simultaneous consumptions of a lazy list without requiring that the entire list be stored. Another example would be computing the length of an ordinary list: do l <- readFile "foo" let len = length l writeFile "bar" l putStrLn $ "Length is " ++ show l It would be nice if one could write length such that the above function doesn't require the entire file be stored in memory. Are there any approaches that would make this possible? The only approach I can imagine would involve something like weak pointers and finalizers. It seems like it'd be a useful paradigm, if it's possible. Basically to be able to write a lazy consumer that doesn't hold onto its input, but instead is computed as the garbage collector frees the input. Something like: length' :: [a] -> Integer length' !xs = l' 0 `safeInterleave` xs where l' n [] = n l' !n (y:ys) = l' (n+1) `safeInterleave` ys safeInterleave :: (a -> b) -> a -> b safeInterleave f !x = -- create weak reference to x, associate finalizer, -- so that if x is GCed, then we'll immediately -- evaluate f x before we lose the value of x. Is this possible? Would it be reasonable? I imagine we'd run into trouble with laziness keeping safeInterleave from being called, with the result that we'd hang onto x even though the safeInterleave would have hoped to allow x to be GCed. -- David Roundy http://www.darcs.net

4 4

Compilling GHC on Vista
by Monique Monteiro 14 May '07

14 May '07

Hi all, I'm trying to compile GHC on Windows Vista, but I encountered the following error when running ./configure --host=i386-unknown-mingw32 --with-gcc=c:/MinGW/bin/gcc: configure: error: C compiler cannot create executables See `config.log' for more details. ./configure: line 3404: cannot create temp file for here document: No such file or directory ./configure: line 3441: cannot create temp file for here document: No such file or directory Has anyone any idea about what may be happening? Thanks in advance, Monique -- __________________________________________________________ Monique Monteiro, MSc MCP .NET Framework 2.0 / SCJP / IBM OOAD Project Manager Recife Microsoft Innovation Center +55 81 34198137 http://www.cin.ufpe.br/~mlbm http://thespoke.net/blogs/moniquelouise/default.aspx monique(a)qualiti.com.br MSN: monique_louise(a)msn.com

5 23

ambiguous type variables at MPTC
by Nicolas Frisby 13 May '07

13 May '07

This is a question about some interesting behaviors in GHC's typechecker regarding MPTCs. The brief code is at the bottom of the message. By the way, the types can be inferred but not declared without the forall and ascription in the where clause. f1 below is illegal because we don't know what type the result of read should be: it's type is ambigious. Why isn't f2 illegal as well? If C had a functional dependency of a -> b, then I could understand accepting the type. However, without the functional dependency, b might not necessarily be determined from a. i) The above reasoning encroaches on the magic of TypeCast, which effectively allows local functional dependencies to be declared at the instance-level. Because of this, the typeclass mechanism might effectively have a means of determining b from a without the class being explicitly decorated with the functional dependency. ii) Type errors where b really isn't determined by a are caught by the typechecker wherever f2's arguments are instantiated (at some usage site). This is convenient at times (it admits the uncertainty of the "might not necessarily") and annoying at others (debugging): perhaps there's a ghc switch to disallow this? If f2 is legal, why if f3 illegal? For some usage site of f3, the constraint C String b might allow b to be resolved given whatever instances of C are in effect. Is there a motivation for these behaviors? Are these sorts of cases discussed in the CHR/FD paper that motivated the coverage condition (which I have yet to read)? If ATs or GADTs would handle these situations differently, why so? Should FDs also handle these situations differently? Thanks for your time. class C a b where method :: a -> b {- illegal due to ambiguous variable f1 :: forall a . (Read a) => String -> () f1 x = () where _ = read x :: a -} -- legal, despite the lack of an FD (a -> b) on C f2 :: forall a b . (C a b) => a -> () f2 x = () where _ = method x :: b {- illegal due to none of the forall'd variables being "reachable" from the type proper f3 :: forall b . (C String b) => String -> () f3 x = () where _ = method x :: b -}

2 1

Re: [Haskell-cafe] GHC Hangs
by Josiah Manson 12 May '07

12 May '07

When the intermediate files are removed, GHC still hangs. In fact, the intermediate files do not seem to be corrupt in any way, as the only way to get a working executable is to run GHC more than once. First to produce the intermediate files, then to link them into an executable. On 5/7/07, Cale Gibbard <cgibbard(a)gmail.com> wrote: > > On 07/05/07, Josiah Manson <josiahmanson(a)gmail.com> wrote: > > There is still a problem when I use the version you linked to. At first > I > > was hopeful, because the first time I tried compiling bisect.hs it > worked. > > All subsequent attempts, however, have failed. > > Maybe try getting rid of all the intermediate (*.hi *.o) files created > when compiling it? Not that this is necessarily a permanent > solution... > > - Cale >

3 4

Ignore
by Ian Lynagh 12 May '07

12 May '07

Sorry, please ignore.

1 0

"Recent content is available under a simple permissive license"
by Robin Green 12 May '07

12 May '07

The Haskell wiki[1] says "Recent content is available under a simple permissive license". But this is unilluminating - recent? how recent, exactly? - and will become increasingly understated as time goes by. Wouldn't it be slightly more helpful to say "Content added after " ... YYYY/MM/DD ... " is available under a simple permissive license"? -- Robin [1] http://www.haskell.org/haskellwiki

3 2

Re: [Haskell] ANNOUNCE: Harpy -- run-time code generation library
by Justin Bailey 12 May '07

12 May '07

On 5/11/07, Dirk Kleeblatt <klee(a)cs.tu-berlin.de> wrote: > > Hi everybody, > > we're pleased to announce the first release of Harpy. > > Harpy is a library for run-time code generation of x86 machine code. > It provides not only a low level interface to code generation > operations, but also a convenient domain specific language for machine > code fragments, a collection of code generation combinators and a > disassembler. Impressive. Does the library require that an assembler (e.g. MASM) be installed? Justin

3 2

Re: [Haskell] ANNOUNCE: Harpy -- run-time code generation library
by Duncan Coutts 11 May '07

11 May '07

On Fri, 2007-05-11 at 10:04 +0200, Dirk Kleeblatt wrote: > Hi everybody, > > we're pleased to announce the first release of Harpy. > > Harpy is a library for run-time code generation of x86 machine code. > It provides not only a low level interface to code generation > operations, but also a convenient domain specific language for machine > code fragments, a collection of code generation combinators and a > disassembler. > > Harpy homepage: > http://uebb.cs.tu-berlin.de/harpy/ This looks cool. I was wondering what the need for ensureBufferSize is? Could this by automated? I would have thought that we could just check this when writing out a single instruction. Duncan

2 1

Monad pronounced like gonad?
by Dan Weston 11 May '07

11 May '07

I've been pronouncing monad like gonad (moh-nad), but it occurs to me that it might be pronounced like monoid (mah-nad). Is there an official way to pronouce this word - maybe with a Scottish accent? :)

14 15

Sudoku solving
by Antoine Latter 11 May '07

11 May '07

I'm a relatively new to Haskell, so I figured I needed to write a Sudoku solver. The key features of this solver are: * It's longer than other Haskell Sudoku solvers I've seen around * It fails to solve many solvable puzzles Fantastic! link: http://panicsonic.blogspot.com/2007/04/sudoku-solving.html The approach: Because I'm new to Haskell, the traditional guess-and-check method of Sudoku solving would involving things like backtracking down a search path, which is still in the realm of Haskell Black Magic. Instead, I cast the problem into successive function applications on data - A Sudoku puzzle is represented as an array of constraints on the values of cells. The constraints are reduced via analysis of the surrounding constraints until the puzzle is solved (or not). For those who like references: my approach is similar to "Solving Sudoku Puzzles with Rewritting Rules" by Gustavo Santos-Garcia and Miguel Palomino, 2005, Electronic Notes in Theoretical Computer Science. My main rules and techniques can be considered as generalizations on some of their rules and techniques - except their solver can solve all solvable puzzles (with the help of a guess-and-check rule). Thanks for taking a look, Antoine

2 1

Re: [Haskell-cafe] generate Haskell code from model
by Brian Smith 11 May '07

11 May '07

On 4/14/07, Steffen Mazanek <steffen.mazanek(a)googlemail.com> wrote: > > Brian, but don't you think that you have to write a lot > of boilerplate code in Haskell? I have never felt I was writing a lot of boilerplate. There are a lot of abstraction mechanisms in Haskell to avoid boilerplate. Second, if Haskell should be more successful in the > real world there has to be a way of demonstrating > basic ideas of a big program to "customers". How > would you do this? Everybody knows UML class > diagrams, for example. In contrast, nobody knows > about termgraphs or lambda *g*. I've never had to show a UML or ER diagram to any business people--usually they want a slideshow that is far simpler and a little prettier. The fact that "nobody knows about termgraphs or lambda" in your group means that you probably shouldn't be considering Haskell (for the same reason my bosses always asked me to document everything--"in case you get hit by a bus"). Thank you very much for contributing to the discussion. > Please assume, that you have to generate the code from > a model. Further assume, that you have no choice and > are not allowed to discuss the sense of this approach :-) > How should the code look like? I am not sure if you are trying to solve a real problem or not. If you are solving a real problem, where you already happen to have an EMF model which you are required to generate code from, then I recommend to just do everything in Java using the existing tools built for EMF. If you decide to still keep working in Haskell, and it works out well, please share your solution because I think many people here will be very interested. wxHaskell, OOHaskell, and O'Haskell are all starting points for this type of project. - Brian

4 4

Grabbing list of functions from current module
by Joel Reymont 11 May '07

11 May '07

Folks, Does anyone have code that can grab a list of functions named with a certain prefix from the current (or given) module? I want to find functions named, say, ast_* and produce a list of tuples like ("input1", ast_input1). Thanks, Joel -- http://wagerlabs.com/

3 3

Co-arbitrary
by Joel Reymont 10 May '07

10 May '07

Would someone kindly explain why we need co-arbitrary in QuickCheck and how to define it? Detailed examples would be awesome! I would be willing to paste an in-depth explanation on my wall and keep it forever. Thanks in advance, Joel -- http://wagerlabs.com/

5 4

Telling Cabal not to install the executable
by Joel Reymont 10 May '07

10 May '07

I tell Cabal to build library and a test harness. How can I tell Cabal that I only want the library installed? Thanks, Joel -- http://wagerlabs.com/

2 1

Re: [Haskell-cafe] Debugging
by Ryan Dickie 10 May '07

10 May '07

On 5/4/07, Monang Setyawan <monang(a)gmail.com> wrote: > > On 5/5/07, Stefan O'Rear <stefanor(a)cox.net> wrote: > > On Sat, May 05, 2007 at 11:36:16AM +0700, Monang Setyawan wrote: > > > Hi, I'm a beginner Haskell user. > > > > > > Is there any way to trace/debug the function application in GHC? > > > > Absolutely! > > > > stefan@stefans:/tmp$ ghci X.hs > > ___ ___ _ > > / _ \ /\ /\/ __(_) > > / /_\// /_/ / / | | GHC Interactive, version 6.7.20070502, for > Haskell 98. > > / /_\\/ __ / /___| | http://www.haskell.org/ghc/ > > \____/\/ /_/\____/|_| Type :? for help. > > > > Loading package base ... linking ... done. > > [1 of 1] Compiling Main ( X.hs, interpreted ) > > Ok, modules loaded: Main. > > *Main> :break fac > > Great!! Thanks, it really helps. > I should update my GHC to the newest version (I use the old 6.4.2 > with no break command) > > Is there any editor/IDE supporting this break command? It should be > cooler if we can debug functions just by placing mark in the line. > > > > > Stefan > > > > > -- > Demi masa.. > > > -- > Demi masa.. > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > I've only written trivial applications and functions in haskell. But the title of this thread got me thinking. In an imperative language you have clear steps, states, variables to watch, etc. What techniques/strategies might one use for a functional language? --ryan

7 8

built-in lists vs inductively defined list
by José Miguel Vilaça 10 May '07

10 May '07

Hi, Can someone tell me if would be any difference (beside syntax) between the built-in Haskell list with [] and : and lists given by a inductive datatype definition like data List a = Nil | Cons a (List a) This is, is any of the compilers doing some special optimizations for the built-in lists? Best Miguel Vilaça

7 8

Vanishing polymorphism
by Matthew Sackman 10 May '07

10 May '07

Hi, To cut a long story short, could someone explain why: > :t negate negate :: forall a. (Num a) => a -> a > :t let f (fn :: forall a . Num a => a -> a) r s = (fn r, fn s) in f negate let f (fn :: forall a . Num a => a -> a) r s = (fn r, fn s) in f negate :: forall r s. (Num r, Num s) => r -> s -> (r, s) but > :t let f r s = (return negate) >>= (\fn -> return (fn r, fn s)) in f let f r s = (return negate) >>= (\fn -> return (fn r, fn s)) in f :: forall a (m :: * -> *). (Num a, Monad m) => a -> a -> m (a, a) and > :t let f r s = (return negate) >>= (\(fn::forall n . (Num n) => n -> n) -> return (fn r, fn s)) in f <interactive>:1:35: Couldn't match expected type `a -> a' against inferred type `forall n. (Num n) => n -> n' In the pattern: fn :: forall n. (Num n) => n -> n In a lambda abstraction: \ (fn :: forall n. (Num n) => n -> n) -> return (fn r, fn s) In the second argument of `(>>=)', namely `(\ (fn :: forall n. (Num n) => n -> n) -> return (fn r, fn s))' I.e. why does the polymorphism get destroyed? Cheers, Matthew -- Matthew Sackman http://www.wellquite.org/

4 6

Object Files Become Downloader.Obfuskated
by SevenThunders 10 May '07

10 May '07

I discovered a curious thing after a compiling a medium sized Haskell project using the 64 bit linux Haskell GHC 6.6.1 compiler. Several of the generated object files (.o) show up as containing the virus Downloader.Obfuskated by my AVG anti-virus program when viewing the files from windows xp 64. Since the files were generated by GHC on linux I find it hard to believe that they actually contain this virus. A google search reveals one other mention of something like this happening with no further explanation. The virus detection appears no where else except in object files generated by the ghc linux compiles. -- View this message in context: http://www.nabble.com/Object-Files-Become-Downloader.Obfuskated-tf3718136.h… Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com.

1 0

Re: [Haskell-cafe] Safe forward-mode AD in Haskell?
by Björn Buckwalter 09 May '07

09 May '07

> > d :: Num a => (forall b. (Num b) => (a -> b) -> b -> b) -> a -> a > > d f x = let (Bundle y y') = f lift (Bundle x 1) in y' > > The key change is in the type of d, which now accepts a polymorphic > function on numbers, but passes in a "lift" function, which allows us to > pass in higher-level variables. In one sense this function is ugly. In > another sense, it's prettier, as you can now hide *all* of the Bundle data > in a "differentiation" module. To summarize: In my original version it is necessary to export 'd' and 'lift', which both expose 'Bundle' through their type signatures (and 'lift' even returns a 'Bundle', though how one could (ab)use it outside the intended context of a 'd' escapes me). In constrast, with your variation only 'd' need be exported and everything else in the module (including 'Bundle) is completely hidden. The cost is that functions must be "conditioned" before they can be differentiated. Thanks for your input! -Bjorn

1 0

Roles == type classes ???
by Magnus Therning 09 May '07

09 May '07

The way roles/traits are described in [1] (and the pages it links to) make me think of Haskell type classes. Am I completely off in doing that? /M [1]: http://griddlenoise.blogspot.com/2007/05/traits-roles-as-alternative-to-abs… -- Magnus Therning (OpenPGP: 0xAB4DFBA4) magnus(a)therning.org Jabber: magnus.therning(a)gmail.com http://therning.org/magnus Software is not manufactured, it is something you write and publish. Keep Europe free from software patents, we do not want censorship by patent law on written works. Those who would give up Essential Liberty to purchase a little Temporary Safety, deserve neither Liberty nor Safety -- Benjamin Franklin, Historical Review of Pennsylvania, 1759

2 1

Re: Cost of Overloading vs. HOFs
by Conal Elliott 09 May '07

09 May '07

[switching to haskell-cafe] thanks for the explanation, John. doesn't the list cases mentioned in the definition of (+) below assume whole program, in order to know all Num instances? On 5/4/07, John Meacham <john(a)repetae.net> wrote: > > On Fri, May 04, 2007 at 05:06:10PM -0700, Conal Elliott wrote: > > Cool. You know which types to consider because jhc is a whole-program > > compiler? > > Yes. though, i have since redone the back end so there is no technical > reason for it to be whole program any more, you can just benefit from > more optimizations that way. The old backend required global knowledge > to compile at all. > > > > Given the whole program, why not monomorphize, and inline away all of > the > > dictionaries? > > Well that is the thing, there are no dictionaries at all, the only extra > arguments passed in are the types so, > > f :: forall a . (Foo a, Baz a, Bar a Int, Bred a) => a -> a > > still is only passed the single hidden argument of 'a' since a case on > it will determine what method to use. > > (+) a x y = case a of > Int -> plusInt x y > Float -> plusFloat x y > > and so forth. a here is a type, of kind '*'. > > > since the method lookup is done explicitly via the case statement, it > can be optimized via standard transformations in nice ways. > > John > > > > > > > > > > - Conal > > > > On 5/4/07, John Meacham <john(a)repetae.net> wrote: > > > > > >On Fri, May 04, 2007 at 03:07:41PM -0700, Conal Elliott wrote: > > >> Does anyone know what became of Dictionary-free Overloading by > Partial > > >> Evaluation <http://web.cecs.pdx.edu/%7Empj/pubs/pepm94.html>? Is it > > >> impractical for some reason? > > > > > >jhc also uses a dictionary free approach, doing a case directly on the > > >type parameter. > > > > > >The nice thing about this is that _all_ methods can be determined by a > > >single case evaluation, because finding out the right instance for any > > >method will determine the right instance for all other methods too for > a > > >given type. The standard case-of-known-value optimization takes care of > > >later scrutinizations (method lookups) on the same type. > > > > > > John > > > > > > > > >-- > > >John Meacham - ⑆repetae.net⑆john⑈ > > >_______________________________________________ > > >Glasgow-haskell-users mailing list > > >Glasgow-haskell-users(a)haskell.org > > >http://www.haskell.org/mailman/listinfo/glasgow-haskell-users > > > > > > -- > > Glasgow-haskell-users mailing list > > Glasgow-haskell-users(a)haskell.org > > http://www.haskell.org/mailman/listinfo/glasgow-haskell-users > > > -- > John Meacham - ⑆repetae.net⑆john⑈ > _______________________________________________ > Glasgow-haskell-users mailing list > Glasgow-haskell-users(a)haskell.org > http://www.haskell.org/mailman/listinfo/glasgow-haskell-users >

2 1

Safe forward-mode AD in Haskell?
by Björn Buckwalter 09 May '07

09 May '07

Dear all, = Introduction = In [1] Siskind and Pearlmutter expose the danger of "perturbation confusion" in forward-mode automatic differentiation. In particular they state: "We discuss a potential problem with forward-mode AD common to many AD systems, including all attempts to integrate a forward-mode AD operator into Haskell." This literate Haskell message shows how, using a type system extension of the Glasgow Haskell Compiler[2] (GHC), we can statically guarantee that perturbation confusion does not occur. = Code = The below code closely follows the Haskell code in the appendices of [1]. It relies on GHC's arbitrary-rank polymorphism(?) extension to Haskell 98. > {-# OPTIONS_GHC -fglasgow-exts #-} In our definition of the 'Bundle' data type we add the phantom type 's', which will be the key to disambiguating between different application of the 'd' operator. > data Bundle s a = Bundle a a > instance Num a => Show (Bundle s a) where > showsPrec p (Bundle x x') = showsPrec p [x,x'] > instance Num a => Eq (Bundle s a) where > (Bundle x x') == (Bundle y y') = (x == y) > lift z = Bundle z 0 > instance Num a => Num (Bundle s a) where > (Bundle x x') + (Bundle y y') = Bundle (x + y) (x' + y') > (Bundle x x') * (Bundle y y') = Bundle (x * y) (x * y' + x' * y) > fromInteger z = lift (fromInteger z) > instance Fractional a => Fractional (Bundle s a) where > fromRational z = lift (fromRational z) We provide a type signature for 'd' where we existentially quantify the phantom type 's' to prevent mixing of bundles from different 'd' operators. > d :: Num a => (forall s. Bundle s a -> Bundle s a) -> a -> a > d f x = let (Bundle y y') = f (Bundle x 1) in y' The extential quantification makes the definition ] constant_one' x = d (\y -> x + y) 1 impossible since 'x' originates externally to the 'd' operator. GHC rejects the definition with a "Inferred type is less polymorphic than expected". In order to pass the compiler the definition must be changed to the corrected[1] version. > constant_one x = d (\y -> (lift x) + y) 1 > should_be_one_a = d (\x -> x * (constant_one x)) 1 > should_be_one_b = d (\x -> x * 1 ) 1 > violation_of_referential_transparency = should_be_one_a /= should_be_one_b = References = [1] http://www.bcl.hamilton.ie/~qobi/nesting/papers/ifl2005.pdf [2] http://haskell.org/ghc/

2 4

Re: Building the community
by Rick Moen 09 May '07

09 May '07

Back on December 14, Conrad Parker write: > On 15/12/06, Nicolas Frisby <nicolas.frisby(a)gmail.com> wrote: > > 2) The "welcome to the mailing list" message could say "if you're > > new to Haskell, please check this FAQ first". I'm talking big letters > > here; I'd even be OK with <marquee>. > > .. hence I'd caution against such a rule. Part of the reason this > community is welcoming is because there is no such barrier for people > new to Haskell to ask questions. Everyone has a different mathematics > ability and programming experience, and an ambiguously posed question > is often just scratching the surface of what someone really wants to > know. It's great that this community recognises that and responds > accordingly. > > By contrast, many technical communities follow the advice of a > document called "How to ask questions the smart way" by Eric Raymond > and Rick Moen [0]. That would be the guy I shave. > Although it contains some useful advice for individuals who want to > find the answers to simply definable technical questions, imposing > that advice on people who ask questions often ends up being elitist. I just re-read the essay (which some love, some hate, and I personally find too verbose to be useful), and find no suggestion therein that anything whatsoever should be "imposed" on querents. Nada. Rein du tout. > At best, answering questions (the smart way ;-) should be thought of > as taking part in a mathematical dialogue, not as a game of wits where > the original poster is only given one chance to precisely formulate > their question. I'll be glad to send US $100 to Conrad if he show me where Eric's and my essay suggests the latter -- as a bug bounty. > For an example from that document: > > What we [hackers] are, unapologetically, is hostile to people who > seem to be unwilling to think or to do their own homework before > asking questions. People like that are time sinks -- they take > without giving back, and they waste time we could have spent on > another question more interesting and another person more worthy of > an answer. We call people like this "losers" (and for historical > reasons we sometimes spell it "lusers"). > > I hope the Haskell community never adopts such an arrogant tone. It's unfortunate that Conrad saw fit to cut out the explanatory comments that immediately _follow_ that quoted passage: We realize that there are many people who just want to use the software we write, and who have no interest in learning technical details. For most people, a computer is merely a tool, a means to an end; they have more important things to do and lives to live. We acknowledge that, and don't expect everyone to take an interest in the technical matters that fascinate us. Nevertheless, our style of answering questions is tuned for people who do take such an interest and are willing to be active participants in problem-solving. That's not going to change. Nor should it; if it did, we would become less effective at the things we do best. We're (largely) volunteers. We take time out of busy lives to answer questions, and at times we're overwhelmed with them. So we filter ruthlessly. In particular, we throw away questions from people who appear to be losers in order to spend our question-answering time more efficiently, on winners. If you find this attitude obnoxious, condescending, or arrogant, check your assumptions. We're not asking you to genuflect to us -- in fact, most of us would love nothing more than to deal with you as an equal and welcome you into our culture, if you put in the effort required to make that possible. But it's simply not efficient for us to try to help people who are not willing to help themselves. It's OK to be ignorant; it's not OK to play stupid. So, while it isn't necessary to already be technically competent to get attention from us, it is necessary to demonstrate the kind of attitude that leads to competence -- alert, thoughtful, observant, willing to be an active partner in developing a solution. If you can't live with this sort of discrimination, we suggest you pay somebody for a commercial support contract instead of asking hackers to personally donate help to you. If you decide to come to us for help, you don't want to be one of the losers. You don't want to seem like one, either. The best way to get a rapid and responsive answer is to ask it like a person with smarts, confidence, and clues who just happens to need help on one particular problem. In my world, a highly public essay that prominently says "most of us would love nothing more than to deal with you as an equal and welcome you into our culture" -- and explains the most effective way to do so -- would qualify as the exact polar opposite of "elitist". Elitism would be the _lack_ of such an essay. It would be, for example, a happy, positive-thinking, nurturing-feeling online environment where people nonetheless seldom effective help because nobody bothered to tell newcomers the truth about how to go about it. Eric and I tried to tell exactly that truth. We were blunt because bluntness _works_ in exactly the way that tiptoeing around important, key facts completely fails to work. (I submit that, if you're a busy technical expert and claim you don't filter ruthlessly and bypass poorly framed questions in favour of answerable and thoughtful ones, you are probably not being honest with yourself, as the trait is pretty nigh unto universal.) Sometimes, when you tell relevant truths, many people don't want to hear them, listen selectively if at all, and then call you names. Oh well. I note that Conrad's objection to Nicholas's suggestion of a FAQ pointer is that it would be a "barrier to asking questions". Huh? A suggestion in the welcome message that "if you're new to Haskell, please check this FAQ first" would tend to deter people from asking questions? How does that work? The suggestion's going to reach over and bruise their fingers? This does reveal one of the many hazards of writing documentation (in addition to http://linuxmafia.com/~rick/lexicon.html#moenslaw-documentation) Some people are hostile to the effort. Oh well. To quote the late Kurt Vonnegut, "So it goes." -- Cheers, If men are from Mars and women are from Venus, there's going Rick Moen to be one big-ass fight over where to set the thermostat. rick(a)linuxmafia.com -- Jim Rosenberg, in The Monastery

1 0

Indenting with PPrint
by Joel Reymont 09 May '07

09 May '07

Folks, Are you using UU.PPrint [1]? Can you tell me how to print stuff like this? { blah blah } I tried the following which sort of works but doesn't return the closing brace to the indentation level of the first one. braces x = PP.braces $ linebreak <> indent 4 x Thanks, Joel [1] http://tinyurl.com/25t6xz -- http://wagerlabs.com/

2 3

QuickCheck invariants for AST transformations
by Joel Reymont 09 May '07

09 May '07

I'm looking for suggestions on how to create invariants for the following AST transformation code. Any suggestions are appreciated! I asked this question before and Lennart suggested abstract interpretation as a solution. This would require interpreters for both ASTs to determine that the result they achieve is the same. I don't fancy writing a C# interpreter, though, so I'm looking for an easier way out. Thanks, Joel [1] http://tinyurl.com/368whq --- instance SharpTransform C.Type Type where toSharp C.TyInt = return TyInt toSharp C.TyFloat = return TyFloat toSharp C.TyStr = return TyStr toSharp C.TyBool = return TyBool toSharp (C.TyArray x) = liftM2 TyArray (toSharp x) (return []) toSharp (C.TySeries C.TyFloat) = return $ TyCustom "DataSeries" toSharp (C.TySeries x) = error $ "Unsupported series type: " ++ show x toSharp (C.TyProp x) = toSharp x toSharp C.TyUnit = return TyVoid instance SharpTransform C.VarIdent VarIdent where toSharp (C.VarIdent x) = return $ VarIdent x instance SharpTransform (Maybe C.Expr) (Maybe Expr) where toSharp Nothing = return Nothing toSharp (Just e) = liftM Just (toSharp e) instance SharpTransform C.Subscript [Expr] where toSharp xs = mapM toSharp xs instance SharpTransform C.BarsAgo Expr where toSharp C.Now = return $ Int 0 toSharp (C.BarsAgo e) = toSharp e -- http://wagerlabs.com/

2 1

Listing package dependencies from GHC
by Dougal Stanton 08 May '07

08 May '07

If I'm doing development between ghci and vim, all the different dependencies I need get linked in when required without me asking. Similarly if I call "ghc --make" from the command line. But I have to write them in manually to my *.cabal file otherwise the compilation process will fail. Until now I've just loaded the program in to ghci and noted down all the dependencies it links in. Am I missing a trick? There must be an easier way, especially for multiple source files. cheers, D.

4 7

Using dump in Netwotk.Pcap
by Harald ROTTER 08 May '07

08 May '07

Dear Haskellers, as a Haskell newbie I really enjoyed Austin Seipp's article on writing a packet sniffer in Haskell using the libpcap. I played around with Network.Pcap and tried to dump packets into a pcap file using the dump function: dump :: Ptr PcapDumpTag -> Ptr PktHdr -> Ptr Word8 -> IO () As compared to the loop function (used by Austin's packet sniffer) loop :: Ptr PcapTag -> Int -> Callback -> IO Int type Callback = PktHdr -> Ptr Word8 -> IO () the dump function takes a "Ptr PktHdr". If I want to "dump" inside a Callback, I have the problem of getting a "PktHdr" argument, but I need a "Ptr PktHdr" to dump. I tried to use "with": with :: Storable a => a -> (Ptr a -> IO b) -> IO b but PktHdr is unfortunately not an instance of the "Storable" class. How is it possible to use the "dump" function (that needs a Ptr PktHdr) inside a Callback that only passes PktHdr ? Any help is appreciated. Thank you Harald. " Ce courriel et les documents qui y sont attaches peuvent contenir des informations confidentielles. Si vous n'etes pas le destinataire escompte, merci d'en informer l'expediteur immediatement et de detruire ce courriel ainsi que tous les documents attaches de votre systeme informatique. Toute divulgation, distribution ou copie du present courriel et des documents attaches sans autorisation prealable de son emetteur est interdite." " This e-mail and any attached documents may contain confidential or proprietary information. If you are not the intended recipient, please advise the sender immediately and delete this e-mail and all attached documents from your computer system. Any unauthorised disclosure, distribution or copying hereof is prohibited."

1 0

How to parse a date and time?
by Justin Bailey 08 May '07

08 May '07

Looking at the libraries documentation, it seems like parsing a string into a time and date should be as simple as: import Data.Time.Format (parseTime) myDate = parseTime "..." where "..." is some string. But these functions don't seem to exist! I can't find many references to them in the wild, and the module "Data.Time.Format" is not found under GHC 6.6 or Hugs. I am running Windows, if it makes a difference. Are the docs just out of date[1] or is it my install? How can I parse a string into a Data.Time.Calendar.Day value (or some other time value)? Thanks for any help! Justin [1] http://haskell.org/ghc/docs/latest/html/libraries/time/Data-Time-Format.html

2 1

The Trivial Monad
by Adrian Neumann 08 May '07

08 May '07

-----BEGIN PGP SIGNED MESSAGE----- Hash: SHA512 I've read this blogpost about the "trivial monad" http://sigfpe.blogspot.com/2007/04/trivial-monad.html, because I still don't understand what this monad thingy is all about. The author defines three functions: data W a = W a deriving Show return :: a -> W a return x = W x fmap :: (a -> b) -> (W a -> W b) fmap f (W x) = W (f x) bind :: (a -> W b) -> (W a -> W b) bind f (W x) = f x and asks the reader to prove the tree monad laws for them. However I don't understand the type signatures for bind and fmap. I'd say (and ghci's type inference agrees) that bind and fmap have the type bind:: (a->W b) -> W a -> W b fmap:: (a->b) -> W a -> W b They take a function f and something and return what f does to that. I don't see why they should return a function. This of course makes it hard for me to prove the monad laws. The first however works nonetheless: 1) bind f (return a)= f a => bind f (return a)= bind f (W a) = f a Can someone explain bind and fmap (and possible law 2 and 3)? Thanks, Adrian -----BEGIN PGP SIGNATURE----- Version: GnuPG v1.4.6 (Darwin) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFGOuQS11V8mqIQMRsRCmngAJ9NwQMwXeS/PSM1NUsVA8gxPuA0KACfSLiA ItqRZW5a4XyQ099bhMtSWmU= =/8i/ -----END PGP SIGNATURE-----

7 10

Re: a question concerning type constructors
by oleg＠pobox.com 08 May '07

08 May '07

> In Haskell, is it possible to declare a type constructor with a variable > number of type variables e.g. > > data Tuple * .... > > allowing the following declarations: > > t: Tuple > u: Tuple Bool > v: Tuple Bool Int > w: Tuple Bool Int Char Although the data constructor such as the `Tuple' is not possible literally, the declarations like the above can be achieved. Please see the examples in http://www.haskell.org/pipermail/haskell/2006-September/018487.html

1 0

Re: [Haskell-cafe] GHC Hangs
by Josiah Manson 08 May '07

08 May '07

> http://www.haskell.org/ghc/dist/6.6.1/ghc-6.6.1-i386-windows-test1.exe > > Might be worth trying that to see if there's still a problem. > There is still a problem when I use the version you linked to. At first I was hopeful, because the first time I tried compiling bisect.hs it worked. All subsequent attempts, however, have failed.

1 0

GHC Hangs
by Josiah Manson 08 May '07

08 May '07

Hello Haskellers, I have a problem where GHC will hang after compiling a file. The problem seems to occur with my computer, but not with everyone else's. I hope that someone my be able to diagnose my problem. My computer is an Acer Aspire 5670, which runs on an Intel Core Duo T2300 and runs Windows XP Home Edition. My version of GHC is The Glorious Glasgow Haskell Compilation System, version 6.6. When supplied the file bisect.hs with the following contents: sign a | a < 0 = -1 sign a | a >= 0 = 1 bisect f a b = if b - a < eps then c else if sign (f a) == sign (f c) then bisect f c b else bisect f a c where c = (a + b) / 2 eps = 0.000000000000001 main = print $ bisect cos 0 2 Running produces this output at which point nothing further happens. The same thing happens without -dcore-lint -debug, but I have included it because someone suggested it would provide useful diagnostics. C:\data\code\other\haskell\simple>ghc --make bisect.hs -dcore-lint -debug [1 of 1] Compiling Main ( bisect.hs, bisect.o ) The file bisect.o is generated, but GHC is stopped and not using any CPU time. As well, there are two other processes that were spawned and must also be killed separately named gcc.exe and as.exe. Interestingly, if I do multiple iterations of running ghc then killing it. I eventually get a working executable. As far as I can tell, GHC is deadlocked, which makes me wonder if dual cores are causing the problem. BTW, problems like this have occurred in other free software like Open Office, but leaves most other programs unaffected. Josiah

2 1

An interesting toy
by Andrew Coppin 08 May '07

08 May '07

12 25

Arbitrary precision?
by Andrew Coppin 08 May '07

08 May '07

Greetings. Haskell has arbitrary precision integers, in the form of the Integer type. Is there a type somewhere that implements arbitrary precision fractional values?

7 11