gmane.comp.lang.haskell.cafe

gona to join in haskell-cafe

Dante.py — 2012-05-26T00:58:59

Hello,friends!
     I come from China, wishing to enjoy haskell with you.

Template Haskell antiquotation in user-definedquasiquoters

Sam Lindley — 2012-05-25T19:51:38

Template Haskell supports antiquotation for built-in quasiquotes, e.g.:

   [| \x -> x + $([|3 * 4|]) |]

However, as far as I can tell, there is no way of supporting 
antiquotation in user-defined quasiquoters, because the only way to 
specify a new quasiquoter is through a quoteExp function of type String 
-> Q Exp. Of course, it is perfectly possible to write a parser for some 
fragment of Haskell inside your quoteExp function, but that seems crazy 
given that Template Haskell or rather GHC already implements a parser 
for the whole language.

I know about Language.Haskell.Exts.Parser in haskell-src-exts, which 
provides parseExp :: String -> ParseResult Exp, but that Exp is a 
different type to the one provided by Template 
Haskell.<http://hackage.haskell.org/packages/archive/haskell-src-exts/1.9.0/doc/html/Language-Haskell-Exts-Syntax.html#t:Exp> 
I'm also aware of Dominic Orchard's syntax-trees package, which supports 
converting between the two representations using a cunning hack that 
pretty-prints the haskell-src-exts representation to a string and uses 
Template Haskell to parse it back.

Is there a saner way of simulating antiquotation in user-defined 
quasiquoters?

Sam

Problem with packet documentation generated by cabalon windows 7

Nicu Ionita — 2012-05-24T23:19:11

Hi cafe,

I have a problem with haddock documentation created when installing new 
packages with cabal on windows.
The generated html files have all links in the form 
j:\Users\...\doc\...\xxx.html, but firefox says, it cannot open that link.
Actually all links should be prefixed by "file:///".

I wonder if this is only on windows so and if there is a solution to 
this. Is there a cabal or haddock flag for this?

Nicu
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

webcam library on github

2012-05-24T22:20:40

Hello Cafe,

since I haven't found anything like that, I wrote a small library [1] to
read from a webcam in Haskell, using V4L on Linux. It uses the v4l2
package and repa for images.
Is anyone interested in contributing to that, or giving some hints on
how it could be made faster (I am not sure if I use repa correctly for
best performance at all times), or just in emitting any other
constructive comments? If yes, please give me a shout.


Cheers,
Christian
PS I would put the whole thing on hackage, but my cabal currently
doesn't want to do an sdist.


[1] https://github.com/cgo/hsimage

"Generic figures and their glueings" book .....please help

Vasili I. Galchin — 2012-05-24T19:03:20

Hello,

      I think the above book by Reyes, Reyes and Zolfaghari is quite
intriguing. At the same time I can't get my mind around the notions of
"generic figures" and "change of figures"! The first seems to be
objects in the base category and the latter morphisms in the base
category. Whoever has read this book and understands it please give me
some pointers. Sorry the vague call for help.

Kind regards,

Vasili

What is the difference between runhaskell andcompile?

Magicloud Magiclouds — 2012-05-24T09:36:26

Hi,
  I am writing a small program using LDAP hackage. A weird problem occured.
  When the code was run by runhaskell, things were fine, worked as expected.
  But when ghc compiled (no any args), and ran, I got this: LDAP
error: ldapSimpleBind: LDAPException LdapServerDown(-1): Can't contact
LDAP server.
  There is sure no problem with the server.
  So I am confused. I thought the two supposed to be the same.

question about linking with sqlite3

Canhua — 2012-05-24T02:04:11

Hi, I made a cabal package that use HDBC-sqlite3 on Windows.
When cabal install it, I got an error from ld.exe: cannot find -lsqlite3.
How can I tell ld.exe where sqlite3.dll is plcaed?

Thanks.

Haskell Meeting Munich

Heinrich Hördegen — 2012-05-23T14:28:27

Dear all,

our local hackathon in Munich on the 12th of May was a real success. 
Thanks to all those who joined! Look at the
site for a picture:

http://www.haskell-munich.de/dates

