- Haskell-Cafe - Haskell.org

Does someone have a compiled binary of the LLVM for Windows 7 or must one compile the source?
by KC 18 Aug '12

18 Aug '12

I just want to get started on some matrix operations with REPA. Or is there a library (package?) like REPA without using the LLVM? -- -- Regards, KC

2 2

Regex string replacement
by José Romildo Malaquias 18 Aug '12

18 Aug '12

Hello. I am looking for a substring replacement based on Perl like regular expressions that would let me use part of the original string in the replacement string. Something like: reReplace "name is (.*)\\." "hi \1!" "my name is john." which would result in "hy john!" Any help? Romildo

2 2

Re: [Haskell-cafe] phantom types
by Florian Hartwig 17 Aug '12

17 Aug '12

> Hi, > > I am currently reading documentation on Generalized Algebraic Data Types: > > http://en.wikibooks.org/wiki/Haskell/GADT > > I have a question concerning this page. Let us consider the following code > proposed in the page: > > ---------------------------------- > -- Phantom type variable a (does not appear in any Expr: it is just a > -- dummy variable). > data Expr a = I Int > | B Bool > | Add (Expr a) (Expr a) > | Mul (Expr a) (Expr a) > | Eq (Expr a) (Expr a) > deriving (Show) > > -- Smart constructors > add :: Expr Int -> Expr Int -> Expr Int > add = Add > > i :: Int -> Expr Int > i = I > > b :: Bool -> Expr Bool > b = B > > eval :: Expr a -> a > eval (I n) = n > ---------------------------------- > > I obtain the following error: > > Phantom.hs:27:14: > Couldn't match type `a' with `Int' > `a' is a rigid type variable bound by > the type signature for eval :: Expr a -> a at Phantom.hs:27:1 > In the expression: n > In an equation for `eval': eval (I n) = n > > The wiki page explains: > > """ > But alas, this does not work: how would the compiler know that encountering > the constructor I means that a = Int? > """ > > I don't understand. When we write "eval (I n) = n", as I is a constructor > which takes an Int as argument, we are able to deduce that the type of n is > Int; so the type of eval should be in this case "Expr Int -> Int". > What do I miss? Since the example uses phantom types, the type of n is not actually related to the type of (I n). It is perfectly possible to have, for example, a value of type Expr String created by the I constructor: *Main> let expr = I 5 :: Expr String *Main> expr I 5 *Main> :t expr expr :: Expr String So if we define eval the way it is defined in the example, the compiler cannot infer that the type of (I n) is Expr Int, even though it knows that n's type is Int. We could prevent the creation of values with the wrong types by only exporting the smart constructors, but that is no help for the type system. Declaring eval as Expr Int -> Int would make the code compile, but since eval should presumably include patterns for other types, such as eval (B b) = b which would have to be of type Expr Bool -> Bool, we cannot do that. I hope I did not misunderstand your question and this helps. Cheers, Florian

2 1

Re: [Haskell-cafe] [Announce] Compositional Compiler Construction, Oberon0 examples available
by Facundo Domínguez 17 Aug '12

17 Aug '12

