- Haskell-Cafe - Haskell.org

Deferred instance declarations (context without type variables)
by Misha Aizatulin 16 Sep '06

16 Sep '06

hello, I have a question about context in type signature. I would like to write a function, say (f :: T -> T) which also relies on an instance of class C being defined for T. The problem is, I don't want this instance defined at the same time f is defined, instead I would like to defer this definition until f is called (in some other module). Naively the code would look like this: ================================= module DefineF where class C a where fC :: a -> a data T = T f :: (C T) => T -> T f T = fC T ================================= module CallF where instance C T where fC = id call = f T ================================= The definition of f in DefineF won't compile because "All of the type variables .. are already in scope". Could you recommend any other way to achieve what I am trying to do? An interesting thing is that I can easily make the code compile with the same meaning by changing the declaration of T to include a dummy type variable: > data T a = T it's just a pity that I have to trick the compiler in such an ugly way. Cheers, Misha

1 0

Re: [Haskell-cafe] Re: ambiguous partially defined type problem
by Maarten 15 Sep '06

15 Sep '06

Dear Brian, Maarten wrote: > Brian Hulley wrote: > > Alternatively, you could wrap the custom part within the node as in: > > data Node = forall cust. ICustom cust => Node cust Common > > getCommon :: Node -> Common > getCommon (Node cust com) = com > Thanks. This really helped. The main thing (I think) that you put the custom part behind an interface. After this I separated the custom and common part of two 'piggy bagged' state transformers, so one can access the functionality separately. The state transformers made into active object by putting them behind a channel in a separate thread and one can invoke actions by writing to the channel. The common functionality provides the connections between the active objects. In this way I would like to create some sort of 'agent' structure, that receive message and process them in their own thread. So far this works quite neat. Wonder if this is they way to go though... Only update (see code below) is a bit ugly (I have no idea why I need fixCastUpdate) and Node itself is probably not necessary, so one level of indirection could be removed. Rest is quite straight forward. Thanks again. Maarten ... (imports) data Node = forall cust. (ICustom cust) => Node cust deriving (Typeable) instance Show Node where -- just for debugging show (Node a) = "Node (" ++ show a ++ ")" class (Show a, Typeable a) => ICustom a where getVal :: forall b cust. (Typeable b, ICustom cust) => a -> (cust -> b) -> Maybe b getVal a f = case cast a of Nothing -> Nothing Just cust -> Just (f cust) -- update :: oif -> (forall a. (ObjectIFace a) => a -> a) -> IO oif update :: a -> (forall b. (ICustom b) => b -> b) -> a update a f = f a instance ICustom Node where getVal (Node n) f = getVal n f update (Node n) f = Node (update n f) type NodeState a = StateT Node (StateT Common IO) a type Connection = Chan (NodeState ()) type Connections = [Connection] instance Show Connection where show o = "Chan (StateT Node (StateT Common IO) ())" -- common part data Common = Common { uid::Integer, connections::Connections } deriving (Show,Typeable) -- custom data data Custom = Custom { val::Integer } deriving (Show,Typeable) instance ICustom Custom where data Custom2 = Custom2 { val2::Integer } deriving (Show,Typeable) instance ICustom Custom2 where -- some function to use common functionality uidM :: NodeState Integer uidM = lift $ gets uid addNodeM :: Connection -> NodeState () addNodeM n = lift $ modify (\s -> addNode s n) where addNode (Common i ns) nn = (Common i (nn:ns)) getNodeM :: Integer -> NodeState Connection getNodeM i = do s <- lift $ get return (getNode s i) where getNode (Common _ ns) i = (ns!!(fromInteger i)) getValM f = do s <- get return (getVal s f) updateM :: forall a b. (ICustom a, ICustom b) => (a -> b) -> NodeState () updateM f = do s <- get let s' = update s (fixCastUpdate f) put s' fixCastUpdate f st = case (cast st) of Nothing -> st Just es -> case cast (f es) of Nothing -> st Just g -> g getStateM = get -- function to create active node functionality action [] = return () action (e:es) = do e s <- get -- just for debugging lift $ lift $ putStrLn $ show s action es newBaseState = do uid <- newUnique return (Common ((toInteger .hashUnique) uid) []) initAction list state = do bs <- newBaseState execStateT (execStateT (action list) state) bs return () send chan action = writeChan chan action sync chan f = do mv <- newEmptyMVar send chan (f' mv) a <- takeMVar mv return a where f' mv = do a <- f lift $ lift $ putMVar mv a newActiveObject action state = do chan <- newChan cs <- getChanContents chan forkIO (action cs state) return chan -- example main = do let n1 = Node (Custom 5) let n2 = Node (Custom2 6) let n3 = Node (Custom2 7) chan <- newActiveObject initAction n1 chan2 <- newActiveObject initAction n3 let l = [chan, chan2] mapM_ (\ch -> send ch (addNodeM chan)) l mapM_ (\ch -> send ch (addNodeM chan2)) l r <- mapM (\ch -> sync ch (getNodeM 0)) l putStrLn $ "r:" ++ show r r2 <- mapM (\ch -> sync ch (uidM)) l putStrLn $ "r2:" ++ show r2 r3 <- mapM (\ch -> sync ch (getValM val)) l putStrLn $ "r3:" ++ show r3 mapM_ (\ch -> send ch (updateM (\s -> s { val2 = 100 }))) l r5 <- mapM (\ch -> sync ch (getStateM)) l putStrLn $ "r5:" ++ show r5 getChar return ()

2 3

Why is type 'b' forced to be type 'm a' and not possibly 'm a -> m a'
by Vivian McPhail 15 Sep '06

15 Sep '06

Dear Haskell Cafe, I have a problem I can't get my head around. The code below sets the problem out. What I need to be able to do is commented out. This code works, the only problem is that what I need is that an argument will be evaluated before it is passed, so ((and fries eats) eggs) has a single `eggs` (fries1 eggs2 and3 eats4 egg2) not (fries1 eggs2 and3 eats4 eggs5). The code that doesn't work is commented out at the bottom. I'm not sure the behaviour of ghc is correct, because when it typechecks it tries to unify `b = t t1` but `b` could actually be `t t1 -> t t1`. I want to be able to specify that when the first argument of `b` is of type `m a` that fork should run it and _then_ fork the argument to the first two arguments of 'fork'. The instance for (a -> b) covers the rest of the possibilities. just type "run test[1-4]" to see results. \begin{code} {-# OPTIONS_GHC -fglasgow-exts -fno-monomorphism-restriction #-} module Fork where {--------------------------------------------------------------------------- --} import Prelude hiding (and) import Control.Monad.State {--------------------------------------------------------------------------- --} data NRef = NS0 String | NS1 String NRef | NS2 String NRef NRef deriving(Show) {--------------------------------------------------------------------------- --} data UniqueS = US { nums :: [String] } deriving(Show) type USM a = StateT UniqueS IO a newUniqueS :: UniqueS newUniqueS = US { nums = [ show x | x <- [1..] ] } freshInstance :: String -> USM String freshInstance x = do (f:fs) <- gets nums put $ US { nums = fs } return $ x ++ f {--------------------------------------------------------------------------- --} single x = do x' <- freshInstance x return $ NS0 x' unary x n = do x' <- freshInstance x n' <- n return $ NS1 x' n' binary x n1 n2 = do x' <- freshInstance x n1' <- n1 n2' <- n2 return $ NS2 x' n1' n2' {--------------------------------------------------------------------------- --} foxy = single "foxy" eggs = single "eggs" golden = unary "golden" white = unary "white" fries = binary "fries" eats = binary "eats" {--------------------------------------------------------------------------- --} class Forkable a where fork :: String -> a -> a -> a instance (Forkable a, Forkable b) => Forkable (a -> b) where fork n a1 a2 a = fork n (a1 a) (a2 a) {- instance (Monad m, Forkable (m a), Forkable b) => Forkable (m a -> b) where fork n a1 a2 a = do a' <- a fork n (a1 $ return a') (a2 $ return a') -} {--------------------------------------------------------------------------- --} instance Forkable (USM NRef) where fork n a1 a2 = do a1' <- a1 a2' <- a2 return $ NS2 n a1' a2' {--------------------------------------------------------------------------- --} and = fork "and" test1 = (and foxy eggs) test2 = (and golden white) eggs test3 = (and fries eats) foxy eggs test4 = (eats foxy (and (golden eggs) (white eggs))) run x = runStateT x newUniqueS >>= (putStrLn . show . fst) \end{code -- No virus found in this outgoing message. Checked by AVG Free Edition. Version: 7.1.405 / Virus Database: 268.12.4/448 - Release Date: 14/09/2006

2 1

parsing long numbers
by Andrea Rossato 15 Sep '06

15 Sep '06

Hello! I'm trying to learn parsing and parser combinations in Haskell, using, as usual, Wadler's Monads in Functional Programming as my text book. Everything works fine except for a small but annoying problem related to "read". I'm sure it must be something easy, some kind of stupid faq. Still I'm not able to find a way out. I created a simple parser and made it an instance of monad and MonadPlus. I then created "iterateP" to combine recursive parsers, and "filterP" to apply some filters. Then I created a function "number", to parse numbers. This function returns a string and works fine. But I wanted to have integers back from parsing. So I created a filter, "digitS", and a new parser for numbers, "number1", that applies recursively digitS and should be returning an Int using "read". The problem is that, when I run it with strings containing a number more then 10 digit long, I get unexpected integers back: *Main> runP number1 "1234567890 and the rest" [(1234567890," and the rest")] *Main> runP number1 "12345678901 and the rest" [(-539222987," and the rest")] Obviously if I use Parsec I can parse that number perfectly. So I tried with another approach: "number2" recursively applies a filter, "digitI", that returns an Int. asNumber is a function that takes a list of single digit integers and returns the corresponding integer. *Main> runP number2 "12345678901 and the rest" [(Just 1234567890," and the rest")] *Main> runP number2 "12345678901 and the rest" [(Just (-539222987)," and the rest")] The very same result. Can you please help me understand why I seem not to be able to get the number I'd like to get? As I said, I think I'm missing something that must be pretty obvious, but still I cannot see it! Thanks for your kind attention. Andrea ps: sorry for such a long message. Moreover, here's the code: module Main where import Control.Monad import Data.Char newtype M a = S {unpack :: String -> [(a,String)]} instance Monad M where return a = S $ \s -> [(a,s)] m >>= f = S $ \s -> [(b,z) | (a,y) <- unpack m s, (b,z) <- unpack (f a) y] instance MonadPlus M where mzero = S $ \x -> [] mplus a b = a `bchoice` b bchoice (S m) (S m1) = S $ \s -> case m s of [] -> m1 s other -> other iterateP m = do { a <- m ; b <- iterateP m ; return (a:b) } `mplus` return [] filterP p = S (\xs -> case xs of [] -> [] (x:xs') -> if p x then [(x,xs')] else []) number = do { a <- filterP isDigit ; b <- number ; return (a:b) } `mplus` return [] digitS = do a <- filterP isDigit return a number1 :: M Int number1 = do a <- iterateP digitS return (read a) -- a different approach maybeAdd a b = do x <- a y <- b return (x + y) asNumber :: [Int] -> Maybe Int asNumber [] = Nothing asNumber (x:[]) = Just x asNumber (x:xs) = Just (x * 10 ^ length xs) `maybeAdd` asNumber xs digitI = do a <- filterP isDigit return $ ord a - ord '0' number2 :: M (Maybe Int) number2 = do a <- iterateP digitI return $ asNumber a runP (S f) = f

2 1

evaluate vs seq
by Michael Shulman 15 Sep '06

15 Sep '06

The GHC documentation says that (evaluate a) is not the same as (a `seq` return a). Can someone explain the difference to me, or point me to a place where it is explained? Mike

4 13

Optimization problem
by Rohan Drape 15 Sep '06

15 Sep '06

> > splitStreams [(3,x),(1,y),(3,z),(2,w)] > [(3,[x,z]),(1,[y]),(2,[w])] [snip] > Furthermore it should work on infinite lists. It can't eat the whole > list before producing any output. This doesn't seem to make sense? Only at the end of the list can you know that you've collected all the events for each channel. If you output anything before scanning to the end, you'd not know if there were perhaps more events on that channel? You could accumulate only over a window, which would produce values on an infinite input, though the output list could have multiple packets for each channel. splitterW 3 [(3,x),(1,y),(3,z),(2,w),(3,v)] > [(3,[x,z]),(1,[y]),(2,[w]),(3,[v])] Or accumulate until either there are 'n' messages on a channel or the end of the list is reached? splitterN 3 [(3,x),(1,y),(3,z),(2,w),(3,v),(1,u),(3,t)] > [(3,[x,z,v]),(1,[y,u]),(2,[w]),(3,[t])] Regards, Rohan

3 4

Anonymous types
by Thomas Conway 15 Sep '06

15 Sep '06

Hi all, Is there any deep and meaningful reason why Haskell doesn't have anonymous discriminated union types? I'm thinking of an example like: data Amount = Amount Integer (Mg|G|Kg|T) Now this particular case is perhaps unconvincing - a seperate Units type would be quite sensible, however I'm thinking of translating ASN.1 definitions into Haskell. ASN.1 allows SEQUENCE (record types) and CHOICE (discriminated unions) as a kind of type constructor. Not having to invent names for anonymous SEQUENCE and CHOICE types would be nice. T.

2 1

Bit string
by Thomas Conway 15 Sep '06

15 Sep '06

Hi all, I'm doing some work with ASN.1, and I'm thinking about how to represent the type "BIT STRING". The obvious, and inefficient representation would be > type BitString = [Bool] A reasonable sparse representation might be > type BitString = [Integer] where the integers represent the positions of the non-zero bits, but other implementations (e.g. C & C++ based ones) mostly seem to use dense representations, and there are certain predictability advantages to be had by following existing implementations in this regard. But given that a value of type BIT STRING is allowed to have leading 0 bits, which have no semantic effect, another representation would be > type BitString = [Word64] (I'm a modern type, and believe in 64bit computing ;-), but you could use Word32 if you liked). However, after a few moments' consideration, I realized, that if I was going to use a representation like that, I could probably use > type BitString = Integer which already has [I assume] a carefully optimized implementation. Also, it ends up being significantly more strict than a list representation, which is probably a good thing in most situations. My question for all present is: Have I missed either a problem with using Integer, or have I overlooked a better representation? T.

5 5

ambiguous partially defined type problem
by Maarten 14 Sep '06

14 Sep '06

Dear all, For a project involving I use some partially defined node (in this case a simple record, in my project state transformers) in which the defined part is common to all nodes, and the custom part is different for each node. They have to become anonymous so I can put them in a list of connections from each node to another. For some reason GHC complains of 'ambigous type variable' in the code below. The thing is, part of the code may be undefined, but since I'm (explicitly) not using that part, why would GHC care? Are there other solutions to this problem? Any pointers or comments appreciated. Thanks. Maarten (This code is just some dummy code that contains the essence of the problem. I posted the complete code with piggy bagged state transformers in active objects on haskell(a)haskell.org, but that is rather long and this seems to be the correct mailing list). -- data structure with custom and common part data Node cust = Node cust Common deriving (Show,Typeable) -- anonymous data structure to put use in list data AN = forall ar. (Show ar, Typeable ar) => AN ar instance Show AN where show (AN an) = "AN (" ++ show an ++ ")" -- common part data Common = Common Integer deriving (Show,Typeable) data Custom = Custom Integer deriving (Show,Typeable) data Custom2 = Custom2 Integer deriving (Show,Typeable) -- extract common part, ignoring type of custom part getCommon :: forall gc. (Node gc) -> Common getCommon (Node cust com) = com main = do let a = AN (Node (Custom 5) (Common 10)) let b = case a of (AN a') -> getCommon (case (cast a') of Just a'' -> a'') putStrLn $ "ok:" ++ show b

3 2

program execution and laziness
by Tim Newsham 14 Sep '06

14 Sep '06

I'm having a problem with program execution in win32 which seems to be tied to laziness. The function I'm using is: runCmd cmd outdir dir base ext = do let argv = words cmd (i,o,e,p) <- runInteractiveProcess (head argv) (drop 1 argv) Nothing Nothing hClose i out <- hGetContents o -- print out x <- waitForProcess p hClose o hClose e case x of ExitSuccess -> return 0 (ExitFailure n) -> return n this is hanging indefinitely when I run it in win32. If I add in the print statement (commented out above) it works fine! So I can only imagine that waitForProcess is hanging when I haven't drained the stdout stream. How can I force hGetContents to be strict (or at least to completely process the stream prior to the waitForProcess command)? Tim Newsham http://www.thenewsh.com/~newsham/

4 3