Our next regular meeting is on Monday, the 28th of May at Cafe Puck at 
19h30. This is a holiday in Germany.
We hope that many of you will come! If you plan to do so, please click 
the button on the above mentioned site.

Until then, I wish all of you a nice time,
Heinrich

--

hoerdegen< at >funktional.info
www.funktional.info

Typed TemplateHaskell?

Ilya Portnov — 2012-05-23T11:45:01

Hello Haskell world.

One well-known missfeature of TemplateHaskell is it's «untypedness». I 
mean, that if you have say an expression (Exp or Q Exp), you do not know 
it's type (does it represent String or Int or whatever). And GHC does 
not know too. So, one could easily construct bad-typed expressions using 
TH, and GHC will complain only on generated code, not on TH code.

Such a missfeature was a reasoned decision, because adding some typing 
into TH will add much complexity to compiler and to language.

As far as can I see, using features of last GHC one could write typed 
TH library relatively easily, and saving backwards compatibility.

For example, now we have Q monad and Exp type in "template-haskell" 
package. Let's imagine some new package, say "typed-template-haskell", 
with new TQ monad and new polymorphic type Exp :: * -> *. Using last 
GHC's features, one will easily write something like "expr :: Exp 
String", which will mean that "expr" represents a string expression. And 
we will need a new function, say runTQ :: TQ a -> Q a (or some more 
complicated type), which will turn TypedTemplateHaskell's constructs 
into plain TH.

One question will be on quotations and antiquotations: they are 
implemented to work untyped TH constructs, how to implement 
compatibility with new typed TH? We could add some support of them to 
GHC... Or, maybe define a phantom type (say, Any), and some conversion 
functions, say untyped :: Language.Haskell.TH.Syntax.Exp -> 
Language.Haskell.TH.Typed.Syntax.Exp Any.

Main idea is: seems new GHC enables us to implement "typed TH" without 
modifying GHC itself, only by writing a library. Is it so?

Any further thoughts?

With best regards,
Ilya Portnov.

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

HPC question

David Turner — 2012-05-23T09:40:00

Dear Haskell Cafe,

I've been playing around with the -fhpc option to GHC and have come 
across some things being highlighted yellow in the HTML markup for which 
I can't work out the right way to 'cover' them.

A cut down program that shows what I'm talking about is at 
http://hpaste.org/68888

Looking at the output of hpc show, I see:

    47          0 Main                            15:6-15:9 ExpBox False
    48          2 Main                            15:6-15:9 ExpBox False
    49          0 Main                            15:6-15:9 ExpBox False
    50          0 Main                            15:6-15:9 ExpBox False
    51          1 Main                          22:13-22:14 TopLevelBox 
["=="]
    52          0 Main                          22:13-22:14 TopLevelBox 
["/="]
    53          1 Main                          22:17-22:20 TopLevelBox 
["showsPrec"]
    54          0 Main                          22:17-22:20 TopLevelBox 
["showList"]

I.e. each of those bits whose highlighting I don't understand is made of 
some overlapping boxes, one of which is used.

Now, if I fiddle in the .tix file by hand to fake a usage of (/=) by 
changing the 52nd entry from 0 to 1, the Eq instance isn't highlighted 
any more in the HTML output. More strangely, if I then remove the usage 
of (==) by changing the 51st entry from 1 to 0, the Eq instance still 
isn't highlighted. A similar effect happens with the Show instance. It 
seems to be highlighting based only on the last entry in the .tix file, 
where there are two or more identically-placed boxes. Is this right? I'd 
have expected that if I use (==) then the deriving (Eq) clause should be 
considered 'used'.

Secondly, I can't work out what the four boxes in position 15:6-15:9 are 
supposed to be. If I use -ddump-simpl I can see many calls to 'tick' but 
there's no mention of numbers 47, 49 or 50. Perhaps they've been 
simplified away? I'm afraid I don't know what else to try dumping to get 
at the instrumented code before the simplifier's had a go at it.

I'm using Haskell Platform 2011.2.0.1 (GHC 7.0.3) on Windows if that's 
relevant.

Thanks in advance,

