- Haskell-Cafe - Haskell.org

Is StateT what I need?
by Andre Nathan 19 Dec '07

19 Dec '07

Hello (Newbie question ahead :) I'm trying to write a program which will build a tree (here represented as a Map) of unix processes. The tree should be built by reading the process information stored in /proc/PID/status. There is also another Map which will be used for faster insertions on the process tree, which I'd like to handle as my program state. So far I have the functions to get a list of entries from /proc, filter the ones that represent processes and get the information from their status file. Now I need an "insertProc" function, which should get the information for a given process ID, update the state and return that information. This is where I think I need StateT, but I couldn't find out how to use it (never used StateT before...). This is what I have so far: > type Pid = FilePath > type Uid = String > > type PsData = Map String Uid > type PsChildren = Map Pid PsInfo > > data PsInfo = PsInfo PsData PsChildren > type PsMap = Map Pid PsInfo > type PsTree = Map Pid PsInfo > > parent :: PsData -> Pid > parent psData = fromJust $ Map.lookup "PPid" psData > > getProcInfo :: PsData -> String -> IO PsData > getProcInfo psData line = do > case matchRegex (mkRegex "^([a-z]+):[[:space:]]+(.*)$") line of > Nothing -> return (psData) > Just [key, value] -> return (Map.insert key value psData) > > procInfo :: Pid -> IO PsInfo > procInfo pid = do > procData <- readFile $ "/proc/" ++ pid ++ "/status" > psData <- foldM getProcInfo Map.empty (lines procData) > let [rUid, eUid, _] = words $ fromJust (Map.lookup "Uid" psData) > let [rGid, eGid, _] = words $ fromJust (Map.lookup "Gid" psData) > let uids = Map.fromList [("RUid", rUid), ("EUid", eUid), > ("RGid", rGid), ("EGid", eGid)] > let psData' = Map.union psData uids > return (PsInfo psData' Map.empty) I tried this for insertProc, but it obviously doesn't work... what would be the correct way to do this? > insertProc :: Pid -> StateT PsMap IO PsInfo > insertProc pid = do > proc <- procInfo pid -- XXX this is obviously wrong... > psMap <- get > put (Map.insert pid proc psMap) > return (proc) A second question: is it possible to make getProcInfo's type to be PsData -> String -> PsData and use some operation similar to lift so that it can be used with foldM, instead of making its return type to be IO PsData explicitely? Thanks in advance, Andre

11 17

Re: [Haskell-cafe] New to Haskell
by Miguel Mitrofanov 19 Dec '07

19 Dec '07

> What I should have been told about upfront: > - the syntax for an expression > - the syntax for a block Don't see your point. > - the adhoc syntax rules (how to distinguish among a tuple and a > pharanthesized expression and how to find the start and end of a block for > example ) Oh, that's pretty easy, parenthesized expression is not divided by a comma. > - what guarantees are made by the LANGUAGE that an IO action (such as do > putStrLn "Hello world" ) is not performed twice There are no such guarantees. If you write a = putStrLn "Hello world" main = do {a; a;} then your putStrLn would be performed twice. IO actions are first-class values, that's a feature, not a bug. > - the lambda expressions can be written (input) but cannot be printed > (output) Yes, since two different lambda expressions can denote the same function. > Here is some strange example: > module Hugs where > aa::Int > aa=7 > cc:: (Int->Int)->(Int->Int->Int)->Int->(Int->Int) > cc a op b = \x-> case x of { _ | x==aa -> x+1 ; _-> a x `op` b } > f::Int->Int > f(1)=1 > f(2)=2 > f(_)=3 > g::Int->Int > g(1)=13 > g(2)=23 > g(_)=33 > h::[Int->Int] -> Int ->Int > h [] x = x > h [rr] x = let { u=Hugs.f ; v=Hugs.g } in case rr of { u -> > Hugs.g(x)+aa ; v -> Hugs.f(x)+aa ; _ ->rr (x) + aa } > h (rr:ll) x = h [rr] x + h (ll) x > What I don't understand is why I'm forced to use guards like x==aa in cc, > when aa is clearly bounded (is 7) and why in function h, the bounded u and > v become free variables in the case expression. No, pattern matching bounds variables; if you write "case x of {aa -> ...} then aa becomes a LOCAL variable for the case statement, and shadows the global definition. The same applies to u and v in h, except that in this case local variables shadow upper-level local variables.

7 18

New to Haskell: The End
by Cristian Baboi 19 Dec '07

19 Dec '07

Haskell strengts as I see them: - it is "lazy with class" - it is strongly typed - it has automatic memory management - it has a standard library - it has a compiler - it is available on several platforms - it has a community - it is free Is there anything you would like to add ? ________ Information from NOD32 ________ This message was checked by NOD32 Antivirus System for Linux Mail Servers. part000.txt - is OK http://www.eset.com

9 9

Haskell purity and printing
by Cristian Baboi 18 Dec '07

18 Dec '07

This is what I "understand" so far ... Suppose we have these two values: a) \x->x + x b) \x->2 * x Because these to values are equal, all functions definable in Haskell must preserve this. This is why I am not allowed to define a function like h :: (a->b) -> (a->b) h x = x The reasons are very complicated, but it goes something like this: - when one put \x->x+x trough the function h, the compiler might change it to \x -> 2*x - when one put \x->2*x trough the function h, the compiler might change it to \x -> x + x And we all know that \x -> 2*x is not the same as \x->x+x and this is the reason one cannot define h in Haskell

