- Beginners - Haskell.org

the equivalent of OO class data and methods
by Michael Mossey 02 Apr '09

02 Apr '09

I'm making the transition from OO to Haskell, and a major problem for me is that I'm used to OO, where member variables are distinct from other variables and functions, so I can use totally generic member variable names and never have a conflict with other member variables or local variables. For example, if I want to create LayoutItem and name its coordinates x and y, I do this: (Python) class LayoutItem : def __init__( self, x, y ) : self.x, self.y = (x, y ) Then later, p = LayoutItem( 10, 20 ) Then later I can refer to p.x and p.y. I can also create other classes and name *their* member variables x and y, with no confusion. Now, I know that in Haskell I can do data LayoutItem = LayoutItem { x, y :: Int } Later, let p = LayoutItem { x = 10, y = 20 } I have read that this automatically creates "accessor" functions called x and y, so I can refer to (x p) and (y p) let foo = (x p)^2 + (y p)^2 Now let's say I create another type that also uses x and y: data Notehead = Notehead { x, y :: Int } n = Notehead { x = 100, y = 200 } This doesn't work. Apparently the accessor functions x and y (for LayoutItem) have global scope and conflict with those for Notehead. Which means I have to name them different things, which is awkward. For example, data LayoutItem = LayoutItem { layoutItemX, layoutItemY :: Int } data Notehead = Notehead { noteheadItemX, noteheadItemY :: Int } Also, I tried using some of these accessor function names as variables, and the compiler doesn't distinguish between them. For example, myfunc :: Notehead -> LayoutItem -> Int myfunc n p = let layoutItemY = layoutItemX p z = layoutItemY n in z^2 This doesn't work, because declaring layoutItemY as a variable hides its defintion as an accessor function. Is there a way to get what I want from Haskell? Thanks, Mike

3 2

making translation from imperative code
by Michael Mossey 02 Apr '09

02 Apr '09

I'm translating a Python program into Haskell, and running into a problem---a type of code where I don't know how to make the conceptual shift. The Python code does a graphical layout of a music score. There is a loop in which it add items (chords, symbols, text, etc.) one at a time, moving to the right, until it reaches the end of the line. So in typical imperative code, we have a bunch of loop state, such as - xpos of last chord or symbol placed - time of last chord or symbol placed - several StaffData objects, each containing the symbols that went on that particular staff - a cache of miscellaneous information about each symbol for later reference So imperative code is pretty simple: loop, and each time update the state. Much of this state consists of lists to which symbols are added once per loop. I'm not sure how to conceive of this problem in Haskell. Without using mutable variables, I would have to "rebuild" the state on each loop. I can do that, but I don't want to see an ugly proliferation of variables. I would like to encapsulate the state in a single object so I can pass it around as a single variable, like LoopState = LoopState { lastXPos :: Int, lastTime :: Double, staffDataLists :: [ ( String, StaffData ) ], chunkCache :: [ ( Double, Chunk ) ] } So lets say I have an instance of this call x. Let's say I want to create y, by "updating" lastXPos. Do I have to do something like this: newLastXPos = 25 y = LoopState ( newLastXPos, lastTime x, staffDataLists x, chunkCache x ) Obviously this is verbose compared to an imperative language in which one would say: newLastPos = 25 x.setLastXPos( newLastXPos ) I am aware that Haskell provides some mutable structures, but part of what drew me to Haskell was the benefit of avoiding mutable data (reducing bugs and making it easier to reason about my program's behavior). Are there any shortcuts for doing things like the above? Thanks, Mike

3 5

Can we make this program better (and shorter)?
by Zachary Turner 02 Apr '09

02 Apr '09

