- Haskell-Cafe - Haskell.org

Re: [Haskell-cafe] Re: Editors for Haskell
by Imam Tashdid ul Alam 09 Jun '06

09 Jun '06

hya this topic is hot, and I wonder why :s well, I've been thinking, the EclipseFP people have done more or less a fine job (I'm trying their "live" build, things feel natural). but the problem is, to build something like EclipseFP you have to know both Java and Haskell and on top of that you have to be very familiar with the Eclipse plug-in architecture. whining: - should have had folds for where and let clauses - the error messages are still cryptic (and unformatted!) - there was no tooltip for functions - the default color chosen for functions is way too bright - ... (many silly Java expectations follow) but what if we _ask_ eclipse.org to help us out? like, an official collaboration? they have done an excellent job promoting free software. this should be sort of a recognition for them. the point is, GUI _is_ easier to build in Java. and those people are experts. should not take much time. as for me, I'll be happy to watch the impact Haskell will have on Java fans. two things just to make sure this post is not absolutely superfluous: - without drinking anything I was feeling drunk that night and so I posted some of my hIDEous thoughts in http://www.haskell.org/haskellwiki/Talk:HIDE page. Lemmih left a note saying I was not so genuine, a project called Proxima has implemented (or at least, proposed) most of the ideas. I checked it out and was ashamed of my lack of original idea. however, though the paper was absolutely dreamy, the implementation,.. how do I put it humbly.. sucked. I am sure the Eclipse people will appreciate the Proxima ideas. please ask them to build a Proxima style IDE for Haskell. - about formatted error messages (I am sure you guys don't care), could someone build a light GHC front end that given a .hs/.lhs file produces two XML files with specified DTD, the parsed structure and the error messages? the reason for choosing XML is that not only the Java people (including Leif Frenzel) but also virtually anyone can access these information (in order to create a great IDE) immediately and without loosing the structure. cheers, Imam __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

4 3

Type class hell
by Christophe Poucet 08 Jun '06

08 Jun '06

