- Haskell - Haskell.org

Re: problems invoking haddock
by Marcus Lindblom 04 May '03

04 May '03

> From: "Andre W B Furtado" <andrefurtado(a)ieg.com.br> > > [heap of woes snipped] > > Argh! I wonder if haddock has a install shield wizard for Windows! :) Hmm. After some further investigation (noted that Python didn't work properly on my system either :), the file/usr/doc/Cygwin/python-2.2.2.README says: --- 3. Due to issues with Cygwin's fork() and DLL base address conflicts, one should rebase their Cygwin system to prevent fork() failures. Use the following procedure to rebase your system: a. install the Cygwin rebase package (if necessary) b. shutdown all Cygwin processes c. start bash (do not use rxvt) d. execute rebaseall (in the bash window) --- Doing b. was a bit tricky (any processes left running lock the DLL's for writing, so rebase complains with error = 6), but after that the only messages I got was: /usr/lib/apache/xxx.dll: skipped because nonexistent .. for a few dll's, but now åython doesn't give me anymore forking errors, so I believe this should work for you as well. /Marcus

1 0

Re: problems invoking haddock
by Andre W B Furtado 03 May '03

03 May '03

> This sounds just like what I got with cygwin and Python. You have to > rebase your dll's due to some upgrade/restructure they did, just search > for rebase and cygwin and I'm sure you'll find some text on how to fix > it. Problems, problems, problems... The info I found told me that I should: 1) Download a file called rebase.cc and build it with "g++ -O2 -o rebase rebase.cc -limagehlp" 2) Use the rebase program against some Cygwin DLLs Now here come the problems: a) Trying to build rebase.cc gives me an error: rebase.cc:45: `main' must return `int'. Making main to return 'int' builds the program, but when trying to rebase the DLLs other problem arises: ReBaseImage() failed with last error = 2 b) I found a pre-installed rebase command in cygwin and gave up building rebase.cc. Trying to run this rebase command gives me the error: REBASE: -R must preceed -o. Adding the -R option to the command line, another error arises: REBASE: Total Size of mapping 0x00200000 REBASE: Range 0x67e00000 -0x68000000 Argh! I wonder if haddock has a install shield wizard for Windows! :) Cheers, -- Andre

1 0

unsafe parsing
by Kenny Lu Zhuo Ming 03 May '03

03 May '03

Hi all, I am currently write a program to type a dynamic string consist of 'A' or 'B' for short, it works in this manner: for 'A', it returns A :: A for 'B', it returns B :: B for "A", it returns Cons A Nil :: Cons A Nil for "AB", it returns Cons A (Cons B Nil) :: Cons A (Cons B Nil) ... The problem is I have to specifically annotate the output type, which is unaffordable, because I might have arbitrary-long string, and I have infinitely many possible singleton types. It seems it is impossible to do it in a type-safe way. Anyone of you have any idea to walk around that? Regards, Kenny module Test where data Content = C1 Char | C2 String deriving Eq class MyType a where parse :: Content -> (Maybe a) data A = A deriving (Show,Eq) instance MyType A where parse (C1 'A') = Just A parse _ = Nothing data B = B deriving (Show,Eq) instance MyType B where parse (C1 'B') = Just B parse _ = Nothing data Cons x xs = Cons x xs deriving Show instance (MyType x,MyType xs) => MyType (Cons x xs) where parse (C2 (x:xs)) = let maybehd = parse (C1 x) in case maybehd of Just hd -> let maybetl = parse (C2 xs) in case maybetl of Just tl -> Just ((Cons hd) tl) Nothing -> Nothing Nothing -> Nothing parse _ = Nothing data Nil = Nil deriving (Show,Eq) instance MyType Nil where parse (C2 []) = Just Nil parse _ = Nothing %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Hugs session for: /usr/share/hugs/lib/Prelude.hs Test.hs Type :? for help Test> parse (C2 "A") :: Maybe (Cons A Nil) Just (Cons A Nil)

2 3

RE: problems invoking haddock
by Marcus Lindblom 02 May '03

02 May '03

From: "Andre W B Furtado" <andrefurtado(a)ieg.com.br> Is the following problem a specific cygwin problem and how can I overcome it? It happened to me while trying to invoke haddock: > /cygdrive/c/haskell/cygwin/usr/local/bin/haddock: > Cannot fork: Resource temporarily unavailable This sounds just like what I got with cygwin and Python. You have to rebase your dll's due to some upgrade/restructure they did, just search for rebase and cygwin and I'm sure you'll find some text on how to fix it. /Marcus

1 0

a nice Pair,, was: Multiparameter classes in HUGS and GHC
by Lloyd Allison 02 May '03

02 May '03

On Wed, Apr 30, 2003 at 07:20:06PM +0100, Graham Klyne wrote: > I've trying to understand better how to use multiparameter classes, and in > particular the things that can be declared as instances. I've consulted > the following: > ... > [[ > class (Eq k, Show k) => Pair a k v where > newPair :: (k,v) -> a k v > getPair :: a k v -> (k,v) > > newtype MyPair1 k v = P1 (Int,String) > > instance Pair MyPair1 Int String where > newPair (x,y) = P1 (x,y) > getPair (P1 (x,y)) = (x,y) > ... --The nicest Pair that I've ever managed is not: class Pair p a b where -- if we use fst' then b is "loose" and v.v. fst' :: p->a -- seems to be :: forall a.(p->a), regardless class Pair p. snd' :: p->b -- can't seem to get a and b from the instances. -- Seems to be a problem overloading both fst and snd in one class -- but OK if one operator per class ... --But rather: -- ... so we can split Pair into two classes, "left" and "right"! class PairL p a where fst'' :: p->a -- OK but a needs to be implied by use class PairR p b where snd'' :: p->b -- ditto instance PairL (((,) a b)) a where fst'' (x,y) = x instance PairR (((,) a b)) b where snd'' (x,y) = y -- could make (a trivial) Pair' a subclass of PairL and PairR --which incidentally will combine with class Function fnType t u where ($) :: fnType -> t -> u -- NB hid std $ instance Function (t->u) t u where f $ x = f x -- Hask' list 29 Oct 2002 --allowing instance Function ((t->u),(v->w)) (t,v) (u,w) where (f, g) $ (x, y) = (f x, g y) --e.g. f2b = ( (\ch->if ch=='a' then 'z' else ch), (not) ) ... ( (f2b $ ('a', False)) :: (Char,Bool) ) -- need the type ... Lloyd -- Lloyd ALLISON, CSSE, Monash University, Victoria, Australia 3800. web: http://www.csse.monash.edu.au/~lloyd/ tel: +61 3 9905 5205 use: http://www.linux.org/ OpenOffice: http://www.openoffice.org/

2 1

Typing problems with polymorphic recursion and typeclasses
by oleg＠pobox.com 01 May '03

01 May '03

[Commenting of the problem in the message "GHC doesn't like its own type?", Iavor Diatchki wrote] > i remeber some time ago levent erkok run intro a simillar problem. take > a look at this post: > http://www.mail-archive.com/haskell@haskell.org/msg06754.html The problems seem different. However, Levent Erkok's problem as well as the problem in the follow-up message to categorical maxima point out that there is something else goes on besides the explicit typing. Let us use Levent Erkok's problem as it is simpler: > class X a where > u :: a b -> a b > f :: X a => b -> a b > f = f > g :: X a => a b -> b > g = g > -- h :: X a => b -> a c > h b = f (g (h b)) This file loads and checks both in GHC and Hugs. The problem is that if we uncomment the explicit type declaration of h (which is identical to the inferred type reported by the compiler), typechecker complains. Let us keep the function h without the explicit type declaration. Let us apply what I thought as an equivalent transformation: > h = \b -> f (g (h b)) Hugs now reports ERROR "/tmp/b.hs":12 - Unresolved top-level overloading *** Binding : h *** Outstanding context : X b and GHCi reports /tmp/b.hs:12: Ambiguous type variable(s) `a' in the constraint `X a' arising from use of `f' at /tmp/b.hs:12 In a lambda abstraction: f (g (h b)) It is interesting that the error message is exactly the same as when we used the explicit type declaration for the old "h b=..." definition. Something seems to be going on...

2 1

problems invoking haddock
by Andre W B Furtado 01 May '03

01 May '03

Is the following problem a specific cygwin problem and how can I overcome it? It happened to me while trying to invoke haddock: > $ haddock -h hello.hs > C:\haskell\cygwin\bin\sh.exe: *** fork: can't reserve memory for stack > 0x40000 - > 0x240000, Win32 error 487 > 4 [main] sh 1212 sync_with_child: child 988(0x72C) died before > initialization with status code 0x1 > 8217 [main] sh 1212 sync_with_child: *** child state > waiting for longjmp > C:\haskell\cygwin\bin\sh.exe: *** fork: can't reserve memory for stack > 0x40000 - 0x240000, Win32 error 487 > 19746 [main] sh 1212 sync_with_child: child 11816(0x720) died before > initialization with status code 0x1 > 19941 [main] sh 1212 sync_with_child: *** child state > waiting for longjmp > /cygdrive/c/haskell/cygwin/usr/local/bin/haddock: Cannot > fork: Resource > temporarily unavailable Cheers, -- Andre

1 0

GHC doesn't like its own type?
by oleg＠pobox.com 01 May '03

01 May '03

The previously message "Deeply uncurried products, as categorists might like them" can be used to demonstrate certain behavior of GHC that seems a bit odd. If we save the text of that message in a file, /tmp/a.lhs, we can load it into GHC: $ ghci -fglasgow-exts /tmp/a.lhs GHC Interactive, version 5.04.1 Ok, modules loaded: Main. *Main> The whole code loads and typechecks. The code contains the following definition, without an explicit type signature: > fcomp a = (. fapp) (mcomp a) We can ask GHCi to tell us the type of fcomp: *Main> :type fcomp forall result f1 a f2 c cp. (FApp a cp c, MCompose f2 cp c result) => (f1 -> f2) -> a -> f1 -> result and make that type, verbatim, to be the signature of fcomp: > fcomp:: forall result f1 a f2 c cp. (FApp a cp c, MCompose f2 cp c result) => (f1 -> f2) -> a -> f1 -> result > fcomp a = (. fapp) (mcomp a) If we reload the file, we get an error: /tmp/a.lhs:124: Could not deduce (FApp a cp c1) from the context (FApp a cp c, MCompose f2 cp c result) Probable fix: Add (FApp a cp c1) to the type signature(s) for `fcomp' arising from use of `fapp' at /tmp/a.lhs:124 In the second argument of `(.)', namely `fapp' In the definition of `fcomp': (. fapp) (mcomp a) /tmp/a.lhs:124: Could not deduce (MCompose f2 cp c1 result) from the context (FApp a cp c, MCompose f2 cp c result) Probable fix: Add (MCompose f2 cp c1 result) to the type signature(s) for `fcomp' arising from use of `mcomp' at /tmp/a.lhs:124 In the first argument of `(. fapp)', namely `(mcomp a)' In the definition of `fcomp': (. fapp) (mcomp a) I used to think that the inferred type is the most general type, and that the compiler would accept as explicit the type that it itself inferred. I was wrong? The second odd circumstance is best illustrated by the following transcript. Assume that /tmp/a.lhs is the text of the previous message as it was posted: $ ghci -fglasgow-exts /tmp/a.lhs GHC Interactive, version 5.04.1, for Haskell 98. Loading package base ... linking ... done. Loading package haskell98 ... linking ... done. Compiling Main ( /tmp/a.lhs, interpreted ) /tmp/a.lhs:76: Warning: No 'main' defined in module Main Ok, modules loaded: Main. *Main> let x = \f -> fapp f (('a','b'),('c',('d','e'))) Bus error (core dumped) Incidentally, if I enter > x = \f -> fapp f (('a','b'),('c',('d','e'))) into /tmp/a.lhs and load the file into GHCi, I get ghc-5.04.1: panic! (the `impossible' happened, GHC version 5.04.1): rdrNameModule zddFApp

3 2

RE: GHC doesn't like its own type?
by Erkok, Levent 30 Apr '03

30 Apr '03

Sometimes ghc/hugs will reject a program when you provide a type signature that it can deduce itself. This has been observed before: See Simon PJ's message: http://www.mail-archive.com/haskell@haskell.org/msg06764.html Of course, the "bus error" and the "panic" are truly GHC bugs, you might be better off reporting them at: http://sourceforge.net/tracker/?group_id=8032&atid=108032 -Levent. > -----Original Message----- > From: oleg(a)pobox.com [mailto:oleg@pobox.com] > Sent: Wednesday, April 30, 2003 3:48 PM > To: haskell(a)haskell.org > Subject: GHC doesn't like its own type? > > > The previously message "Deeply uncurried products, as categorists > might like them" can be used to demonstrate certain behavior of GHC > that seems a bit odd. If we save the text of that message in a file, > /tmp/a.lhs, we can load it into GHC: > > $ ghci -fglasgow-exts /tmp/a.lhs > GHC Interactive, version 5.04.1 > Ok, modules loaded: Main. > *Main> > > The whole code loads and typechecks. The code contains the following > definition, without an explicit type signature: > > > fcomp a = (. fapp) (mcomp a) > > We can ask GHCi to tell us the type of fcomp: > > *Main> :type fcomp > forall result f1 a f2 c cp. > (FApp a cp c, MCompose f2 cp c result) => > (f1 -> f2) -> a -> f1 -> result > > and make that type, verbatim, to be the signature of fcomp: > > > fcomp:: forall result f1 a f2 c cp. (FApp a cp c, MCompose f2 cp c > result) => (f1 -> f2) -> a -> f1 -> result > > fcomp a = (. fapp) (mcomp a) > > If we reload the file, we get an error: > > /tmp/a.lhs:124: > Could not deduce (FApp a cp c1) > from the context (FApp a cp c, MCompose f2 cp c result) > Probable fix: > Add (FApp a cp c1) to the type signature(s) for `fcomp' > arising from use of `fapp' at /tmp/a.lhs:124 > In the second argument of `(.)', namely `fapp' > In the definition of `fcomp': (. fapp) (mcomp a) > > /tmp/a.lhs:124: > Could not deduce (MCompose f2 cp c1 result) > from the context (FApp a cp c, MCompose f2 cp c result) > Probable fix: > Add (MCompose f2 cp c1 result) to the type signature(s) for > `fcomp' > arising from use of `mcomp' at /tmp/a.lhs:124 > In the first argument of `(. fapp)', namely `(mcomp a)' > In the definition of `fcomp': (. fapp) (mcomp a) > > I used to think that the inferred type is the most general type, and > that the compiler would accept as explicit the type that it itself > inferred. I was wrong? > > The second odd circumstance is best illustrated by the following > transcript. Assume that /tmp/a.lhs is the text of the previous message > as it was posted: > > $ ghci -fglasgow-exts /tmp/a.lhs > GHC Interactive, version 5.04.1, for Haskell 98. > Loading package base ... linking ... done. > Loading package haskell98 ... linking ... done. > Compiling Main ( /tmp/a.lhs, interpreted ) > > /tmp/a.lhs:76: Warning: No 'main' defined in module Main > Ok, modules loaded: Main. > *Main> let x = \f -> fapp f (('a','b'),('c',('d','e'))) > Bus error (core dumped) > > Incidentally, if I enter > > x = \f -> fapp f (('a','b'),('c',('d','e'))) > into /tmp/a.lhs and load the file into GHCi, I get > > ghc-5.04.1: panic! (the `impossible' happened, GHC version 5.04.1): > rdrNameModule zddFApp > _______________________________________________ > Haskell mailing list > Haskell(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell

1 0

Deeply uncurried products, as categorists might like them
by oleg＠pobox.com 30 Apr '03

30 Apr '03

This is a belated answer to a Haskell-categorical question posted two years ago on comp.lang.functional [1]: ] It is common in (say) category theory to write ] ] max3 = max . (max * id) Can we write this in Haskell? Specifically, can we write something more complex: max7 = max3 . ((max2 * max3) * max2) We show that we can, exactly in this notation (modulo alpha conversion). A potentially useful side-effect is a deep uncurrying of arbitrarily complex pairs, such as ((1,2),(3,(4,5))) The simplest max3 can be expressed in the desired form: *> prod x y = \(argx,argy) -> ((x argx),(y argy)) *> max2 x y = if x < y then y else x *> *> max3:: Ord a => a->a->a->a *> max3 = (curry (curry ((uncurry max2) . ((uncurry max2) `prod` id)))) Alas, the solution uses too much curry to be palatable. Generalizations to longer functions are mind-racking. Thus the problem is how to get the compiler (GHC) put and take the right amount of curry automatically. It seems that a polyvariadic composition combinator [2] can help. The combinator is specified as follows: given f:: a1->a2->.... ->cp, where cp is not functional and g:: cp->d then f `mcomp` g:: a1->a2->.... ->d of obvious meaning. In the simplest case of f::a->b (b not functional), "f `mcomp` g = g . f" . For a reason I can't recall `mcomp` has the reverse order of arguments compared to the regular composition. Given such a combinator, defined in the appendix, we can introduce a categorical product as *> prod f g = f `mcomp` (\fresult -> g `mcomp` (\gresult -> (fresult,gresult))) or, after some eta-reductions, *> prod f g = mcomp f ((mcomp g) . (,)) Given two functions, f:: a1->a2->...->an->c |c,d non-exponential types g:: b1->b2->...->bn->d their product f `prod` g:: a1->a2->...->an->b1->b2->...->bn->(c,d) The number of as and bs is arbitrary. We can subject the expression for prod to even more eta-reductions, yielding the following compact, combinational definition: > prod:: (MCompose a b (c -> d) e, MCompose f g (b,g) d) => > (h -> a) -> (c -> f) -> h -> e > prod = (. ((. (,)) . mcomp)) . mcomp The constraints in the prod's type are intricately related. The final expression for prod bears some similarity with Unlambda code. Perhaps because both Unlambda and the category theory eschew "elements" in favor of combinations of arrows. Probably there are other similarities. Now we are ready to define our maxima. To make our approach truly polymorphic, we have to restrict it first by the following declaration. It's not much a restriction because the type under the wrapper can be anything at all. Unfortunately, the intuitionist logic of class instances makes it impossible to say directly "forall x. (NOT Constraint x)". Thus we have to resort to the contortions: > newtype W a = W a deriving Show We also need a projected identity and the basic max: > tid:: (Ord a) => (W a)->(W a) > tid = id > max2 (W x) (W y) = if x < y then W y else W x We also need to "invert" the prod operation -- to deeply uncurry arbitrarily complex pairs. > -- An uncurrying application: flattening the product > class FApp f a c | a c -> f where > fapp:: f -> a -> c > > instance FApp (Char->c) Char c where > fapp = ($) > > instance FApp ((W a)-> c) (W a) c where > fapp = ($) > > instance (FApp fx a r, FApp r b c) => FApp fx (a,b) c where > fapp f = uncurry (fapp . (fapp f)) > -- test > fappt = fapp (\a b c d e -> [a,b,c,d,e]) (('a','b'),('c',('d','e'))) Combinators fapp and mcomp will occur together. Therefore, we define > fcomp a = (. fapp) (mcomp a) That expression can be further reduced to "fcomp = (. fapp) . mcomp" However, doing so blows the Unlambda fuse in GHC. Now we can indeed write our maxima: > max3:: Ord a => W a->W a->W a->W a > max3 = (max2 `prod` tid) `fcomp` max2 which looks almost the same as the categorical expression for max3. We can easily generalize: > max4:: Ord a => W a->W a->W a->W a -> W a > max4 = (max2 `prod` max2) `fcomp` max2 which would, in the categorical notation, be written as max2 . (max2 * max2) Our notation is almost a literal translation. There are other expressions for max4, for the other commuting branches: > -- max41 = max2 . (max3 * id) > max41:: Ord a => W a->W a->W a->W a -> W a > max41 = (max3 `prod` tid) `fcomp` max2 > -- max42 = max2 . (id * max3) > max42:: Ord a => W a->W a->W a->W a -> W a > max42 = (tid `prod` max3) `fcomp` max2 > -- max51 = max2 . ((max2 * id) . (max2 * max2)) > max51:: Ord a => W a->W a->W a->W a -> W a -> W a > max51 = ((max2 `prod` max2) `fcomp` (max2 `prod` tid)) `fcomp` max2 And finally, > max7:: Ord a => W a->W a->W a->W a->W a->W a->W a->W a > max7 = ((max2 `prod` max3) `prod` max2) `fcomp` max3 > > max7t = max7 (W 'a') (W 'b') (W 'c') (W 'd') (W 'e') (W 'f') (W 'g') Perhaps the wrapper W also has some categorical significance. [1] "Re: On products and max3" A thread on a newsgroup comp.lang.functional, Thu, 12 Apr 2001 02:14:27 +0000 [2] http://pobox.com/~oleg/ftp/Haskell/polyvar-comp.lhs The code was originally posted as "Re: composition" on a newsgroup comp.lang.functional on Wed, 30 Oct 2002 19:09:32 -0800 Appendix: polyvariadic composition, to make this whole code work. Excerpted from [2]. Compilation flags: -fglasgow-exts > class MCompose f2 cp gresult result | f2 cp gresult -> result, f2->cp > where > mcomp:: (f1->f2) -> (cp->gresult) -> (f1 -> result) > > -- Class instances. Please keep in mind that cp must be a non-functional type > -- and f2 and cp must be the same. These instances enumerate the base cases. > > instance MCompose (Maybe b) (Maybe b) c c where > --mcomp f::(a->(Maybe b)) g::((Maybe b)->c) :: a->c > mcomp f g = g . f > > instance MCompose [b] [b] c c where > --mcomp f::(a->[b]) g::([b]->c) :: a->c > mcomp f g = g . f > > instance MCompose Int Int c c where > --mcomp f::(a->Int) g::(Int->c) :: a->c > mcomp f g = g . f > > instance MCompose Char Char c c where > --mcomp f::(a->Char) g::(Char->c) :: a->c > mcomp f g = g . f > > instance MCompose (W a) (W a) c c where > --mcomp f::(x->(W a)) g::((W a)->c) :: x->c > mcomp f g = g . f > > instance MCompose (a,b) (a,b) c c where > mcomp f g = g . f > > -- Induction case > instance (MCompose f2 cp gresult result) => > MCompose (f1->f2) cp gresult (f1->result) where > mcomp f g = \a -> mcomp (f a) g >

1 0