March 2009 - Beginners

Circular Linked Lists
by Matthew J. Williams 04 Feb '10

04 Feb '10

Dear All How would one mimic, in Haskell, a C++ circular linked list i.e., where the last element precedes (points to) the first? Sincerely Matthew J. Williams

10 20

Event handling in GTK2hs: managing events and global state
by Александър Л. Димитров 04 Apr '09

04 Apr '09

Hello community, I'm just diving into my first bigger Haskell problems, and got stuck at a certain point with gtk2hs. I couldn't find documentation or even small examples for it, no matter where I looked, so I turn to this list. My basic problem is that I want a certain action to happen based on the effects of a side effect; in my case, loading a file into a widget. Together with the file, I load a data structure, and define an event that will translate clicks on the widget into some magic on the data structure. So when I load a file, I do the following: > loadFile :: GladeXML -> FilePath -> IO () > loadFile xml fp = do widget <- xmlGetWidget -- … > -- do stuff with the widget, yield some 'data' > connectId <- widget `on` buttonPressEvent $ handler data > … (this is a minimal trivial example, to show the crucial point.) So, the handler step depends on the particular contents of the file. This means, that for every file I load, I first have to disable the old action, and only then install a new one, since I generate a new handler every time a file is loaded. Every addition of a handler gives me a connectId, which is its true name. And, as the gtk2hs docs inform me, I have to call it by its true name to dispel it. The gtk2hs docs suggest I 'keep around' the connectId, but herein lies my problem. The loadFile function can be called from several spots in the application (and I'd like to keep it that way.) Even if I wrapped loadFile in a State monad, those entry points to load file (command line, menu, button, possibly more) have no way of knowing the state of connectId, lest I make it global (*shudders*) using unsafePerformIO and a Maybe IORef. Forgive me if I'm missing something obvious, but I have thus far only used monads for serialized code flows, and not for asynchronous, event-driven computation. So the other approach would be (and thanks to mmorrow at freenode for the idea) to wrap my widget component (if I understood correctly) in a new type that also keeps track of its connectedId (namely, the event it's been connected to) via an IORef. This way the state gets 'hidden' in the IO monad, via IORef. I'd end up with something like data WW = WW { widget :: SomeWidget , connectId :: IORef (Maybe (ConnectId SomeWidget)) } and of course no monads to indicate there's something state-changing going on (Except the IO monad, which is the underlying monad for the whole brouhaha anyway.) The above call would look more like: > main = do … > widget <- xmlGetWidget … > nothingRef <- newIORef Nothing > openButton `onClicked` $ loadFile xml fp (WW widget nothingRef) > … > > > loadFile :: GladeXML -> FilePath -> WW -> IO () > loadFile xml fp (WW widget cid) = -- do stuff, yield some 'data' > ref <- readIORef cid > case ref of > (Just i) -> signalDisconnect i > Nothing -> return () > connectId <- widget `on` buttonPressEvent $ > handler data widget > writeIORef cid $ Just connectId > … This doesn't strike me as a very elegant way of doing it. I'm sure there is some nice Haskellery that would make it more beautiful, so I'd like to ask this list what that might be? Also, a small plea: the gtk2hs documentation is sorely lacking an example of the usage of "signalDisconnect". I can provide a working minimal example of this solution, if anyone is interested, so maybe that could serve as a documentation. Though I still hope that this isn't the best possible way of doing it. Thanks in advance, Aleks

2 2

beginner's type error
by Ivan Moore 03 Apr '09

03 Apr '09

Hi all, consider this very small function: thing n = n + round(sqrt n) It loads into ghci with no warnings. When I try to run "thing 10" I get: *Main> :load c:\temp\statictype.hs [1 of 1] Compiling Main ( C:\temp\statictype.hs, interpreted ) Ok, modules loaded: Main. *Main> thing 10 <interactive>:1:0: Ambiguous type variable `t' in the constraints: `Integral t' arising from a use of `thing' at <interactive>:1:0-7 `RealFrac t' arising from a use of `thing' at <interactive>:1:0-7 `Floating t' arising from a use of `thing' at <interactive>:1:0-7 Probable fix: add a type signature that fixes these type variable(s) I have tried to add various type signatures (without really knowing what I'm doing!) and haven't been able to get it to work. I am confused about a few things related to this: (a) what type signature fixes it and why it needs any help - it looks like the sort of thing that type inference shouldn't need any help with (b) it looks like a runtime type error and I thought you didn't get runtime type errors in Haskell (c) if I substitute 10 for n and do "10 + round(sqrt 10)" I get the expected answer 13 any help most welcome. cheers, Ivan

8 13

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

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

01 Apr '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

can run in ghci but can't compile.
by Anand Mitra 30 Mar '09

30 Mar '09

Hi, I can run the following program in the interpreter ghci but can't compile it. The program I am trying to compile is a simple copy using the lazy bytestrings. I have been working out exercises from Real World haskell and I was benchmarking this version which is supposed to be optimum. ,---- | import qualified System as S | import qualified Data.ByteString.Lazy as L | | main = do | [from, to ] <- S.getArgs | file <- L.readFile from | L.writeFile to file `---- While trying to compile this i get the following errors. ,---- | mitra@ravan:~/laptop/haskell/learn$ /opt/ghc-6.10.1/bin/ghc cp.hs | cp.o: In function `sB1_info': | (.text+0xab): undefined reference to `bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_writeFile_closure' | cp.o: In function `sAW_info': | (.text+0xe1): undefined reference to `bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_readFile_closure' | cp.o: In function `sB5_info': | (.text+0x30f): undefined reference to `__stginit_bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_' | cp.o: In function `sB5_srt': | (.data+0x4): undefined reference to `bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_readFile_closure' | cp.o: In function `sB5_srt': | (.data+0x8): undefined reference to `bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_writeFile_closure' | collect2: ld returned 1 exit status | mitra@ravan:~/laptop/haskell/learn$ rm cp.o | mitra@ravan:~/laptop/haskell/learn$ /opt/ghc-6.10.1/bin/ghc cp.hs | cp.o: In function `sB0_info': | (.text+0xab): undefined reference to `bytestringzm0zi9zi1zi4_DataziByteStringziLazzy_writeFile_closure' | cp.o: In function `sAV_info': `---- But this program is not syntactically or otherwise flawed since I can run it under ghci. ,---- | mitra@ravan:~/laptop/haskell/learn$ /opt/ghc-6.10.1/bin/ghci | GHCi, version 6.10.1: http://www.haskell.org/ghc/ :? for help | Loading package ghc-prim ... linking ... done. | Loading package integer ... linking ... done. | Loading package base ... linking ... done. | Prelude> :l cp.hs | Ok, modules loaded: Main. | Prelude Main> :main /etc/passwd /tmp/xyz | Loading package bytestring-0.9.1.4 ... linking ... done. | Loading package unix-2.3.1.0 ... linking ... done. | Loading package filepath-1.1.0.1 ... linking ... done. | Loading package old-locale-1.0.0.1 ... linking ... done. | Loading package old-time-1.0.0.1 ... linking ... done. | Loading package directory-1.0.0.2 ... linking ... done. | Loading package process-1.0.1.0 ... linking ... done. | Loading package syb ... linking ... done. | Loading package array-0.2.0.0 ... linking ... done. | Loading package random-1.0.0.1 ... linking ... done. | Loading package haskell98 ... linking ... done. | Prelude Main> `---- Since I suspect that this might be a problem with the way I have installed gch-6.10.1 I will explain how I have installed it.

3 3