Nabble - Haskell - Haskell-Cafe

Sending patches to ghc related repositories

2009-11-10T08:46:57Z

Hi, all,

I just tried to send a patch to a ghc tool. I see in hackage that
the maintainer e-mail is 'cvs-fptools@...' (package is
hsc2hs). I tried sending darcs patch to this e-mail, but it's
refused as it's not on that server allowed e-mails table.

The patch isn't really important, just a documentation typo,
but I'm curious about what is the proper way to do it.

Thanks,
Maurício

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

Re: Help Haskell driving Medical Instruments

2009-11-10T08:27:17Z

Am Dienstag 10 November 2009 14:01:33 schrieb Philippos Apolinarius:
> Hi, Jason.
> I don't know how to mark the call unsafe. And I don't know what is a *Nix
> (perhaps unix?).

Unix or unix-derivate (linux, BSD, ...)

> I am running the main program on Windows.

Then it might be necesary to let the foreign calls have the calling convention stdcall
instead of ccall.

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

Re: is proof by testing possible?

2009-11-10T08:02:51Z

On 2009-11-10 08:24 +0000 (Tue), Conor McBride wrote:

> On 10 Nov 2009, at 05:52, Curt Sampson wrote:
>
> This is sometimes described as the "reflective" proof method: express
> problem in language capturing decidable fragment; hit with big stick.

Well, that's pretty sweet. *And* you get to use a big stick. Who can
argue with that?

> I'm sure there's more to be found here. It smells a bit of theorems
> for free: the strength comes from knowing what you don't.

Yup. But this seems to me to be heading towards keeping proofs with your
code (which we're already doing in sort of a simple way with our type
systems; how long can it be until we're embedding Coq or Agda proofs in
our production Haskell code?). That's heading well away from testing.
(And I approve.)

cjs
--
Curt Sampson <cjs@...> +81 90 7737 2974
Functional programming in all senses of the word:
http://www.starling-software.com
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: Help Haskell driving Medical Instruments

2009-11-10T05:01:33Z

Hi, Jason.
I don't know how to mark the call unsafe. And I don't know what is a *Nix (perhaps unix?). I am running the main program on Windows. Here is the compilation script:

ghc -fglasgow-exts serial.c %1.hs -L./ -ljapi --make
erase *.hi
erase *.o
strip %1.exe

BTW I figure out that passing an argument to closecport only makes the problem occur less often. Here is an example:

D:\ghc\sensors>strip temper.exe
D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\se nsors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
4

D:\ghc\sensors>temper.exe
unable to set comport cfg settings
4

--- On Mon, 11/9/09, Jason Dusek <jason.dusek@...> wrote:

From: Jason Dusek <jason.dusek@...>
Subject: Re: [Haskell-cafe] Help Haskell driving Medical Instruments
To: "Philippos Apolinarius" <phi500ac@...>
Cc: "Haskell Cafe" <haskell-cafe@...>
Received: Monday, November 9, 2009, 11:41 PM

Does marking the call `unsafe` make any difference?

This is running on a *NIX of some flavour?

--
Jason Dusek

Be smarter than spam. See how smart SpamGuard is at giving junk email the boot with the All-new Yahoo! Mail
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Type-indexed expressions with fixpoint

2009-11-10T04:12:27Z

Brent Yorgey wrote:
> This email is literate Haskell. I'm struggling to come up with the
> right way to add a fixpoint constructor to an expression language
> described by a type-indexed GADT (details below).
>
> but since Haskell doesn't have type-level lambdas, I don't see how
> to make that work.

John Reynolds showed long ago that any higher-order language can be
encoded in first-order. We witness this every day: higher-order
language like Haskell is encoded in first-order language (machine
code). The trick is just to add a layer of interpretive overhead -- I
mean, a layer of interpretation. The closure conversion on type level
was shown in
http://okmij.org/ftp/Computation/lambda-calc.html#haskell-type-level

Here's how a similar technique applies to the problem at hand. There is
an alternative solution: encode higher-order functors by means of SKI
combinators. Somehow I prefer the pointed solution.

The complete code follows.