Sorry, fixed the subject. On Fri, Aug 17, 2012 at 11:11 AM, Facundo Domínguez <facundominguez(a)gmail.com> wrote: > I have one unbearable doubt, how do you accent CoCoCo? CóCoCo? CoCóCo? CoCoCó? > > Facundo > >> Date: Thu, 16 Aug 2012 21:40:28 +0200 >> From: Doaitse Swierstra <doaitse(a)swierstra.net> >> Subject: [Haskell-cafe] [Announce] Compositional Compiler >> Construction, Oberon0 examples available >> To: "haskell-cafe(a)haskell.org Cafe" <haskell-cafe(a)haskell.org>, >> Haskell List <haskell(a)haskell.org> >> Message-ID: <3B4B9FFC-B1BB-4156-BE80-5E60632EE5CD(a)swierstra.net> >> Content-Type: text/plain; charset=us-ascii >> >> Over the years we have been constructing a collection of Embedded Domain Specific Languages for describing compilers which are assembled from fragments which can be compiled individuallu. In this way one can gradually ``grow a langauge'' in a large number of small steps. The technique replaces things like macro extensions or Template Haskell; it has become feasable to just extend the language at hand by providing extra modules. The nice thing is that existing code does not have to be adapted, nor has to be available nor has to be recompiled. >> >> Recently we have been using (and adapting) the frameworks such that we could create an entry in the ldta11 (http://ldta.info/tool.html) tool challenge, where one has to show how one's tools can be used to create a compiler for the Oberon0 language, which is used a a running example in Wirth's compiler construction book. >> >> We have uploaded our implementation to hackage at: http://hackage.haskell.org/package/oberon0. >> >> More information can be found at the wiki: http://www.cs.uu.nl/wiki/bin/view/Center/CoCoCo >> >> You may take a look at the various Gram modules to see how syntax is being defined, and at the various Sem modules to see how we use our first class attribute grammars to implement the static semantics associated with the various tasks of the challenge. >> >> We hope you like it, and comments are welcome, >> >> Marcos Viera >> Doaitse Swierstra

1 0

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 108, Issue 22
by Facundo Domínguez 17 Aug '12

17 Aug '12

I have one unbearable doubt, how do you accent CoCoCo? CóCoCo? CoCóCo? CoCoCó? Facundo > Date: Thu, 16 Aug 2012 21:40:28 +0200 > From: Doaitse Swierstra <doaitse(a)swierstra.net> > Subject: [Haskell-cafe] [Announce] Compositional Compiler > Construction, Oberon0 examples available > To: "haskell-cafe(a)haskell.org Cafe" <haskell-cafe(a)haskell.org>, > Haskell List <haskell(a)haskell.org> > Message-ID: <3B4B9FFC-B1BB-4156-BE80-5E60632EE5CD(a)swierstra.net> > Content-Type: text/plain; charset=us-ascii > > Over the years we have been constructing a collection of Embedded Domain Specific Languages for describing compilers which are assembled from fragments which can be compiled individuallu. In this way one can gradually ``grow a langauge'' in a large number of small steps. The technique replaces things like macro extensions or Template Haskell; it has become feasable to just extend the language at hand by providing extra modules. The nice thing is that existing code does not have to be adapted, nor has to be available nor has to be recompiled. > > Recently we have been using (and adapting) the frameworks such that we could create an entry in the ldta11 (http://ldta.info/tool.html) tool challenge, where one has to show how one's tools can be used to create a compiler for the Oberon0 language, which is used a a running example in Wirth's compiler construction book. > > We have uploaded our implementation to hackage at: http://hackage.haskell.org/package/oberon0. > > More information can be found at the wiki: http://www.cs.uu.nl/wiki/bin/view/Center/CoCoCo > > You may take a look at the various Gram modules to see how syntax is being defined, and at the various Sem modules to see how we use our first class attribute grammars to implement the static semantics associated with the various tasks of the challenge. > > We hope you like it, and comments are welcome, > > Marcos Viera > Doaitse Swierstra

1 0

How to simplify the code of Maybe within a monad?
by Magicloud Magiclouds 17 Aug '12

17 Aug '12

Hi, Since Maybe is a monad, I could write code like 'maybeA >> maybeB >> maybeC' to check if all these are not Nothing. Or 'liftM foo maybeD' to avoid ugly 'case of'. But how if here maybe[ABC] are like 'IO (Maybe Int)', or foo is type of 'Int -> IO Int'? -- 竹密岂妨流水过山高哪阻野云飞 And for G+, please use magiclouds#gmail.com.

3 2

Working with remote HTTP file as ZIP archive
by Dennis Yurichev 16 Aug '12

16 Aug '12

Hi. I want %subj%. Is it possible with lazy evaluation and any existing Haskell libraries do: 1) open remote file via HTTP, read random pieces of it but not to download the whole file? HTTP standard supporting partial reads... 2) open remote file via HTTP as ZIP archive, get list of files, get specific file (whole) or get part of specific file, but again, using lazy eval, not to fetch all stuff. So is it possible? Thanks in advance!

1 0

Parsing pragmas in a Haskell-like language
by Björn Peemöller 16 Aug '12

16 Aug '12

