October 2012 - Beginners

Pound character use in code?
by M.v.Gulik 23 Oct '12

23 Oct '12

Hi Trying to learn a bit about Haskell as general (script) coder (batch, autoit, python). And run into some code I don't get. (could not find the right online doc that explained it.) [Code] length' :: [a] -> Int length' l = len l 0# where len :: [a] -> Int# -> Int len [] a# = I# a# len (_:xs) a# = len xs (a# +# 1#) [/Code] source: http://www.haskell.org/ghc/docs/latest/html/libraries/base/src/GHC-List.htm… 1) What is the purpose of the used pound/"#" character here. (Looks like some type-casting, but that's just a wild guess from me here. (I'm not a C~ or Java coder)) 2) kinda the same for the "I#" in the "len [] ..." line. As the length function takes only one return result. (note: its a capital i and not a lowercase L.) 3) Why is it giving a compile error on the "where" line. Error: "Haskell\baby.hs:<lineNr>:9: parse error on input `where'" (while the adjusted code below compiles fine. Tab(4s) indented.) [Code] length' :: [a] -> Int length' l = len l 0 where len :: [a] -> Int -> Int len [] a = a len (_:xs) a = len xs (a + 1) [/Code] Using: WinGHCi 1.0.6 on Windows Xp. (Haskell Platform 2012.2.0.0 windows install) TIA MvGulik

2 1

no instance for monad
by Emmanuel Touzery 21 Oct '12

21 Oct '12

Hello, in my program i have a function which can be simplified like this: writeProgramInfo :: Handle -> ProgramInfo -> IO () writeProgramInfo handle program = do hPrintf handle "hello" This is using the hPrintf from Text.Printf. Unfortunately that hPrintf works on String parameters which is not good enough because I need unicode character support (if I use unpack it works on linux but complains about invalid characters on windows, I guess because my locale on linux is utf-8 but on windows it's a local codepage). So I found the Text.Format library: http://hackage.haskell.org/packages/archive/text-format/0.3.0.7/doc/html/Da… Which appears to solve exactly that problem (out of the box Text support). However I can't just install the library, add the import statements, and replace hPrintf by TF.hprint and change the format string, that doesn't work; if I change this function to: import qualified Data.Text.Format as TF writeProgramInfo :: Handle -> ProgramInfo -> IO () writeProgramInfo handle program = do TF.hprint handle "hello" I get this error message at build time: Couldn't match expected type `IO ()' with actual type `ps0 -> m0 ()' In the return type of a call of `TF.hprint' In the expression: TF.hprint handle "hello" In the expression: do { TF.hprint handle "hello" } Now this clearly results from the type of hprint, which is: hprint :: (MonadIO<http://hackage.haskell.org/packages/archive/transformers/0.2.2.0/doc/html/C…>m, Params<http://hackage.haskell.org/packages/archive/text-format/0.3.0.7/doc/html/Da…>ps) => Handle<http://hackage.haskell.org/packages/archive/base/4.4.1.0/doc/html/GHC-IO-Ha…>-> Format<http://hackage.haskell.org/packages/archive/text-format/0.3.0.7/doc/html/Da…>-> ps -> m ()<http://hackage.haskell.org/packages/archive/ghc-prim/0.2.0.0/doc/html/GHC-U…> while the type of hPrintf is: hPrintf<http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/Text-Prin…>:: HPrintfType<http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/Text-Prin…>r => Handle<http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/GHC-IO-Ha…>-> String<http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/Data-Char…>-> r with the precision: The return type is restricted to (IO<http://hackage.haskell.org/packages/archive/base/4.2.0.1/doc/html/System-IO…>a) . Well I didn't completely 'get' the monad thing yet. I think I'm pretty close.. but not there yet. I'm pretty sure understanding this specific example will take me one step closer... What am I missing here? Thank you! Emmanuel

2 8

Phantom types and export lists
by Emmanuel Surleau 20 Oct '12

20 Oct '12

Hi, In order to get a feel for Haskell, I decided to write a simple CRUD application. I stumbled upon phantom types while looking for ways to validate data in Haskell. Here is what I have done so far: {-# OPTIONS_GHC -XTemplateHaskell #-} module Foo.Entities(buildTask, Sanitise, sanitise, Task, Validated, Unvalidated, name) where import Data.Lens.Lazy ( (~=), access, (%=), mapLens, (^=), (^.), (^%=), (^%%=), (^$) ) import Data.Lens.Template ( makeLenses ) data Validated data Unvalidated data Task a = Task { _name :: String } makeLenses [''Task ] buildTask :: String -> Task Unvalidated buildTask name = Task { _name = name } class Sanitise a where sanitise :: Task a -> Either (Task Validated) String instance Sanitise Validated where sanitise t = Left t instance Sanitise Unvalidated where sanitise t | t ^. name == "" = Right "Error: the name field should be not be empty" | otherwise = Left (Task { _name = t ^. name } ) Is this the recommended way of doing something like this? Do I really need to export each lens I'm using? When I'm exporting "Task", I seem to be exporting the data type, but is there a way to export the Task constructor itself (not that I would want that)? Also, how would I go about generalizing my Sanitise typeclass, so that it would work on other data types than Task? Of course, it's quite possible that I'm reinventing the wheel and that I've missed a perfectly useable data validation module on hackage. Thanks, Emm

2 2

Get responsecode(Int) from simpleHTTP's Response
by Jacques du Rand 18 Oct '12

18 Oct '12

HI all I'm trying to write a function that gives me the HTTP code in Int --This is broken getStatusCode::Response->String getStatusCode (Response _,x1,_,_) = x1 --this work the download trying to get http status code as well download_file fname url= do let clean_uri = check_url url putStrLn ("Downloading " ++ url ++ "...") rsp <- simpleHTTP (defaultGETRequest_ clean_uri) --problamatic function next line print (getStatusCode rsp) file_buffer <- getResponseBody(rsp) B.writeFile fname file_buffer Best Regards Jacques

3 5

Re: [Haskell-beginners] FRP
by Christopher Howard 16 Oct '12

16 Oct '12

On 09/17/2012 12:09 PM, Kim-Ee Yeoh wrote: > Ever wired up some simple electronic circuits? Take a flip-flop for > instance. Suppose each electronic component was a Haskell function. How > would you design their types in order for the whole program be > functionally equivalent? > > FRP is a theory for the design and construction of programs along such > lines. > > > -- Kim-Ee > > Which FRP framework (i.e., Haskell package) is the best one to play with for someone still trying to grasp the basics of FRP? -- frigidcode.com indicium.us

6 18

Avoid Case Analyses
by Costello, Roger L. 15 Oct '12

15 Oct '12

Hi Folks, "Programs that avoid case analyses are clearer and simpler than those that use case analyses." Richard Bird made that surprising statement in his book, Introduction to Functional Programming using Haskell. It is worthwhile to understand why he said that. In the process we will see a fabulous example of how to start with a specification and systematically develop an implementation. An extreme example of case analyses is using it to implement an identity function: color c | c == "red" = "red" | c == "green" = "green" | c == "blue" = "blue" It is read: - In the case the color c is "red" then return "red" - In the case the color c is "green" then return "green" - In the case the color c is "blue" then return "blue" The program is more clearly and simply implemented without case analyses: color c = c Let's take a less trivial example. We will implement the floor function. Although Haskell already has a built-in floor function, it will be instructive to see how floor :: Float -> Integer can be programmed. The program will be developed in a systematic manner, starting with a specification for floor. After implementing floor without case analyses, we will then compare it against an implementation that uses cases analyses. Recall that the floor of x is the largest integer n satisfying n <= x. Here are a couple examples: floor 2.3 returns 2 floor (-2.3) returns -3 Let us begin with a specification of floor: floor :: Float -> Integer floor x = n == n <= x < n +1 floor maps a value of type Float to a value of type Integer. The floor of x is n, where x is between n and n +1. It is tempting to plunge immediately into a case analysis, considering what to do if x is positive, what to do if x is negative, and, possibly, what to do if it is zero. But the specification does not mention cases and we should try not to mention cases either. How shall we find n, given an arbitrary x? You might respond: Simply truncate x's decimal point and its decimal digits, like so: truncate 2.3 returns 2 But that approach produces the wrong answer for negative values: truncate (-2.3) returns (-2), whereas the correct answer is -3 You might then suggest: If x is negative, then truncate and subtract 1. But that is descending into a case analysis on the sign of x: if x is positive, then truncate; if x is negative, then truncate and subtract 1. We do not need case analyses. The specification suggests an approach. The specification suggests that a search be conducted. Search for an n that satisfies the condition n <= x, and then increase n until the condition x < n+1 holds: - Start the search from some starting point, say, start n at 0. - Lower n until n <= x - Increase n until x < n+1 Example #1: find the floor of (-2.3): - Start the search at n = 0 - Lower n until n <= x: 0, -1, -2, -3 - Increase n until x < n+1: this terminates at once since -2.3 < (-3)+1 floor (-2.3) is -3 Example #2: find the floor of 2.3: - Start the search at n = 0 - Lower n until n <= x: this terminates at once since 0 < 2.3 - Increase n until x < n+1: 0, 1, 2 floor (2.3) is 2 The idea of searching until some condition holds can be encapsulated in a function until, defined by: until :: (a -> Bool) -> (a -> a) -> a -> a until p f x = if p x then x else until p f (f x) Function until takes 3 arguments p, f, and x: - p is a Boolean function. Function p is given a value x and it returns True or False. Example: this p returns True if x is less than zero (observe that p is a partially applied function): p = (<0) p (-2) returns True p 2 returns False - f is a function that processes x. Example: this f decreases x by one (observe that f is also a partially applied function): f = (subtract 1) f 5 returns 4 f (-5) returns (-6) - x is the value operated on. Read this use of function until: until (<0) (subtract 1) 5 returns -1 like so: starting n at 5, repeatedly subtract 1 until n is less than 0. Function until is a built-in Haskell function, as is floor, but for learning purposes we will use our own implementation of them, so place this at the top of your file to hide the built-in version: import Prelude hiding (until, floor) To search for an n satisfying the condition n <= x we will use this function lower: x = (-2.3) lower = until (<=x) decrease where decrease n = n - 1 Function lower decreases its argument n until the condition n <= x is satisfied: lower 5 returns -3 lower (-5) returns -5 Suppose we wish to find the floor of (5.3) and we start our search at n = 0. Function lower immediately returns because the condition 0 <= 5.3 is immediately satisfied: x = 5.3 lower 0 returns 0 In this example, the result n found by the search is too small. We need a second search to increase n until the condition x < n+1 is satisfied. We will increase n in steps of 1 to ensure the condition n <= x is maintained. Actually, we will increase n until it just exceeds x and then decrease it by 1. We create a function upper for this: upper = until (>x) increase where increase n = n + 1 decrease n = n - 1 The output of function upper will be the input to function decrease, so we compose the two functions: decrease . upper Further, we want the input of (decrease . upper) to be the output of function lower, so we compose them: decrease . upper . lower Example: we wish to find the floor of (5.3) and we start our search at n=0. Function lower immediately returns 0 because the condition 0 <= 5.3 is satisfied. Function upper increases 0 to 6, at which point 6 > 5.3 is satisfied. Finally, 6 is decreased by 1 to the answer 5: x = 5.3 (decrease . upper . lower) 0 returns 5 We now have all the ingredients needed to create function floor. The function takes one argument, x: floor x It starts the search from some point, let's choose n=0 as the starting point: floor x = searchFrom 0 Function searchFrom lowers n=0 until the condition n <= x is satisfied and then raises n until the condition n > x is satisfied and then decreases n by 1: floor x = searchFrom 0 where searchFrom = decrease . upper . lower Add the definitions for decrease, upper, and lower: floor x = searchFrom 0 where searchFrom = decrease . upper . lower lower = until (<=x) decrease upper = until (>x) increase decrease n = n - 1 increase n = n + 1 Notice that this implementation of function floor does not use case analyses. The program is surprisingly short, owing mainly to the absence of a case analysis on the sign of x. Compare that with a version that uses case analyses: floor x | x < 0 = lower 0 | x > 0 = (decrease . upper) 0 | x == 0 = 0 where lower = until (<=x) decrease upper = until (>x) increase decrease n = n - 1 increase n = n + 1 Read as: if x is less than 0 then lower 0 until n <= x is satisfied. If x is greater than 0 then increase 0 until n > x is satisfied and then decrease n by 1. Lastly, if x equals 0 then return 0. The case analysis version is longer and arguably more complex. /Roger

6 6

different getChar behaviour in interpeter and compiled program
by Motiejus Jakštys 14 Oct '12

14 Oct '12

Hi, consider this program: main = do c <- getChar putStrLn ("Entered: " ++ [c]) main (It reads a character and prints it out, for ever). When invoked from interpreter: motiejus@precise> ghci GHCi, version 7.4.1: http://www.haskell.org/ghc/ :? for help Loading package ghc-prim ... linking ... done. Loading package integer-gmp ... linking ... done. Loading package base ... linking ... done. Prelude> :load getchar.hs [1 of 1] Compiling Main ( getchar.hs, interpreted ) Ok, modules loaded: Main. *Main> main lEntered: l aEntered: a The behaviour is fine: right after entering a character, I get echo back. However, when started with runhaskell (or compiled ./getchar): motiejus@precise> runhaskell getchar.hs la<CR> Entered: l Entered: a Entered: Behaviour is different: I entered "l", but did not get the "entered" back. Only after I entered carriage-return, I got my multiple echos (including the CR). Why is it so? Is it possible to make Haskell read character-by-character in a compiled program? Clarification: behaviour of $ runhaskell ./getchar.hs is the same as $ ghc ./getchar.hs && ./getchar Ubuntu 12.04.1 i386, Haskell from standard repositories 7.4.1-1ubuntu2. Regards, Motiejus

2 2

Re: [Haskell-beginners] [Haskell-cafe] Tutorial: Haskell for the Evil Genius
by KC 14 Oct '12

14 Oct '12

The latest Haskell Platform is 2012.2.0.0 You are apparently running a much older version. >> #!"c:/Program Files/Haskell Platform/2010.2.0.0/bin/" runhaskell -- -- Regards, KC

2 1

import checking and filtering
by Christopher Howard 13 Oct '12

13 Oct '12

Maybe I'm losing it, but I seem to remember, when I first started out with Haskell, using some program which would check the import list in each of my source files, and then it would output a new import list that only imported exactly those functions that my program actually used. At the time I didn't think that was important, but now I really want it, yet I can't remember which utility it was that did this. Does anyone happen to know which utility it is I'm thinking of? -- frigidcode.com indicium.us

2 1

parsec problem
by Tobias 13 Oct '12

13 Oct '12

Hello, I would like to parse the input "word1 word2 word3 ." into ["word1","word2","word3"] using Parsec. My code below fails with: /> unexpected "."// //> expecting letter or digit /I guess the problem is that the blank before the dot is considered as belonging to the "sepBy word blank" parsing and therefore a next word is expected, and it is missing. I would like the "sepBy word blank" parsing to stop after "word3". How can I do this? / //sentence :: Parser [String]// //sentence = do words <- word `sepBy` blank// // blank// // oneOf ".?!"// // return words// // //word :: Parser String// //word = many1 (letter <|> digit) // // //blank :: Parser String// //blank = string " " /Regards, Tobias

2 2