December 2007 - Haskell-Cafe

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

19 Dec '07

> >> As a user, I just want to be able to spot the basic components of a > >> source > >> file without thinking about transformation rules. > > Well, most users are. > Are what ? Sorry if I've confused you. English isn't my native language. "Are able", of course. > Have you asked them all ? If you're unsure, we can vote here or somewhere else. > >> Is this legal (`plus`) x y ? > > > > Never tried to write this myself, it looks stupid. > What else haven't you tried to write by know ? Well, I hope, I haven't tried to write the most of stupid-looking things. > > What kind of guarantees do you want? > Written in blood. Write it yourself, I don't have too much blood. > >> I just want the sistem to be able to print one of these expressions ! > >> Its this too much to ask ? > > Yes, 'cause it means you want to embed almost all source code into the > > compiled program. > So ? So, I don't know any compiler of any language which does it.

5 4

ANN: SearchPath v0.9
by Alex Jacobson 19 Dec '07

19 Dec '07

SearchPath v0.9 does recursive module chasing accross the internet using a combination of mapfiles you provide and the default map file, caching the downloaded modules in a local directory. Searchpath can handle modules in module hierarchies based at a URLs, in tgz archives accessible via URL, and in accessible darcs/svn/cvs etc repos at particular tags. New in v0.9 * handling tagged darcs/svn repos * handling .tgz archives * massive code cleanup * substantially faster * easier/better command line options * better usage documentation * handling non-local haskell files Check it out at http://searchpath.org. -Alex-

1 0

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 18 Dec '07

18 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