- Haskell-Cafe - Haskell.org

RE: [Haskell-cafe] Function composition confusion
by Anuj Seth 27 Apr '05

27 Apr '05

Thanks, that clears it up I was thinking that the output of (splitAt blockSize) would get piped to (splitAt blockSize . snd). Did not realize it goes to the whole iterate part. -----Original Message----- From: Henning Thielemann [mailto:lemming@henning-thielemann.de] Sent: Wednesday, April 27, 2005 4:37 PM To: Anuj Seth Cc: haskell-cafe(a)haskell.org Subject: Re: [Haskell-cafe] Function composition confusion On Wed, 27 Apr 2005, Anuj Seth wrote: > Excuse the newbie'ness of my question. > Saw an example in Two Dozen Questions by Rexx Page. > > blocks blockSize = > takeWhile ( not . null ) . map fst . > iterate (splitAt blockSize . snd) . splitAt blockSize > > What is the meaning of the . operators outside the parentheses ? The same as inside. :-) (splitAt blockSize) transforms a list to a pair of lists. So imagine a list input at the right of (splitAt blockSize) and a pair output at the left. This pair is piped into the 'iterate' part which transforms a list of pairs into a list of pairs of lists. This in turn is piped to (map fst) and so on. The information contained in this message is proprietary of Amdocs, protected from disclosure, and may be privileged. The information is intended to be conveyed only to the designated recipient(s) of the message. If the reader of this message is not the intended recipient, you are hereby notified that any dissemination, use, distribution or copying of this communication is strictly prohibited and may be unlawful. If you have received this communication in error, please notify us immediately by replying to the message and deleting it from your computer. Thank you.

2 1

Function composition confusion
by Anuj Seth 27 Apr '05

27 Apr '05

Hi, Excuse the newbie'ness of my question. Saw an example in Two Dozen Questions by Rexx Page. blocks blockSize = takeWhile ( not . null ) . map fst . iterate (splitAt blockSize . snd) . splitAt blockSize What is the meaning of the . operators outside the parentheses ? Thsi does not look like function composition to me. Thanks, Anuj. The information contained in this message is proprietary of Amdocs, protected from disclosure, and may be privileged. The information is intended to be conveyed only to the designated recipient(s) of the message. If the reader of this message is not the intended recipient, you are hereby notified that any dissemination, use, distribution or copying of this communication is strictly prohibited and may be unlawful. If you have received this communication in error, please notify us immediately by replying to the message and deleting it from your computer. Thank you.

2 1

Small Project coder needed
by Mike Richards 26 Apr '05

26 Apr '05

Hi everyone, Calling all Haskell coders! I just got back into coding haskell and need to take over from another lecturer at our University.I need to get a solution done out to a problem he set my students last week, and as Im attending a conference on XP for the next couple of days, I doubt I'll have time to get it done between flights. Its not a very large project, and should only take an hour or two of your time to code.I can offer between £30-45 if it meets the specs I set (and functions 100% of course!). Let me know before the weekend, Thanks Mike Richards -- _______________________________________________ Get your free email from http://mail.oxygen.ie Powered by Outblaze

1 0

do statement
by Walt Potter 26 Apr '05

26 Apr '05

Can anyone point me to examples of using the do statement which does not involve IO? I find that the texts I have do not provide enough examples. Thanks, Walt

3 2

RE: [Haskell-cafe] FFI and pointers to pointers
by Simon Marlow 26 Apr '05

26 Apr '05

On 25 April 2005 21:40, John Meacham wrote: > On Mon, Apr 25, 2005 at 12:51:04PM +0100, Simon Marlow wrote: >> The syntax you want is >> >> foreign import ccall "&bar" :: Ptr CInt >> >> But note that GHC 6.4 has a bug whereby this doesn't work as expected >> when compiling via C. Either use the native code generator (-fasm) >> or wait for 6.4.1. > > Any ETA on 6.4.1? I am debating whether to rewrite code to work around > this bug or just wait for the point-release? We don't have any firm plans yet. It makes sense to wait until the flow of bug reports has slowed, and that hasn't happened yet. But I'll take your message as a vote for sooner rather than later. Cheers, Simon

1 0

How to debug GHC
by Monique Louise 25 Apr '05

25 Apr '05

Hi, all, I'm developing a back end for GHC and I have the following problem: my program is throwing an "empty list exception" due to head [] and I need to compile GHC with -prof -auto-all in order to see the stack trace when running it with +RTS -xc -RTS. I changed the makefile but the option +RTS -xc -RTS was not recognized as an available RTS option Does anyone have any idea about how I can do that ? Thanks in advance, -- ________________________________ Monique Louise B.Monteiro Msc Student in Computer Science Center of Informatics Federal University of Pernambuco

1 0

RE: [Haskell-cafe] FFI and pointers to pointers
by Simon Marlow 25 Apr '05

25 Apr '05

On 22 April 2005 16:18, Dimitry Golubovsky wrote: > I am trying to generalize my knowledge about FFI declarations when > dealing with pointers to pointers (import from C to Haskell). Maybe > these are silly questions, but It seems to me, I am missing some > understanding. > > Per the FFI Addendum: > > For a variable, we use "&" import: > > int bar; > > foreign import ccall "&" bar :: Ptr CInt The syntax you want is foreign import ccall "&bar" :: Ptr CInt But note that GHC 6.4 has a bug whereby this doesn't work as expected when compiling via C. Either use the native code generator (-fasm) or wait for 6.4.1. Cheers, Simon

2 1

RE: [Haskell-cafe] FFI and pointers to pointers
by Simon Marlow 25 Apr '05

25 Apr '05

On 25 April 2005 12:51, Simon Marlow wrote: > On 22 April 2005 16:18, Dimitry Golubovsky wrote: > >> I am trying to generalize my knowledge about FFI declarations when >> dealing with pointers to pointers (import from C to Haskell). Maybe >> these are silly questions, but It seems to me, I am missing some >> understanding. >> >> Per the FFI Addendum: >> >> For a variable, we use "&" import: >> >> int bar; >> >> foreign import ccall "&" bar :: Ptr CInt > > The syntax you want is > > foreign import ccall "&bar" :: Ptr CInt oops, never mind. Your version was fine. Cheers, Simon

1 0

RE: [Haskell-cafe] String search algorithms
by Bayley, Alistair 25 Apr '05

25 Apr '05