Be warned, this code is really ugly. I need some help to make it better. I was in this situation this week where there was a sample of some numbers. I knew the valid possible range that numbers could lie in, and I knew about 30% of the actual values from the sample. I also knew the original average and the original standard deviation. I wanted more information about the other values in the sample, so I sat down and derived two formulas: One that, given an average, the number of items in the average, and 1 number that you know was used somewhere in the calculation of the average, calculates what the average would be if that number had not been there. Another that does the same for standard deviation. The second formula is fairly insane, if someone can figure out how to simplify it let me know, it took forever to derive it without making any mistakes. Actually I didn't even know it was possible to do a running standard deviation like that until I sat down and derived it. So anyway the program asks the user how large the original sample was, and the average and standard deviation. Then it runs in a loop asking it for a value to remove from the sample set and calculate the updated values. For certain values however, even if they are actually in the range of valid values for the range of the sample space, they might be impossible to achieve given a certain sample size, average, and stdev (for example, if you have two numbers in the range [0..100] and the average is 100, and you remove 1 number, none of the remaining numbers can be 0 obviously). So I wanted to detect this if the user inputs such a value, that way for one thing I can calculate exact upper and lower bounds for the actual range of the numbers just by trying all possible values. I know that the nature of the program mandates that there's going to be a lot of IO Monadic code, but I still feel like my code sucks. For one thing, I really tried to make the removePoints method be pure, and just accept a list as the argument and do the I/O in another function. I imagined some kind of lazy list comprehension, where each time the removePoints method asked for the next item, it would ask for the input and do all that stuff. I couldn't figure out how to make this work. Perhaps it's not even possible, since by definition a list comprehension that asked for input when forced isn't pure. But I still think there's a better way to do it. I also really dislike having to do manual recursion for getting input, there's got to be a way to use lists and built-in functions to do it for you, using some kind of takeWhile() perhaps. Anyway if anyone has any suggestions for making this code look better, more elegant, or more Haskelly, let me know :) import Control.Arrow promptUntilValid :: (Read a, Show a, Eq a) => String -> IO a promptUntilValid prompt = do putStr prompt putStr " " result <- getLine case (reads result) of [(parsed,_)] -> return parsed invalid -> do putStrLn $ "Invalid input! You entered " ++ result ++ ", and results length is " ++ (show (length invalid)) promptUntilValid prompt newStdev :: Int -> (Int,Int,Double,Double,Double) -> Double newStdev removeValue (old_count, new_count, old_stdev, old_avg, new_avg) = sqrt.(/ (n-1.0)) $ n * σ_x^2 + 2.0*old_avg*new_avg*(n-1.0) - (n-1.0)*old_avg^2 - (a_n - old_avg)^2 - (n-1.0)*new_avg^2 where σ_x = old_stdev n = fromIntegral old_count a_n = fromIntegral removeValue removeSinglePoint :: Int -> (Int,Double,Double) -> (Int,Double,Double) removeSinglePoint value (count,stdev,avg) = (new_count,new_stdev,new_avg) where new_count = count-1 new_avg = (avg*(fromIntegral count) - (fromIntegral value)) / (fromIntegral new_count) new_stdev = newStdev value (count, new_count, stdev, avg, new_avg) removePoints :: (Int,Double,Double) -> IO () removePoints (count,stdev,avg) = do putStr "Enter a number to remove from the sample set (Enter to stop): " putStr " " result <- getLine case (result,reads result) of ("",_) -> return () (_, [(parsed,_)]) -> do if (any (uncurry (||) . (isInfinite &&& isNaN)) [new_stdev, new_avg]) then do putStrLn "That number could not have been there! The new values are NaN!" removePoints (count,stdev,avg) else do putStrLn $ "New count: " ++ (show new_count) ++ ", new stdev: " ++ (show new_stdev) ++ ", new avg: " ++ (show new_avg) removePoints (new_count,new_stdev,new_avg) where (new_count,new_stdev,new_avg) = removeSinglePoint parsed (count,stdev,avg) (_,invalid) -> do putStrLn $ "Invalid input! You entered " ++ result ++ ", and results length is " ++ (show (length invalid)) removePoints (count,stdev,avg) main = do num_values::Int <- promptUntilValid "Enter the initial number of values: " stdev::Double <- promptUntilValid "Enter the initial standard deviation: " average::Double <- promptUntilValid "Enter the initial average: " putStrLn ("num_values = " ++ (show num_values)) putStrLn ("stdev = " ++ (show stdev)) putStrLn ("average = " ++ (show average)) removePoints (num_values, stdev, average) return ()

1 0

short function to remove and replace an item
by Michael P Mossey 02 Apr '09

02 Apr '09

What if I have a list xs, and I want to remove one item and replace it with another? The item to remove can be detected by a predicate function. The order of the items doesn't matter. How about this: replaceItem :: (a -> Bool) -> a -> [a] -> [a] replaceItem p new xs = new : snd (partition p xs) This will actually replace all items that match the predicate with one copy of 'new'. It will also prepend 'new' even if no items match the predicate. For another challenge, can someone explain to me how to write this in point-free style? Thanks, Mike

4 4

Basic Parsec question
by Zachary Turner 01 Apr '09

01 Apr '09