5 6

[ANN] Wadler talk in San Francisco on Jan 9, 2008
by Keith Fahlgren 18 Dec '07

18 Dec '07

Hi all, Philip Wadler will be in San Francisco for POPL '08 so the Bay Area Functional Programmers have asked him to reprise his ICFP '07 talk "Well-typed programs can’t be blamed". He's been good enough to set us up with a proper room in the ACM conference hotel. The meeting will take place in the Stanford Room, The Stanford Court Hotel, San Francisco at 7:30pm on Wednesday, January 9th, 2008. Please watch http://groups.google.com/group/bayfp or http://www.bayfp.org/blog/ for more details and pass this along to others in the area that might be interested. Thanks, Keith

1 0

A Show instance for simple functions
by Benja Fallenstein 18 Dec '07

18 Dec '07

Hi all, Below is a program that implements Show for functions whose type is composed of only (->) and type variables (or, more precisely, of (->) and (State Int Term), but any type composed of (->) and type variables can obviously be specialized to that). (-fglasgow-exts is needed only for the convenience of being able to declare "instance MkTerm (State Int Term)" -- if we'd wrap the State Int Term in a newtype, as far as I can see this would be H98.) - Benja {-# OPTIONS_GHC -fglasgow-exts #-} import Control.Monad import Control.Monad.State import Data.Char data Term = Var Int | App Term Term | Lam Int Term showVar i = [chr (ord 'a' + i)] showTerm :: Term -> String showTerm (Var i) = showVar i showTerm (Lam i x) = "\\" ++ showVar i ++ " -> " ++ showTerm x showTerm (App f x) = showTerm f ++ " " ++ showArg x where showArg (Var i) = showVar i; showArg x = "(" ++ showTerm x ++ ")" class MkTerm a where argument :: State Int Term -> a mkTerm :: a -> State Int Term instance MkTerm (State Int Term) where argument = id mkTerm = id instance (MkTerm a, MkTerm b) => MkTerm (a -> b) where argument f x = argument $ liftM2 App f (mkTerm x) mkTerm f = do i <- get; modify (+1) body <- mkTerm (f (argument (return (Var i)))) return $ Lam i body instance (MkTerm a, MkTerm b) => Show (a -> b) where show f = showTerm $ evalState (mkTerm f) 0 type X = State Int Term main = do print (id :: X -> X) print (id :: (X -> X) -> (X -> X)) print ((.) :: (X -> X) -> (X -> X) -> (X -> X)) print ((\x y -> y x) :: X -> (X -> X) -> X) print ((\f x -> f x x) :: (X -> X -> X) -> X -> X) print ((\f -> f id id) :: ((X -> X) -> (X -> X) -> X) -> X)

1 0

OOP'er with (hopefully) trivial questions.....
by Nicholls, Mark 18 Dec '07

18 Dec '07

I'm trying to teach myself Haskell....I've spent a few hours going through a few tutorials....and I sort of get the basics... My interest in Haskell is specifically around the strength of the type system. After many years of OOP though my brain is wired up to construct software in that 'pattern'....a problem for me at the moment is I cannot see how to construct programs in an OO style in Haskell....I know this is probably not the way to approach it...but I feel I need to master the syntax before the paradigm. I'm not fussed about mutability, and I'm not fussed about implementation inheritance (as apposed to subtyping).... my concerns are encapsulation of 'state' and abstraction, and extension/expansion....a simple example would be. interface IShape { Int GetArea(); } class Square : IShape { Readonly int length; Public Square(int length) { this.length = length; } Int GetArea() { return length * length;} } Class Rectangle : IShape { Readonly int lengthA; Readonly int lengthB; Public Rectangle (int lengthA,int lengthB) { this.lengthA = lengthA; this.lengthB = lengthB; } Int GetArea() { return lengthA * lengthB;} } Class Circle : IShape { Readonly int radius; Public Circle(int radius) { this.radius = radius; } Int GetArea() { return pi * radius * radius;} } Client code..... Void Foo(IShape shape) { // look!....I know nothing except its of type IShape. Int area = shape.GetArea(); } I can obviously at a later date add a new class Triangle, and not have to touch any of the above code....

28 52

Foldable Rose Trees
by Dominic Steinitz 18 Dec '07

18 Dec '07

I've been trying to re-label nodes in a rose tree without re-inventing wheels (although I'm beginning to wish I had). I've got as far as this but haven't yet cracked the general case for Traversable. Any help would be much appreciated. Thanks, Dominic. > *Main> let (p,_) = runState (unwrapMonad (traverse (\x -> WrapMonad update) (Rose' 3 [Rose' 5 [Rose' 11 [Rose' 19 []], Rose' 13 [], Rose' 17[]], Rose' 7 []]))) 0 in p > Rose' 0 [Rose' 1 [Rose' 2 [Rose' 3 []],Rose' 4 [],Rose' 5 []],Rose' 6 []] > import Control.Applicative > import Data.Foldable > import Data.Traversable > import Data.Monoid > import Control.Monad.State > > update :: MonadState Int m => m Int > update = > do x <- get > put (x + 1) > return x > > data Rose' a = Rose' a [Rose' a] > deriving Show > > instance Functor Rose' where > fmap f (Rose' x rs) = Rose' (f x) (map (fmap f) rs) > > instance Foldable Rose' where > foldMap f (Rose' x rs) = f x `mappend` (mconcat (map (foldMap f) rs)) > > instance Traversable Rose' where > traverse f (Rose' x []) = Rose' <$> f x <*> pure [] > traverse f (Rose' x [x0]) = Rose' <$> f x <*> (pure (\x -> [x]) <*> traverse f x0) > traverse f (Rose' x [x0,x1]) = Rose' <$> f x <*> (pure (\x y -> x:y:[]) <*> traverse f x0 <*> traverse f x1) > traverse f (Rose' x [x0,x1,x2]) = Rose' <$> f x <*> (pure (\x y z -> x:y:z:[]) <*> traverse f x0 <*> traverse f x1 <*> traverse f x2)

2 2

list utilities -- shouldn't these be in the hierarchical libs somewhere?
by Thomas Hartman 18 Dec '07

18 Dec '07

I found http://haskell.cs.yale.edu/haskell-report/List.html had many useful "one off" type list functions such as "subsequences" and "permutations" which are nowhere to be found in hoogle, Data.List, or the haskell hierarchical libs Shouldn't these be included somewhere? thomas. --- This e-mail may contain confidential and/or privileged information. If you are not the intended recipient (or have received this e-mail in error) please notify the sender immediately and destroy this e-mail. Any unauthorized copying, disclosure or distribution of the material in this e-mail is strictly forbidden.

3 2

New to Haskell
by Cristian Baboi 18 Dec '07

18 Dec '07

A few days ago, for various reasons, I've started to look at Haskell. At first I was quite impressed, after reading some FAQ, and some tutorials. Evrything was nice and easy ... until I've started writing some code on my own. What I should have been told about upfront: - the syntax for an expression - the syntax for a block - the adhoc syntax rules (how to distinguish among a tuple and a pharanthesized expression and how to find the start and end of a block for example ) - the fact that lambda expressions are not the same thing as "algebraic data" values - what guarantees are made by the LANGUAGE that an IO action (such as do putStrLn "Hello world" ) is not performed twice - the lambda expressions can be written (input) but cannot be printed (output) The biggest problem for me, so far, is the last one. Here is some strange example: module Hugs where aa::Int aa=7 cc:: (Int->Int)->(Int->Int->Int)->Int->(Int->Int) cc a op b = \x-> case x of { _ | x==aa -> x+1 ; _-> a x `op` b } f::Int->Int f(1)=1 f(2)=2 f(_)=3 g::Int->Int g(1)=13 g(2)=23 g(_)=33 h::[Int->Int] -> Int ->Int h [] x = x h [rr] x = let { u=Hugs.f ; v=Hugs.g } in case rr of { u -> Hugs.g(x)+aa ; v -> Hugs.f(x)+aa ; _ ->rr (x) + aa } h (rr:ll) x = h [rr] x + h (ll) x What I don't understand is why I'm forced to use guards like x==aa in cc, when aa is clearly bounded (is 7) and why in function h, the bounded u and v become free variables in the case expression. ________ Information from NOD32 ________ This message was checked by NOD32 Antivirus System for Linux Mail Servers. part000.txt - is OK http://www.eset.com

5 7