Dear cafe, I'm experimenting with extending the parser for a Haskell-like language by module pragmas. The parser is written using parser combinators. Currently, I adapted the lexer to ignore whitespace and comments, but create lexemes for both the pragma start and end (and the pragma's content, of course). While these lexemes are necessary for parsing the pragmas before the module header, they somehow should be ignored (treated like comments) afterwards. Could anyone give me a hint me how this behaviour (treat pragmas like comments) is achieved in GHC or in haskell-src-exts? Thanks in advance, Björn

2 1

Can pipes solve this problem? How?
by oleg＠okmij.org 16 Aug '12

16 Aug '12

> Consider code, that takes input from handle until special substring matched: > > > matchInf a res s | a `isPrefixOf` s = reverse res > > matchInf a res (c:cs) = matchInf a (c:res) cs > > hTakeWhileNotFound str hdl = hGetContents hdl >>= return.matchInf str [] > > It is simple, but the handle is closed after running. That is not good, > because I want to reuse this function. This example is part of one of Iteratee demonstrations http://okmij.org/ftp/Haskell/Iteratee/IterDemo1.hs Please search for -- Early termination: -- Counting the occurrences of the word ``the'' and the white space -- up to the occurrence of the terminating string ``the end'' The iteratee solution is a bit more general because it creates an inner stream with the part of the outer stream until the match is found. Here is a sample application: run_bterm2I fname = print =<< run =<< enum_file fname .| take_until_match "the end" (countWS_iter `en_pair` countTHE_iter) It reads the file until "the end" is found, and counts white space and occurrences of a specific word, in parallel. All this processing happens in constant space and we never need to accumulate anything into string. If you do need to accumulate into string, there is an iteratee stream2list that does that. The enumeratee take_until_match, as take and take_while, stops when the terminating condition is satisfied or when EOF is detected. In the former case, the stream may contain more data and remains usable. A part of IterDemo1 is explained in the paper http://okmij.org/ftp/Haskell/Iteratee/describe.pdf I am not sure though if I answered your question since you were looking for pipes. I wouldn't call Iteratee pipes.

2 1

Fwd: 'let' keyword optional in do notation?
by David Feuer 16 Aug '12

16 Aug '12

---------- Forwarded message ---------- From: David Feuer <david.feuer(a)gmail.com> Date: Wed, Aug 8, 2012 at 12:22 PM Subject: Re: [Haskell-cafe] 'let' keyword optional in do notation? To: Martijn Schrage <martijn(a)oblomov.com> Changing scoping rules based on whether things are right next to each other? No thanks. On Wed, Aug 8, 2012 at 11:44 AM, Martijn Schrage <martijn(a)oblomov.com> wrote: > On 08-08-12 17:27, Ertugrul Söylemez wrote: > > Vo Minh Thu <noteed(a)gmail.com> wrote: > > This is not a parsing problem, but a scoping one: try to run this > program: > > main = do > let x = y > y = 5 > let a = b > let b = 6 > print (x, y, a, b) > > Cheers, > Thu > > Martijn has actually covered this question: > > Where each sequence of let-less bindings is put in a separate > binding group. I'm no parsing wizard, but I couldn't come up with > any situations in which this would cause ambiguity. To me, the > let-less version is easier on the eyes, more consistent with <- > bindings, and also makes it less of a hassle to move stuff around. > > > To make it more clear, this is the transformation I propose: > > do ... -- not a let-less binding > x1 = exp1 -- \ > .. -- only let-less bindings > xn = expn -- / > ... -- not a let-less binding > > becomes > > do ... > let x1 = exp1 > .. > xn = expn > ... > > So > > main = do > > x = y > y = 5 > a = b > > b = 6 > print (x, y, a, b) > > > would put everything in the same binding group and compile successfully. To > get Thu's example, you would write > > main = do > > x = y > y = 5 > let a = b > let b = 6 > print (x, y, a, b) > > The last let could even be left out. > > Cheers, Martijn > > The suggestion seems sound to me, and the additional 'let' can really be > annoying in cases where you have a lot of 'let' bindings among very few > monadic actions. My current way to deal with this is to move the stuff > to separate computations, but it's certainly not a nice solution: > > myComp = c >>= f > where > f x = ... > where > a = ... > b = ... > > > Greets > Ertugrul > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe > > > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe >

5 6