Hi, I downloaded the package lispparser to, well, parse lisp code. I really have absolutely no idea what I'm doing though. I can look at the source of the module and see that it's exporting a single data type called LispVal and a single function called parseExpr, so somehow I should be able to pass an arbitrary block of lisp code into this function and get back a LispVal. But for the life of me I can't figure out how. I've looked at the documentation but I get even more confused because it links me to the Parsec documentation which is probably way over my head. Basically I just want a simple function: parse :: String -> LispVal parse expr = ??? presumably by making some use of the exported 'thing' (since I'm not really sure how to interpret its type) parseExpr :: Parser LispVal Thanks for any help

2 2

Re: [Haskell-cafe] abou the Godel Numbering for untyped lambda calculus
by Dan Weston 31 Mar '09

31 Mar '09

DISCLAIMER: The last I studied this was over 20 years ago, so my brain is seriously rusty. You are warned... > you mean the godel function (denoted by # and generally will be in type, > #:term -> number ?) is a kind of functions instead of a particular > function? No. The Godel mirror function (as defined by Godel) is a single function, the product of primes (whose ordering gives the position in the string) with exponents (giving the symbol at that position). However, I think any total injective function with partial injective inverse will do. Don't get hung up on the details of the mirroring (Godel doesn't). Once you accept that it can be done, there is no need to actually do it. There is nothing magic about integers, beyond the fact that elementary arithmetic is "well understood" by humans and should not have inconsistencies (it probably doesn't, but we can't prove it within any language more intuitive than arithmetic, so why should be believe the proof in that language?). Importantly, all but the last step of the proof can be encoded as primitive recursive functions, meaning that they always halt within a predetermined number of steps (satisfying the Finitists). Only the last step cannot be so limited. This is a clear example where non-finite mathematics has demonstrably more power in a fundamentally important way. Why bother going through this encoding? The main reason for the encoding is to overcome the fundamental limitation of structural induction whereby there is no "this" smaller than this. I.e. quoting a sentence only makes it longer. With functions on integers, this limitation is removed, so that although there is no string saying "This statement is not true", (since "This statement" != "\"This statement is not true\""), there *is* some function taking the Godel number of the unquoted This to the Godel number of the string to which it refers. Doing so takes some bit of cleverness, but the original proof in German is only about 8 pages long, as I recall. If we don't go with mirroring and just use strings, we need to introduce some equivalent trick, namely named functions. In a language without pointers and only lambda expressions, there is no way to refer to oneself without repeating the quote in infinite regression. For instance "\x -> 3333333" is longer than "333333". You cannot talk about a string without embedding it as a substring. However, once you add named functions to your metalanguage (Haskell): f 3 = 33333333 Then the string "f 3" is shorter than the string "xxxxxxx". Suppose f 4 = "~xxxxxxx". Now one can talk about the other with the shorter string on the left: length "f 3" < length "~xxxxxxx" but also length "f 4" < length "xxxxxxx". A longer string can talk about a shorter string (but not vice versa), so this mapping is critical to overcoming the limitation about talking about oneself. After that, the rest is easy: encode the Liar's Paradox and voila. once we have the encoding of a language, and construct functions to encode proof transformations, we can reduce derivability to a simple predicate derivable :: String -> Bool and look for some formula f such that derivable (f) == False and derivable("~" ++ f) == False. Godel's First Incompleteness Theorem merely says that there is some integer (which mirrors some well-formed formula) not in the set of integers that mirror "derivable theorems", making your system incomplete. Moreover, if you remedy this situation by adding this integer to the set as an axiom, you immediately can derive another integer which mirrors its negated formula, making your system inconsistent. The metasystem (with symbols for derivable, transformation rules like modus ponens, and the like), are not part of the formal system, but in the metalanguage. By encoding this metalanguage as well and redoing the above, you get Godel's Second Incompleteness Theorem, which says that no system can prove its own consistency, and if an axion is added to assert consistency, you can immediately also prove its negation, making it unsound. Don't look for a hat trick. Encoding the meta-meta-system buys you nothing extra. That's about all I can remember without hypnosis, and I'm afraid of what I might say under hypnosis... :) Dan Algebras Math wrote: > you mean the godel function (denoted by # and generally will be in type, > #:term -> number ?) is a kind of functions instead of a particular > function? If so, what kind of property this kinds of functions have? any > limitation? how capable they will be? > > Thanks > > alg > > On Tue, Mar 31, 2009 at 4:01 AM, Dan Weston <westondan(a)imageworks.com > <mailto:westondan@imageworks.com>> wrote: > > I can't tell exactly what you're asking, but I'll give it a try! :) > > primes :: [Integer] > primes = [2,3,5,7,11,13,17,19,23,29,31,undefined] > > godel :: String -> Integer > godel = product . zipWith (^) primes . map (toInteger . ord) > > -- Here is the identity function (note that double backslash is a > single character > godel "\\x -> x" > 1629920514342441477851613634029704631135430980107335428017064836156091059806450516131002598452000651374890570022191128551421788559667251656959733380229796871976693176094558797489489057311763922507760911447493016261397754567695234219623056037447490713525815311253273691703346455275115486717580778238094808661626709709766328915159206002675716287759792707200037683200000000000000000000000000000000 > > -- = 2^92 * 3^120 * 5^32 * 7^45 * 11^62 * 13^32 * 17^120 > > ungodel :: Integer -> String > -- ungodel . godel = id > > (See http://en.wikipedia.org/wiki/Fundamental_theorem_of_arithmetic > for why this works). > > These numbers get large quickly, but are finite for any finite > string of finite alphabet. > > godel is a total function (every string has a unique integer), and > its inverse (an exercise to the reader involving prime factor > decomposition) would also be total if the alphabet were infinite (so > that ord would be total). > > Frankly, I wouldn't know how to begin encoding the godel numbering > in the type system (shudder!), but being that it is a total > primitive recursive function, I suppose there is no theoretical > impediment. > > In contrast, Godel's Theorems themselves cannot be so encoded > because the last step involves a general recursive function. > > Dan > > > Algebras Math wrote: > > Hi all, > > I am reading the book "The lambda calculus: Its syntax and > Semantics" in the chapter about Godel Numbering but I am > confused in some points. > > We know for Church Numerals, we have Cn = \fx.f^n(x) for some > n>=0, i.e. C0 = \fx.x and C1 = \fx.fx. > > From the above definition, I could guess the purpose of this > kind of encoding is trying to encode numeral via terms. > > How about the Godel Numbering? From definition we know people > say #M is the godel number of M and we also have [M] = C#M to > enjoy the second fixed point theorem : for all F there exists X > s.t. F[X] = X. > > What the mapping function # is standing for? How could I use it? > What the #M will be? How to make use of the Godel Numbering? > > Thank you very much! > > alg > > >

1 0

What is the Haskell idiom for "if then else if then"
by Peter Hickman 31 Mar '09

31 Mar '09

I've just written this piece of code if r < 0 then LEFT else if r > 0 then RIGHT else STRAIGHT which works just fine but it does look rather clunky (as it would in any language I suppose). Is there a Haskell idiom for this type of code?

4 3

abou the Godel Numbering for untyped lambda calculus
by Algebras Math 31 Mar '09

31 Mar '09

Hi all, I am reading the book "The lambda calculus: Its syntax and Semantics" in the chapter about Godel Numbering but I am confused in some points. We know for Church Numerals, we have Cn = \fx.f^n(x) for some n>=0, i.e. C0= \fx.x and C 1 = \fx.fx. >From the above definition, I could guess the purpose of this kind of encoding is trying to encode numeral via terms. How about the Godel Numbering? From definition we know people say #M is the godel number of M and we also have [M] = C#M to enjoy the second fixed point theorem : for all F there exists X s.t. F[X] = X. What the mapping function # is standing for? How could I use it? What the #M will be? How to make use of the Godel Numbering? Thank you very much! alg

2 1

Need help to edit the Haskell script in Winhugs and documentation.
by RAJESH DALSANIYA 31 Mar '09

31 Mar '09

* * *Both sections relate to the case study: Index for a document of text.* * * *SECTION A: * * * *Given the attached Haskell code which produces an index of words, make the following alterations by modifying existing functions and including new functions where necessary – parts 1) to 5):* * * *1) **Where a word occurs N times on the same line, ensure that the line number occurs n times in the index entry for that word. * * * *2) **Allow words to be hyphenated and treat a hyphenated word as a single word. However, for those words which are split over two lines, treat a split word as a single word without the hyphen. * * * *3) **Treat a capitalised word (one or more capitals) as being different from the word in all lower case (but they should still be sorted alphabetically) – unless it is at the start of a sentence with only the initial letter capitalised. A sentence is terminated by a ‘.’, ‘?’ or ‘!’. * * * *4) **Make the output more readable in the form of an index table in columns with appropriate spacing and without brackets. * * * *5) **Include a user-friendly menu, so that the user can choose input/output file names or default files, and choose to rerun or exit. * * * *Parts 1) to 5) may be developed in any order. * * * * * *SECTION B:* * * *6) **For your version of function, makeIndex (only), show how an alternative ordering of the composed functions would provide a more efficient execution of makeIndex. Justify your answer. * * * *7) **For the parts 1) to 5) above that you have attempted, discuss the use you have made of a) higher-order functions, b) list comprehension, c) monadic input/output, d) functional composition, and/or e) partial parameterisation (or Curried functions). Include an evaluation of how useful your use of these concepts has been. * * * * * * * *import Prelude* * * *type Doc = String* *type Line = String* *type Word = String * * * *makeIndex :: Doc -> [ ([Int], Word) ]* * * *makeIndex* * = shorten . -- [([Int], Word)] -> [([Int], Word)]* * amalgamate .-- [([Int], Word)] -> [([Int], Word)]* * makeLists . -- [(Int, Word)] -> [([Int], Word)]* * sortLs . -- [(Int, Word)] -> [(Int, Word)]* * allNumWords .-- [(Int, Line)] -> [(Int, Word)]* * numLines . -- [Line] -> [(Int, Line)]* * splitUp -- Doc -> [Line]* * * *splitUp :: Doc -> [Line]* * * *splitUp [] = []* *splitUp text* * = takeWhile (/='\n') text : -- first line* * (splitUp . -- splitup other lines* * dropWhile (==’\n’) . -- delete 1st newline(s)* * dropWhile (/='\n')) text -- other lines* * * *numLines :: [Line] -> [(Int, Line)]* * * *numLines lines -- list of pairs of * * = zip [1 .. length lines] lines -- line no. & line* * * *-- for each line* *-- a) split into words* *-- b) attach line no. to each word* * * *splitWords :: Line -> [Word] -- a)* * * *splitWords [] = []* *splitWords line * * = takeWhile isLetter line : -- first word in line* * (splitWords . -- split other words* * dropWhile (not.isLetter) . -- delete separators* * dropWhile isLetter) line -- other words* * where* * isLetter ch* * = (‘a’<=ch) && (ch<=’z’)* * || (‘A’<=ch) && (ch<=’Z’)* * * *numWords :: (Int, Line) -> [(Int, Word)] -- b)* * * *numWords (number, line)* * = map addLineNum ( splitWords line) -- all line pairs* * where* * addLineNum word = (number, word) -- a pair* * * *allNumWords :: [(Int, Line)] -> [(Int, Word)]* * * *allNumWords = concat . map numWords -- doc pairs * * * *sortLs :: [(Int, Word)] -> [(Int, Word)]* * * *sortLs [ ] = [ ]* *sortLs (a:x)* * = sortLs [b | b <- x, compare b a] -- sort 1st half* * ++ [a] ++ -- 1st in middle* * sortLs [b | b <- x, compare a b] -- sort 2nd half* * where* * compare (n1, w1) (n2, w2)* * = (w1 < w2) -- 1st word less* * || (w1 == w2 && n1 < n2) -- check no. * * * *makeLists :: [(Int, Word)] -> [([Int], Word)]* * * *makeLists * * = map mk -- all pairs* * where mk (num, word) = ([num], word)* * -- list of single no.* * * *amalgamate :: [([Int], Word)] -> [([Int], Word)]* * * *amalgamate [ ] = [ ]* *amalgamate [a] = [a]* *amalgamate ((n1, w1) : (n2, w2) : rest)-- pairs of pairs* * | w1 /= w2 = (n1, w1) : amalgamate ((n2, w2) : rest)* * | otherwise = amalgamate ((n1 ++ n2, w1) : rest)* * -- if words are same grow list of numbers* * * *shorten :: [([Int], Word)] -> [([Int], Word)]* * * *shorten* * = filter long -- keep pairs >4* * where* * long (num, word) = length word > 4 -- check word >4* * *

3 3

Logging in Haskell
by Sergey Mikhanov 31 Mar '09

31 Mar '09

Hi community, As my Haskell programs grow above 100 lines of code, I feel the necessity to trace the execution of them more closely. In imperative languages one may use logging facilities for checking intermediary values of variables, the execution flow, etc. How this usually handled in Haskell (I bet that despite the fact that in Haskell it is relatively easier to write bug-free and checked code, the industrial systems still need some logging being done)? Regards, Sergey

3 2