October 2011 - Beginners

slightly scramble list randomly
by Dennis Raddle 22 Oct '11

22 Oct '11

I want to take a list of size N that starts in ascending order and "slightly randomly scramble it"--- each element is moved within M steps of its original position (there can be some tolerance for slightly over M). The application is a backtracking algorithm that produces random solutions but tends to favor certain choices--at each node of the search tree I can evaluate the goodness of each possible next step, but I don't want the algorithm to always take the best choice. Just roughly, much of the time. Dennis

2 1

[Yesod] How can I dynamically generate selectFields
by Michael Litchard 21 Oct '11

21 Oct '11

Link to details http://stackoverflow.com/questions/7854923/how-can-i-dynamically-generate-s…

1 0

Unresponsive interactive GHC using Leksah
by Hugo Ferreira 21 Oct '11

21 Oct '11

Hello, I am trying out the code in the book http://nlpwp.org/. When testing the code in chapter 7 (POS tagger), the interactive session consumes much memory and the whole system becomes unresponsive (Ubuntu 10.04, Dual Core, 2 Gig memory). I even find it difficult to kill the process. If I execute a ghci session I see very large memory (1.6Gig) use and relative slow execution. However the system does not become as unresponsive. If I run the executable directly the execution goes from minutes to seconds. Anyone know if I can tweak GHCi and/or leksah to avoid or simple reduce this problem? TIA, Hugo F.

2 2

TLS, PGP and maybe more crypto-stuff
by Mateusz Neumann 21 Oct '11

21 Oct '11

Hi I am considering using Haskell in my next project. However the very core of my application depends on strong cryptographic algorithms securing communication. I thought about using GnuPG (PGP) but did not find Haskell library (I admit, I did not search for long). So my idea was to look into TLS based stuff, but here I found few different libraries. For a moment I thought of developing something basing on ECC, but again I did not find anything. My questions are: * is there a (decent) GnuPG (PGP) library in Haskell? * what TLS (possibly 1.2) library would you suggest? * is there a ECC library? -- Mateusz

2 4

About Data (was List of all prelude function types?)
by Rustom Mody 20 Oct '11

20 Oct '11

Ive a related couple of questions: Whats with the word 'Data'? Almost every Haskell module seems to be under Data. I dont get exactly the usage of the word. Also is there some easy way of browsing up and down the hackage hierarchical structure? [I know about hoogle and hayoo. I perhaps dont know how to use them well]

2 1

parser error coordinates transformation from preprocessed to original text
by Radoslav Dorcik 20 Oct '11

20 Oct '11

Hi! The parser function in my library is exposed to user which hides internally preprocessing & parsing. When parser error ocurr the coordinates are in preprocessed text, but library function user deserves to know coordinates in original text. Following is my application flow (simplified): {- User exposed library function -} parseLDIF :: String -> Either ParseError LDIF parseLDIF xs = myParser $ myPreprocessor xs {- Expects the preprocessed input -} myParser :: String -> Either ParseError LDIF {- Remove comments and unwarp lines; No new text added only removed -} myPreprocessor :: String -> String My approach I'm going to implement is to keep information what myProcessor did on text (some kind of journal of preprocessing). In the case of error this journal will be used for original text coordinates calculation. myPreprocessor :: String -> (String,[PreprocessorOperation]) Anyway, I have feeling that I'm doing something very wrong... reason for this email. What is the common approach to transform error coordinates from preprocessed to original text ? Is that common to separate preprocessing & parsing phase ? Thanks, Rado

2 3

using record in aeson
by Rick Murphy 19 Oct '11

19 Oct '11