David

_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

vector operations

Evan Laforge — 2012-05-23T04:33:36

So I wanted to find the first index in a vector whose running sum is
greater than a given number.

The straightforward way is to create the running sum and then search:

Vector.findIndex (>=target) (Vector.scanl' (+) 0 vector)

But vectors are strict so it could do extra work, and what if I don't
want to generate garbage?  I could do it with a fold, but it would
have to have the ability to abort early.  Of course I could write such
a fold myself using indexing:

import qualified Data.Vector.Generic as Vector

fold_abort :: (Vector.Vector v a) => (accum -> a -> Maybe accum) -> accum
    -> v a -> accum
fold_abort f accum vec = go 0 accum
    where go i accum = maybe accum (go (i+1)) $ f accum =<< vec Vector.!? i

find_before :: (Vector.Vector v a, Num a, Ord a) => a -> v a -> Int
find_before n = fst . fold_abort go (0, 0)
    where
    go (i, total) a
        | total + a >= n = Nothing
        | otherwise = Just (i+1, total+a)

So it's bigger and clunkier, but I would think it would be much more
efficient (provided using Data.Vector.Generic won't inhibit inlining
and unboxing).  But I'm a bit surprised there isn't already something
like fold_abort... or is there?

Haskell Day 2012 (in Japan)

Kazu Yamamoto — 2012-05-23T02:20:59

Hello Cafe,

This is just FYI.

We Hasekell community in Japan will have an event called Haskell Day
2012 on 27th May to cerebrate the publication of the Japanese version
of "Learn you". 180+ people have already registered:

# This page is written in Japanese.

http://partake.in/events/ab7f77b4-7541-47a4-867d-21a096ca883c

P.S.

The Japanese version of "Learn you" was on sale yesterday and already
sold out in many bookstores. :-)

--Kazu

(+1) vs let inc=(+1)

Greg Fitzgerald — 2012-05-22T19:27:54

In ghci 7.4.1:

Prelude> :t (+1)
(+1) :: Num a => a -> a

Prelude> let inc=(+1)
Prelude> :t inc
inc :: Integer -> Integer

Why the difference?

Thanks,
Greg
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Encoding issues with LDAP package

Vincent Ambo — 2012-05-22T14:30:47

Hej,

I'm using the LDAP package by John Goerzen to retrieve some information from an Active Directory database. Part of this information are the full names of my company's employees.

Many of these names contain characters which aren't part of the standard ASCII set, for example ä å ü ê and so on. When I retrieve those names from the directory (the LDAP package returns them as Strings) the encoding breaks and I get results like "R\195\188diger" instead of "Rüdiger".