Dear, I am writing a compiler (as you may have gathered from some previous messages). Anyways I am stuck with a small monadic issue. I mostly use indirect composite as this gives me the most flexibility with regards taking out parts of the AST, or decorating at whim. Basically the question regards how to implement a certain instance. Currently I have the code that can be seen below. What I would like to do is combine HasVars and Type (mostly because in my framework the two concepts shouldn't be divided from a design perspective) into one type class to clean it up a bit. However I fail to see how I would implement toType and fromType for the given instance. Is this feasible without resorting to ugly hacks? --- Types data MonoType mt = TyVar Var | TyConst Const [mt] deriving (Eq, Show) data PolyType mt = TyPoly [Var] mt deriving (Show) class Type mt where toType :: mt -> MonoType mt fromType :: MonoType mt -> mt class HasVars a where freeVars :: a -> [Var] occurs :: Var -> a -> Bool toPoly :: (HasVars a) => a -> PolyType a toPoly x = TyPoly (freeVars x) x instance HasVars a => HasVars (MonoType a) where freeVars (TyVar x) = [x] freeVars (TyConst _ xs) = nub . concatMap freeVars $ xs occurs x (TyVar y) = x == y occurs x (TyConst _ xs) = or . map (occurs x) $ xs Cheers, Christophe(vincenz) -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

5 10

Editors for Haskell
by Walter Potter 08 Jun '06

08 Jun '06

All, I hope that this is the right place for this question. I'm using Haskell (GHC and Hugs) on several different platforms. Windows, OS X and Linux systems. I'd like to have an IDE that works well for medium to large size projects. I know of Eclipse and hIDE. Vim works fine but I'd like more. hiDE seems to be "in process." What would you suggest? I'll be asking my students to use the same IDE. Thanks, Walt

16 22

HAppS in production?
by Joel Reymont 07 Jun '06

07 Jun '06

Folks, Is anyone using HAppS in production right now? It seems to be the most advanced Haskell web development platform right now but I would like to hear about others as well. Production (heavy) use is what I'm looking for. Thanks, Joel -- http://wagerlabs.com/

2 5

Eclipse and Haskell
by Walter Potter 07 Jun '06

07 Jun '06

All, I intend to start using Eclipse as my IDE. Please pass along any suggestions that I may find useful. Thanks, Walt

4 3

Polymorphic Sudoku solver
by Chris Kuklewicz 07 Jun '06

07 Jun '06

A while back there was a long thread about Sudoku solvers (some of which ended up on http://haskell.org/haskellwiki/Sudoku ). I contributed my brute-force dancing links solver at the time, and mentioned that I had a by-logic solver that, while a bit slow, was as good as most of those being discussed. At the time the code for my solver was too ugly to post. Attached is a cleaned up version. I have gone back and rewritten it, and come to the conclusion: There are only two deduction algorithms: "subsets" and "blocks". These subsume the other types of propagation and deduction. So I made this version as a "minimalist" example instead of going for performance. The "subsets" algorithm can be applied to all 6 permutations of row column and value, as well as 1 special case of value and block indices. The "blocks" algorithm can be applied 4 ways (in two flavors and to either permutation of row/column or column/row). There are newtypes for row, column, value, block index, and sub-block index. The state is held in an array of type DiffArray (R,C,V) Bool The actual computation is a series of concat/map/filter/group/sort operations on the assocs's of the array. The choice of which permutation is handled by leaning on the type system to reify the type into appropriate view,shuffle, and unshuffle functions. It should solve exactly the same number of puzzles as my older version, where "I sent the 36628 line sudoku17 puzzle through it and it could solve 31322 of the puzzles, leaving 5306 resistant." -- Chris Kuklewicz module Main (main) where import Data.Ix(inRange,range) import Data.Char(intToDigit,digitToInt) import Deduce(deduce,lo,hi) loC = intToDigit lo hiC = intToDigit hi unsetC = pred loC main = do all <- getContents let puzzles = zip [1..] (map parseBoard (lines all)) act (i,p) = do p' <- deduce p return (i,length p,length p') mapM_ (\ip -> act ip >>= print) puzzles parseBoard :: String -> [(Int,Int,Int)] parseBoard s = map toHint justSet where rcs = [ (r,c) | r <- range (lo,hi), c <- range (lo,hi) ] isHint vC = inRange (loC,hiC) vC justSet = filter (isHint . snd) (zip rcs s) toHint ((r,c),vC) = (r,c,digitToInt vC) {- By Chris Kuklewicz <haskell(a)list.mightyreason.com> -} module Deduce (deduce,lo,hi) where {- The exposed function deduce takes a list of (row,column,value) tuples that are the known parts of the solutions and returns a (hopefully longer) list in the same format. The indices can be any enumerated type in the range (lo,hi). -} import Data.Array.Diff (assocs,(!),(//),ixmap,range,inRange,accumArray,DiffArray,Ix) import Data.List(sortBy,groupBy,transpose,(\\)) import Control.Monad(liftM,guard) default () -- Typesafe values for indices -- This machinery allows for more type safety than if R,C,V,B,D were all Int or Char type E = Int newtype R = R E deriving (Eq,Ord,Ix,Enum,Show) -- Row index newtype C = C E deriving (Eq,Ord,Ix,Enum,Show) -- Column index newtype V = V E deriving (Eq,Ord,Ix,Enum,Show) -- Value index newtype B = B E deriving (Eq,Ord,Ix,Enum,Show) -- 3x3 Block index newtype D = D E deriving (Eq,Ord,Ix,Enum,Show) -- Inside 3x3 Block index lo,hi :: (Enum a) => a lo = toEnum 1 hi = toEnum 9 fullRange :: (Enum a,Ix a) => [a] fullRange = range (lo,hi) rcToBD (R r) (C c) = let (rq,rm) = quotRem (r-lo) 3 (cq,cm) = quotRem (c-lo) 3 b = lo + ( 3*rq + cq ) d = lo + ( 3*rm + cm ) in (B b, D d) bdToRC (B b) (D d) = let (bq,bm) = quotRem (b-lo) 3 (dq,dm) = quotRem (d-lo) 3 r = lo + ( 3*bq + dq ) c = lo + ( 3*bm + dm ) in (R r, C c) -- Typeclasses and Data for "shuffle" and "unshuffle" class (Show x, Ix x, Enum x, Ord x) => IE x instance IE R; instance IE C; instance IE V; instance IE B; instance IE D data Perms a b c = Perms { shuffle' :: (R,C,V) -> (a,b,c) , unshuffle' :: (a,b,c) -> (R,C,V) } -- Reify the types "a b c" to a value of type Perms class (IE a, IE b, IE c) => Perm a b c where perm :: Perms a b c instance Perm R C V where perm = Perms id id instance Perm R V C where perm = Perms (\ (r,c,v) -> (r,v,c)) (\ (r,v,c) -> (r,c,v)) instance Perm C V R where perm = Perms (\ (r,c,v) -> (c,v,r)) (\ (c,v,r) -> (r,c,v)) instance Perm C R V where perm = Perms (\ (r,c,v) -> (c,r,v)) (\ (c,r,v) -> (r,c,v)) instance Perm V R C where perm = Perms (\ (r,c,v) -> (v,r,c)) (\ (v,r,c) -> (r,c,v)) instance Perm V C R where perm = Perms (\ (r,c,v) -> (v,c,r)) (\ (v,c,r) -> (r,c,v)) -- Special cases instance Perm B D V where perm = Perms (\ (r,c,v) -> let (b,d) = rcToBD r c in (b,d,v)) (\ (b,d,v) -> let (r,c) = bdToRC b d in (r,c,v)) instance Perm V B D where perm = Perms (\ (r,c,v) -> let (b,d) = rcToBD r c in (v,b,d)) (\ (v,b,d) -> let (r,c) = bdToRC b d in (r,c,v)) shuffle :: (Perm a b c) => (R,C,V) -> (a,b,c) shuffle = shuffle' perm unshuffle :: (Perm a b c) => (a,b,c) -> (R,C,V) unshuffle = unshuffle' perm -- Array types, values and functions type Index = (R,C,V) type Cell = Bool on,off :: Cell on = True -- Means this might be part of the solution off = False -- Means this cannot be part of the solution boundsCube :: (Perm a b c) => ((a,b,c),(a,b,c)) boundsCube = ((lo,lo,lo),(hi,hi,hi)) type Cube = DiffArray Index Cell emptyCube :: Cube emptyCube = accumArray const on boundsCube [] type View a b c = DiffArray (a,b,c) Cell {-# INLINE view #-} view :: (Perm a b c) => Cube -> View a b c view cube = ixmap boundsCube unshuffle cube type Hints = [(Index,Cell)] isOn :: (Perm a b c) => View a b c -> [(a,b,c)] isOn = map fst . filter snd . assocs -- The goal is to create functions that turn the current Cube into a -- list of Hints. These Hints will be purely subtractive: they all -- turn a Cell from 'on' to 'off'. type Rule = Cube -> Hints -- Small utility functions fst3 (x,_,_) = x; snd3 (_,x,_) = x; thd3 (_,_,x) = x fst4 (x,_,_,_) = x; snd4 (_,x,_,_) = x; thd4 (_,_,x,_) = x; fth4 (_,_,_,x) = x by un bi = (\ left right -> (un left) `bi` (un right)) sortWith un = sortBy (by un compare) groupWith un = groupBy (by un (==)) groupSort un = groupWith un . sortWith un atLeastOne = not . null atLeastTwo (_:_:_) = True; atLeastTwo _ = False exactlyOne [_] = True; exactlyOne _ = False oneOrTwo [_] = True; oneOrTwo [_,_] = True; oneOrTwo _ = False {- ruleBlock1 : When operating on Perm V R C: Given a value V, look along each row and see which blocks that value may occupy. Find a row R1 for which the value is allowed in exactly one block B1 (an no other blocks). This occupies [(B1,d)] in B1. Eliminate V from the other locations in B1. Given a value V, look along each row and see which blocks that value may occupy. Find two rows [R1,R2] for which the value only is allowed in exactly the same two blocks [B1,B2] (and no others). These occupy [(B1,d11s)] in R1, [(B2,d12s)] in R1, [(B1,d21s)] in R2, and [(B2,d22s)] in R2. Eliminate V from the other locations in B1 and the other locations in B2. Works for R and C reversed, of course. -} {- ruleBlock2 : When operating on Perm V R C: Given a value V, look inside each block and see which rows that value may occupy. Find a block B1 for which only one row R1 is occupied (and no other rows). This occupies [(R1,c11s)] in B1. Eliminate V from all the other c's in row R1. Given a value V, look inside each block and see which rows that value may occupy. Find two blocks [B1,B2] for which the value only is allowed in exactly the same two rows [R1,R2] (and no others). These occupy [(R1,c11s)] in B1, [(R1,c12s)] in B2, [(R2,c21s)] in B1, and [(R2,c22s)] in B2 for some C's. Eliminate V from the other rows in R1 and the other columns in R2. Works for R and C reversed, of course. -} {- ruleBlockP There is enough similarity between ruleBlock1 and ruleBlock2 to parameterize over expand and contract. The V index is special because it is "orthogonal" to the 3x3 blocks. The line sVsA2 = map (filter atLeastTwo) $ sVsA -- drop unique ones is used to prevent propagating solved constraints, as rule4P should already do this in its k==1 case. (assocs view) becomes useful hints through a chain of map, sort, group, filter, and concat operations. The assemble function also takes care to remove redundant hints by consulting the view. -} {-# INLINE ruleBlockP #-} ruleBlockP :: forall a b c x y . (IE a, IE b, IE c, Perm V x y) => ( (V,x,y) -> (V,a,b,c) ) -- "expand" -> (V -> b -> [c] -> [Index]) -- "contract" -> View V x y -> Hints ruleBlockP expand contract view = let allOn :: [(V,a,b,c)] allOn = map expand . isOn $ view sV :: [ [(V,a,b,c)] ] sV = groupWith fst4 $ allOn -- group by V sVsA :: [[ [(V,a,b,c)] ]] sVsA = map (groupSort snd4) $ sV -- group by a sVsAsB,sVsAsB2 :: [[[ [(V,a,b,c)] ]]] sVsAsB = map (map (groupSort thd4)) $ sVsA -- group by b -- These filters are to remove empty and redundantly full possibilities sVsAsB2 = filter atLeastOne . map (filter oneOrTwo) $ sVsAsB sVsAsBgB :: [[ ([b],[[(V,a,b,c)]]) ]] -- The filter is to remove solved parts of the puzzle (punt to ruleSubsetP) sVsAsBgB = map (map getAllB . filter (atLeastTwo . concat)) $ sVsAsB2 where getAllB :: [[(V,a,b,c)]] -> ([b],[[(V,a,b,c)]]) getAllB vabcss = (map (thd4 . head) vabcss, vabcss) -- length (concat vabcss) >= 2 useful :: [ [([b],[[(V,a,b,c)]])] ] useful = concatMap (filter exactlySame . groupSort fst) $ sVsAsBgB where exactlySame :: [([b],[[(V,a,b,c)]])] -> Bool exactlySame sas@((sbs,_):_) = length sas == length sbs assemble :: [ ([b],[[(V,a,b,c)]]) ] -> Hints assemble stuff = [ (rcv,off) | rcv <- ixs, (view ! shuffle rcv) /= off ] where byVB :: [[(V,a,b,c)]] byVB = map concat . transpose . map snd $ stuff -- Regroup by identical 'b' -- byVB = groupSort thd4 . concat . concat . map snd $ stuff -- equivalent act :: [(V,a,b,c)] -> [Index] act allVB@((v,_,b,_):_) = contract v b (fullRange \\ map fth4 allVB) ixs :: [Index] ixs = concatMap act byVB in concatMap assemble useful {-# INLINE ruleBlock1 #-} ruleBlock1 :: (Perm V x y) => View V x y -> Hints ruleBlock1 = ruleBlockP expand contract where expand all@(v,x,y) = let (r,c,_) = unshuffle all (b,d) = rcToBD r c in (v,x,b,d) contract v b ds = map undo ds where undo d = let (r,c) = bdToRC b d in (r,c,v) {-# INLINE ruleBlock2 #-} ruleBlock2 :: (Perm V x y) => View V x y -> Hints ruleBlock2 = ruleBlockP expand contract where expand all@(v,x,y) = let (r,c,_) = unshuffle all (b,_) = rcToBD r c in (v,b,x,y) contract v x ys = map undo ys where undo y = unshuffle (v,x,y) ruleBlocks :: [Rule] ruleBlocks = [ (\ known -> ruleBlock1 (view known :: View V R C) ) , (\ known -> ruleBlock1 (view known :: View V C R) ) , (\ known -> ruleBlock2 (view known :: View V R C) ) , (\ known -> ruleBlock2 (view known :: View V C R) ) ] {- Given a list of locations, such as for the 9 columns of a row, look at the allowed values at each location. Find a subset of k columns for which the union of their allowed values [V..] has length k. Then eliminate [V..] from the (9-k) other columns. This clearly finds a list of N columns each with the same N values if such a thing exists, so it subsumes rule1P. This is fully symmetric in R C and V and depends on the constaints in R and V but not C. So the (View B D V) case also works. A useful property of this rule is that once there is only one way to place a value in a row or column or block then it will propagate that solution to the related contraints. This is the case when minK is 1. -} {-# INLINE ruleSubsetP #-} ruleSubsetP :: forall a b c.(Perm a b c) => View a b c -> Hints ruleSubsetP view = let allOn :: [(a,b,c)] allOn = isOn $ view sAsB :: [[ [(a,b,c)] ]] sAsB = map (groupWith snd3) . groupWith fst3 $ allOn sAsBgC :: [ [(Int,[c],[(a,b,c)])] ] sAsBgC = map (sortWith fst3 . map (\ abcs -> (length abcs ,map thd3 abcs ,abcs) ) ) $ sAsB makeChains :: [(Int,[c],[(a,b,c)])] -> Int -> [(a,[b],[c])] makeChains input k = filter check . map toChain . subsets k . upToK $ input where upToK :: [(Int,[c],[(a,b,c)])] -> [(Int,[c],[(a,b,c)])] upToK = takeWhile ((k>=).fst3) toChain :: [(Int,[c],[(a,b,c)])] -> (a,[b],[c]) toChain vals = ( fst3 . head . thd3 . head $ vals -- record "a" for easy retrieval later , map (snd3 . head . thd3) $ vals -- the bs, length [b] == length vals == k by property of subsets k , combine . map snd3 $ vals) -- union of the cs at each b in bs check :: (a,[b],[c]) -> Bool check (_,_,cs) = (k == length cs) -- check that length [c] == k as well getUseful :: [(Int,[c],[(a,b,c)])] -> [(a,[b],[c])] getUseful [] = [] getUseful input = concatMap (makeChains input) [minK .. maxK] -- assertion: (length input) == (length . combine . map snd3 $ input) where minK,maxK :: Int minK = fst3 . head $ input maxK = pred . length $ input useful :: [(a,[b],[c])] useful = concatMap getUseful sAsBgC {- The chains are (a,bs,cs) such that cs == nub . sort $ [ z | (x,y,z) <- allOn, x==a, y `elem` bs] and length bs == length cs. Thus all the (a,b in bs,c) in the final puzzle have distict c in cs. For location (a,b' not in bs,c') cannot have c' in cs, thus if c' is in cs then (a,b',c') should be turned off. -} assemble :: (a,[b],[c]) -> Hints assemble (a,inBs,inCs) = do -- List Monad b <- fullRange \\ inBs c <- inCs let abc :: (a,b,c) abc = (a,b,c) guard (view ! abc) return (unshuffle abc,off) in concatMap assemble useful -- All subsets of length 'k', order is stable subsets :: Int -> [a] -> [[a]] subsets 0 _ = [[]] subsets _ [] = [] subsets k (x:xs) = (fmap (x:) (subsets (pred k) xs)) ++ subsets k (xs) -- Hopefully efficient merge of (list of (sorted lists)), unique values only combine :: (Ord a) => [[a]] -> [a] combine [] = [] combine [x] = x combine xs = let (a,b) = split xs in merge (combine a) (combine b) where split [] = ([],[]) split [a] = ([a],[]) split (x:y:cs) = let (a,b) = split cs in (x:a,y:b) merge a [] = a merge [] b = b merge a@(x:a') b@(y:b') = case compare x y of EQ -> x : merge a' b' LT -> x : merge a' b GT -> y : merge a b' {-# INLINE eachPerm #-} eachPerm :: (forall x y z. (Perm x y z) => View x y z -> Hints) -> [ Rule ] eachPerm rule = [ (\ known -> rule ( view known :: View R C V ) ) , (\ known -> rule ( view known :: View R V C ) ) , (\ known -> rule ( view known :: View C V R ) ) , (\ known -> rule ( view known :: View C R V ) ) , (\ known -> rule ( view known :: View V R C ) ) , (\ known -> rule ( view known :: View V C R ) ) ] ruleSubsets :: [ Rule ] ruleSubsets = eachPerm ruleSubsetP ++ [ (\ known -> ruleSubsetP (view known :: View B D V) ) ] allRules :: [ Rule ] allRules = ruleSubsets ++ ruleBlocks -- Applying the rules {- The evolution strategy is simple: Apply each rule in turn, keeping track whether or not there were any changes. If all rules cause no change then it is done evolving. -} evolve :: Cube -> Cube evolve cube = let (cube',changed) = foldl step (cube,False) allRules in if changed then evolve cube' else cube' where step orig@(known,_) rule = case rule known of [] -> orig hints -> (known // hints,True) toCube :: (Monad m,Enum e) => [(e,e,e)] -> m Cube toCube locs = do hints <- liftM concat $ mapM setLoc locs return (emptyCube // hints) where setLoc:: (Enum e,Monad m) => (e,e,e) -> m Hints setLoc i@(re,ce,ve) = mapM checkM (rs ++ cs ++ vs) where r = toEnum $ fromEnum re c = toEnum $ fromEnum ce v = toEnum $ fromEnum ve rs = [((r',c,v),off) | r' <- fullRange, r' /= r] cs = [((r,c',v),off) | c' <- fullRange, c' /= c] vs = [((r,c,v'),off) | v' <- fullRange, v' /= v] checkM hint = if check hint then return hint else fail "Input location is out of range" check ((r,c,v),_) = and [ inRange (lo,hi) r , inRange (lo,hi) c , inRange (lo,hi) v ] fromCube :: (Enum e) => Cube -> [(e,e,e)] fromCube cube = map head . filter exactlyOne $ [ [ eee | v <- fullRange, cube ! (r,c,v) , let eee = (toEnum $ fromEnum r ,toEnum $ fromEnum c ,toEnum $ fromEnum v) ] | r <- fullRange, c <- fullRange ] consistent :: Cube -> Bool consistent known = and [ consistentView ( view known :: View R C V ) , consistentView ( view known :: View C V R ) , consistentView ( view known :: View R V C ) , consistentView ( view known :: View V B D ) ] where consistentView :: (Perm a b c) => View a b c -> Bool consistentView view = and [ atLeastOne [ () | c <- fullRange, view ! (a,b,c) ] | a <- fullRange, b <- fullRange ] checkCube :: (Monad m) => String -> Cube -> m Cube checkCube msg cube = if consistent cube then return cube else fail msg deduce :: (Monad m,Enum e) => [(e,e,e)] -> m [(e,e,e)] deduce locs = toCube locs >>= checkCube "Inconsistent locations passed in" >>= return . evolve >>= checkCube "Inconsistent cube deduced from input" >>= return . fromCube test :: [(E,E,E)] test = [(1,8,1),(1,9,2),(2,5,3),(2,6,5),(3,4,6),(3,8,7),(4,1,7),(4,7,3),(5,4,4),(5,7,8),(6,1,1),(7,4,1),(7,5,2),(8,2,8),(8,8,4),(9,2,5),(9,7,6)] testC :: IO Cube testC = toCube test check :: IO () check = do c <- testC print (consistent (evolve c))

2 1

Profiling Gtk2HS applications
by Dmitry V'yal 07 Jun '06

07 Jun '06

Hello. How can one profile a program which uses gtk2hs? I get this: $ ghc --make MainGui.hs -prof Chasing modules from: MainGui.hs Could not find module `Graphics.UI.Gtk.Mogul': use -v to see a list of the files searched for (imported from ./TreeViewHelpers.hs) I tried to specify gtk2hs source path using -i option with no success.

2 1

Undecideable instances for one instance?
by Christophe Poucet 07 Jun '06

07 Jun '06

Dear, Recently I was wrapping something in a typeclass (you may argue the reason for the typeclass, I will admit that's no longer needed, yet the compile error still begs questioning). Basically if you have only one global instance of a typeclass (so there is no overlapping), GHC will still complain about overlapping. Is there any reason this is so or is this a remnant of more complicated overlapping situations? The sample code is: {-# OPTIONS_GHC -fglasgow-exts #-} module Main where data Located a = L a class Locatable a where value :: Located a -> a wrap :: a -> Located a instance Locatable a where value (L a) = a wrap a = L a main :: IO () main = do print . value . wrap $ 1 -- Illegal instance declaration for `Locatable a' -- (There must be at least one non-type-variable in the instance head -- Use -fallow-undecidable-instances to permit this) -- In the instance declaration for `Locatable a' Christophe(vincenz) -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

3 3

Fwd: [Haskell-cafe] Undecideable instances for one instance?
by Christophe Poucet 07 Jun '06

07 Jun '06

Hello Bulat, You are indeed correct. However I fail to see how there is any undecideability. If instead one specified it as follows, it would be fine: class Locatable a b | a -> b, b -> a where value :: a -> b wrap :: b -> a instance Locatatable (Located a) a where value (L a) = a wrap a = L a It compiles fine, yet this is semantically the same. On 6/7/06, Bulat Ziganshin <bulat.ziganshin(a)gmail.com> wrote: > > Hello Christophe, > > Wednesday, June 7, 2006, 12:27:22 PM, you wrote: > > > global instance of a typeclass (so there is no overlapping), GHC will > > still complain about overlapping. Is there any reason this is so or is > > GHC compains here about undecidability, not overlapping :) > > > -- Illegal instance declaration for `Locatable a' > > -- (There must be at least one non-type-variable in the instance head > > -- Use -fallow-undecidable-instances to permit this) > > -- In the instance declaration for `Locatable a' > > > Christophe(vincenz) > > > > > -- > Best regards, > Bulat mailto:Bulat.Ziganshin@gmail.com > >

1 0

FunDeps conflict
by Joel Björnson 06 Jun '06

06 Jun '06

Hi. I have a question regarding type classes and FunDeps. Consider the following code : > class Class2 a b | a -> b > class IsFoo a > data Bar a = Bar a > instance IsFoo a => Class2 a a > instance IsFoo a => Class2 (Bar a) a The last two instantiations will yield a 'Functional dependencies conflict error'. From what I understand, this is because (Bar a) *MAY* instantiate the type class isFoo, which would obviously lead to a conflict between the two instantiations. Is there anyway to get around this, knowing that (Bar a) won`t instantiate the isFoo class, or is the right answer simply to get rid of the FunDep ? Thanks /Joel

3 4

Problem in code
by Jenny678 06 Jun '06

06 Jun '06

hello, I can not find the problem, I use WinHugs and shows me(Syntax error in input (unexpected keyword "where"). here is my code: f :: (Float,Float) -> Float f (x,y) = (a(x,y) + 4) * (b(x,y) + 3) where a :: (Float,Float) -> Float a(x,y) = (x + y)*2 b :: (Float,Float) -> Float b(x,y) = (y - x)*5 How can I define this code with let in? Thanks for any help. -- View this message in context: http://www.nabble.com/Problem-in-code-t1742233.html#a4734684 Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

2 1

Combinations
by developer＠imaginando.net 06 Jun '06

06 Jun '06

Hi, I need a functions which takes as argument a list of lists like this one: [[1,2],[3],[4]] and gives me a list of list with all the possible combinations like this one: [[1,3,4],[2,3,4]] In this case there are only 2 combinations but if there was more than one element in the other lists the results were much more. I'm a little stuck in this simple problem. First i was thinking in cartesian product but then i realized that i may not be what i really need. Any tip? Many thx, Nuno Santos

6 6

[ANNOUNCE] Hitchhikers guide to Haskell - chapter 5 is online
by Dmitry Astapov 05 Jun '06

05 Jun '06

It's bigger. It's better. It now comes with source code included. If you already know what it is - just go and read a new chapter. If you dont know what it is - just go and read it from the very beginning. http://www.haskell.org/haskellwiki/Hitchhikers_guide_to_Haskell Or "darcs get http://adept.linux.kiev.ua/repos/hhgtth" and drown me in patches. -- Dmitry Astapov //ADEpt GPG KeyID/fprint: F5D7639D/CA36 E6C4 815D 434D 0498 2B08 7867 4860 F5D7 639D

1 0

Re: [Haskell-cafe] Features of Haskell]
by Bernard James POPE 05 Jun '06

05 Jun '06

On Sun, Jun 04, 2006 at 11:21:23AM +0200, Niels Van Och wrote: [snip] > Now, in a week I have to present this work formally, and I'm a bit > stumped as to how I'm going to do this. I've got about 15-20 minutes, > so I can only discuss the major features. Right now I'm thinking about: > > - Short introduction to functional programming, and Haskell in it > - Basic syntax in a few minutes > - Features like polymorphism, overloading, higher-order functions, > comprehensions, .. > - Lazy evaluation > - Monads: why and how? > > However, I'd love to know what you think. Furthermore, do you think I > should include an example on the usage of Haskell, and if so, which? Hi Niels, 15-20 mins isn't much time, so I would get straight to the point. I wouldn't bother introducing the syntax, just explain it as you go, to save time. I've always liked zipWith as an example for _short_ presentations. It is higher-order, polymorphic, and lazy. The classic fibonacci generator comes to mind as a "cute" example [1]. fibs = 0 : 1 : zipWith (+) fibs (tail fibs) If you want to show overloading and monads then you can extend it to zipWithM. You'll probably want to argue why all of the features you mentioned are important for real programming problems (not fibs). John Hughes' paper "Why Functional Programming Matters" is a good source of material. You might also like to argue that one of Haskell's strengths is that it is built up from a very small core language (the lambda calculus plus let). Higher-order functions, a good type system, and lazyness, allow many powerful features to be included in the programmer's toolkit without having to change the underlying core. For example, list comprehensions are simply syntax sugar, rather than some fundamentally new gadget. You might say Haskell takes abstraction and composition very seriously. To make your talk more even-handed, you might like to mention some of the outstanding problems faced by Haskell programmers. For instance, while we seem to have a good handle on the declarative side of programming, the operational side can be troublesome. Witness: space leaks and deepseq. The foldl leak is a possible example: sum = foldl (+) 0 Now some people might complain "Sure, Haskell looks nice in theory, but the proof is in the pudding; where's the pudding?". You might like to toss in a few examples of "real world" Haskell programs at the end, as a kind of pre-emptive strike against the non-believers. With some kind of note as to why Haskell was useful. Darcs and Pugs come to mind. As usual, all of this is qualified by the usual proviso: "It depends who your audience is." Add salt or sugar to taste. Hope that is of some help, Bernie. [1] Though, depending on your audience, this might be like playing "Stairway to Heaven" in a guitar shop.

1 0

ComputerWorld AU mention
by Manuel M T Chakravarty 04 Jun '06

04 Jun '06

This ComputerWorld (Australia) article, although about OSes, mentions Haskell favourably: http://www.computerworld.com.au/index.php?id=710118083 Technical detail on how Haskell helps to improve OS security is in a recent paper: http://www.cse.unsw.edu.au/~chak/papers/DEKC+06.html Manuel

1 0

Is there any url lib?
by Marc Weber 04 Jun '06

04 Jun '06

Hi. Did anyone implement something like pythons urllib yet? I wont to retrieve some files via http (I could use wget -O - for that ) and send some form information (post/get).. In other words: Something like expect but for downloading some documents from a website.. ;) Perhaps I should have another look at wash? I think I can find encoding/decoding parameters for method = get there.. Marc

2 1

Bug in Data.Graph
by Christophe Poucet 04 Jun '06

04 Jun '06

Dear, I think I have discovered a bug in Data.Graph. If one looks at the documentation it states: Vertex = (Node, Node) An edge from the first vertex to the second. Ergo (i,j) => j is reachable from i Then continuing, one reads that: topSort :: Graph -> [Vertex] A topological sort of the graph. The order is partially specified by the condition that a vertex /i/ precedes /j/ whenever /j/ is reachable from /i/ but not vice versa. However if one tries to evaluate it, one gets: > print . G.components $ G.buildG (1,4) [(1,2), (1,3), (2,4), (2,3)] > [1,3,2,4] According to specification we have the graph (with arrows pointing down) 1 / \ | 3 |/ 2 | 4 Therefore one would expect [4,2,3,1]. Is this a bug in the documentation or the implementation? With regards, Christophe -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

1 1

Library Repository?
by Bryan Burgers 03 Jun '06

03 Jun '06

Recently, I have seen a few messages to Haskell Cafe (Like Marc Weber's "Is there any url lib?" and Ferenc Wagner's "LDIF output library", as well as many replies like "oh, you can find that library at this link...") that have prodded me to ask what I've been wondering for a long time. What are the pros and cons of having a library repository for Haskell libraries. At current, I'm thinking of Perl's CPAN, which many Perl experts claim is the most important aspect of Perl ("Don't reinvent the wheel" is a common reply at Perlmonks.org) and I believe Ruby has something similar (RubyGems?). It seems to me that with the emergence of Cabal as a standard way to package Haskell libraries, this could be possible. Here's a short, non-exhaustive list of pros and cons I came up with. Pros: * Localized place to find libraries. If I want to know if a urllib exists, I can go to the server and search for 'url' and come up with relevant libraries. * Encourages programmers to share their libraries. If there's a place to put libraries, I would imagine that some people who have good libraries lying around might put them there. Or if they have something close, they might generalize it into a library and put it there. Cons: * It obviously needs a server, which costs money, and other things like that cost money. * Personel. It would take a bit of initiative to start a project like this, as well as continued upkeep. That would either require some knowledgable volunteers, or, once again, money. I'd love to hear the thoughts of the community on this. Bryan

2 1

Bytes to float
by Ivan Tikhonov 02 Jun '06

02 Jun '06

Hello. I have 4 bytes long String and i want to convert it to Float. How can i do this in Haskell? Don't want to use Ptr's. Thanks.

2 1

Teaching Haskell
by Walter Potter 02 Jun '06

02 Jun '06

All, Is there a list for those of us who teach Haskell ? Or should teaching questions be posted here? Thanks, Walt

1 0

Tips for converting Prolog to typeclasses?
by Greg Buchholz 01 Jun '06

01 Jun '06

Lately, in my quest to get a better understanding of the typeclass system, I've been writing my typeclass instance declarations in Prolog first, then when I've debugged them, I port them over back over to Haskell. The porting process involves a lot trial and error on my part trying to decide when to use functional dependencies and which compiler extension to enable ( -fallow-undecidable-instances, -fallow-overlapping-instances, etc.). Which might be okay, but I still can produce things that won't compile, and I don't necessarily know if I'm making a fundamental mistake in a program, or if there's something trivial that I'm not doing quite right. For example, there was a question on haskell-cafe last week about creating an "apply" function. My first solution ( http://www.haskell.org//pipermail/haskell-cafe/2006-May/015905.html ) was to use type classes and nested tuples for the collection of arguments. This works fine. But then I wanted to try to get closer to what the original poster wanted, namely to use regular homogenous lists to store the arguments. So I thought I could reuse the class definition and just provide new instances for a list type, instead of the nested tuple type. Here's the class definition... > class Apply a b c | a b -> c where > apply :: a -> b -> c ...So I wrote the following Prolog snippets which seemed like they might properly describe the situation I was looking for... :- op(1000,xfy,=>). % use => instead of -> for arrow type app(A=>B,[A],C) :- app(B,[A],C). app(C,[A],C). ...which I translated into the following Haskell instances... > > instance Apply b [a] c => Apply (a->b) [a] c where > apply f [] = error "Not enough arguments" > apply f (x:xs) = apply (f x) xs > instance Apply c [a] c where > apply f _ = f ...and here's a test program... > g :: Int -> Int -> Int -> Int -> Int > g w x y z = w*x + y*z > > main = do print $ apply g [1..] ...but I haven't been able to get GHC to accept this yet. So I'm wondering if there's an easy route to learning this stuff. Some sort of comprehensive tutorial out there which I should be reading that describes what should be possible with Haskell's typeclasses plus GHC extenstions, and when and where to enable these extentions. (Bonus points awarded if it explains things in terms of Prolog). Or is this just one of those things that requires reading lots of papers on each extentsion and possibly the source code of the implementation? Thanks, Greg Buchholz

2 3

Filtering on data constructors with TH
by Christophe Poucet 01 Jun '06

01 Jun '06

Dear, After having read Bulat's mail regarding TH when I had mentioned my wish for Pretty, I decided to use TH for a much smaller project. That's why today I have created an automated derivation for data constructor filtering. As I started coding someone mentioned that something similar can be done with list comprehensions, so I'm not certain about the scope of usefulness, however personally I have found the need for this at times. Anyways, the code can be obtained from the darcs repo at http://oasis.yi.org:8080/repos/haskell/filter Suggestions, bugs, additions are always welcome :) Here is an example: {-# OPTIONS_GHC -fglasgow-exts -fth #-} module Main where import Filter data T = A Int String | B Integer | C deriving Show data Plop a b = Foo a | Bar b deriving Show $(deriveFilter ''T) $(deriveFilter ''Plop) main :: IO () main = do let l = [A 1 "s", B 2, C] let l2 = [Foo 1, Bar "a", Foo 2, Bar "b"] print l print $ filter isA l print l2 print $ filter isFoo l2 Cheers Christophe (vincenz@irc) -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

3 2

Re[2]: [Haskell] My summer of code project: HsJudy
by Bulat Ziganshin 01 Jun '06

01 Jun '06

(moved to haskell-cafe) Hello Jean-Philippe, Tuesday, May 30, 2006, 2:58:01 PM, you wrote: >> you should also see to the Collections package: >> darcs get --partial http://darcs.haskell.org/packages/collections/ >> although it contains only _immutable_ datastructures at this >> moment. may be, you can codevelop with Bernardy interface for mutable >> maps/sets > I'm not sure there is significant overlap between what we're doing. > I'd be delighted to cooperate if you think this is possible though. well, what i think: while all the actual work will be performed by Caio himself, we can help him (and to ourselves as possible future users of this lib) by describing infrastructure in that he need to insert his work and pointing to "adjancent" projects so, Caio, now i write for you, better organizing my previous post: 1. In terms of Haskell, Judy is a library of _mutable_ collections of _unboxed_ elements. i pointed you to the Array wiki page, where differences between boxed and unboxed, mutable and immutable datastructures are described 2. Collections is a library of _immutable_ datastructures, and Jean-Philippe especially omitted any support for mutable datastructures - because it's the whole story of it's own. So, you don't need to write your work as part of the Collections library 3. Nevertheless, Collections has GREAT organization and it will be very helpful to study it. in particular, see at the Data.Collections module, what describes various classes into which all collections are fitted, and hierarchy between them 4. Next, when you will search for the datatypes/classes whose interface you can imitate, you will find only Data.HashTable - other datatypes in standard libraries are either immutable (say, Map) or need contiguous indexes (say, MArray). So you will need to create your own interface and here you can borrow from the Collections lib. Just see at the differences between IArray and MArray classes. They are very close, only MArray class update arrays on-the-place and has additional 'Monad m' on all it's return types. say, class IArray a e where unsafeAt :: (Index i) => a i e -> i -> e becomes class MArray a e m where unsafeRead :: (Index i) => a i e -> i -> m e You can do the same with Collections classes. instead of reinventing the wheel, you can add letter 'M' to it :) say, class Monoid c => Map c k a | c -> k a where insert :: k -> a -> c -> c delete :: k -> c -> c member :: k -> c -> Bool would become class (Monoid c, Monad m) => MapM c k a | c -> k a where insertM :: k -> a -> c -> m () deleteM :: k -> c -> m () memberM :: k -> c -> m Bool 5. as i already said, then you should use StablePtr and any form of hashing/seriazliation in order to map between boxed (Haskell) and unboxed (C) values. and then you can develop series of Diff transformers what emulates immutable collections via mutable ones (say interface of class Map via the interface of class MapM), DiffArray can serve as template here 6. There is no class framework for container types other than this Data.Collections module, so implementing it's close imitation (with monadic operations) will help future users to easily learn and use both interfaces -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

3 4

sum-file shootout test
by Bulat Ziganshin 01 Jun '06

01 Jun '06

Hello Haskell-cafe, i have analyzed performance of various sum-file implementations (see http://shootout.alioth.debian.org/debian/benchmark.php?test=sumcol&lang=all ) first, one-liner implementation (attached as b.hs) works about 500 seconds on my cpu. it can be made 10x faster just by using it's own 'read' procedure (c.hs). this tells us that current 'read' implementation in GHC is VERY SLOW. next step to make things go faster you can see at http://shootout.alioth.debian.org/debian/benchmark.php?test=sumcol&lang=ghc… - now it's the fastest GHC entry on this test. speedup is a result of throwing away all the lines/map/read/sum individual procedures and writing entire algorithm over the plain stream of Chars. this allows us to omit all the construction/deconstruction of lazy boxes, so this program works about 10 seconds on my box. now the main problem is getContents itself, which uses about 70% of total time, because it requires to construct/deconstruct lazy box for each Char read. Using Streams library, we can omit this work and use straightforward imperative code (h.hs). this program works 4 times faster (2.8 seconds) than faster Haskell variant, what should be about 1.5 times faster than today's fastest (D Digital Mars) entry in this test i think that close speed can be also obtained by using line-oriented I/O in Streams+ByteString combination and then applying some "readInt :: ByteString -> Int" conversion while compiling under GHC 6.5 -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

1 0

Re: [Haskell] installing streams library
by Chad Scherrer 31 May '06

31 May '06

On 5/20/06, Donald Bruce Stewart <dons(a)cse.unsw.edu.au> wrote: > > > Data.ByteString is in the base libraries now. > For a bit of the flavour, see: > http://haskell.org/haskellwiki/Wc > In this message http://article.gmane.org/gmane.comp.lang.haskell.general/13625 Bulat says, i foresee that Streams + Fast Packed Strings together will yield a breakthrough in GHC I/O speed, and this can be implemented even without waiting for GHC 6.6 Before reading this I had thought it might be an XOR situation, but now it seems a happy coexistence may be possible. Are there any preliminary results on how these might work together, and the potential speedups? -- Chad Scherrer "Time flies like an arrow; fruit flies like a banana" -- Groucho Marx

8 20

Re: [Haskell-cafe] Editors for Haskell
by Doaitse Swierstra 31 May '06

31 May '06

On 2006 mei 30, at 17:33, Brian Hulley wrote: > But the buffer will nearly always be incomplete as you're editing it. > > I was kind of hoping that the syntax of Haskell could be changed so > that for > any sequence of characters there would be a unique parse that had a > minimum > number of "gaps" inserted by the editor to create a complete parse > tree, and > moreover that this parse could be found by deterministic LL1 recursive > descent. If you use my parsercombinators, and are willing to work on the grammar I think this can in principle be done. The combinators automatically "correct" incorrect (i.e. in this case incomplete) input, but: - you may really need some time to tune the grammar so the corrections are what a user might expect (there are many hooks for doing so, but it will takje some effort, since this s also a human interface issue) - making a Haskell grammar that parsers top-down is not an easy task, and making it LL1 is definitely impossible, but also not needed if you use my combinators - we could in principle provide you with a complete parser for Haskell using our combinators that was tested by replacing the GHC parser with this parser, and that worked (contact athurb(a)cs.uu.nl to get a copy of his code) - did you think about how to handle the offside rule? If not, the good news is that we have combinators for that too. Doaitse Swierstra > > Haskell already seems so very close to having this property - its a > real > pity about => Not only the =>, but e.g. the commonality between patterns and expressions makes left factorisation a not so simple task. > > The problem is: when Haskell was designed, no one seems to have > thought > about the syntax from the point of view of making it easy to parse or > ensuring that it would have this nice property for editing. > >> >>> foo :: {SomeClass a} a->a >>> a Prelude.+ b -- no spaces in the qvarsym >>> a `Prelude.(+)` b -- a little generalization >>> a `Prelude.(+) b -- no need for closing ` >> >> I would not like an editor that forces me to use a special coding >> style (like using brackets where not strictly necessary). Even less >> would I like to use one that introduces non-standard syntax. >> >> My humble opinion is that you'll have to bite the bullet and >> implement >> your syntax recognizer so that it conforms to Haskell'98 (including >> the approved addenda) [and addtionally however many of the existing >> extensions you'll manage to support]. It may be more difficult but in >> the end will also be a lot more useful. And you'll have to find a way >> to (unobtrusively!) let the user know whether some piece of code does >> not yet have enough context to parse it unambigously. > > Thanks for the feedback - I suppose I was being overly optimistic > to think I > could just change the language to suit my editor ;-). > I'll have to find a balance between what I'm able to implement and > what is > specified in Haskell98 (or Haskell' etc) - just as GHCi has done with > qvarsym, and perhaps have different levels of conformance to H98 so > people > could choose their preferred balance between conformity and > instantaneousness of feedback (everything would of course still be > loaded/saved as H98). > > Regards, Brian. > > -- > Logic empowers us and Love gives us purpose. > Yet still phantoms restless for eras long past, > congealed in the present in unthought forms, > strive mightily unseen to destroy us. > > http://www.metamilk.com > > _______________________________________________ > Haskell-Cafe mailing list > Haskell-Cafe(a)haskell.org > http://www.haskell.org/mailman/listinfo/haskell-cafe

2 1

Newbie: Applying Unknown Number Arguments to A Partial Function
by Aditya Siram 30 May '06

30 May '06

I am trying to write a function 'applyArguments' which takes a function and a list and recursively uses element each in the list as an argument to the function. I want to do this for any function taking any number of arguments. applyArgument f (arg) = f arg applyArgument f (arg:args) = applyArgument (f arg) args This has failed in Hugs, so my question is: Can I conceptually do this? If so, what is the type signature of this function? Deech

8 9

changing out
by Jenny678 30 May '06

30 May '06

hello, i want to change my input integers In> 23 98 Out> 98 23 I think its simple... sorry .... my first steps in Haskell.... thanks for solutions. -- View this message in context: http://www.nabble.com/changing+out-t1707014.html#a4634189 Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

2 1

String to binary tree
by Nuno Santos 30 May '06

30 May '06

Hi, I have this type which represents polish expressions (floorplan representation): data PeAux a = Folha Char | Nodo Char (PeAux a) (PeAux a) deriving Show The reverse polish expression are the result of doing a post order visit to the tree One example of this reverse polish expression is "12H3V" and a example of tree is pe5 = Node 'V' (Node 'H' (Folha '1') (Folha '2')) (Folha '3') the tree above is the same as the expression "12H3V" What i need and i cant do is turn the expression a tree again... I have done the following: converteAux [] (x,y) = (x,y) converteAux (a:t) (x,y) | ((length (a:t))<3) = converteAux [] (x,y ++ (a:t)) converteAux (a:b:t) (x,y) | ((length (a:b:t))<3) = converteAux [] (x,y ++ (a:b:t)) converteAux (a:b:c:t) (x,y) | (isNumber a) && (isNumber b) && (isLetter c) = converteAux t (x ++ [(Nodo c (Folha a) (Folha b))],y) | otherwise = converteAux (b:c:t) (x,y++[a]) The strategy followed is to recognize operand, operand, operator and then put it as a basic element in a list, for instance, 12H -> Node 'H' (Folha '1') (Folha '2') And at the end put it togheter in one tree. ( not done yet) But i'm getting to the conclusion that it doesnt cover every case... Can anybody give me a light here? Many thx, Best regards, Nuno Santos

4 5

On GADT, phantom types, etc. terminology
by oleg＠pobox.com 30 May '06

30 May '06

David Roundy wrote: > data CommuteResult a b c where > CR :: C a b c d => (P a d, P d c) -> CommuteResult a b c > ... > or that somehow GADTs aren't interacting with FDs as I'd like It must be emphasized that there are *NO* GADTs is the above code. Except Stefan Monnier's message, no code posted in the thread `help with MPTC for type proofs?' had any GADTs, the notation |data ... where| notwithstanding. In particular, the data type |CommuteResult a b c| is the ordinary algebraic datatype, and can be written in the traditional notation as > data CommuteResult a b c = forall d. C a b c d => CR (P a d, P d c) To recall, the datatype > data MEither a b where > MLeft :: a -> MEither a b > MRight :: b -> MEither a b is the ordinary algebraic datatype > data MEither a b = MLeft a | MRight b The two notations are totally equivalent. The constructors MLeft and MRight create the values of the type |MEither a b| -- which is just as general as the type being defined |MEither a b|. OTH, > data MEither2 a b where > MLeft2 :: Int -> MEither2 Int b > MRight2 :: b -> MEither2 Char b is truly _generalized_ ADT, because the values created by the constructors MLeft2 and MRight2 have the types that span only the subset of the type family |MEither2 a b|. Thus, to tell if something written in the |data ... where| notation is GADT or not, we just look at the result type. If it is the same as what follows the |data| keyword, we have the ordinary ADT. Incidentally, I strongly prefer writing ordinary algebraic data types in the traditional notation (precisely to avoid the confusion with GADTs and to keep the code portable). Because David Roundy's example had no GADTs, it is not fair to blame GADT's interacting with FD. There are indeed issues, at present, with GADT and FD. But those issues do not bear on the problem at hand. Therefore, waiting for GHC 6.8 is, alas, hopeless in this respect. David Roundy wrote: > I want the return type "d" to be a phantom type of some sort (although > I'm not clear on the distinction between phantom and existential > types). Well, they are, in a sense, dual to each other. In the declaration, > data Patch a b = P a the type variable 'b' appears only on the left-hand side of the definition. The corresponding type is phantom. In the declaration > data PatchW a = forall b. PW (Patch a b) the type variable 'b' appears only on the right-hand side of the defining equation. So, informally, the type |PatchW a| is existential, abstracting over |b|. Perhaps the |where| notation makes things clearer: > data Patch a b where P :: a -> Patch a b > data PatchW a where PW :: Patch a b -> PatchW a Here, the type variable |b| shows up only in the result of |P|. It is phantom. The type variable |b| shows up only in the argument of |PW|. It is existential. David Roundy wrote: > when I realized that the problem could be solved much more elegantly > using GADTs as a type witness (with unsafeCoerce#, admittedly) That is quite puzzling: the whole advantage of GADTs is that we don't need to coerce values because type coercion, after checking the run-time evidence (that is, successful pattern-match) is the very essence of GADTs. Incidentally, to coerce phantom types, there is no need to resort to unsafeCoerce#. The access to the data constructor suffices. David Roundy wrote: > Can someone explain to me why this doesn't work? > > {-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-} > > module MPTC where > > > > class C a b c d | a b c -> d, a d c -> b > > > > instance (C a b c d) => C a d c b > > > > data P a b = P deriving (Show) > > > > data CommuteResult a b c where > > CR :: C a b c d => (P a d, P d c) -> CommuteResult a b c When we abstract over |d|, there is generally no way to get the original type back (short of various casts, which generally require run-time evidence). One can think of it as upcast/downcast problem in OO: we can always pretend that an object of the type A is an object of a more general type ASuper (and any object is an object of the Top type). However, downcasting from a value of a more general type to the value of a more specific type requires some run-time evidence (even if the more general value was obtained by the upcast from the desired specific type). The nature of abstraction is to irreversibly forget -- hence the encapsulation guarantee. If that is not desired, we can use some other translucent, type-preserving, ways. For example, > {-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-} > module MPTC where > > data P a b = P deriving (Show) > > data CommuteResult a b c = forall d. CR (P a (d b), P (d b) c) > > commute :: (P a (d b), P (d1 b) c) -> CommuteResult a b c > commute (P, P) = CR (P, P) > > test (x,y) = do CR (y',x') <- return $ commute (x,y) > CR (y'', x'') <- return $ commute (x,y) > CR (x''',y''') <- return $ commute (y',x'') > return () which type-checks... David Roundy wrote: > I guess what hasn't been addressed is the question I didn't know to ask... It would help me personally to see the `ideal' code -- the code that you wish to write and to typecheck. The code should be sufficiently realistic (the IO can be stubbed though). I'll be out of town for a week so unable to reply promptly.

2 1

LDIF output library
by Ferenc Wagner 30 May '06

30 May '06

Hi, does anybody know of a library for writing LDIF files? If not, I may create one, and would be grateful for suggestions. Is it worth integrating with John Goerzen's LDAP binding, for example? -- Thanks, Feri.

1 0

Haskell RPC
by Joel Reymont 30 May '06

30 May '06

Folks, I'm curious about how the following bit of Lisp code would translate to Haskell. This is my implementation of Lisp RPC and it basically sends strings around, printed "readably" and read on the other end by the Lisp reader. If I have a list '(1 2) it prints as "(1 2)" and becomes '(1 2) again when read on the other end. I'm wrote a couple of macros to make the job of defining the RPC easier. def-remote-class defines the main (server) class as well as the client (proxy) class. def-remote-method creates the server method as well as a proxy method that sends data over and possibly waits for results and returns them (depending on the :async or :sync qualifier). My Lisp RPC code runs on top of UDP, looks good and works well. I have a soft spot for Haskell in my heart, though, so I wonder how I would go about implementing the same architecture in Haskell. This is an example from my test harness: (define-test remote-basic (def-remote-class remote (server) ()) (def-remote-method sum :sync ((self remote) (a fixnum) (b integer)) (declare (ignorable ip port)) (+ a b seqnum)) (let* ((port (+ 1000 (random 50000))) (server (make-instance 'remote :port port)) (client (make-instance 'remote-proxy :host (host-address) :port port))) (assert-equal '(6) (sum client 1 2 :seqnum 3)) (stop server) (stop client) )) I think I can send Haskell code over the wire to be read on the other side just like I do with Lisp. The part that baffles me is being able to provide an interface that lets one easily define remote classes and methods. I totally hate Template Haskell because I find it incomprehensible and I'm not going to compare it to Lisp macros. Is there a way to do it without TH? Also, it seems to me that the only way to deal with variable numbers of differently typed arguments is to use the HList approach which is quite heavy machinery, IMO. Any suggestions? Thanks, Joel P.S. The Haskell Cafe has been a bit quiet lately so I do mean to stir it up some. I think this example shows the advantage of dynamically-typed languages. I'm also genuinely interested in possible Haskell solutions. -- http://wagerlabs.com/

9 11

State Variables
by Matthew Bromberg 30 May '06

30 May '06

I've been toying with the idea of using Haskell to write a medium sized simulation of a wireless network. However I have a number of concerns as I've begun to program a bit more in Haskell. The first concern is that the simulation needs to be fast, much faster than Matlab for example, to justify the use of Haskell. Given GHCs speed improvement in recent releases, I have high hopes that this is possible. To be honest, I'd probably pick Clean here, but I've been unable to consistently link to third party DLLs with the Clean IDE. The second concern is that the simulation requires heavy use of complex valued matrices. Since I'm on windows and the only reasonably well developed matrix library doesn't run on windows I would be forced to use the FFI to bring in various BLAS and LAPACK routines to support this. I've convinced myself that this is quite possible, if somewhat tedious by virtue of the unpleasant array access syntax for mutable arrays. The third and final concern is the point of this post. How does one handle state efficiently in Haskell? I've seen the various state monads and gained a superficial enough understanding to be concerned about how useful they are, for the following reason: I would like to aggregrate a large number of state variables (possibly in the hundreds of variables) into a few data structures. These structures would not only contain basic variable types, but probably some rather large mutable arrays. So lets say I have such a structure called world and I wish to update just 1 entry. If I do w=world{entry=newentry}, the entire enormous world structure is copied to w. If I bury world in a state monad, then inside a do loop it appears that the get function extracts the entire world state and the set function writes it back into the monad after I've altered it. It still seems to me that the entire structure is copied again to achieve this. I'm not sure if this is true or not. Perhaps the compiler can pull apart the aggregation to fix this issue, but I'm not sure if such an optimization is performed. The only other thing I could think of would be to somehow create get and set functions for every variable in the aggregation, which also would be impossibly tedious. It is possible for me to structure the program so that most of the simulation parameters are set once by the user and then never changed during the rest of the program operation, although incremental state updates are a bit more efficient than this approach. To make this reasonably clean I would probably do some kind of unsafe extraction out of the IO monad to get my input variables, which would then not be changed for the rest of the simulation, although many of the matrices, themselves embedded in the IO monad would have to change incrementally as the simulation progresses. Right now I would favor the latter approach, if I stay with Haskell, but so far it's not clear to me that Haskell is 'convenient' for this kind of development, though I would like to be proven wrong. I am also looking at D or possibly LUA+C for this task, but LUA is not much faster than Matlab.

4 12

Re: [Haskell-cafe] swap a pair of integers
by David House 29 May '06

29 May '06

This was originally, and accidentally, sent to just Jenny, and not the list. On 29/05/06, Jenny678 <mestor1(a)gmx.de> wrote: > hello, > i want swap a pair of integers > for example > Main> 17 > out> 71 > Can somebody help me? When you want to do manipulation on the digits of a number like this, normally the easiest thing to do is to convert it to a string, use list manipulation functions, then convert back to an integer. For example: Prelude> (read . reverse . show) 17 71 -- -David House, dmhouse(a)gmail.com

2 1

Re: help with MPTC for type proofs?
by oleg＠pobox.com 29 May '06

29 May '06

David Roundy wrote: > class Commutable a b d c > > commute :: Commutable a b d c => > (Patch a b, Patch b c) -> (Patch a d, Patch d c) > > But for this to work properly, I'd need to guarantee that > > 1. if (Commutable a b d c) then (Commutable a d b c) > > 2. for a given three types (a b c) there exists at most one type d > such that (Commutable a b c d) The problem seems easily solvable, exactly as described. We need to take care of the two requirements separately. > {-# OPTIONS -fglasgow-exts #-} > {-# OPTIONS -fallow-undecidable-instances #-} > > module D1 where > > data Patch a b = Patch String deriving Show > > -- This is identical to what Tom Schrijvers wrote > class Commutable a b c d | > a b c -> d, -- 2. > a d c -> b -- based on 1. + 2. > > -- But how do we make sure that Commutable a d c b exists whenever > -- Commutable a b c d does? very easily: with the help of another > -- type class > instance (Commutable' a b c d, Commutable' a d c b) > => Commutable a b c d > > class Commutable' a b c d | a b c -> d > > -- The desired function > commute :: Commutable a b c d => > (Patch a b, Patch b c) -> (Patch a d, Patch d c) > commute ((Patch p1),(Patch p2)) = ((Patch p1),(Patch p2)) > > -- Testing > -- Define some patch labels > > data PL1 > data PL2 > data PL2I > data PL3 > data PL4 > > instance Commutable' PL1 PL2 PL3 PL2I > -- If the latter is commented out, there will be an error in testab below > instance Commutable' PL1 PL2I PL3 PL2 > > pa :: Patch PL1 PL2 = Patch "PA: 1->2" > pe :: Patch PL2 PL3 = Patch "PE: 2->3" > > -- Test as was in David Roundy's message > test (a,b) = do (b',a') <- return $ commute (a,b) > (b'', a'') <- return $ commute (a,b) > (a''',b''') <- return $ commute (b',a'') > return () > > testab :: IO () = test (pa,pe) However, something tells me that the above approach isn't useful. We really would like to have as many patch labels as _dynamically_ needed. Also, we probably would like to specify which patches commute dynamically, rather than statically. That is, we wish to examine the patches and only then conclude if they commute. Thus we need to program with evidence. The function commute becomes a semantic function: it really does something, at run-time. It examines the patches. If it decides the patches commute, it produces the pair of patches, marked with a unique and unforgeable type d -- along with the evidence that d is indeed determined by b, and vice versa. We need this evidence for the creative mixing of patches, as in the original test. This approach is not unlike the one described half a year ago, in response to a similar query: http://www.haskell.org/pipermail/haskell-cafe/2005-December/012703.html I still don't know if the were some problems with that approach. Anyway, here's the complete code: > {-# OPTIONS -fglasgow-exts #-} > > module D2 where > > data Patch a b = Patch String deriving Show > > -- Define the commutation pair > data CP a b c = forall d. CP (Patch a d) (Patch d c) (EQP b d) > > data EQP b d = EQP -- Hide the constructor > > -- The following creates the proof > -- Assume patches commute if their bodies are the same > commute :: Patch a b -> Patch b c -> CP a b c > commute (Patch p1) (Patch p2) | p1 == p2 = CP (Patch p1) (Patch p2) EQP > > -- Testing > -- Define some patch labels > > data PL1 > data PL2 > data PL3 > data PL4 > > pa :: Patch PL1 PL2 = Patch "PA: 1->2" > pe :: Patch PL2 PL3 = Patch "PA: 1->2" > > -- coercion functions, using the evidence > a1 :: Patch a d -> EQP b d -> Patch a b > a1 (Patch p) EQP = Patch p > a2 :: Patch d c -> EQP b d -> Patch b c > a2 (Patch p) EQP = Patch p > > test a b = do CP b' a' e' <- return $ commute a b > CP b'' a'' e'' <- return $ commute a b > CP a''' b''' e''' <- return $ commute (a1 b' e') (a2 a'' e'') > return () > > testab :: IO () = test pa pe

4 5

Re: [Haskell] (.) . (.)
by Brian Hulley 29 May '06

29 May '06

[moved to cafe] Dominic Steinitz wrote: > Taral wrote: >> On 5/28/06, Dominic Steinitz <dominic.steinitz(a)blueyonder.co.uk> >> wrote: >>> Is this defined in some library? Thanks, Dominic. >> >> Don't think so. I use: >> >> \a b -> f (g a b) >> > Taral, > > Thanks. What prompted this question is that I find myself writing > things like: > > foo = ((.).(.)) concat intersperse Hi Dominic - I hope it's ok for me to ask this question and I'm absolutely burning with curiosity to find out the answer... How did you know to write ((.).(.)) instead of (\f g a b -> f (g a b)) ? Although the correctness of the above translation has been proved, it seems extremely non-obvious to me that to compose a function with another function which takes two arguments you should use the compose function to compose the compose function with itself... Is this kind of composition common in some branch of Lambda calculus? Is it something that I might in time be able to see directly without having to go through a proof? Does anyone else "see" the above translation intuitively and is there a way to imagine it? Thanks, Brian. -- Logic empowers us and Love gives us purpose. Yet still phantoms restless for eras long past, congealed in the present in unthought forms, strive mightily unseen to destroy us. http://www.metamilk.com

5 8

swap a pair of integers
by Jenny678 29 May '06

29 May '06

hello, i want swap a pair of integers for example Main> 17 out> 71 Can somebody help me? -- View this message in context: http://www.nabble.com/swap+a+pair+of+integers-t1700880.html#a4615989 Sent from the Haskell - Haskell-Cafe forum at Nabble.com.

1 0

How to print the " character without the backslash
by Nuno Santos 29 May '06

29 May '06

Hi, I have this basic question of how to print the character " without the backslash. I'm trying to print html code, so i need " a lot. giveHtml (Leaf (a,(b,c))) = "<frame src=\"\" name=\"" ++ [a] ++ "\" scrolling=\"No\" noresize=\"noresize\" id=\"" ++ [a] ++ "\" title=\"" ++ [a] ++ "\" />" Can anybody give me a light here? Many thx, Nuno Santos

3 2

OT - lamba calculus definition - alpha reduction
by Dušan Kolář 29 May '06

29 May '06

Hello all, I'm asking in place of several my colleagues and myself of course. The question is almost off topic. It is from lambda calculus definition, in particular, definition of alpha reduction (and others as well). Alpha reduction definition: a lambda expression (\v.e) can be transformed (reduced) to (\v'.e[v'/v]) if the substitution e[v'/v] is valid. Beta reduction definition: a lambda expression (e1 e2) can be reduced to the expression e[e2/v] if e1 is of the form (\v.e) and if the substitution e[e2/v] is valid. Eta reduction definition: a lambda expression e can be reduced to a lambda expression (\v.e v) if v is not free in e. OK. If we have these two expressions: 1) (\x.x b x) 2) (\x.x c x) The question is, are they equal? (They are not identical, of course.) For answer "no", there is a strong argument - there is no reduction sequence that can make these identical. On the other hand, their "meaning" expresses the same operation. Well, what is the answer? I will be lucky with any link to WWW resource or your opinion. Nevertheless, the more formal and precise your answer will be the more I will be lucky. ;-) Thx and regards Dusan

4 5

(no subject)
by Christophe Poucet 29 May '06

29 May '06

Dear, I will try to explain what I'm trying to achieve, below you can find the code demonstrating where I'm at currently, and where I would like to ideally get, as well as the current compilation error. Basically I'm working on a minilanguage that I would like to simulate. This language is based on a core concept which can in the example below is "Foo". Now there is a 'primitive' instance of Foo that is the list. What I now want to do is make FooF an instance as well. FooF being a record based on a map that contains some other instances of Foo by name as well as code that will use this lookup table. For instance (this is not definite syntax): my pseudoproglanguage: A = [1..10] (aka refer to the 'primitive' instance of Foo) B = [1..10] (aka refer to the 'primitive' instance of Foo) bar C = if dum B then bar A else bar B dum C = dum A && dum B I realize I need existentials for this, but I'm afraid that my type-fu is lacking in this area. Perhaps one of you could point me in the right direction. With regards, Christophe ------------------------------------------------------------------------------------------------------------ {-# OPTIONS_GHC -fglasgow-exts #-} module FooBar where import qualified Data.Map as M class Foo f b | f -> b where foo :: f a -> b bar :: f a -> b -> b dum :: f a -> b -> Bool instance Foo [] Int where foo c = 0 bar c i = i+1 dum c i = (length c == i) data F b a = forall f. Foo f b => F (f a) instance Foo (F b) b where foo (F c) = F . foo $ c bar (F c) i = bar c i dum (F c) i = dum c i data FooF b a = FooF { cols :: M.Map String (F b a), barC :: M.Map String (F b a) -> b -> b, dumC :: M.Map String (F b a) -> b -> Bool } instance Foo (FooF b) b where foo c = fmap (foo) c bar c i = barC c (cols c) i dum c i = dumC c (cols c) i makeFooF cols barC dumC = FooF {cols = cols, barC = barC, dumC = dumC} -- Example: -- makeFooF -- [("A", [1..10]), ("B", [1..8])] -- (\t -> if dum (M.lookup "A" t) -- then bar (M.lookup "B" t) -- else bar (M.lookup "A" t) -- (\t -> dum (M.lookup "A" t) && dum (M.lookup "B" t) -- Ideally this system would also allow to make some FooF that is based on another FooF, hence the reason for existentials -- FooBar.hs:19:16: -- Couldn't match the rigid variable `b' against `F b1 a' -- `b' is bound by the instance declaration at FooBar.hs:18:0 -- Expected type: b -- Inferred type: F b1 a -- In the expression: (F . foo) $ c -- In the definition of `foo': foo (F c) = (F . foo) $ c -- -- FooBar.hs:31:12: -- Couldn't match the rigid variable `b' against `f b1' -- `b' is bound by the instance declaration at FooBar.hs:30:0 -- Expected type: b -- Inferred type: f b1 -- In the application `fmap (foo) c' -- In the definition of `foo': foo c = fmap (foo) c -- Failed, modules loaded: none. -- ----------------------------------------- -- Christophe Poucet Ph.D. Student Phone:+32 16 28 87 20 E-mail: Christophe (dot) Poucet (at) imec (dot) be Website: http://notvincenz.com/ IMEC vzw – Register of Legal Entities Leuven VAT BE 0425.260.668 – Kapeldreef 75, B-3001 Leuven, Belgium – www.imec.be *****DISCLAIMER***** This e-mail and/or its attachments may contain confidential information. It is intended solely for the intended addressee(s). Any use of the information contained herein by other persons is prohibited. IMEC vzw does not accept any liability for the contents of this e-mail and/or its attachments. **********

1 0

Re: [Haskell] (.) . (.)
by Brian Hulley 28 May '06

28 May '06

[moved to cafe] Robert Dockins wrote: > On Sunday 28 May 2006 05:02 pm, Brian Hulley wrote: >> I see my error was that I was reversing the args in eta expansion, >> so the correct derivation is: > > FYI, eta-expansions isn't valid in Haskell. Its safe in this > derivation, but it isn't always. Am I right in thinking that this is because of _|_ ? In any case I suppose I should have instead just replaced the function with it's definition like you (view Lambda Shell) and Christophe did. Also, is your Lambda Shell publicly available? (I had a quick look on the wiki in the Theorem provers section but couldn't find a link.) Thanks, Brian.

2 2

Re: [Haskell-cafe] Linking to third party libraries in windows
by Matthew Bromberg 28 May '06

28 May '06

That's an interesting statement that bears further scrutiny. I've been viewing monads as a kind of encapsulation in a quasi-hidden world state. Yes a monad is a function that would give you an output if you had access to the input world. That is the picture drawn in Simon Peyton Jones' tutorial. I've been thinking of actions in terms of the functions x -> IO(a), but Simon calls these IO actions and calls monads actions as you do. Is it your claim that whenever an 'IO action' is performed on something like IO (x) with x <- newListArray a l that the newListArray function will be called ? So with the old paradigm, where Rmatrix was stored as (Int, Int, IO(StorableArry Int CDouble)). A typical matrix operation, that calls out to a BLAS C routine cside_effect() looks something like this under the old scheme matfunc A = (u,v, arr) where u = f1 (getrows A) (getcols B) v = f2 (getrows A) (getcols B) arr = do arrA <- getarr A withStorableArray arrA (\vara -> cside_effect vara ) return arrA Now when one uses this code do A <- getAfromSomewhere fA = matfunc A B <- anotherfunc A fA has been changed by the cside_effect function, but A has not! Is it your contention that the array in A is essentially copied or created anew for every getarr A call? I think getarr A looked something like getarr (Rmatrix (r,c,arr)) = arr in the old technique, but now looks like getarr (Rmatrix (r,c,arr)) = return arr Is this perhaps an effect of lazy evaluation? When does one actually need to evaluate the constructor for the storable array contained in A? Hmmm. Is it that the rules specify that an IO action forces the evaluation of the value in the monad, but otherwise this value may be unevaluated? So return x doesn't evaluate x but (return x) >>= \z -> IOfunc z does? This would actually make sense in the end. The IO action of A <- getAfromSomewhere would not evaluate the monad that is the third element of the tuple A, since there is no real 'need' to do so. So in fact no constructor of A's array would ever get evaluated until a function was applied to it, which would have to be in the form of an IO action. That's a nice mind twister. Clean's uniqueness types are a little easier to grasp I think. Ahh I think I understand now. It has to work that way or else you cannot guarantee the sequential execution property of monads. Thus if y :: IO (a) and you evaluate z <- func (f1 y) (f2 y), the evaluation order of y is controlled by what is implemented in func (and f1 and f2), not by evaluation rules for arguments. The value wrapped in y MUST remain unevaluated until IO 'actions' are performed on it. Brian Hulley wrote: this is not correct. IO (StorableArray Int CDouble) is a monadic *value* itself, which represents an *action* which returns a storable array, and since you are filling in the slot in Rmatrix with the action (newListArray a l), this monadic value represents the action of creating a new array whenever the action is executed.

3 4

Re: [Haskell] (.) . (.)
by Brian Hulley 28 May '06

28 May '06

[Moved to cafe] Christophe Poucet wrote: > Hello, > > I think you look at the (.) . (.) as all being c's in the wrong way. > You have to consider what will evaluate first (syntactical priority > rules). (.) . (.) === (.) (.) (.) -- a + b === (+) a b === c c c > Anyways the simplest case that this is equivalent can be seen > here: 22:33 < vincenz> @pl \f g a b -> f (g a b) > 22:33 < lambdabot> (.) . (.) > > Writing it explicilty: > (.) f g a = f (g a) > > > so we get > (.) . (.) = \f -> (.) ((.) f) > (.) . (.) f = (.) ((.) f) > (.) . (.) f g = (.) ((.) f) g > (.) . (.) f g = ((.) f) . g > (.) . (.) f g a = ((.) f) (g a) > (.) . (.) f g a = (.) f (g a) > (.) . (.) f g a = f . (g a) > (.) . (.) f g a b = f . (g a) $ b > (.) . (.) f g a b = f ((g a) b) > (.) . (.) f g a b = f (g a b) Thanks for the proof. I see it's got the advantage over mine that it doesn't need to use eta expansion and is also much clearer. Regards, Brian.

1 0

Projects related to Haskell
by Imam Tashdid ul Alam 27 May '06

27 May '06

I was just wondering, when the HCAR will come out. just the same, for people like me who are not very involved with the community, it is difficult to get an overview of the ongoing projects. the wiki says Gofer is now abandoned and Hugs replaces it. nice to know. I wonder how about Mondrian, Eden and the rest. there should be a mechanism to officially deprecate a project, shouldn't there? and once again, a mechanism to nominate a successor so that newbies like me will know where to start exploring. cheers. Imam __________________________________________________ Do You Yahoo!? Tired of spam? Yahoo! Mail has the best spam protection around http://mail.yahoo.com

1 0

request for co-development: improving Data.CharEncoding module
by Bulat Ziganshin 27 May '06

27 May '06

Hello Haskell, i plan to publish new version of Streams library on next week (see http://haskell.org/haskellwiki/Library/Streams if you still don't know about it :) ). one of it's current drawbacks is lack of support for file encodings other than UTF-8 and Latin-1. if someone can work on this support, it will widen usage area of the library i attached to letter current version of this module. it uses monadic approach to encoding and decoding: each encoder is just a function that performs monadic PutChar action via calls to monadic PutByte action, and decoder in the same fashion translates each call to GetChar into calls to GetByte. this allows to use encoders in various environments - for monadic i/o, string conversion and so on this module requires two improvements - first, support for other UTF encodings; second, raising an exception in situations when data can't be encoded (such as char > '\255' for Latin-1) or decoded (bad UTF bytes sequence). if you are going to work on this module, please write about this here - to avoid overlapping of work -- Best regards, Bulat mailto:Bulat.Ziganshin@gmail.com

2 2

Re: [Haskell] Keeping input separate from output?
by Clifford Beshers 27 May '06

27 May '06

ihope wrote: > > How would I keep the "Foo!" from conflicting with the "Lorem ipsum > dolor sit amet."? Well, if two millennia were not enough, I'm not sure any amount of Haskell will help.

1 0

help with MPTC for type proofs?
by David Roundy 26 May '06

26 May '06

Hi all, I've been thinking about extending some (experimental) GADT-based proof code that verifies that the darcs patch theory code is properly used. A given patch has type (Patch a b), and I'd like to be able to write something like commute :: (Patch a b, Patch b c) -> (Patch a d, Patch d c) in such a way that the type system know that the type d is one particular type, uniquely determined by the types a, b and c. Currently, which I do is to make d be existential with data Pair a c where (:.) :: Patch a d -> Patch d c -> Pair a c commute :: Pair a c -> Pair a c which prevents misuse of the returned pair, but doesn't allow proper use, for example we ought to be able to compile: test (a :. b) = do (b' :. a') <- return $ commute (a :. b) (b'' :. a'') <- return $ commute (a :. b) (a''' :. b''') <- return $ commute (b' :. a'') return () but this will fail, because the compiler doesn't know that b' and b'' have the same type. So I'd like to write something like class Commutable a b d c commute :: Commutable a b d c => (Patch a b, Patch b c) -> (Patch a d, Patch d c) But for this to work properly, I'd need to guarantee that 1. if (Commutable a b d c) then (Commutable a d b c) 2. for a given three types (a b c) there exists at most one type d such that (Commutable a b c d) I have a feeling that these may be enforceable using fundeps (or associated types?), but have pretty much no idea to approach this problem, or even if it's soluble. Keep in mind that all these types (a, b, c and d) will be phantom types. Any suggestions would be welcome. -- David Roundy http://www.darcs.net

2 1

Re: [Haskell-cafe] Linking to third party libraries in windows
by Brian Hulley 26 May '06

26 May '06

Dear friends - I must have clicked "reply" instead of "reply all" so here is the reply haskell cafe would have received: Matthew Bromberg wrote: > Not only does your suggestion make more sense than what I was doing, > but also > it causes the 'matrices' to behave as expected, namely to have the > side effects > incorporated into their array values. > > I can't say I fully understand why this is true. In both cases I was > wrapping Rmatrix in > a monad after every computation. The difference is that the array > component had an > additional monad wrapper around and now it doesn't. That is, > > old case > newtype Rmatrix = Rmatrix (Int, Int, IO(StorableArray Int CDouble)) > > new case > newtype Rmatrix = Rmatrix (Int, Int, StorableArray Int CDouble) > > In the old way, the additional IO wrapper forces an additional > nesting of do loops for most processing. This is the essential difference, but I think you haven't quite understood what it means. When you say > The difference is that the array component had an > additional monad wrapper around and now it doesn't. this is not correct. IO (StorableArray Int CDouble) is a monadic *value* itself, which represents an *action* which returns a storable array, and since you are filling in the slot in Rmatrix with the action (newListArray a l), this monadic value represents the action of creating a new array whenever the action is executed. Whereas (StorableArray Int CDouble) is the actual array itself. You could also use your old definition of Rmatrix but change the way it is created eg: listtoRmatrix r c es = do arr <- newListArray (0, r * c) es return (Rmatrix r c (return arr)) do r2 <- listtoRmatrix 3 2 [1, 1, 1, 1, 1, 1] -- the rest is old code and everything would work as expected, because in this case, the monadic action contained in Rmatrix just returns the array arr that was created in the execution of listtoRmatrix 3 2 [1, 1, 1, 1, 1, 1], because listtoRmatrix is the only place where the action of creating a new array, ie (newListArray (0, r * c) es) is actually executed. I think the subtlety is one of these things that's very difficult to understand at first, but once you've grasped the fact that in Haskell expressions can evaluate to actions which are themselves values, and which in turn can create new values when executed, it will hopefully become a lot clearer. Regards, Brian. -- Logic empowers the living and justifies the dead. But societal laws, and religious dogma, empower the dead, to destroy what's living. http://www.metamilk.com

1 0

Re: [Haskell-cafe] Linking to third party libraries in windows
by Matthew Bromberg 26 May '06

26 May '06

Not only does your suggestion make more sense than what I was doing, but also it causes the 'matrices' to behave as expected, namely to have the side effects incorporated into their array values. I can't say I fully understand why this is true. In both cases I was wrapping Rmatrix in a monad after every computation. The difference is that the array component had an additional monad wrapper around and now it doesn't. That is, old case newtype Rmatrix = Rmatrix (Int, Int, IO(StorableArray Int CDouble)) new case newtype Rmatrix = Rmatrix (Int, Int, StorableArray Int CDouble) In the old way, the additional IO wrapper forces an additional nesting of do loops for most processing. It is certainly the case that the do loop that performs the withStorableArray operations has the contents of the array modified. Outside that loop, once all actions on the monad are done, I am not convinced the array will mutate unless it's explicitly returned. Now hopefully I won't induce unnecessary copying. Thanks again for your help. Brian Hulley wrote: > > Hi Matthew - > Sorry about the long delay in my reply to your last message - I'd > composed the reply but when I tried to send it I was blocked by > spamhaus.com because the dynamic IP that my ISP had allocated to me at > the time I was connected had been listed on some composite spam > blocker database, and even when I tried reconnecting several times I > kept ending up being allocated the same client IP. So I did a complete > scan of my system and now (several hours later) when I tried to > reconnect again, I've been allocated a different client IP so my reply > to your last message was sent at last! ... > > I hope it answers your question relating to the above: the array is > not created in the let statement, but twice, in > rout <- mac r2 (-0.5) rmat > and then again in > mprint r2 > > Rmatrix really needs to have type (Int, Int, StorableArray Int > CDouble) if your intention is to pass around an actual allocated > matrix together with its dimensions, and listtoRmatrix would need to > be typed as: > > listtoRmatrix :: Int -> Int -> IO Rmatrix > > so that the let statement could be replaced by > > r2 <- listtoRmatrix 3 2 [1, 1, 1, 1, 1, 1] > > and for example mprint would be defined as: > > mprint :: Rmatrix -> IO () > mprint (Rmatrix cols rows arr) = do > -- just print element at (0,0) for the moment > readArray arr 0 >>= print > > (Of course the above needs to iterate through the rows cols etc but > you've already got the code to do this...) > > Hope this helps, > > Brian. >

2 1

Re: [Haskell-cafe] Linking to third party libraries in windows
by Matthew Bromberg 26 May '06

26 May '06

OK I'm punting on the AMD libraries for now and will just use the Atlas libraries until I can get to the bottom of this. However, for me, it seems the rabbit hole goes a little deeper on the issue of array copies. Consider this code snippet import Matrix main = do print "Matrices" let r2 = listtoRmatrix 3 2 [1, 1, 1, 1, 1, 1] rout <- mac r2 (-0.5) rmat putStrLn "\nrout" mprint rout putStrLn "\nrmat2" mprint r2 putStrLn "\nrmat" mprint rmat An Rmatrix has type (Int, Int, IO (StorableArray Int CDouble)) and mac (multiply and accumulate) should provide the side effecting operation A <- A+ alpha * B for mac A alpha B . It returns IO(Rmatrix) for clarity here. listtoRmatrix just returns a regular Rmatrix. Now mac is implemented via daxpy and it should modify the mutable array in r2. rout is printed prior to r2, which (surprisingly?) remains unchanged. Here are the outputs rout 0.5000000 -1.0000000 0.0000000 -1.5000000 -0.5000000 -2.0000000 rmat2 1.0000000 1.0000000 1.0000000 1.0000000 1.0000000 1.0000000 rmat 1.0000000 4.0000000 2.0000000 5.0000000 3.0000000 6.0000000 Thus Haskell does not allow the side effect to affect the let binding. How does it achieve this without copying r2? If I bound r2 to this matrix using <- and a monad wrapper the result is the same. Does it recreate r2 just prior to the call to mprint r2? If Haskell has a magic way of doing this, without actually making a copy of the mutable array in r2, that would be pretty nifty actually. Brian Hulley wrote: > > I'd thought the stub was just to give the compiler something to > compile against, and that __stdcall was only used by Windows API > rather than all DLLs, but no doubt you're right. Ive just been looking > at the "Exporting from a DLL" help page from Visual Studio and it says > "When exporting functions with either method, make sure to use > __stdcall", so perhaps the functions I've exported using > __declspec(dllexport) are using __stdcall after all. > >> >> Now for my 'surprising' result. The matrix library is working against >> double arrays stored in a StorableArray. Presumably these storable >> arrays are mutable, but in fact the compiler makes sure that the >> array's are copied, when I enter a do clause. So for example >> arrx = newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int CDouble) >> arry = newListArray (1 , 3) [1,1,1]:: IO (StorableArray Int CDouble) >> >> allocates two Storable arrays. > > No - this doesn't do any allocation. It just sets up two equations so > that anywhere you write arrx is equivalent to writing newListArray (1 > , 3) [3,2,1]:: IO (StorableArray Int CDouble) > > > It's not copied. A new array is created. Your do loop is the same as: > > -- the outer do > do > -- presumably you wrote arr <- arrx somewhere here > arr <- newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int CDouble) > > -- the do loop quoted above > do > arr <- newListArray (1 , 3) [3,2,1]:: IO (StorableArray Int > CDouble) > withStorableArray arr sumarr >>= print > > -- view the contents of the first "arr" > putStrLn "Element 1: " >> (readArray arr 1 >>= print) > > Regards, Brian. >

1 0