April 2005 - Haskell-Cafe

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 21 Apr '05

21 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 20 Apr '05

20 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