The Active Directory server supports LDAP v2 and v3. I assume the OpenLDAP C API, which is the backend behind the LDAP package, automatically chooses v3 to connect if available (this is speculation, correct me if I'm wrong).

Since LDAP v3 only speaks UTF8 and ASCII I also assume that the server returns UTF8.

Is this a known problem in the LDAP package? Or is this related to the OpenLDAP C API? Or even something on the server side?

Any information would be helpful!

Best regards,
Vincent

Parallel cooperative multithreading?

Benjamin Ylvisaker — 2012-05-22T13:55:41

Has anyone ever worked on implementing something like this in Haskell?

http://www.cs.hmc.edu/~stone/papers/ocm-unpublished.pdf

The outline of the idea:

- Concurrent programming is really hard with the popular frameworks
today.
- For most purposes parallel programming is hard, in some part because
it requires concurrent programming.  Of course there are attempts to do
non-concurrent parallel programming, but I hope it's not too
controversial to say that such frameworks are still on the fringe.
- Cooperative concurrency is way easier than preemptive concurrency
because between invocations of pause/yield/wait, sequential reasoning
works.
- Historically, cooperative concurrency only worked on a single
processors, because running threads in parallel would break the
atomicity of sequential blocks (between invocations of p/y/w).
- Researchers have been poring tons of effort into efficiently running
blocks of code atomically.
- Hey, we can do parallel cooperative multithreading!

The paper discusses implementations in Lua, C++ and C, but I think
Haskell could be an awesome substrate for such a framework.  Has anyone
thought about this?

Ben

Data.Array.Unboxed in GHC 7.4

Tom Nielsen — 2012-05-22T09:41:57

Dear cafe,

I have just upgraded to GHC 7.4, and now I run into some compilation
problems. Specifically, I have a package that needs both Data.Array.Unboxed
and System.IO.Unsafe. But I cannot enable both base and haskell98 in a
cabal file. is there any way out of this?

If I enable both haskell98 and base, I get

Query.hs:1:1:
    Ambiguous module name `Prelude':
      it was found in multiple packages: base haskell98-2.0.0.1
cabal: Error: some packages failed to install:

as documented elsewhere (http://hackage.haskell.org/trac/ghc/ticket/4958)

With haskell98 replacing base, I get

Query.hs:55:8:
    Could not find module `System.IO.Unsafe'
    It is a member of the hidden package `base'.
    Perhaps you need to add `base' to the build-depends in your .cabal file.
    Use -v to see a list of the files searched for.
cabal: Error: some packages failed to install:

and without haskell98 or array, cabal tells me to add those to .cabal
build-depends.

So how can I use the Data.Array.Unboxed package together with all the stuff
from base that is not in haskell98?

Thanks,

Tom
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Zipper and Comonad

Mathijs Kwik — 2012-05-22T06:42:46

Hi all,

After using zippers for a while, I wanted to dig a bit deeper into them.
I found there is some relation between Zipper and Comonad, but this
confuses me somewhat.

After reading a bit more about Comonads [1] and [2], I think I
understand them somewhat, and I see how they too are useful for
navigating a data structures and giving functions the ability to "look
around".

What confuses me though, is the relation between these 2.
This source [3] mentions all zippers can be made instances of Comonad,
and demonstrates how to do this for simple, 1-dimensional (list)
zippers.
But a comment on [4] says a Zipper by itself is already an application
of Comonad.
I want to find out which is the case. Looking at the types does not
yield me a solution yet.

This is Zipper from LYAH:

data Tree a = Empty | Node a (Tree a) (Tree a)
data Crumb a = LeftCrumb a (Tree a) | RightCrumb a (Tree a)
type Breadcrumbs a = [Crumb a]
type Zipper a = (Tree a, Breadcrumbs a)

This is Comonad from the comonad package (flattened to 1 class):

class Functor w => Comonad w where
    duplicate :: w a -> w (w a)
    extend :: (w a -> b) -> w a -> w b
    extract :: w a -> a

Now, if [3] is correct, I can write "instance Comonad Zipper".
If I understood all this correctly, "extend" becomes "(Zipper a -> b)
-> Zipper a -> Zipper b".
This gives me something like a "look-around fmap" which sounds useful.

If the comment on [4] is correct though, Zipper somehow has a Comonad
"built-in", (probably hidden the interaction between Tree and
[Crumb]).
So in that case, a Zipper would be a (somewhat customized) "instance
Comonad Tree" with some extensions.
"(Tree a -> b) -> Tree a -> Tree b" seems reasonable. It will build up
a new tree with the same shape as the input tree, and allows the
mapping function to examine every node _and_ its child nodes. It does
not allow "looking up" though.

So what do I make of this?
It's clear that every Zipper can be a Comonad, and it's probably
useful in some cases, but on the other hand, a Zipper already gives
the ability to look around and modify (a -> a) things, so the
comonadic instance only allows you to do this in a somewhat
structure-preserving way.

It's still not clear to me whether there is some truth in "a Zipper
itself is an application of Comonad". What I looked at above is just a
Tree instance, which obviously lost power compared to a full Zipper.
But I somehow feel there indeed is a somewhat deeper relation between
these 2 compared to just "can be made instance of".

Please share your thoughts.

Thanks,
Mathijs

[1] http://blog.sigfpe.com/2006/12/evaluating-cellular-automata-is.html
[2] http://blog.sigfpe.com/2008/03/comonadic-arrays.html
[3] http://blog.sigfpe.com/2007/01/monads-hidden-behind-every-zipper.html
[4] http://gelisam.blogspot.com/2007/04/i-understand-comonads.html

Formalisation for types of monads

Yves Parès — 2012-05-21T13:25:40

When explaining monads to beginners (having an imperative background), I
found myself to say that there is *roughly* three "groups" of monads
(because they're always worried about their cost, i.e. their incidental
complexity):

- Function-oriented monads (e.g. State, Reader, Cont)
- Reductible data-oriented monads (e.g. Maybe, Identity, Writer)
- Irreductible data-oriented monads (e.g. List, free monads) (which, as I
understood, have a (>>=) operation that has a quadratic complexity if not
used properly)

Are there others "groups" I'm missing and is there terms to formalize them?
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe< at >haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe

Mighttpd 2.6.0 has been released

Kazu Yamamoto — 2012-05-21T02:49:34

Hello cafe,

I have released Mighttpd 2.6.0:

http://mew.org/~kazu/proj/mighttpd/en/

Some users started using Mighttpd 2 and I was requested to implement
missing features for real world operation. So, I implemented the
following features in Mighttpd 2.6.0:

- Route file reloading
- Graceful shutdown for upgrading
- URL rewriting (with HTTP redirection)

For more information, please read the homepage above.

I would like to thank Michael Snoyman for merging the necessary patch
to warp.

Regards,

--Kazu

Cardinal Haskell RBTree? And structural sharing.

Matt Lamari — 2012-05-20T20:34:03

I dug this haskell code of the internet wayback machine.  Don't worry,
Dons - it may be old; but it's still Golden. . .  it seems to be from
the Okasaki book with a working delete and key-value variant:

http://web.archive.org/web/20100629235553/http://www.cse.unsw.edu.au/~dons/data/RedBlackTree.html

I'm still at the lower end of Haskell expertise; but I can read this,
and am porting the concept into my Heresy library for CL.  The algorithm
seems to be proven via some haskell static means (that I don't fully
understand); but it also holds up to my heavy unit tests.

What I value from functional containers, though, is that the modded
structure shares the bulk of its identity/nodes with the prior variant. 
However, I added sharing as a metric to my unit test, so it can also
discover when a new (by identity) node exists in the modified/new
reference that is logically analogous to a node the old/prior one. . . .
.  which would waste space if people are holding various references to
evolving containers.

When purely translating this code, even in zero-change cases, one
function will build a red node from a black, only to have the caller use
*that* to build a brand new black - as across the 2 levels it has no way
of seeing that the optimal node is merely the original node.

Through some fundamental changes, and a bit of "whack a mole"
(especially in the delete case) I *think* I caught and removed them all.
. . .

Anyway, my point:  It seems that these containers can be analyzed with
respect to their pure algorithm/logical correctness; but also structural
storage.  Is there much talk on that side of the issue?  Is there any
cardinal reference for this or similar data structures with the storage
issue resolved?  I'd be interested in looking at another implementation,
especially one where the size issue isn't just tested; but proven. . . .

A functional programming solution for Mr and MrsHollingberry

Andreas Pauley — 2012-05-20T17:33:13

Hi all,

I'm in the process of learning how to approach problems from a
functional perspective, coming from an Object Oriented background
(mostly Smalltalk).

One of the general concerns/questions raised when talking to people in
a similar position is:
"How do I design/model a problem when I don't have my trusted classes
and objects available?"

With this in mind I've created a programming exercise where I imagine
an OO programmer would use an object hierarchy with subtype
polymorphism as part of the solution. And then I'd like to compare
functional implementations of the same problem:

https://github.com/apauley/HollingBerries

I want to see how elegant a solution I can get in a functional
language, given that the problem description is not really elegant at
all. It has a few annoying exceptions to the normal rules, typical of
what one might get in a real specification from some client.

Currently there are 3 implementations:
 - one in Erlang, my attempt at implementing a functional solution
 - one in Ruby, my attempt to see how an object hierarchy could be used
 - one in Clojure, done by one of the people in our FP user group [1]

I would love to include some Haskell implementations as well, if any
of you are interested.

Kind regards,
Andreas Pauley

1. http://www.meetup.com/lambda-luminaries/