> From: Henning Thielemann [mailto:lemming@henning-thielemann.de] > > But I'm curious if you really need the index. Working with indexes on > lists is quite inefficient. E.g. if you want to replace > substrings you > may want to use this implementation: I'm not mutating the list, but I am extracting sublists. I'm toying with porting FIT and I'm starting with the Parse class, as recommended ( http://fit.c2.com/wiki.cgi?TipsForCoreImplementors ). They warn against using a generic parser: "Parse is the internal representation of the test data. Don't be seduced by generalized html/xml parsers. This one has unique features. Make it work. Consider replacing it only after you've used this one a while." Their parser is in Java, and makes heavy use of String.indexOf(), and I'm just trying to port it more-or-less as-is. I appreciate that'll be somewhat inefficient, but until I understand all of the wrinkles in their implementation, I'll take the simplest approach. Alistair. ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

String search algorithms
by Bayley, Alistair 25 Apr '05

25 Apr '05

I'm a bit puzzled to find no sub-string search in the Haskell libraries (unless there's some neat composition of the existing Data.List functions that I've missed). Google doesn't help much either. I've found a KMP implementation: http://haskell.org/hawiki/RunTimeCompilation I'm after something that'll report the position of the first occurrence, like Java's String.indexOf(). Alistair. ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

2 2

RE: [Haskell-cafe] String search algorithms
by Bayley, Alistair 25 Apr '05

25 Apr '05

> From: Henning Thielemann [mailto:lemming@henning-thielemann.de] > > > (unless there's some neat composition of the existing > Data.List functions > > List.findIndex (List.isPrefixOf "bla") (List.tails "dfvbdbblaesre") Oh, so there is. Thanks. ----------------------------------------- ***************************************************************** Confidentiality Note: The information contained in this message, and any attachments, may contain confidential and/or privileged material. It is intended solely for the person(s) or entity to which it is addressed. Any review, retransmission, dissemination, or taking of any action in reliance upon this information by persons or entities other than the intended recipient(s) is prohibited. If you received this in error, please contact the sender and delete the material from any computer. *****************************************************************

1 0

Why doesn't this work?
by Michael Vanier 25 Apr '05

25 Apr '05

I've been trying to generate an infinite list of random coin flips in GHC 6.4, and I've come across some strange behavior: ---------------------------------------------------------------------- import System.Random data Coin = H | T deriving (Eq, Show) -- Generate a random coin flip. coinFlip :: IO Coin coinFlip = do b <- getStdRandom random return (bool2coin b) where bool2coin True = H bool2coin False = T -- Generate an infinite list of coin flips. coinFlips :: IO [Coin] coinFlips = sequence cfs where cfs = (coinFlip : cfs) -- Print n of them. test :: Int -> IO () test n = do f <- coinFlips print (take n f) ---------------------------------------------------------------------- Now when I do "test 1" (for instance), it hangs forever. It seems as if there is some kind of strictness constraint going on that I don't understand. My understanding is that cfs is an infinite list of (IO Coin), sequence lifts this to be IO [Coin] where [Coin] is an infinite list, and then test should extract the infinite list of coin flips into f, take some number of them, and print them. But instead, the system appears to be trying to compute all the coin flips before taking any of them. Why is this, and how do I fix it? Thanks, Mike

5 4

Haskell example archive?
by Echo Nolan 25 Apr '05

25 Apr '05

Hello all, I recently read the post about a problem using the list monad, and I was wondering if there was an archive of monad usecases. If there is one, I'd like to see it, and if not it'd be a helpful part of the haskell community. Something like the example of the Maybe monad from "All About Monads".

3 2

a simple algebra for creating & editing values
by Conal Elliott 23 Apr '05

23 Apr '05

I've been playing a simple idea for creating and editing values, and I'd appreciate some feedback on whether or not this idea is well-explored territory. The idea is to construct functions that direct transformations (functions or other arrow-typed values) to the insides of values. This note is a literate Haskell program briefly demonstrating the idea. It runs under hugs and ghc/ghci. > module Path where > import Control.Arrow Consider, for example, a value of type (a->(f,b->(c,g)),e), and Suppose we'd like to apply a function to the c part. We'd want a transformation path > p1 :: (c->c') -> (a->(f,b->(c ,g)),e) > -> (a->(f,b->(c',g)),e) To define p1, simply list the steps taken to get to the type c in the type (a->(f,b->(c,g)),e), as follows: > p1 = first.result.second.result.first Function arguments may be edited also. In general, the part-changer (of type c->c' in p1) will need to have its domain and range types swapped if it appears in a negative position. > p2 :: (b'->b) -> (d->(a,b)->c) -> (d->(a,b')->c) > p2 = result.argument.second > p3a :: (a->a') -> ((a->b)->c) -> ((a'->b)->c) > p3a = argument.argument > p3b :: (a->a') -> ((((e,a)->b),d)->c) -> ((((e,a')->b),d)->c) > p3b = argument.first.argument.second The "first" and "second" path components are simply the Arrow methods of those names. As for "result" and "argument", for functions, we can define > result :: (b->b') -> (a->b)->(a->b') > argument :: (a'->a) -> (a->b)->(a'->b) >From the types, you can guess the definitions: > result = (.) > argument = flip (.) (BTW, Fritz Ruehr pointed out in his Feb 20 haskell-cafe note that compositions of (.) can be used to "compose a 1-argument function with an n-argument function".) Generalizing to arrows, look at the types of the "first" and "second" Arrow methods: > class Arrow arrow where > first :: arrow a a' -> arrow (a, b) (a', b ) > second :: arrow b b' -> arrow (a, b) (a', b ) > ... Similarly, define "result" and "argument" as methods of a new class: > class Arrow arrow => ArrowRA arrow where > result :: arrow b b' -> arrow (a->b) (a ->b') > argument :: arrow a' a -> arrow (a->b) (a'->b ) > instance ArrowRA (->) where > result = (.) > argument = flip (.) (I've also defined ArrowRA instances for GUI construction and for Haskell code generation.) Here's a suitable second argument for p1: > has1 :: (Bool -> (Bool, String -> (String, Int)), Bool) > has1 = (\ a->(not a, \ b->("hello"++b,3)), True) To see the result, fill in function arguments > x1 :: (Bool -> (f, String -> cg), e) -> ((f, cg), e) > x1 = first (second ($" world") . ($True)) and test: > t1a = x1 $ has1 -- ((False,("hello world",3)),True) > t1b = x1 $ p1 reverse has1 -- ((False,("dlrow olleh",3)),True) > t1c = x1 $ p1 length has1 -- ((False,(11,3)),True) Here's a suitable second argument for p2: > has2 :: Bool->(String,Int)->Bool > has2 b (str,n) = b && length str == n To see the result, fill in function arguments > x2 :: (Bool->(String,a)->Bool) -> a ->Bool > x2 f a = f True ("string",a) For testing: > t2a = x2 (p2 length has2) "bow" -- False > t2b = x2 (p2 ($ "fiddle") has2) length -- True These transformation paths allow us to apply a function inside of a value. What about applying a function that itself is inside some value. Transformation paths can do this job also, if we combine them with reverse application. In general, both the function and its argument may be buried inside of values. In that case, we might want the function's context to end up on the outside and the argument's context on the inside, or vice versa. > applyF pathF pathX hasF hasX = > pathF (\ f -> pathX (\ x -> f x) hasX) hasF > applyX pathF pathX hasF hasX = > pathX (\ x -> pathF (\ f -> f x) hasF) hasX As an example, > hasF1 = ("square", (^2)) > hasX1 = (3,"three") > t3a = applyF second first hasF1 hasX1 -- ("square",(9,"three")) > t3b = applyX second first hasF1 hasX1 -- (("square",9),"three") How about some other type constructors, besides (,) and (->)? Try lists. > class Arrow arrow => ArrowL arrow where > elementL :: arrow a a' -> arrow [a] [a'] > instance ArrowL (->) where elementL = map Generalizing from [] to any functor: > class Arrow arrow => ArrowF arrow where > elementF :: Functor f => arrow a a' -> arrow (f a) (f a') > instance ArrowF (->) where elementF = fmap The following example combines all four transformation combinators so far: > p4 :: (b'->b) -> (a->Maybe(b,d)->c) -> (a->Maybe(b',d)->c) > p4 = result.argument.elementF.first Comments? - Conal

2 1

a newbie's question
by SCOTT J. 22 Apr '05

22 Apr '05

Hi, I'm trying to investigate the list monad. I program instance Monad [] where xs >= f = concat ( map f xs ) return x = [x] a = [1,2,3] b = "there" do { x <- a y <- b return (x , y) } And I get the error Syntax error in input (unexpected backslash (lambda)) Jan

9 15

FFI and pointers to pointers
by Dimitry Golubovsky 22 Apr '05

22 Apr '05

Hi, I am trying to generalize my knowledge about FFI declarations when dealing with pointers to pointers (import from C to Haskell). Maybe these are silly questions, but It seems to me, I am missing some understanding. Per the FFI Addendum: For a variable, we use "&" import: int bar; foreign import ccall "&" bar :: Ptr CInt If we have int *pbar;, will Ptr (Ptr CInt) be correct? For arbitrary level of pointer nesting, will nesting of the same number of Ptr's be correct? For a function, we use "static" import: int system (char *str); foreign import ccall "static stdlib.h" system :: Ptr CChar -> IO CInt but for a pointer to a function (i. e. a variable) we use: int (*psystem) (char *str); foreign import ccall "dynamic" mkFun :: FunPtr (CInt -> IO ()) -> (CInt -> IO ()) and then psystem should be declared as a variable with "&" import, I believe. Or as a FunPtr? And then (mkFun psystem) returns something to be called as a function. Then (talking to myself) pointer to pointer to a function may be imported as shown in the very beginning, i. e. by nesting Ptr's? So indeed my question is: would nesting of Ptr's work if nested pointers are imported? I haven't experimented with this yet, but maybe someone has? Thanks for any advice. -- Dimitry Golubovsky Anywhere on the Web

1 0

read with pattern
by Walt Potter 22 Apr '05

22 Apr '05

I'd like to find a reference to reading with patterns such as read::[(Int,Int)] Thanks, Walt

2 1

Re: [Haskell-cafe] Haskell Questions
by Daniel Fischer 21 Apr '05

21 Apr '05

Am Donnerstag, 21. April 2005 20:00 schrieben Sie: > Daniel, > Thanks for your offer to help me. > > There was a site with some challenges on extending Thompsons code, and the > first question they asked was the following: > > ------------------------------------------------------ > Extend matchType so that it becomes capable of parsing polymorphic types > like Either a b. > > Hint. Define a new type, VarName, > capable of representing variables, like a, b and entry, as well as its > associated parser matchVarName. > > You might want to Add a new constructor, PolyT, to the definition of Type > to represent polymorphic types, and define its associated parser > matchPolyT. Adjust any other functions that definitely need adjusting > ------------------------------------------------------ > > I hope this helps you understand what Im trying to achieve more clearly. > > Regards > Mike Richards Partly. The Problem now is, I don't know what this refers to. No 'matchType' etc. appear in my copy of Thompson's book - maybe it's been added after I bought mine. I suppose, part of the exercise is parsing type signatures, right? To be of real assistance, I'd need to know what's given, so URL or direct text would be great. Daniel

1 0

a newbie's question
by SCOTT J. 21 Apr '05

21 Apr '05

Hi, I'm beginning to study Haskell, For the following a = [1,2,3] b = "there" do x <- a y <- b return (x , y) Winhugs cannot run it. Gives Syntax error in input (unexpected backslash ( lambda))

5 4

Haskell Questions
by Mike Richards 21 Apr '05

21 Apr '05

Hi, I'm working on a version of Simon Thompson's code from "The Craft of Functional programming" to handle polymorhpic data types. Heres the question Im working on - Ive tried doing the first part, but i would really apprecate it if someone could let me know if ive implemented it wrong. Mike import "Hugs.Prelude"; import Monad; import System; import Control.Monad.Error; import Char; {------------------------------------------------------------------------------ USEFUL AUXILIARY CONSTRUCTS ------------------------------------------------------------------------------} list2set :: Eq a => [a] -> [a] list2set [] = [] list2set (x:xs) | x `elem` xs = list2set xs | otherwise = x : list2set xs inBrackets :: String -> String inBrackets str = "(" ++ str ++ ")" inBrackets2 :: String -> String -> String inBrackets2 [] s2 = s2 inBrackets2 s1 [] = s1 inBrackets2 s1 s2 = inBrackets (s1 ++ " " ++ s2) joinStrings :: String -> [String] -> String joinStrings _ [] = "" joinStrings _ [s] = s joinStrings sep (s:ss) = s ++ sep ++ joinStrings sep ss char2str :: Char -> String char2str x = [x] dig2int :: Char -> Int dig2int d = fromEnum d - fromEnum '0' str2int :: String -> Int str2int s = str2intAux (reverse s) where str2intAux [x] = dig2int x str2intAux (x:xs) = dig2int x + 10*(str2intAux xs) {------------------------------------------------------------------------------ PARSING / PATTERN MATCHING Code based on Thompson, Section 17.5 ------------------------------------------------------------------------------} infixr 5 >*> type Parse a b = [a] -> [(b,[a])] -- Don't match anything matchNone :: Parse a b matchNone inp = [] -- Add a symbol into the stream and assert match matchAndAdd :: b -> Parse a b matchAndAdd val inp = [(val,inp)] -- Match if next input satisfies a given property matchProperty :: (a -> Bool) -> Parse a a matchProperty p (x:xs) | p x = [(x,xs)] | otherwise = [] matchProperty _ [] = [] -- Match the next input symbol matchInput :: Eq a => a -> Parse a a matchInput t = matchProperty (t==) -- combine the results of two matchs -- e.g. (matchLP `alt` matchDigit) checks for an LP or a digit alt :: (Eq a, Eq b) => Parse a b -> Parse a b -> Parse a b alt p1 p2 inp = list2set (p1 inp ++ p2 inp) -- Chain matches together to recognise strings (>*>) :: Parse a b -> Parse a c -> Parse a (b,c) (>*>) p1 p2 inp = [((y,z),rem2) | (y,rem1) <- p1 inp, (z,rem2) <- p2 rem1 ] -- Build values from matchd strings build :: Parse a b -> (b -> c) -> Parse a c build p f inp = [ (f x, rem) | (x, rem) <- p inp ] -- Match a list of symbols all satisfying the same property matchList :: (Eq a, Eq b) => Parse a b -> Parse a [b] matchList p = (matchAndAdd []) `alt` ((p >*> matchList p) `build` (uncurry (:))) -- Match a single symbols satisfying a property lift :: (Eq a, Eq b) => Parse a b -> Parse a [b] lift p = (p >*> matchAndAdd []) `build` (uncurry (:)) -- Match a non-empty list of symbols all satifying the same property matchNEList :: (Eq a, Eq b) => Parse a b -> Parse a [b] matchNEList p = (p >*> matchList p) `build` (uncurry (:)) -- Match an alphanumeric string of characters matchAlphaNums :: Parse Char [Char] matchAlphaNums = matchList matchAlphaNum -- Match a non-empty string of inputs, one after the other matchInputs :: Eq a => [a] -> Parse a [a] matchInputs [] = error "matchInputs: Empty test string" matchInputs [x] = matchInput x `build` buildMatch1 where buildMatch1 x = [x] matchInputs (x:xs) = (matchInput x >*> matchInputs xs) `build` (uncurry (:)) where buildMatch2 (x,y) = [x,y] {------------------------------------------------------------------------------ PARTICULAR TOKENS OF INTEREST ------------------------------------------------------------------------------} matchLP = matchInput '(' -- left parenthesis matchRP = matchInput ')' -- right parenthesis matchCO = matchInput ',' -- comma matchSP = matchInput ' ' -- space matchLB = matchInput '[' -- left bracket matchRB = matchInput ']' -- right bracket matchPT = matchInput '.' -- point (dot) matchSQ = matchInput '\'' -- single quote matchDQ = matchInput '"' -- double quote matchSL = matchInput '\\' -- slash matchAny = matchProperty (\_ -> True) matchAlphaNum = matchProperty isAlphaNum matchUpper = matchProperty isUpper matchLower = matchProperty isLower matchDigit = matchProperty isDigit matchWhiteSpace = matchList matchSP matchArrow = (matchWhiteSpace >*> matchInputs "->" >*> matchWhiteSpace) `build` buildArrow where buildArrow _ = "->" matchInt = matchNEList matchDigit matchFloat = (matchInt >*> matchPT >*> matchInt) `build` buildFloat where buildFloat (x,(_,y)) = (x ++ "." ++ y) matchChar = (matchSQ >*> ((matchInputs "\\'" ) `alt` ((matchProperty ('\'' /=)) `build` char2str)) >*> matchSQ) `build` buildChar where buildChar (_,(s,_)) = "'" ++ s ++ "'" matchString = (matchDQ >*> matchList ((matchInputs "\\\"" ) `alt` ((matchProperty ('"' /=)) `build` char2str)) >*> matchDQ) `build` buildString where buildString (_,(ss,_)) = "\"" ++ (foldr (++) "" ss) ++ "\"" matchBool = (matchInputs "True") `alt` (matchInputs "False") {------------------------------------------------------------------------------ PARSING TYPES ------------------------------------------------------------------------------} type TypeName = String type TypeNameParser = Parse Char TypeName matchTypeName :: TypeNameParser matchTypeName = (matchUpper >*> matchAlphaNums) `build` (uncurry (:)) type TypeParser = Parse Char Type {------------added PolyT ----------------------------------------------} data Type = NullT | UnaryT TypeName | ListT Type | TupleT [Type] | FuncT Type Type | PolyT Type Type deriving (Show) instance Eq Type where NullT == NullT = True UnaryT s == UnaryT t = s == t ListT s == ListT t = s == t TupleT s == TupleT t = s == t FuncT u v == FuncT x y = (u == x) && (v == y) UnaryT s == TupleT [t] = UnaryT s == t UnaryT s == FuncT NullT t = UnaryT s == t _ == _ = False --PolyT a b == PolyT x y = (a==x) || (b == y) PolyT a b == PolyT x y = polyT x y normalise :: Type -> Type normalise (TupleT []) = NullT normalise (TupleT [t]) = normalise t normalise (FuncT _ NullT) = NullT normalise (FuncT NullT t) = normalise t normalise (ListT t) = ListT (normalise t) normalise t = t {--------------------- Question One parts -----------------------------} {-----------define new type VarName to represent polymorphic types---} type VarParse a b = [a]->b {--------------- recognise characters like a, b ---------------------} varParse:: Parse Char Expr varParse = spot isVar 'build' Var isVar :: Char->Bool isVar x = ('a' <= x && x <= 'z') {--------------- polymorhpic function -------------------------------} polyT :: (a -> c) -> (b -> c) -> Either a b -> c polyT a b = either a b {--------------- Polymorphic data matching -------------------------} matchType :: TypeParser matchType = matchUnaryT `alt` matchListT `alt` matchTupleT `alt` matchFuncT `alt` matchNullT `alt` matchPolyT matchPolyT :: TypeParser matchPolyT = (matchLP >*> matchPolyT >*> matchRP) `build` buildPolyT where buildPolyT (_,(t,_)) = normalise t -------------------------------------------------------- matchNullT :: TypeParser matchNullT = (matchLP >*> matchWhiteSpace >*> matchRP) `build` (\_ -> NullT) matchUnaryT :: TypeParser matchUnaryT str = [ (UnaryT s, rem) | (s,rem) <- matchTypeName str ] matchListT = (matchLB >*> matchWhiteSpace >*> matchType >*> matchWhiteSpace >*> matchRB) `build` buildListT where buildListT (_,(_,(t,(_,_)))) = t matchTupleT = (matchLP >*> matchType >*> matchRepeatingBlock >*> matchRP) `build` buildTupleT where matchBlock = matchCO >*> matchWhiteSpace >*> matchType matchRepeatingBlock = matchList matchBlock buildTupleT (_,(t,(blocks,_))) = normalise typ where typ = TupleT (t : (map getTypes blocks)) getTypes (_,(_,x)) = x matchFuncT :: TypeParser matchFuncT = matchFuncNoBracketsT `alt` matchFuncInBracketsT matchFuncInBracketsT :: TypeParser matchFuncInBracketsT = (matchLP >*> matchFuncT >*> matchRP) `build` buildFuncIBT where buildFuncIBT (_,(t,_)) = normalise t matchFuncNoBracketsT :: TypeParser matchFuncNoBracketsT = ( (matchUnaryT `alt` matchTupleT `alt` matchFuncInBracketsT `alt` matchNullT) >*> matchArrow >*> matchType ) `build` buildFuncNBT where buildFuncNBT (t1,(_,t2)) = normalise (FuncT t1 t2) {------------------------------------------------------------------------------ TYPE GENERATED BY FUNCTION APPLICATION ------------------------------------------------------------------------------} doApplicationT :: Type -> Type -> Type doApplicationT t1 t2 | t2 == getFst t1 = getSnd t1 | otherwise = NullT where getFst (FuncT x _) = x getFst _ = NullT getSnd (FuncT _ y) = y getSnd _ = NullT {------------------------------------------------------------------------------ PARSING EXPRESSIONS ------------------------------------------------------------------------------} type FuncName = String type ExprParser = Parse Char Expr data Expr = NullE | FuncE FuncName | IntE Int | FloatE Float | CharE Char | StringE String | BoolE Bool | ListE [Expr] | TupleE [Expr] | ApplyE [Expr] deriving (Eq, Show) matchExpr :: ExprParser matchExpr = matchNotNullE `alt` matchNullE matchNotNullE :: ExprParser matchNotNullE = matchNotNullOrApplyE `alt` matchApplyE matchNotNullOrApplyE :: ExprParser matchNotNullOrApplyE = matchFuncE `alt` matchIntE `alt` matchFloatE `alt` matchCharE `alt` matchStringE `alt` matchBoolE `alt` matchListE `alt` matchTupleE matchNullE :: ExprParser matchNullE = (matchLP >*> matchWhiteSpace >*> matchRP) `build` (\_ -> NullE) matchFuncE :: ExprParser matchFuncE = ((matchLower >*> matchAlphaNums) `build` (FuncE . (uncurry (:)))) matchIntE :: ExprParser matchIntE = matchInt `build` (IntE . read) matchFloatE :: ExprParser matchFloatE = matchFloat `build` (FloatE . read) matchCharE :: ExprParser matchCharE = matchChar `build` (CharE . read) matchStringE :: ExprParser matchStringE = matchString `build` (StringE . read) matchBoolE :: ExprParser matchBoolE = matchBool `build` (BoolE . read) matchListE = (matchLB >*> matchWhiteSpace >*> matchExpr >*> matchWhiteSpace >*> matchBlock >*> matchRB) `build` buildListE where buildListE :: (Char,([Char],(Expr,([Char],([Expr],Char))))) -> Expr buildListE (_,(_,(e,(_,(es,_))))) = ListE (e:es) matchBlock = matchList matchComponent matchComponent = (matchCO >*> matchWhiteSpace >*> matchExpr >*> matchWhiteSpace) `build` buildComponent buildComponent :: (Char,(String,(Expr,String))) -> Expr buildComponent (_,(_,(e,_))) = e matchTupleE = (matchLP >*> matchWhiteSpace >*> matchExpr >*> matchWhiteSpace >*> matchBlock >*> matchRP) `build` buildTupleE where buildTupleE :: (Char,([Char],(Expr,([Char],([Expr],Char))))) -> Expr buildTupleE (_,(_,(e,(_,(es,_))))) = TupleE (e:es) matchBlock = matchList matchComponent matchComponent = (matchCO >*> matchWhiteSpace >*> matchExpr >*> matchWhiteSpace) `build` buildComponent buildComponent :: (Char,(String,(Expr,String))) -> Expr buildComponent (_,(_,(e,_))) = e matchApplyE = (matchNotNullOrApplyE >*> matchRepeatingBlock) `build` buildApplyE where matchRepeatingBlock = matchList (matchSP >*> matchWhiteSpace >*> matchExpr) buildApplyE :: (Expr,[(Char,(String,Expr))]) -> Expr buildApplyE (e,xs) = ApplyE (e : map third xs) third :: (Char,(String,Expr)) -> Expr third (_,(_,e)) = e {------------------------------------------------------------------------------ DECLARING TYPES OF USER-SPECIFIED FUNCTIONS ------------------------------------------------------------------------------} data Declaration = NullD | Declare Expr Type deriving (Eq, Show) type DeclarationParser = Parse Char Declaration matchDeclaration = (matchExpr >*> matchWhiteSpace >*> matchInputs "::" >*> matchWhiteSpace >*> matchType) `build` buildDeclaration where buildDeclaration (e,(_,(_,(_,t)))) = Declare e t declare :: String -> Declaration declare str | null ds = NullD | otherwise = head ds where ds = [ d | (d,"") <- matchDeclaration str ] type TypeLib = [Declaration] typeLib :: TypeLib -- EXAMPLE: A system with 3 user-defined functions typeLib = map declare [ "double :: Int -> Int", "fst :: (Int, Int) -> Int", "snd :: (Int, Int) -> Int" ] {------------------------------------------------------------------------------ GETTING THE TYPE OF A GENERAL EXPRESSION ------------------------------------------------------------------------------} dec2expr :: Declaration -> Expr dec2expr NullD = NullE dec2expr (Declare e _) = e dec2type :: Declaration -> Type dec2type NullD = NullT dec2type (Declare _ t) = t getTypeFromLib :: FuncName -> Type getTypeFromLib f | null ts = NullT | otherwise = head ts where ts = [ dec2type d | d <- typeLib, dec2expr d == (FuncE f) ] -- Get the type of a specified expression getType :: Expr -> Type getType NullE = NullT getType (FuncE f) = getTypeFromLib f getType (IntE _) = UnaryT "Int" getType (FloatE _) = UnaryT "Float" getType (CharE _) = UnaryT "Char" getType (StringE _) = UnaryT "String" getType (BoolE _) = UnaryT "Bool" getType (ListE []) = NullT getType (ListE (e:es)) = ListT (getType e) getType (TupleE []) = NullT getType (TupleE [e]) = getType e getType (TupleE es) = TupleT (map getType es) getType (ApplyE []) = NullT getType (ApplyE [e]) = getType e getType (ApplyE (e:es)) = foldl doApplicationT (getType e) (map getType es) {------------------------------------------------------------------------------ SIMPLIFIED INPUT AND OUTPUT ------------------------------------------------------------------------------} -- Reads an expression and determines its type typeOf :: String -> Type typeOf = getType . asExpr -- Reads a valid type and outputs it asType :: String -> Type asType str | null ts = NullT | otherwise = head ts where ts = [ t | (t,"") <- matchType str ] -- Reads a valid expression and outputs it asExpr :: String -> Expr asExpr str | null es = NullE | otherwise = head es where es = [ e | (e,"") <- matchExpr str ] -- Parse an expression and give its type parse :: String -> Declaration parse str = Declare e t where e = asExpr str t = getType e -- _______________________________________________ Get your free email from http://mail.oxygen.ie Powered by Outblaze

2 1

a question about import and parsec...
by Greg Wolff 21 Apr '05

21 Apr '05

I'm new at using Haskell and I'm trying to make use of the parsec library. I've started by working through the examples in the user guide which don't work as written in ghci when I run them. I've made modifications that have gotten them working, up to a point. But now I have an error one of the examples that has me stumped and looking in the documentation didn't help. When I run the following code without the "import Data.Char" I get an error that digitToInt is not defined. When I put the import in I get a large number of errors that weren't there before. Can some one explain this to me? How can I get this code to work? --- Here is the code --- > module Expressionparser where > > import Data.Char > import Text.ParserCombinators.Parsec > import Text.ParserCombinators.Parsec.Expr > import Text.ParserCombinators.Parsec.Token > import Text.ParserCombinators.Parsec.Language > > run :: Show a => Parser a -> String -> IO() > run p input > = case(parse p "" input) of > Left err -> do { putStr "parse error at " ; print err } > Right x -> print x > > runLex :: Show a => Parser a -> String -> IO() > runLex p > = run (do{ whiteSpace lang > ; x <- p > ; eof > ; return x > } > ) > > lang = makeTokenParser > (haskellStyle{ reservedNames = ["return","total"]}) > > expr = buildExpressionParser table factor <?> "expression" > > table = [ [op "*" (*) AssocLeft, op "/" div AssocLeft] > , [op "+" (+) AssocLeft, op "-" (-) AssocLeft] > ] > where > op s f assoc > = Infix (do{ symbol lang s; return f } <?> "operator") assoc > > factor = parens lang expr > <|> natural lang > <?> "simple expression" > > test1 = do{ n <- natural lang > ; do{ symbol lang "+" > ; m <- natural lang > ; return (n+m) > } > <|> return n > } > > ----------------------------------------------------------- > > price :: Parser Int -- this is the price in cents > price = lexeme (do{ ds1 <- many1 digit > ; char '.' > ; ds2 <- count 2 digit > ; return (convert 0 (ds1 ++ ds2)) > }) > <?> "price" > where > convert n [] = n > convert n (d:ds) = convert(10*n + digitToInt d) ds > > receipt :: Parser Bool > receipt = do{ ps <- many produkt > ; p <- total > ; return (sum ps == p) > } > > produkt = do{ symbol "return" > ; p <- price > ; semi > ; return (-p) > } > <|> do{ identifier > ; p <- price > ; semi > ; return p > } > <?> "produkt" > > total = do{ p <- price > ; symbol "total" > ; return p > } --- end code --- Here are the errors: > ___ ___ _ > / _ \ /\ /\/ __(_) > / /_\// /_/ / / | | GHC Interactive, version 6.2.2, for Haskell 98. > / /_\\/ __ / /___| | http://www.haskell.org/ghc/ > \____/\/ /_/\____/|_| Type :? for help. > > Loading package base ... linking ... done. > Prelude> :l ~/expression-parser.hs > Compiling Expressionparser ( /home/greg//expression-parser.hs, interpreted ) > > /home/greg//expression-parser.hs:59: > Variable not in scope: `digitToInt' > Failed, modules loaded: none. > Prelude> :r > Compiling Expressionparser ( /home/greg//expression-parser.hs, interpreted ) > > /home/greg//expression-parser.hs:51: > Couldn't match > `GenParser tok st a' > against > `CharParser st1 a1 -> CharParser st1 a1' > Expected type: GenParser tok st a > Inferred type: CharParser st1 a1 -> CharParser st1 a1 > Probable cause: `lexeme' is applied to too few arguments in the call > (lexeme (do > ds1 <- many1 digit > char '.' > ds2 <- count 2 digit > return (convert 0 (ds1 ++ ds2)))) > In the first argument of `(<?>)', namely > `lexeme (do > ds1 <- many1 digit > char '.' > ds2 <- count 2 digit > return (convert 0 (ds1 ++ ds2)))' > > /home/greg//expression-parser.hs:67: > Couldn't match `GenParser tok st' against `(->) String' > Expected type: GenParser tok st t > Inferred type: String -> CharParser st1 String > Probable cause: `symbol' is applied to too few arguments in the call > (symbol "return") > In a 'do' expression: symbol "return" > > /home/greg//expression-parser.hs:80: > Couldn't match `GenParser Char ()' against `(->) String' > Expected type: GenParser Char () t > Inferred type: String -> CharParser st String > Probable cause: `symbol' is applied to too few arguments in the call > (symbol "total") > In a 'do' expression: symbol "total" > Failed, modules loaded: none. > Prelude> -- +++++ Greg Wolff Our Lady Queen of Peace pgwolff(a)verizon.net Pray for us!

2 1

Re: [Haskell] Y in haskell?
by Albert Lai 21 Apr '05

21 Apr '05

Bernard Pope <bjpop(a)cs.mu.OZ.AU> writes: > I also meant to add that I think these solutions are not what Lloyd is > after, because they rely on recursive equations, which I believe was > avoided in Lloyd's SML code. Those recursive equations are avoided in SML because SML is eager - y f = f (y f) never terminates - and an SML programmer has to thunk by hand; the obfuscation shows. In Haskell there is no such need.

1 0

embedded interpreters
by Tim Docker 21 Apr '05

21 Apr '05

[I've asked this question on lambda-the-ultimate, but it remained unanswered, and it's probably more appropriate here in any case] The papers referenced here: http://lambda-the-ultimate.org/node/view/552 describe a means of projecting values in an implementation language to and from values in an embedded interpreted language. The papers use ML, but Derek Elkin gives a straightforward translation to haskell, via a typeclass. An excerpt is here: > data U = UF !(U -> U) | UP !U !U | UU | UB !Bool | UI !Int | US !String > deriving Show > > class EmbedProject a where > embed :: a -> U > project :: U -> a > > instance EmbedProject Int where > embed = UI > project (UI i) = i > > instance (EmbedProject a, EmbedProject b) => EmbedProject (a -> b) where > embed f = UF (embed . f . project) > project (UF f) = project . f . embed This is nice and tidy. However, the project function can fail in practise - in the above, this results in pattern matching failures. I'd like have more control of this, which suggests the following: > class EmbedProject a where > embed :: a -> U > project :: U -> Maybe a > > instance EmbedProject Int where > embed = UI > project (UI i) = Just i > project _ = Nothing ...etc, until it comes to to defining the instance of EmbedProject for functions. embed is ok - incorrect parameters map to return values of the UU type. But I'm lost as to what needs to happen with the project function. The definition belows doesn't compile because (project.f.embed) has type a->Maybe b, but I need something of type Maybe (a->b): > instance (EmbedProject a, EmbedProject b) => EmbedProject (a -> b) where > embed f = UF (\a -> maybe UU (embed.f) (project a) ) > project (UF f) = project.f.embed > project _ = Nothing Any suggestions? Is there something obvious (or non-obvious!) that I am missing? Thanks, Tim

1 0

Re: [Haskell] Going nuts
by Albert Lai 21 Apr '05

21 Apr '05

"Alexandre Weffort Thenorio" <alethenorio(a)home.se> writes: > outputLine keyno key orgFile = do > part1 <- getLeft keyno orgFile > part2 <- getRight keyno orgFile > total <- part1 ++ (strUpper key) ++ part2 ++ "\n" > newHexFile <- openFileEx "newfile" (BinaryMode WriteMode) > hPutStrLn newHexFile (orgFile!!0 ++ "\n" ++ total ++ unlines (drop 2 > orgFile)) outputLine keyno key orgFile = do let part1 = getLeft keyno orgFile let part2 = getRight keyno orgFile let total = part1 ++ (strUpper key) ++ part2 ++ "\n" newHexFile <- openFileEx "newfile" (BinaryMode WriteMode) hPutStrLn newHexFile (orgFile!!0 ++ "\n" ++ total ++ unlines (drop 2 orgFile)) "let ... =" instead of "<-" because getLeft et al. aren't IO commands. (Why type error rather than syntax error then? Because getLeft returns a list, and list is a monad too. E.g., do { part1 <- getLeft keyno orgFile; return part1 } = [ part1 | part1 <- getLeft keyno orgFile ] so part1 is inferred to be a Char.) There will be another problem. The type of orgFile is expected to be String here, but the callsite gives it "lines(hexFile)" of type [String].

1 0

Haskell Assistance Question
by Mike Richards 20 Apr '05

20 Apr '05

Hi, Im currently working on a haskell constraint parser for polymorhpic data types for a group of third year programmers, and was wondering if there was a help resource, or board on the internet for haskell programmers to ask questions about code they're working on. Any help or links would be much appreciated. Thanks a lot Mike mike.richards(a)oxygen.ie -- _______________________________________________ Get your free email from http://mail.oxygen.ie Powered by Outblaze

2 1

Bencoding in Haskell
by Tommi Airikka 20 Apr '05

20 Apr '05

Hi! I was just wondering if there are any good ways to represent a bencoded (http://en.wikipedia.org/wiki/Bencoding) message in Haskell? Any suggestions? Thanks, Tommi Airikka

2 6

WASH Unspecified Action
by John Goerzen 19 Apr '05

19 Apr '05

Hi, I've got one particular submit0 button in my WASH program that's causing trouble. Every time a person clicks on it, they get an error message saying "Unspecified Action". What does that mean and how would I fix it? The strange thing is that I have the exact same submit0 button pointing to the exact same function on a different page, and it works fine. Any ideas? Thanks, John

1 0

Re: [Haskell-cafe] Trying to implement this code
by Dmitry Vyal 19 Apr '05

19 Apr '05

Lizz Ross wrote: > Hi im new to Haskell (really just learning). > > Im trying to code a function to take in a List of Strings (e.g.) [apple, orange, > banana, orange, apple, orange] , and create > a binary search tree containing the Strings and integers (where the integers are > the number of occurrences of each word. I think you can use something like this to get statistics about repeats: data (Ord a, Updateable a) => BinTree a = Leaf | Node (BinTree a) a (BinTree a) class Updateable a where update :: a -> a data Word_stat = Word_stat String Int deriving Show instance Eq (Word_stat) where (==) (Word_stat s1 _) (Word_stat s2 _) = s1 == s2 instance Ord (Word_stat) where (Word_stat s1 _) < (Word_stat s2 _) = s1<s2 instance Updateable (Word_stat) where update (Word_stat s i) = Word_stat s (i+1) -- inserts new element in the tree or updates existing one ins_in_tree :: (Ord a, Updateable a) => BinTree a -> a -> BinTree a ins_in_tree Leaf el = Node Leaf el Leaf ins_in_tree (Node left cur right) el | el < cur = Node (ins_in_tree left el) cur right | el == cur = Node left (update cur) right | otherwise = Node left cur (ins_in_tree right el) -- loads list of strings in the tree ins_list :: [String] -> BinTree Word_stat ins_list lst = foldl ins_in_tree Leaf (map wrap lst) where wrap :: String -> Word_stat wrap s = Word_stat s 1 --traverses the tree flat_tree :: (Ord a, Updateable a) => BinTree a -> [a] flat_tree Leaf = [] flat_tree (Node left el right) = (flat_tree left) ++ [el] ++ (flat_tree right) -- function you probably need summary :: [String] -> [Word_stat] summary lst = flat_tree $ ins_list lst --------------- Am not sure about the relevance of this approach as i have very little experience with Haskell and FP. So it would be great if someone offers better solution. Why doesnt translator automatically deduce constraints in type of ins_in_tree and flat_tree functions so i need to explicitly define them?

4 4

Parsec question
by Ketil Malde 19 Apr '05

19 Apr '05

Hi, I've started using Parsec for my parsing needs, and must say I'm very happy with it. There is one thing that I'm struggling with implementing though. Basically, I want to parse a file containing multiple records. I already have a parser for a single record, and of course I could parse the file simply as many record However, this gives me the type Either ParseError [Record] which AFAICT, requires the whole file to be parsed correctly before any result is returned. I think it would be better for my purposes to have a parser of type [Either ParseError Record] so that the list of Records can be processed in an on-line fashion, until an error occurs. Is there an obvious way to achieve this? -kzm -- If I haven't seen further, it is by standing in the footprints of giants

2 1

Re: Trying to implement this code
by Dmitry Vyal 18 Apr '05

18 Apr '05

Lizz Ross wrote: > > This gives me the error message :28 - Syntax error in input (unexpected > symbol "wrap") > Sorry. Looks like my mailer ate tabulation. Just correct the intendation: -- loads list of strings in the tree ins_list :: [String] -> BinTree Word_stat ins_list lst = foldl ins_in_tree Leaf (map wrap lst) where wrap :: String -> Word_stat wrap s = Word_stat s

1 0

Re: [Haskell-cafe] Trying to implement this code
by Scott Turner 18 Apr '05

18 Apr '05

On 2005 April 18 Monday 13:42, Lizz Ross wrote: > Im trying to code a function to [...] create > a binary search tree containing the Strings and integers (where the > integers are the number of occurrences of each word. What have you got so far? Have you declared a data structure for the search tree? Have you seen http://haskell.org/hawiki/HomeworkHelp?

2 1

HTTP and Browser modules
by Atwood, John Wesley 18 Apr '05

18 Apr '05

> 11. HTTP and Browser modules (David Owen) > Message: 11 > Date: Mon, 18 Apr 2005 02:28:17 +0000 > From: "David Owen" <d_w_o(a)hotmail.com> > Subject: [Haskell-cafe] HTTP and Browser modules > To: haskell-cafe(a)haskell.org > Message-ID: <BAY101-F23ED428D824D7DBAF21C54B3290(a)phx.gbl> > Content-Type: text/plain; format=flowed > > Good morning > > I have a query about compiling the original version of the HTTP > implementation in Windows > (http://homepages.paradise.net.nz/warrickg/haskell/http/) > <snip details> > If anybody has seen this problem before or knows how to > correct it I'd be very interested in your assistance :-) David, in HTTP.hs, replace the 2 occurences of "ioError" with "throw". John Atwood

1 0

HTTP and Browser modules
by David Owen 18 Apr '05

18 Apr '05

Good morning I have a query about compiling the original version of the HTTP implementation in Windows (http://homepages.paradise.net.nz/warrickg/haskell/http/) Using the compile commands stipulated a series of similar errors to do with the HTTP module appear. They are to do with a type mismatch, one of these errors for example is: ./HTTP.hs:592: Couldn't match 'IOError' against 'Exception' Expected type: Exception -> IO (Either a [Char]) Inferred type: IOError -> IO (Either ConnError b) In the application 'handleSocketError sk' In the second argument of 'Control.Exception.catch', namely '(handleSocketError sk)' Line 592 is: readBlock sk n = (liftM Right $ fn n) `Exception.catch` (handleSocketError sk) Have hacked about for some time to no avail. I don't know why this occurs because the code appears exactly the same in the updated version (http://www.dtek.chalmers.se/~d00bring/haskell-xml-rpc/http.html) and that compiles, albeit in linux only due to the Cabal constraint. I need it to work in Windows though so must use the original version. (I need it to compile using GHC 6.2.2) If anybody has seen this problem before or knows how to correct it I'd be very interested in your assistance :-) cheers to all david

1 0

Thompson's Exercise 9.13
by Kaoru Hosokawa 17 Apr '05

17 Apr '05

I've been working through Thompson's exercises and got to one I could not solve. It's Exercise 9.13. This is where I need to define init using foldr. init :: [a] -> [a] init "Greggery Peccary" ~> "Greggary Peccar" This is as far as I got: init xs = foldr left [] xs left :: a -> [a] -> [a] left x [] = [] left x1 : (x2 : xs) = x1 : (left x2 xs) But this returns [] and doesn't work. I can't get "left" to know that it is working with the rightmost element. It just throws away every element when its right hand side is empty. I found a solution that works for Strings, but I am looking for a more general solution. This exercise may yet again be one of those that is difficult to solve with my current knowledge of Haskell, but I'm asking anyway. -- Kaoru Hosokawa khosokawa(a)gmail.com

7 15

GHC Survey source?
by Alson Kemp 15 Apr '05

15 Apr '05

Simons, Would y'all hand out the source code for the survey @ http://www.haskell.org/ghc/survey/start.cgi? I looked through the CVS repo but couldn't find it. Aside from generalities (GHC, WASH, etc), I wanted to see some actual web programming with Haskell. Thanks, Alson

2 2

Do you use GHC?
by Simon Peyton-Jones 15 Apr '05

15 Apr '05

Dear Haskell folk, PLEASE READ THIS IF YOU USE THE Glasgow Haskell Compiler (GHC). I virtually never send messages to overlapping sets of lists, but I'm doing so this time, because I'd really like to get to everyone who uses GHC. Here at GHC HQ, we are often asked how many people use GHC, and what kind of folk they are. Since GHC is free software, we have no clue. Download stats tell us a bit, but not much, because GHC gets out through a variety of other routes too (e.g. Debian). We also have little idea about which aspects of GHC are most valued, nor of what enhancements would be most sought after, or which platforms are most important to you. We hear quite a bit from the bleeding-edge folk who push the limits, but much less from people who just want to get the job done. Thus motivated, Tomasz Zielonka kindly put together a (WASH-powered) survey for us, which asks you to tell us a bit yourself and how you use GHC. We've had about 230 responses so far; thank you to those 230 folk. But I'm pretty certain there are more than 230 people in the world who use GHC! THIS MESSAGE IS TO ASK YOU TO TAKE 5 MINS TO COMPLETE THE SURVEY http://www.haskell.org/ghc/survey/start.cgi We'd like to hear from *absolutely everyone* who uses GHC: whether you are a first-year undergraduate or a famous professor; whether you use GHC for industrial applications or recreation; whether you use higher-rank polymorphism or have only just learned what functional programming is. Everyone! We'll use the information to guide our future priorities, and we'll publish some kind of summary of what we learn in due course. It's all anonymous, of course, unless you choose to say who you are. If you think it's appropriate, please circulate this announcement locally, e.g. to your students who may not be on the Haskell mailing list Many thanks Simon PJ and Simon Marlow

1 0

Haskell with Apache?
by Graham Klyne 14 Apr '05

14 Apr '05

I'm interested in running Haskell code invoked from an Apache web server request. I discovered the mod_haskell project [1] which looks prima facie v. promising. Does anyone have any recent experience of using this (there apparently being no recent activity on this project)? I wonder if there's any other project or activity in this area I should be aware of? #g -- [1] http://losser.st-lab.cs.uu.nl/mod_haskell/ ------------ Graham Klyne For email: http://www.ninebynine.org/#Contact

5 4

Call for Contributions -- HC&A Report (May 2005 edition)
by Andres Loeh 14 Apr '05

14 Apr '05

Dear Haskellers, it is nearly time for the eighth edition of the ================================================================ Haskell Communities & Activities Report http://www.haskell.org/communities/ Submission deadline: 03 May 2005 (please send your contributions to hcar at haskell.org, in plain ASCII or LaTeX format) ================================================================ This is the short story: * If you are working on any project that is in some way related to Haskell, write a short entry and submit it to the me. * If you are interested any project related to Haskell that has not previously been mentioned in the HC&A Report, tell me, so that I can contact the project leaders and ask them to submit an entry. * Feel free to pass on this call for contributions to others that might be interested. More detailed information: The Haskell Communities & Activities Report is a bi-annual overview of the state of Haskell as well as Haskell-related projects over the last, and possibly the upcoming 6 months. If you have only recently been exposed to Haskell, it might be a good idea to browse the November 2004 edition -- you will find interesting topics described as well as several starting points and links that may provide answers to many questions. Contributions will be collected until the beginning of May. They will be compiled into a coherent report which will appear sometime during May. As always, this is a great opportunity to update your webpages, make new releases, announce of even start new projects, or to point at some developments you want every Haskeller to see! As the purpose of the report is to collect recent or current activities, we encourage you to update all existing summaries and reports. We will probably drop any topics that have not had any activity for the past year, i.e., since May 2004, but we would very much prefer you to present an updated description of the topic. Of course, new entries are more than welcome. Reports should generally be kept brief and informative, ranging from a few sentences to a few hundred words, to keep the whole report reasonably sized. Looking forward to your contributions, Andres (current editor) ----------------------------------- topics New suggestions for current hot topics, activities, projects, etc. are welcome - especially with names and addresses of potential contacts, but here is a non-exclusive list of likely topics (see also http://www.haskell.org/communities/topics.html ): General Haskell developments; Haskell implementations; Haskell extensions; Standardization and documentation; Haskell tutorials, howtos and wikis; Organisation of Haskell tool and library development; Haskell-related projects and publications; new research, fancy tools, long-awaited libraries, cool applications; Feedback from specialist mailing lists to the Haskell community as a whole; Haskell announcements; all (recent) things Haskell Announcements: if you've announced anything new on the Haskell list over the last six months, you'll want to make sure that is reflected in this edition! Project pings: if you're maintaining a Haskell tool or library or somesuch, you'll want to let everyone know that it is still alive and actively maintained, even if there have been no new additions, but all the more if there have been new developments. Tutorials: if you've fought with some previously undocumented corner of Haskell, and have been kind enough to write down how you did manage to build that graphical user interface, or if you've written a tutorial about some useful programming techniques, this is your opportunity to spread the word (short, topic-specific, and hands-on tutorials that only show how to achieve a certain practical task would do a lot to make things easier for new Haskellers - please write some!) Applications: if you've been working quietly, using Haskell for some interesting project or application (commercial or otherwise), you might want to let others know about what you're using Haskell for, and about your experiences using the existing tools and libraries; are you using Haskell on your job? An interesting thread about using Haskell and more generally functional programming for non-Haskell things seems to recur with reasonable frequency - why not write a sentence or two about your use of Haskell for our report? Feedback: if you're on one of the many specialist Haskell mailing lists, you'll want to report on whatever progress has been made there (GUI API discussions, library organisation, etc.) If you're unsure whether a contact for your area of work has come forward yet, have a look at the report's potential topics page, or get in touch with me. I have contacted last time's contributors, hoping they will volunteer to provide updates of their reports, and will update the contacts on the topics page fairly regularly. But where you don't yet see contacts listed for your own subject of interest, you are very welcome to volunteer, or to remind your local community/project team/mailing list/research group/etc. that they really ought to get their act together and let the Haskell community as a whole know about what they've been doing! :-) -------------------------- what should I write? That depends on your topic, but as a general rule, it shouldn't take you long. A simple sentence or two about your use of Haskell could go into the "Individual Haskellers and their projects" section. If you're a company, or if you're working on a project using Haskell as the implementation language, a paragraph on that could go into the "Commercial Applications" and "Non-Commercial Applications" sections. A typical summary report about a tool/library/project/application/... would be between 1 and 3 paragraphs of ASCII text (what's it about? major topics and results since the last report? current hot topics? major goals for the next six months?) plus pointers to material for further reading (typically to a home page, or to mailing list archives, specifications and drafts, implementations, meetings, minutes, ...). For those who prefer templates to fill in, the report is edited in LaTeX, and an entry template might look something like this: \begin{hcarentry}{<MYSTUFF>} \report{<MY NAME>} \status{<PROJECT STATUS IN ONE LINE>} \makeheader <WHAT IS IT?> <WHAT IS ITS STATUS? / WHAT HAS HAPPENED SINCE LAST TIME?> <CAN OTHERS GET IT?> <WHAT ARE THE IMMEDIATE PLANS?> \FurtherReading \url{<PROJECT URL>} \end{hcarentry} Browsing through previous editions should give you a good idea of the variety of possibilities, ranging from very brief to extensive.

1 0

Closest analog to popen()
by Dimitry Golubovsky 14 Apr '05

14 Apr '05

Hi, Does there exist any analog of popen in the standard Haskell libraries? I need to execute an external program (not a Haskell funciton) - maybe in a shell, being able to feed something to its stdin, and finally catch the exit code. Does there exist a way to do this without dealing with multithreading, writing my own ffi and other stuff? Something like rawSystem, but acting asynchronously (returning a writeable pipe handle, and a process ID), and later I would use getProcessStatus to catch the exit code. PS I have found http://community.moertel.com/ss/space/Tom's+Haskell+code/POpen.hs so far, but it does not seem to be part of the standard library. -- Dimitry Golubovsky Anywhere on the Web

5 6

predicates in XML toolboxes
by Henning Thielemann 14 Apr '05

14 Apr '05

The XML toolboxes HaXml, HXML and the XML toolbox uses one function type (called filter) for different purposes. The functions of types predicates a -> Bool selectors, transformators a -> a list-valued functions a -> [a] are all implemented with the one type (a -> [a]). In this design predicates don't return False or True, but an empty list or a one-element list containing the input value. Transformators return single element lists. In my opinion this means a significant loss of type safety and quality of documentation. Are there more type safe XML/HTML processor libraries in Haskell?

3 4

Passing Constructors as arguments
by Ralph Hodgson 13 Apr '05

13 Apr '05

I am learning Haskell and have set a small exercise for myself on a frames and slots program. Would appreciate some help on how to pass constructors of data structures as arguments to a function. Thanks, -- Ralph __________ A Frames test > module Frames > where Define frame slots: > type FirstName = String -- first name > type LastName = String -- last name > type Organization = String > type Email = String > type WorkPhone = String > type CellPhone = String > type TelephoneNumber = String Define slots for a contact > data ContactProperty = FN FirstName > | LN LastName > | OR Organization > | EM Email > | WP TelephoneNumber > | MP TelephoneNumber > deriving (Show, Eq) > data Contact = Contact [ContactProperty] > deriving (Show, Eq) > type Contacts = [ Contact] Now I need a way to extract properties from the frame. Start by testing pattern matching without using parameters. Then I need to find out how to pass a constructor as a parameter. > getProperty:: [ContactProperty] -> FirstName > getProperty ((FN fn):_) = fn > getProperty (_:xs) = getProperty xs > getProperty [] = "unknown" > firstName:: Contact -> FirstName > firstName (Contact cpl) = getProperty cpl Define Contacts > c1::Contacts > c1 = > [ ( Contact [(FN "Ralph"),(LN "Hodgson"),(OR "TopQuadrant"),(EM "rhodgson(a)topquadrant.com")]), > ( Contact [(FN "Mills"),(LN "Davis"),(EM "mdavis(a)project10x.com")])] Tests > t1=firstName $ head c1 -- should be "Ralph" > t2=firstName $ last c1 -- should be "Mills" ___________________________

3 4

foldr1 min [(maxBound::Int)%1,1 % 2]
by Bo Herlin 13 Apr '05

13 Apr '05

Hi How come > foldr1 min [(maxBound::Int) % 1,1 % 2] 2147483647 % 1 but > foldr1 min [2147483647 % 1,1 % 2] 1 % 2 Why??? /Bo Herlin

3 4

[Q] A typing problem
by Didier Verna 13 Apr '05

13 Apr '05

Hi ! I'm trying to write a function that combines folding and mapping. This function would take two arguments (a folding function and a mapping function), and would return a function of one argument (a list of 'a''s) returning a 'a'. The idea is to write something like sumsquare = foldmap (+) square Here's what I write: foldmap :: (c -> c -> c) -> (c -> c) -> (c -> c -> c) foldmap f m = foldr1 f (map m) But this gives a typing error: ERROR "src/ssq4.hs":2 - Type error in application *** Expression : foldr1 f (map m) *** Term : map m *** Type : [b] -> [b] *** Does not match : [a] What can I do to get what I want ? Thanks. -- Didier Verna, didier(a)lrde.epita.fr, http://www.lrde.epita.fr/~didier EPITA / LRDE, 14-16 rue Voltaire Tel.+33 (1) 44 08 01 85 94276 Le Kremlin-Bicêtre, France Fax.+33 (1) 53 14 59 22 didier(a)xemacs.org

3 3

Re: [Haskell-cafe] Binary file r/w example
by Bo Herlin 13 Apr '05

13 Apr '05

Yes, I am, and the IOExtension module IS one of my problems. The other problem is that I am interested in this Ptr thing, and I havent seen any examples in using it, and is seems like Ptr is not in any of my Haskell-books or in any of the tutorials that I have found. Henning Thielemann wrote: > > On Wed, 13 Apr 2005, Bo Herlin wrote: > >> Hi, does anyone have a small but complete example on how to read a >> (portion of) a binary file, like r/w the header of a Midi-file? >> >> It seems like readBinaryFile (ans writeBinaryFile) is deprecated and I >> should use hGetBuf (and hPutBuf), but what is this Ptr thing? >> >> How would I implement readBinaryFile using hGetBuf? > > > > Are you aware of Haskore (www.haskell.org/haskore and > cvs.haskell.org/darcs/haskore) which provides a MidiFile reader and > writer? It has no good solution for reading and writing binary files, > but uses a platform dependent IOExtension module. :-( >

2 1

Binary file r/w example
by Bo Herlin 13 Apr '05

13 Apr '05

Hi, does anyone have a small but complete example on how to read a (portion of) a binary file, like r/w the header of a Midi-file? It seems like readBinaryFile (ans writeBinaryFile) is deprecated and I should use hGetBuf (and hPutBuf), but what is this Ptr thing? How would I implement readBinaryFile using hGetBuf? Best/ Bo Herlin

1 0

Installing and running QuickCheck
by Adam Wyner 12 Apr '05

12 Apr '05

Hi, I'd like to use QuickCheck for testing Haskell programs. I'm using Hugs in Windows. I'm a newbie to Haskell. Just running QuickCheck.hs itself, which comes with the Hugs98 libraries, I get an error message and the Monad command line, which indicates that quickcheck didn't load. ERROR "C:\Program Files\Hugs98/libraries\QuickCheck.hs":147 - Undefined variable "chr" Monad> Here is the line in QuickCheck.hs which leads to the error. instance Arbitrary Char where arbitrary = choose (32,255) >>= \n -> return (chr n) coarbitrary n = variant (ord n) This code is from the website: http://www.cs.chalmers.se/~rjmh/QuickCheck/QuickCheck.hs I tested it with the following module, as per the instructions in on QuickCheck's manual page: ---- module TestQuickCheck where import QuickCheck prop_RevRev xs = reverse (reverse xs) == xs where types = xs::[Int] ---- Loading just this, I get the same error: Prelude> :l TestQuickCheck ERROR "C:\Program Files\Hugs98/libraries\QuickCheck.hs":147 - Undefined variable "chr" Monad> I know others report using QuickCheck, so this problem must have been resolved. Also, I guess the quickcheck script is for Linux alone? Any scripts for Hugs in Windows? Cheers, Adam

4 3

Re: [Haskell-cafe] Thompson's Exercise 9.13
by Daniel Fischer 10 Apr '05

10 Apr '05

Am Sonntag, 10. April 2005 17:33 schrieben Sie: > On 2005/04/10, at 18:18, Daniel Fischer wrote: > >> But this returns [] and doesn't work. I can't get "left" to know that > >> it is working with the rightmost element. It just throws away every > >> element when its right hand side is empty. > >> > >> I found a solution that works for Strings, but I am looking for a more > >> general solution. This exercise may yet again be one of those that is > >> difficult to solve with my current knowledge of Haskell, but I'm > >> asking > >> anyway. > > > > I cannot imagine how you could do it for Strings, but not for general > > lists. > > Mind sending me the code? > > The code is here: > http://wiki.pragprog.com/cgi-bin/wiki.cgi/ThompsonNineAnswersJD Look > for 9.13 towards the bottom of the page. > > It uses chr 0 as an end of string marker, and so this solution only > works for Strings. Unfortunately, Strings may contain '\0': *Init> finit "this doesn't\0quite\0work\0!" "this doesn't\NULquite\NULwor" so it doesn't work in all cases. The idea is nice, though: import Data.Maybe finit = catMaybes . foldr f [Nothing] . map Just where f x ys = case ys of [Nothing] -> [] _ -> x:ys will do fine. > > -- > Kaoru Hosokawa > khosokawa(a)gmail.com Cheers, Daniel

1 2

List containing different types but all implementing the same class
by Bo Herlin 09 Apr '05

09 Apr '05

Hi everyone. Being new to Haskell I wonder how I can make a list contain different types but all implementing the same class, like this: data X = X data Y = Y class Z a where f :: a -> Int instance Z X where f x = 0 instance Z Y where f y = 1 test1 :: Z a => [a] test1 = [X,Y] test2 = map f test1 Is it possible to make this work? /Bo Herlin

3 4

Instances of constrained datatypes
by Arjun Guha 08 Apr '05

08 Apr '05

This is a contrived example, but contains the essence of what I'd like to do. Suppose I have this datatype: > data (Eq v) => EqList v = EqList [v] I'd like to make it an instance of Functor. However, fmap takes an arbitrary function of type a -> b. I need an Eq constraint on a and b. Is there any way to do this without creating my own `EqFunctor' class with explicitly-kinded quantification: > class (Eq a) => EqFunctor (f :: * -> *) a where > eqfmap:: (Eq b) => (a -> b) -> f a -> f b Thanks. -Arjun

4 7

Re: Instances of constrained datatypes
by John Hughes 07 Apr '05

07 Apr '05

> > >This is a contrived example, but contains the essence of what I'd like >to do. Suppose I have this datatype: > > > data (Eq v) => EqList v = EqList [v] > >I'd like to make it an instance of Functor. However, fmap takes an >arbitrary function of type a -> b. I need an Eq constraint on a and >b. Is there any way to do this without creating my own `EqFunctor' >class with explicitly-kinded quantification: > > > class (Eq a) => EqFunctor (f :: * -> *) a where > > eqfmap:: (Eq b) => (a -> b) -> f a -> f b > >Thanks. > >-Arjun > > > > > I wrote a paper proposing an extension to allow this, published at the Haskell Workshop in 1999. Here's the link: http://www.cs.chalmers.se/~rjmh/Papers/restricted-datatypes.ps Getting the right dictionaries to the right place involves adding a concept of well-formed types, which perhaps is why it hasn't been taken up by the Simons... John Hughes

1 0