{-# LANGUAGE TypeFamilies, KindSignatures, GADTs, FlexibleInstances #-}

data U :: (* -> *) -> * where
Unit :: U None
Var :: U Id
(:+:) :: U f -> U g -> U (Sum f g)
(:*:) :: U f -> U g -> U (Prod f g)
Mu :: HOFunctor f => f -> U (MU f)

data None a = None deriving Show
data Id a = Id a deriving Show
data Sum f g a = Inl (f a) | Inr (g a) deriving Show
data Prod f g a = Prod (f a) (g a) deriving Show

newtype MU f a = MU (Res f (MU f) a)

type family Res f self :: * -> *
type instance Res List self = Sum None (Prod Id self)

data List = List -- the code for the HO functor

class HOFunctor f where
fn :: f -> U g -> U (Res f g)

instance HOFunctor List where
fn _ self = Unit :+: (Var :*: self)

enumShapes :: Int -> U f -> [f ()]
enumShapes 0 Unit = [None]
enumShapes _ Unit = []
enumShapes 1 Var = [Id ()]
enumShapes _ Var = []
enumShapes n (f :+: g) = map Inl (enumShapes n f) ++ map Inr (enumShapes n g)
enumShapes n (f :*: g) = [ Prod x y | x <- enumShapes n f, y <- enumShapes n g]

enumShapes n self@(Mu f) = map MU $ enumShapes (n-1) (fn f self)

test0 = enumShapes 0 (Unit :+: (Var :*: Var))
-- [Inl None]
test1 = enumShapes 1 (Unit :+: (Var :*: Var))
-- [Inr (Prod (Id ()) (Id ()))]

test2 = enumShapes 1 (Mu List)
-- [Inl None]
test3 = enumShapes 2 (Mu List)
-- [Inr (Prod (Id ()) Inl None)]

instance Show (MU List ()) where
show (MU x) = show x

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

Re: filter using foldr point-free?

2009-11-10T03:56:56Z

On Tue, Nov 10, 2009 at 12:47 PM, damodar kulkarni
<kdamodar2000@...> wrote:
> Hi,
> We can define filter using foldr as under:
>
> filter1 p = foldr (\x xs -> (if (p x) then (x:xs) else xs)) []
>
> Can we define filter using foldr but in pointfree style?
>
Pointfree code is (nearly) always possible, but sometimes not very
desirable. The first thing to do is to ask lambdabot for help; in this
case, the answer is.. this:

filter1 = flip foldr [] . flip flip id . (ap .) . (`ap` (:)) . (((.) . if') .)

if' p a b = if p then a else b

Now, there may be a better way to go about this, but I don't think I'd
bother trying. The pointful variant seems quite readable as-is. :P

--
Svein Ove Aas
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

filter using foldr point-free?

2009-11-10T03:47:54Z

Hi,
We can define filter using foldr as under:

filter1 p = foldr (\x xs -> (if (p x) then (x:xs) else xs)) []

Can we define filter using foldr but in pointfree style?

Thanks
-DM

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

Re: pattern match failure as control structure

2009-11-10T02:50:45Z

Have a look at this recently uploaded package:

http://hackage.haskell.org/package/first-class-patterns

Examine the "tryMatch" function in particular.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: is proof by testing possible?

2009-11-10T02:46:08Z

Conor McBride wrote:
> ....and you can calculate how much testing is enough by
> computing an upper bound on the polynomial degree of the
> expression. (The summation operator increments degree,
> the difference operator decreases it, like in calculus.)
>
> This is sometimes described
> as the "reflective" proof method: express problem in
> language capturing decidable fragment; hit with big stick.

The fact that summation maps polynomials to polynomials needs to be
proven, of course, and I guess that this proof is not much simpler than
proving

sum . map (^3) $ [1..n] = (sum $ [1..n])^2

in the first place. But once proven, the former can be reused ad libitum.

Regards,
apfelmus

--
http://apfelmus.nfshost.com

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

pattern match failure as control structure

2009-11-10T02:16:44Z

hey all, is there something special about pattern match exceptions?

i'm attempting to catch pattern match failures to use as control for a
production system.

so i want to be able to do something like

catch (head []) (\e -> print "that theres pattern fail!" )

any suggestions?
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: is proof by testing possible?

2009-11-10T00:24:51Z

On 10 Nov 2009, at 05:52, Curt Sampson wrote:

> On 2009-11-09 14:22 -0800 (Mon), muad wrote:
>
>>> Proof: True for n = 0, 1, 2, 3, 4 (check!), hence true for all n.
>>> QED.
>>> ...
>
> Actually, the test is that it's true for 0 through 4 is not sufficient
> for a proof;

It's enough testing...

> you also need to prove in some way that you need do no
> further tests.

...and you can calculate how much testing is enough by
computing an upper bound on the polynomial degree of the
expression. (The summation operator increments degree,
the difference operator decreases it, like in calculus.)

> Showing that particular point in this case appears to me
> to lie outside the realm of testing.

You need to appeal to a general theorem about expressions
of a particular form, but if that theorem is in the
library, the only work you need do is to put the
expressions in that form. This is sometimes described
as the "reflective" proof method: express problem in
language capturing decidable fragment; hit with big stick.

There are lots of other examples of this phenomenon. The
zero-one principle for sorting networks is a favourite of
mine. I'm sure there's more to be found here. It smells
a bit of theorems for free: the strength comes from
knowing what you don't.

All the best

Conor

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

Re: Help Haskell driving Medical Instruments

2009-11-09T22:41:16Z

Does marking the call `unsafe` make any difference?

This is running on a *NIX of some flavour?

--
Jason Dusek
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: is proof by testing possible?

2009-11-09T21:52:21Z

On 2009-11-09 14:22 -0800 (Mon), muad wrote:

> > Proof: True for n = 0, 1, 2, 3, 4 (check!), hence true for all n. QED.
> > ...

Actually, the test is that it's true for 0 through 4 is not sufficient
for a proof; you also need to prove in some way that you need do no
further tests. Showing that particular point in this case appears to me
to lie outside the realm of testing.

cjs
--
Curt Sampson <cjs@...> +81 90 7737 2974
Functional programming in all senses of the word:
http://www.starling-software.com
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Help Haskell driving Medical Instruments

2009-11-09T21:04:05Z

Recently, I received as gift medical instruments designed by one of my father former students. There is a description of these instruments on my web page. Here is the address:

http://www.discenda.org/med/

By the way, I am not that guy that appears in a picture wearing emg sensors. That said, the instruments and everything else are programmed in Clean. Then I have a new opportunity of translating Clean programs to Haskell and test them in a real application application. Of course, I simplified the programs to see how they work.

The medical instruments have on-board computers, that record signals (electromyograms, electroencephalograms, electrocardiograms, end-tydal CO2 partial pressure and temperature), pre-process them and send them to the main computer. The main-computer recognizes patterns in the signals, and use the result to drive a wheelchair, or to call a doctor. On my page you wil find more complete explanations and pictures of the instruments. For ready reference, here is my address:

http://www.discenda.org/med/

I decided start my translation work from the most simple programs, the graphical interface and the communication protocol. After substituting a Haskell program for the Clean original, I discovered that the system did not work anymore if I exited the Haskell program. In few words, after leaving the Haskell program without turning off the computer or the sensors, and entering the Haskell program again, Haskell failed to communicate with the sensors. I did what I always do in such a situation: I simplified the program until I reduced it to a few lines. I discovered that Haskell failed to close the serial port. There is a serial to UART-0 driver that allows me to plug the serial cable to a USB port, that both feeds the sensors, and permit communication.

I fixed the bug by passing a useless integer argument to the function used to close the port. Since I don't like this kind of patch (useless arguments), I would like to know why the original program does not work, and also I would appreciate if someone could suggest a way to get rid of the argument whose sole job is force Haskell to close the port. The GUI is based on the Small JAPI biding, fixed and incremented with text processing components. Here is the fixed Haskell program:

import Gui.Binding
import Gui.Types
import Gui.Constants
import SER.IAL
import Control.Monad
import Data.Char

main = do rv <- j_start
          frame <- j_frame "Sensors"
    exit_button <- j_button frame "Exit"
    j_setpos exit_button 50 50
    j_setsize exit_button 80 30
    fld <- j_textfield frame 30
    j_setpos fld 50 100
          j_show frame
          opencport(4)
          waitForFrameAction frame fld exit_button
          let r = closecport 7 {- without the argument, closecport does not work -}
          print r
          return j_quit


waitForFrameAction :: Frame -> Object -> Object -> IO Bool
waitForFrameAction frame f b =
    do obj <- j_nextaction
       again <- if obj == event b
                     then return False
             else
               do {- nm <- j_gettext f 200 -}
                  tx <- sendMessage 1 "t"
                  let tp= filter (> ' ') tx
                  rx <- sendMessage 1 "x"
                  let rd= filter (> ' ') rx
                  let x = hex2dec rd
                  let tt= (fromIntegral x)*209.0/1024 - 67.5
                  j_settext f ((show tt)++" ==> "++tp)
                  return True
       if not again
    then return True
    else waitForFrameAction frame f b

hex2dec :: String -> Int
hex2dec h= sum (zipWith (*)
                    (map (16^) [3,2,1,0])
                    [digitToInt c | c <- h])

convert d r s0= (fromIntegral (hex2dec d))*r/1024.0- s0

As I told before, let r = closecport 7 did not work until I gave it an argument. Here is the interface between the C-side, and the Haskell-side of the program:

{-# LANGUAGE ForeignFunctionInterface #-}
module SER.IAL where

import Control.Monad
import Foreign

import Foreign.C.Types
import Foreign.C

foreign import ccall "rs232.h opencport" opencport :: CInt -> IO ()
foreign import ccall "rs232.h closecport" closecport :: CInt -> CInt

foreign import ccall "rs232.h rdrs232" c_sendmsg :: CInt -> CString -> CString
sendMessage :: Int -> String -> IO String
sendMessage n msg =
   withCString msg $
      \str -> peekCString (c_sendmsg (fromIntegral n) str)


Originally, I had the following line (that did not work properly):

foreign import ccall "rs232.h closecport" closecport :: IO ()

You will find below the C-program. The original program (that did not work) had the following definition for closecport:

int closecport() {
   CloseComport();
   return 3; }

This deffinition (that did not work) was replaced by the following one:

int closecport(int n) {
   CloseComport();
   return n; }

Here is the complete C program:

#include "serial.h"
#include <string.h>
#include <stdio.h>

/*
Possible baudrates on a normal pc:

50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800,
2400, 4800, 9600, 19200, 38400, 57600, 115200
*/

#define BAUD "baud=9600 data=8 parity=N stop=1"

HANDLE Cport;

char comports[16][10]={"\\\\.\\COM1", "\\\\.\\COM2", "\\\\.\\COM3", "\\\\.\\COM4",
                       "\\\\.\\COM5", "\\\\.\\COM6", "\\\\.\\COM7", "\\\\.\\COM8",
                       "\\\\.\\COM9", "\\\\.\\COM10", "\\\\.\\COM11", "\\\\.\\COM12",
                       "\\\\.\\COM13", "\\\\.\\COM14", "\\\\.\\COM15", "\\\\.\\COM16"};

int OpenComport(int comport_number)
{
if(comport_number>15)
{
    printf("illegal comport number\n");
    return(1);
}

Cport = CreateFileA(comports[comport_number],
                      GENERIC_READ|GENERIC_WRITE,
                      0,                          /* no share */
                      NULL,                       /* no security */
                      OPEN_EXISTING,
                      0,                          /* no threads */
                      NULL);                      /* no templates */

if(Cport==INVALID_HANDLE_VALUE)
{
    printf("unable to open comport\n");
    return(1);
}

DCB port_settings;
memset(&port_settings, 0, sizeof(port_settings)); /* clear the new struct */
port_settings.DCBlength = sizeof(port_settings);

if(!BuildCommDCBA(BAUD, &port_settings))
{
    printf("unable to set comport dcb settings\n");
    CloseHandle(Cport);
    return(1);
}

if(!SetCommState(Cport, &port_settings))
{
    printf("unable to set comport cfg settings\n");
    CloseHandle(Cport);
    return(1);
}

COMMTIMEOUTS Cptimeouts;

Cptimeouts.ReadIntervalTimeout         = MAXDWORD;
Cptimeouts.ReadTotalTimeoutMultiplier = 10;
Cptimeouts.ReadTotalTimeoutConstant    = 10;
Cptimeouts.WriteTotalTimeoutMultiplier = 10;
Cptimeouts.WriteTotalTimeoutConstant   = 10;

if(!SetCommTimeouts(Cport, &Cptimeouts))
{
    printf("unable to set comport time-out settings\n");
    CloseHandle(Cport);
    return(1);
}

return(0);
}

int PollComport(unsigned char *buf, int size)
{
int n;

if(size>4096) size = 4096;

/* added the void pointer cast, otherwise gcc will complain about */
/* "warning: dereferencing type-punned pointer will break strict aliasing rules" */

ReadFile(Cport, buf, size, (LPDWORD)((void *)&n), NULL);

return(n);
}

int RdByte(unsigned char* m)
{
int n;

ReadFile(Cport, m, 1, (LPDWORD)((void *)&n), NULL);

return(n);
}

int SendByte(unsigned char byte)
{
int n;

WriteFile(Cport, &byte, 1, (LPDWORD)((void *)&n), NULL);

if(n<0) return(1);

return(0);
}

int SendBuf(unsigned char *buf, int size)
{
int n;

if(WriteFile(Cport, buf, size, (LPDWORD)((void *)&n), NULL))
{
    return(n);
}

return(-1);
}

int CloseComport(void)
{
CloseHandle(Cport);
return(0);
}

int IsCTSEnabled(void)
{
int status;

GetCommModemStatus(Cport, (LPDWORD)((void *)&status));

if(status&MS_CTS_ON) return(1);
else return(0);
}

int cprintf(const char *text) /* sends a string to serial port */
{
while(*text != 0)   SendByte(*(text++));
return(0);
}

int opencport(int p) {
   OpenComport(p-1);
   return 3;

}

int closecport(int n) {
   CloseComport();
   return n;

}

char* rdrs232(int n, char* msg) {

    char *str;

    char mm;
    int i, j;

    for (j=0; j<n; j++) {
       SendByte(msg[j]); }
    str = (char *) malloc(16000);

    i=0;
    mm=0;
    while (mm != 10) {
        RdByte(&mm);
        str[i]= mm;

        i= i+1;

}
    if (i>0 && str[0]==0) { str[0]= ' ';}

    return(str);
}

Finally, here is the serial.h file:

#ifndef rs232_INCLUDED
#define rs232_INCLUDED

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <string.h>

#ifdef __linux__

#include <termios.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <limits.h>

#else

#include <windows.h>

#endif

int OpenComport(int);
int PollComport(unsigned char *, int);
int SendByte(unsigned char);
int SendBuf(unsigned char *, int);
int CloseComport(void);
int cprintf(const char *);
int IsCTSEnabled(void);
char *topa(int n);
int opencport(int p);
int closecport(int n);
char* rdrs232(int n, char* msg);

#ifdef __cplusplus
} /* extern "C" */
#endif

#endif

Re: ANN: acme-dont

2009-11-09T20:48:41Z

On Nov 9, 2009, at 11:27 PM, Gracjan Polak wrote:
> With special apologies to Luke Palmer that it took the Haskell
> community 7.5 years to catch up with Perl.

We may not have had the simple name "don't",
but we've been able to write "const $ return ()" for a long time.

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

Exciting job opportunity

2009-11-09T15:28:17Z

Principal investment firm based in Manhattan is looking for an outstanding software developer to maintain and develop proprietary accounting and portfolio management systems.

You should have at least a bachelor’s degree in computer science from a top university and impeccable coding style. This is a high-impact, high-visibility job opportunity where successful candidates will be entrusted with a lot of responsibility for products that have a direct effect on the P&L of the firm and influences our workflow.

This is a very small hedge fund with me being the only developer right now. The next hire will have a very direct say into how this side of our business progresses from here. We are a growth oriented firm that values people who take a craftsman’s pride in their work. We always like to take a contrarian view of things and value experimenting and using often overlooked technologies. That is one of the main reasons why we currently started using Haskell in developing our quantitative models. We are looking for a canditate who shows strong analytical, organizational, and communication skills. Attention to detail is essential, i.e. we fully document everything we do and pay a lot of attention to coding style.

The majority of our existing code was written in Java, so candidates must have at least some experience with Java and related technologies. Experience working with SQL would be desired as well. Background in accounting is not necessary but is definitely a
plus.

Please send your CV and cover letter to recruitment at karamaan.com, or reply to this post if you have any questions.

Thanks

Type-indexed expressions with fixpoint

2009-11-09T15:09:21Z

Hi all,

This email is literate Haskell. I'm struggling to come up with the
right way to add a fixpoint constructor to an expression language
described by a type-indexed GADT (details below). Any suggestions,
comments, or pointers welcome.

> {-# LANGUAGE KindSignatures, GADTs #-}

Consider the following type-indexed GADT, which encodes descriptions
of polymorphic regular types:

> data U :: (* -> *) -> * where
> Unit :: U None
> Var :: U Id
> (:+:) :: U f -> U g -> U (Sum f g)
> (:*:) :: U f -> U g -> U (Prod f g)
>
> data None a = None
> data Id a = Id a
> data Sum f g a = Inl (f a) | Inr (g a)
> data Prod f g a = Prod (f a) (g a)

Given u :: U f, thanks to the type indexing, we can write the
following function to enumerate all the shapes of a given size
described by u:

> enumShapes :: Int -> U f -> [f ()]
> enumShapes 0 Unit = [None]
> enumShapes _ Unit = []
> enumShapes 1 Var = [Id ()]
> enumShapes _ Var = []
> enumShapes n (f :+: g) = map Inl (enumShapes n f) ++ map Inr (enumShapes n g)
> enumShapes n (f :*: g) = [ Prod x y | x <- enumShapes n f, y <- enumShapes n g ]

But of course this isn't very interesting without adding a least
fixpoint constructor. That is, I'd like to have something like

data U :: (* -> *) -> * where
Unit :: U None
Var :: U Id
(:+:) :: U f -> U g -> U (Sum f g)
(:*:) :: U f -> U g -> U (Prod f g)
Mu :: ???

enumShapes n (Mu ...) = ...

But I am quite at a loss as far as expressing the type of Mu. If the
GADT wasn't type-indexed, I'd just use HOAS, i.e. Mu :: (U -> U) ->
U; but since Haskell doesn't have type-level lambdas, I don't see how
to make that work.

Suggestions greatly appreciated! Pointing out that I am looking at
this in the wrong way (if you think such is the case) would be highly
appreciated as well.

thanks,
-Brent
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: Observer pattern in Haskell?

2009-11-09T15:08:45Z

I haven't looked at the code extensively, I just wanted to comment on
this point:

> There is no way to remove an observer, which is something I'd expect to have
> available. I realise this would require assigning a key to each observer
> (and thus perhaps storing them in an associative map) or some way to filter
> them, but I think if you can only ever add observers, it will get awkward.

It might be convenient to have the `addObserver` function return a
"detachment function" as its result.

At Microsoft, Erik Meijer is working on an "Rx framework" [1], which
is an implementation of the GoF Observer pattern. The implementation
is, as Erik describes it, the mathematical dual of the Enumerable
pattern.

In the Rx framework, the `addObserver` method returns an `IDisposable`
object with a single method `dispose()`, this will detach the observer
from its subject. This is more convenient than trying to remember the
unique object identity of the observer (as that disallows anonymous
lambdas).

I don't know how this would work in a Haskell context, but it might be
interesting to think about.

- Tom Lokhorst

[1]: http://channel9.msdn.com/shows/Going+Deep/Expert-to-Expert-Brian-Beckman-and-Erik-Meijer-Inside-the-NET-Reactive-Framework-Rx/

On Mon, Nov 9, 2009 at 3:50 PM, Neil Brown <nccb2@...> wrote:

> Andy Gimblett wrote:
>>
>> Hi all,
>>
>> I've been doing some GUI programming recently, using wx. To help manage
>> dependencies between state and UI elements, I looked for a Haskell version
>> of the Observer design pattern, and I found an implementation written by
>> Bastiaan Heeren of ou.nl [1].
>>
>> Now, before I make a hackage release:
>>
>> 1. Does anyone have any comments, on either version?
>
> There is no way to remove an observer, which is something I'd expect to have
> available. I realise this would require assigning a key to each observer
> (and thus perhaps storing them in an associative map) or some way to filter
> them, but I think if you can only ever add observers, it will get awkward.
>
>> 2. In particular, is the MVar version sensible? I'm aiming for mutual
>> exclusion between threads. I _think_ I've got it, but I'm perhaps not
>> familiar enough with the semantics of MVar to be certain. Advice
>> appreciated. If it _is_ sensible, then is there any reason not to just use
>> this, and discard the IORef version?
>
> It looks fine (and thread-safe) to me, but I'd agree that you may as well
> just use the MVar version and leave out the IORef version.
>
>> The current implementation is synchronous, in that any observer functions
>> are called immediately and synchronously (and in the same thread as the
>> change of subject value). I'm pondering extending the package with an
>> asynchronous version where the update just trips a flag, and the observer
>> function picks this up later - possibly in another thread. The idea there
>> is to help in cases where certain operations have to be in a particular
>> thread. But this will mean a change to the typeclass too, I guess - or the
>> addition of another one for observers themselves. Again, any thoughts?
>
> I was a bit surprised at first that the observers were called synchronously.
> Asynchronous is what I'd expect, and it's also harder to code the
> asynchronous handlers wrongly. One blocking call (such as putMVar) in a
> synchronous handler can screw up your whole program by delaying the
> subsequent observers (and at that stage, the order in which the observers
> were added begins to matter). But my idea of how asynchronous would be
> implemented seems different to yours, judging by your description. Why not
> just augment this function in the synchronous version:
>
> notifyObservers :: Subject sub val => sub -> IO ()
> notifyObservers subject =
> do value <- getValue subject
> observers <- getObservers subject
> mapM_ ($ value) observers to become:
>
> notifyObserversAsync :: Subject sub val => sub -> IO ()
> notifyObserversAsync subject =
> do value <- getValue subject
> observers <- getObservers subject
> mapM_ (forkIO . ($ value)) observers
>
> This is what I was expecting to happen -- all the observer actions are
> spawned off into their own thread to run whatever code they want (either
> communicating back to an existing thread, or performing some long in-depth
> action).
>
> Thanks,
>
> Neil.
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@...
> http://www.haskell.org/mailman/listinfo/haskell-cafe
>

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

Re: Cabal

2009-11-09T14:23:35Z

On Mon, 2009-11-09 at 17:40 +0000, Stephen Tetley wrote:

> 2009/11/9 Duncan Coutts <duncan.coutts@...>:
>
> >
> > That should work, and probably the recommendation should be for cygwin
> > users to edit their cabal config to at add C:\cygwin\lib and C:\cygwin
> > \usr\include as standard.
>
>
> Hi Duncan
>
> That would definitely be the best idea, but where does the cabal
> config live?

If you were running the current version then "cabal --help" would say.

To upgrade run:

cabal install cabal-install

Otherwise, it's somewhere like
C:\Documents and Settings\$user\Application Data\cabal\config

though on some systems (vista perhaps?) I think it's under the user's
roaming profile directory.

Duncan

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

Re: is proof by testing possible?

2009-11-09T14:22:00Z

I have come across an example:

> However, the following proof of the lovely identity:
> sum . map (^3) $ [1..n] = (sum $ [1..n])^2 is perfectly rigorous.
>
> Proof: True for n = 0, 1, 2, 3, 4 (check!), hence true for all n. QED.
>
> In order to turn this into a full-ﬂedged proof, all you have to do is mumble the following incantation:
> Both sides are polynomials of degree ≤ 4, hence it is enough to check the identity at ﬁve distinct
> values.
>

from http://www.math.rutgers.edu/~zeilberg/mamarim/mamarimPDF/enquiry.pdf

Now this sort of idea surely applies to more than just number theory?

Re: classes question

2009-11-09T14:13:30Z

It's not your class definition that is the problem -- your class
definition is good.

The problem is that when you interact with it using the REPL, you
don't specify any particular type you want so it's ambiguous. Usually
this is not a problem in actual programs that you compile because
there's enough context for the type inferencer to figure out what type
'a' should be.

You can give it enough context in the REPL either by annotating the
value or by using some other typed thing, e.g.

let a = 1:: Int

If you really want it to only work on Int, then you shouldn't use a
typeclass, instead just write the function directly --

plus :: Int -> Int -> Int
plus = (+)

-Ross

On Nov 9, 2009, at 5:09 PM, Paul Tokarev wrote:

>
> Thanks, that works. But how sould I change my class definition, so
> that it
> works without (2::Int), but just with 2?
>
>
> Ross Mellgren wrote:
>>
>> You did not specify what type of number it is -- in Haskell numeric
>> constants like "1" are actually typed as forall a. Num a -- that is,
>> can be any type of Num.
>>
>> Try: plus (2::Int) 3
>>
>> -Ross
>>
>> On Nov 9, 2009, at 1:44 PM, Paul Tokarev wrote:
>>
>>>
>>> Hi.
>>>
>>> I am using Hugs 98
>>> I have that piece of code:
>>>
>>> class PlusTimes a where
>>> plus :: a -> a -> a
>>>
>>> instance PlusTimes Int where
>>> plus x y = x + y
>>>
>>> when I run : "plus 2 3" I get this error:
>>> ERROR - Unresolved overloading
>>> *** Type : (Num a, PlusTimes a) => a
>>> *** Expression : plus 2 3
>>>
>>> What am I doing wrong?
>>> Thanks.
>>>
>>> --
>>> View this message in context:
>>> http://old.nabble.com/classes-question-tp26271257p26271257.html
>>> Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com
>>> .
>>>
>>> _______________________________________________
>>> Haskell-Cafe mailing list
>>> Haskell-Cafe@...
>>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>> _______________________________________________
>> Haskell-Cafe mailing list
>> Haskell-Cafe@...
>> http://www.haskell.org/mailman/listinfo/haskell-cafe
>>
>>
>
> --
> View this message in context: http://old.nabble.com/classes-question-tp26271257p26274624.html
> Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com
> .
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@...
> http://www.haskell.org/mailman/listinfo/haskell-cafe

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

Re: classes question

2009-11-09T14:09:48Z

Thanks, that works. But how sould I change my class definition, so that it works without (2::Int), but just with 2?

Ross Mellgren wrote:

You did not specify what type of number it is -- in Haskell numeric
constants like "1" are actually typed as forall a. Num a -- that is,
can be any type of Num.

Try: plus (2::Int) 3

-Ross

On Nov 9, 2009, at 1:44 PM, Paul Tokarev wrote:

>
> Hi.
>
> I am using Hugs 98
> I have that piece of code:
>
> class PlusTimes a where
> plus :: a -> a -> a
>
> instance PlusTimes Int where
> plus x y = x + y
>
> when I run : "plus 2 3" I get this error:
> ERROR - Unresolved overloading
> *** Type : (Num a, PlusTimes a) => a
> *** Expression : plus 2 3
>
> What am I doing wrong?
> Thanks.
>
> --
> View this message in context: http://old.nabble.com/classes-question-tp26271257p26271257.html
> Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com
> .
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@haskell.org
> http://www.haskell.org/mailman/listinfo/haskell-cafe

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

strict mapM implementation correctness

2009-11-09T14:07:28Z

Hi all,

while coding recently I came across the need for
a strict mapM (that I indicidently use for m = MaybeT IO).

I implementented this with the following simple code
(it works for my use case):

mapM' :: Monad m => (a-> m b) -> [a] -> m [b]
mapM' _ [] = return []
mapM' f (x:xs) = do y <- f x
ys <- y `seq` mapM' f xs
return (y:ys)

Now a couple of questions:

1. is it so "rare" to need such a beast? Why there isn't anything
like that in standard libraries?
2. Is my implementation correct?
3. I've seen that mapM is implemented in base via sequence
(which is in turn based on foldr). Is that any specific
reason to prefer base implementation to mine?

Thanks!
Pao

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

Re: Cabal

2009-11-09T13:04:40Z

On Sun, 2009-11-08 at 19:29 -0800, Philippos Apolinarius wrote:

> D:\ghc\ghcapi>cabal install mkcabal

Note that as of cabal-install-0.8, the "mkcabal" functionality is
integrated as "cabal init" (thanks to Brent Yorgey). This does not
depend on less portable packages like pcre and readline (meaning it will
work on Windows).

> Resolving dependencies...
> Downloading pcre-light-0.3.1...
> Configuring pcre-light-0.3.1...

There's no reason pcre-light needs a configure script. It should be
removed. (It's also not used consistently, the Setup.hs is for a
different build-type than the one specified in the .cabal file).

> Downloading readline-1.0.1.0...
> Configuring readline-1.0.1.0...
> cabal: Error: some packages failed to install:
> mkcabal-0.4.2 depends on readline-1.0.1.0 which failed to install.
> pcre-light-0.3.1 failed during the configure step. The exception was:
> exit: ExitFailure 1
> readline-1.0.1.0 failed during the configure step. The exception was:
> exit: ExitFailure 1

As of Cabal-1.8 the error is reported as:

cabal: The package has a './configure' script. This requires a
Unix compatibility toolchain such as MinGW+MSYS or Cygwin.

Duncan

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

Re: classes question

2009-11-09T10:49:17Z

Oh, crap, I'm sorry, I completely misread your post...

Disregard my previous message.

/Joe

On Nov 9, 2009, at 1:44 PM, Paul Tokarev wrote:

>
> Hi.
>
> I am using Hugs 98
> I have that piece of code:
>
> class PlusTimes a where
> plus :: a -> a -> a
>
> instance PlusTimes Int where
> plus x y = x + y
>
> when I run : "plus 2 3" I get this error:
> ERROR - Unresolved overloading
> *** Type : (Num a, PlusTimes a) => a
> *** Expression : plus 2 3
>
> What am I doing wrong?
> Thanks.
>
> --
> View this message in context: http://old.nabble.com/classes-question-tp26271257p26271257.html
> Sent from the Haskell - Haskell-Cafe mailing list archive at
> Nabble.com.
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@...
> http://www.haskell.org/mailman/listinfo/haskell-cafe

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

Re: classes question

2009-11-09T10:48:22Z

(+) is a name that is already taken by the Num typeclass, you're
trying to overload it with a different class. It's equivalent to doing:

foo :: Int
foo = 1

foo :: String
foo = "abc"

this would cause an (obvious) namespace collision. If you want to
redefine (+), you'll have to import a qualified prelude, by using the
NoImplicitPrelude
pragma and `import qualified Prelude`.

A better alternative is to use a different name, `+`, `++` are both
taken (for normal addition and list concatenation, resp.).

/Joe

On Nov 9, 2009, at 1:44 PM, Paul Tokarev wrote:

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

Re: classes question

2009-11-09T10:47:41Z

You did not specify what type of number it is -- in Haskell numeric
constants like "1" are actually typed as forall a. Num a -- that is,
can be any type of Num.

Try: plus (2::Int) 3

-Ross

On Nov 9, 2009, at 1:44 PM, Paul Tokarev wrote:

>
> Hi.
>
> I am using Hugs 98
> I have that piece of code:
>
> class PlusTimes a where
> plus :: a -> a -> a
>
> instance PlusTimes Int where
> plus x y = x + y
>
> when I run : "plus 2 3" I get this error:
> ERROR - Unresolved overloading
> *** Type : (Num a, PlusTimes a) => a
> *** Expression : plus 2 3
>
> What am I doing wrong?
> Thanks.
>
> --
> View this message in context: http://old.nabble.com/classes-question-tp26271257p26271257.html
> Sent from the Haskell - Haskell-Cafe mailing list archive at Nabble.com
> .
>
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@...
> http://www.haskell.org/mailman/listinfo/haskell-cafe

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

classes question

2009-11-09T10:25:00Z

Hi.

I am using Hugs 98
I have that piece of code:

class PlusTimes a where
plus :: a -> a -> a

instance PlusTimes Int where
plus x y = x + y

when I run : "plus 2 3" I get this error:
ERROR - Unresolved overloading
*** Type : (Num a, PlusTimes a) => a
*** Expression : plus 2 3

What am I doing wrong?
Thanks.

Re: Observer pattern in Haskell?

2009-11-09T10:15:52Z

On 9 Nov 2009, at 17:41, Neil Brown wrote:

> Just to clarify -- I meant access to another MVar. Basically, if I
> do this:
>
> do v <- newMVar
> addObserver sub (putMVar v)
>
> If when the observers are run, the MVar v (that I've allocated) is
> non-empty, my code will block until it is empty, which will also
> block all the subsequent observers from being run (and block the
> code that called setValue) until the MVar is cleared by another
> thread. So my one poorly-written observer could deadlock (or cause
> stutter in) the system, whereas in the forkIO version, this observer
> would be fine -- it would block in its own new thread.

Ah yes, of course - I understand. Of course, there's nothing really
to stop application authors doing such things in the main thread
too... ;-)

Thanks for the clarification,

-Andy

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

Re: O'Haskell

2009-11-09T10:11:21Z

That sounds vaguely ominous... "Sir, we've achieved reactive in
O'Haskell, we'll have ten minutes till the VB GUI detects his IP
address!"

...

But in all seriousness, it is my understanding that O'Haskell has
fallen into disuse. IIRC Timber is the spiritual successor, but I have
no idea how accurate that information is.

As for implementing reactive in such a language, I imagine it would be
pretty easy, as FRP is a _functional_ (hence the name) construct.
Objects ought only get in the way (assuming they introduce possibly
conflicting syntax)

/Joe

On Nov 9, 2009, at 7:17 AM, shengwang wrote:

> Hi,
>
> Somebody has idea, how to achieve reactive in O'Haskell?
>
>
> Shawn Wang
>
> 使用新一代 Windows Live Messenger 轻松交流和共享！立刻下载！
> _______________________________________________
> Haskell-Cafe mailing list
> Haskell-Cafe@...
> http://www.haskell.org/mailman/listinfo/haskell-cafe

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

Re: Observer pattern in Haskell?

2009-11-09T09:41:32Z

Andy Gimblett wrote:

>>> was a bit surprised at first that the observers were called
>>> synchronously. Asynchronous is what I'd expect, and it's also
>>> harder to code the asynchronous handlers wrongly. One blocking call
>>> (such as putMVar) in a synchronous handler can screw up your whole
>>> program by delaying the subsequent observers (and at that stage, the
>>> order in which the observers were added begins to matter).
>
> True, but the observers shouldn't be able to access the MVars
> directly, I think? They should only be able to use the exposed
> interface, which won't let that happen?
>

Just to clarify -- I meant access to another MVar. Basically, if I do this:

do v <- newMVar
addObserver sub (putMVar v)

If when the observers are run, the MVar v (that I've allocated) is
non-empty, my code will block until it is empty, which will also block
all the subsequent observers from being run (and block the code that
called setValue) until the MVar is cleared by another thread. So my one
poorly-written observer could deadlock (or cause stutter in) the system,
whereas in the forkIO version, this observer would be fine -- it would
block in its own new thread.

Thanks,

Neil.
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: ANNOUNCE: feldspar-language

2009-11-09T09:41:25Z

On Mon, Nov 9, 2009 at 10:09 AM, Emil Axelsson <emax@...> wrote:
> Nice!
>
> One of our project members has been looking at Atom, not for numerical
> computations, but for real-time scheduling (which Feldspar should deal with
> eventually).
>
> What kind of code (in terms of efficiency) does the above description
> compile to?

Here's and example:

module Main (main) where

import Language.Atom

main :: IO ()
main = do
compile "filter" defaults design
return ()

design :: Atom ()
design = atom "filter" $ do
input <- float' "input"
output <- float' "output"
x <- iirFilter "filter" 1 [(2,3), (4,5)] (value input)
output <== x

-- | IIR filter implemented using direct form 2.
iirFilter :: Name -> Float -> [(Float, Float)] -> E Float -> Atom (E Float)
iirFilter name b0 coeffs x = do
-- Create the filter taps.
vs <- mapM (\ i -> float (name ++ show i) 0) [1 .. length coeffs]
-- Cascade the filter taps together.
mapM_ (\ (vA, vB) -> vA <== value vB) $ zip (tail vs) vs
-- Calculate the input to the chain of taps.
let w0 = sum ( x : [ (value v) * Const (-a) | (v, (a, _)) <- zip vs coeffs ])
bs = b0 : (snd $ unzip coeffs)
ws = w0 : map value vs
us = [ w * Const b | (w, b) <- zip ws bs ]
head vs <== w0
-- Return the output.
return $ sum us

Here's the generated C. Note the filter calculation is done entirely
by function __r0:

static unsigned long long __global_clock = 0;
static const unsigned long __coverage_len = 1;
static unsigned long __coverage[1] = {0};
static unsigned long __coverage_index = 0;
static float __v1 = 0; /* filter.filter.filter2 */
static float __v0 = 0; /* filter.filter.filter1 */

/* filter.filter */
static void __r0(void) {
unsigned char __0 = 1;
float __1 = 0.0;
float __2 = input;
float __3 = __1 + __2;
float __4 = __v0 /* filter.filter.filter1 */ ;
float __5 = -2.0;
float __6 = __4 * __5;
float __7 = __3 + __6;
float __8 = __v1 /* filter.filter.filter2 */ ;
float __9 = -4.0;
float __10 = __8 * __9;
float __11 = __7 + __10;
float __12 = 1.0;
float __13 = __11 * __12;
float __14 = __1 + __13;
float __15 = 3.0;
float __16 = __4 * __15;
float __17 = __14 + __16;
float __18 = 5.0;
float __19 = __8 * __18;
float __20 = __17 + __19;
if (__0) {
__coverage[0] = __coverage[0] | (1 << 0);
}
output = __20;
__v0 /* filter.filter.filter1 */ = __11;
__v1 /* filter.filter.filter2 */ = __4;
}

void filter(void) {
{
static unsigned char __scheduling_clock = 0;
if (__scheduling_clock == 0) {
__r0(); /* filter.filter */
__scheduling_clock = 0;
}
else {
__scheduling_clock = __scheduling_clock - 1;
}
}

__global_clock = __global_clock + 1;
}
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: Cabal

2009-11-09T09:40:01Z

2009/11/9 Duncan Coutts <duncan.coutts@...>:

>
> That should work, and probably the recommendation should be for cygwin
> users to edit their cabal config to at add C:\cygwin\lib and C:\cygwin
> \usr\include as standard.

Hi Duncan

That would definitely be the best idea, but where does the cabal config live?

I have the cabal that ships with GHC-6.10.3 and can't find anything:

cabal-install version 0.6.0
using version 1.6.0.1 of the Cabal library

By the way, this one should be unnecessary, it was a legacy of me
hacking all sorts of things to get readline installed:

--extra-include-dirs=C:\cygwin\usr\include\readline

Best wishes

Stephen
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: Observer pattern in Haskell?

2009-11-09T09:00:12Z

On 9 Nov 2009, at 16:47, Eduard Sergeev wrote:

> Andy Gimblett-2 wrote:
>> Possibly. Care to expand? If you have a more elegant solution,
>> which
>> fits in well with ordinary wxHaskell, I'd be interested.
>
> I believe there are a few experimental frameworks built on top of
> wxHaskell
> which use Functional Reactive Programming, like
> http://www.haskell.org/haskellwiki/Phooey Phooey . They seem to be
> more
> ellegant, but probably less practical for now since they are still
> experimental. I just thought that FRP is more suitable for Haskell but
> probably in case of wxHaskell it is not a case. Sorry if it was off
> topic.

In that case, I am 100% in agreement with you. :-) I do look forward
to using such technology in the future...

Thanks!

-Andy
_______________________________________________
Haskell-Cafe mailing list
Haskell-Cafe@...
http://www.haskell.org/mailman/listinfo/haskell-cafe

Re: Cabal

2009-11-09T08:50:12Z

On Mon, 2009-11-09 at 13:08 +0000, Stephen Tetley wrote:

> At this point I'd edit the *.cabal files in each component – this is
> not 'the done thing', but both libraries need extra flags and as I
> have to compile them rarely I tend to forget the format (which appears
> to be Windows style full paths even though you are running Cygwin).

Does it not work to say:

cabal install readline \
--extra-lib-dirs=C:\cygwin\lib \
--extra-include-dirs=C:\cygwin\usr\include \
--extra-include-dirs=C:\cygwin\usr\include\readline

That should work, and probably the recommendation should be for cygwin
users to edit their cabal config to at add C:\cygwin\lib and C:\cygwin
\usr\include as standard.

Duncan

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