Hi All: I've been elaborating on aeson examples and wondered whether someone could clarify the syntax for using a record in a pair. My goal is to substitute a record for the list of pairs created through the data constructor O [(T.Text, Value)] in MyPair below. Reason being to embed the semantics of the json file into the record. To reproduce, just uncomment the lines in the source below. The json file structure is as follows: {"outer":{"type":"literal","value":"rick"}} Note my naive attempt in the commented lines returns the following message from ghci. 'f0 b0' doesn't give me much to go on. -- E1.hs:35:41: -- Couldn't match expected type `MyRecord' with actual type `f0 b0' -- In the expression: MyRecord <$> o'' .: "type" <*> o'' .: "value" -- In the first argument of `R', namely -- `(t, MyRecord <$> o'' .: "type" <*> o'' .: "value")' -- In the expression: R (t, MyRecord <$> o'' .: "type" <*> o'' .: "value") -- Failed, modules loaded: none. {-# LANGUAGE OverloadedStrings #-} module Main where import Control.Applicative import Control.Monad (mzero) import qualified Data.ByteString as B import qualified Data.Map as M import qualified Data.Text as T import Data.Aeson import qualified Data.Aeson.Types as J import Data.Attoparsec -- data MyRecord = MyRecord {s :: String, u :: String} deriving (Show) data MyPair = O (T.Text, [(T.Text, Value)]) -- | R (T.Text, MyRecord) deriving (Show) data ExifObject = ExifObject [MyPair] deriving Show data Exif = Exif [ExifObject] deriving Show instance FromJSON ExifObject where parseJSON (Object o) = ExifObject <$> parseObject o where parseObject o' = return $ map toMyPair (M.assocs o') toMyPair (t, Object o'')= O (t, M.assocs o'') -- toMyPair (t, Object o'')= R (t, MyRecord <$> o'' .: "type" <*> o'' .: "value") toMyPair _ = error "unexpected" parseJSON _ = mzero parseAll :: B.ByteString -> [ExifObject] parseAll s = case (parse (fromJSON <$> json) s) of Done _ (Error err) -> error err Done ss (Success e) -> e:(parseAll ss) _ -> [] main :: IO () main = do s <- B.readFile "e1.json" let p = Exif $ parseAll s print p -- Rick

2 3

Data-List-Utils
by CEO'Riley 19 Oct '11

19 Oct '11

Hello, I am new to Haskell and eager to learn what I believe is an exciting language. I have recently attempted to load the ProviderLookupApp module attached and received the following error message: ProviderLookupApp.hs:14:8: Could not find module `Data.List.Utils': Use -v to see a list of the files searched for. I then located the Data.List.Utils module and attempted to load that but received the error message: Data.List.Utils.hs:63:8: Ambiguous module name `Control.Monad.State': it was found in multiple packages: monads-fd-0.2.0.0 mtl-2.0.1.0 Failed, modules loaded: none. I am running in the Windows environment. Any assistance in this matter would be greatly appreciated. Additionally, exactly how is the -v argument used? Thanks. Regards, CEO'Riley Charles E. O'Riley Jr.

2 3

Re: [Haskell-beginners] recursion and pattern matching
by Alia 18 Oct '11

18 Oct '11

Ok, so having spent some further time on this. Methinks I have a solution below. The aha moment occurred when I fell upon the definition of foldr and then looked at the recursive functions. foldr :: (a -> b -> b) -> b -> [a] -> b foldr f z [] = z foldr f z (x:xs) = f x (foldr f z xs) treeFold is implemented two ways, the first is as Brent advised, the second places the accumulator after the function and follows from foldr. I suspect the first approach is probably more practical because you can curry the accumulator away. The final check function verifies the equivalence of recursive and fold friendly functions. It was a cool exercise in all. Thanks Brent! (-: AK <Test.hs> module Test where data Tree a b = EmptyTree | Node a b [Tree a b] deriving (Show, Read, Eq) t = Node "goal" 1.0 [ Node "a2" 0.5 [ Node "a3" 3.0 [ Node "a4" 1.0 [ Node "a5" 1.0 [] ] ] ], Node "b2" 0.5 [ Node "b3.1" 2.0 [], Node "b3.2" 2.0 [ Node "b4" 10.0 [] ] ] ] maximum0 [] = 0 maximum0 xs = maximum xs sumTree :: (Num b) => Tree a b -> b sumTree EmptyTree = 0 sumTree (Node _ value children) = value + sum (map sumTree children) count :: Tree a b -> Int count EmptyTree = 0 count (Node _ value children) = 1 + sum (map count children) depth :: Tree a b -> Int depth EmptyTree = 0 depth (Node _ value children) = 1 + maximum0 (map depth children) treeFold :: c -> (a -> b -> [c] -> c) -> Tree a b -> c treeFold acc f EmptyTree = acc treeFold acc f (Node name value children) = f name value (map (treeFold acc f) children) treeFold' :: (a -> b -> [c] -> c) -> c -> Tree a b -> c treeFold' f z EmptyTree = z treeFold' f z (Node name value children) = f name value (map (treeFold' f z) children) sumTree' :: String -> Double -> [Double] -> Double sumTree' name value xs = value + sum xs count' :: (Num c) => a -> b -> [c] -> c count' name value xs = 1 + sum xs depth' :: (Num c, Ord c) => a -> b -> [c] -> c depth' name value xs = 1 + maximum0 (xs) check = [ count t == treeFold' count' 0 t , sumTree t == treeFold' sumTree' 0 t , depth t == treeFold' depth' 0 t ] <Test.hs>

2 1

Ord and Eq instances for complex types
by Mike Meyer 18 Oct '11

18 Oct '11

I'm working on a problem dealing with poker hands, and need to rank them. The Ord instance seems like a natural for this, but the code came out with a lot of repetitions in it. To wit, given suitable definitions for Rank, Suit and Card, I define a Hand as: data Hand = HighCard [Card] | PairOf Rank [Card] | TwoPair Rank Rank [Card] | ThreeOfAKind Rank [Card] | Straight [Card] | Flush [Card] | FullHouse Rank Rank [Card] | FourOfAKind Rank [Card] | StraightFlush [Card] deriving (Show) [N.B. - the single or double rank is the Rank of the cards participating in that type of hand, and is compared before the rest of the cards, so AQQJT is not as good a hand as KK321 - a pair of kings beating a pair of queens.] Eq winds up looking like: instance Eq Hand where h1 == h2 = cards h1 == cards h2 where cards (HighCard h) = h cards (PairOf _ h) = h -- etc. and Ord (with appropriate check functions) like: instance Ord Hand where compare (StraightFlush h1) (StraightFlush h2) = compare h1 h2 compare (StraightFlush _) _ = GT compare _ (StraightFlush _) = LT compare (FourOfAKind r1 h1) (FourOfAKind r2 h2)= check r1 h1 r2 h2 compare (FourOfAKind _ _) _ = GT compare _ (FourOfAKind _ _) = LT -- etc Seems like there ought to be an easier way. I can see that making the types of hands an enum (HandType), then defining a hand as a record: data Hand = { type :: HandType, rank1 :: Maybe Rank, -- (2, 3, 4) of a kind rank2 :: Maybe Rank, -- 2 pair, full house cards :: [Card] } would make the comparisons a lot easier. But that would make constructing them a lot more painful. I can't just say "PairOf Ace hand" to mark a hand as a pair of aces. It also the type checking from the constructors. Is there some third alternative I've overlooked that combines the best features of both approaches? Thanks, <mike

2 6