September 2012 - Beginners

elegant handling of maybe and non-maybe values
by Christopher Howard 21 Sep '12

21 Sep '12

I have a code situation similar to this simplified one: Let's say that I've got a value v that is a Maybe type, and values x, y, and z that are not. x, y, and z are dependent on the value inside v. So I must provide default values for x, y, and z. An additional complication is that every calculation returns a new (possibly different) value for v. So, I could do something like this: code: -------- let (v', x) = case v of Nothing -> (Nothing, defaultValueOfX) Just vValue -> f vValue in let (v'', y) = case v' of Nothing -> (Nothing, defaultValueOfY) Just vValue -> g vValue in let (v''', z) = case v'' of Nothing -> (Nothing, defaultValueOfZ) Just vValue -> h vValue in -------- (f, g, h represent the calculations I am performing.) In the end, I need the values of x, y, and z, and the last v value. Obviously, the above solution is not very elegant, especially if I add a few more variables. My other thought was some kind of fold operation, where I store the functions (calculations) and the default values in a list, and then fold over the list, applying subsequent values of v or returning default values, as appropriate. But this seems rather clunky, especially if I want to attach the values in the new list to variable names afterwards. Is there a better approach? -- frigidcode.com indicium.us

3 2

an observation about Haskell vs. Python
by Dennis Raddle 21 Sep '12

21 Sep '12

As a somewhat-newbie haskell user and longtime Python user, what I have observed is this. Haskell creates compile-time error messages that are somewhat hard to understand for beginners. Python (or any scripting language) creates run-time bugs that are hard to understand. One reason for the weird (to a beginner) compile errors in Haskell is its expressivity -- almost any sequence of identifiers could potentially mean something, and if you make a mistake, the compiler is sure to find some "weird" way to interpret it. But Python suffers from a similar problem -- it's not as expressive a language, but it is very permissive, not insisting on type correctness, order of arguments, or any of a number of things so that the programmer can write a program that compiles with no errors -- but has strange run-time bugs. I'll take Haskell. I'm a bit OCD about getting the bugs out of my programs, and Python just opens up too many holes for me to relax with it. Dennis

6 7

an observation about Haskell vs. Python
by Dennis Raddle 21 Sep '12

21 Sep '12

Thanks. I'm okay with the status quo.. I just see it as a tradeoff. You are giving up something to get something. In Python you give up any kind of compile-time type checking, you give up the safety of immutable data, and you get a whole lot of automatic type conversions and brief ways to express certain algorithms. In Haskell you give up easy-to-comprehend error messages and mutable data, and get back in reward a lot of reassurance that your program does what you meant and expressivity. (I realize Haskell has mutable data but it's not like Python's) On Wed, Sep 19, 2012 at 7:43 PM, Ertugrul Söylemez <es(a)ertes.de> wrote: > > Notice: You probably forgot to apply `sin' to an argument. > > However, I think that no work is done on that, and there is another > possible path: An average Haskell tutorial should always include a > section on understanding error messages. In fact the latest issue of > The Monad Reader [1] has an article on that by Jan Stolarek. > > [1]: http://themonadreader.files.wordpress.com/2012/08/issue20.pdf > > > Greets, > Ertugrul > > -- > Not to be or to be and (not to be or to be and (not to be or to be and > (not to be or to be and ... that is the list monad. > > _______________________________________________ > Beginners mailing list > Beginners(a)haskell.org > http://www.haskell.org/mailman/listinfo/beginners > >

3 2

Strange new Haskell Platform
by bucephalus org 20 Sep '12

20 Sep '12

Dear fellow Haskellers, last weak my Linux machine broke down and refused to start again. I bought a new one and installed a fresh new KDE/Linux distribution (Mint/Ubuntu) and it looks and feels awesome. I also installed the Haskell platform via the default GUI installer (mintInstall). But when I try to run my recovered Haskell modules again, strange things happen. First of all, I have a module that has a line import System and that used to be fine. But now, when I try to load the module in a ghci session, I get a complaint: Could not find module 'System' It is a member of the hidden package 'haskell98-2.0.0.1' ... The same happens if I do a Prelude> :m System What is going on? Secondly, I have another module that has a data type definition like this data (Show n, Show v, Ord n, Ord v) => Automaton n v = Automaton { nameSet :: Set.Set n, valueSet :: Set.Set v, .... } deriving (Show, Eq, Ord) and that used to work fine, too. But now, I get the complaint Illegal datatype context (use -XDatatypeContexts): (Show n, Show v, Ord n, Ord v) => But when I follow the advice and start the module file with a {-# LANGUAGE DatatypeContexts ... #-} I got the opposite complaint: Warning: -XDatatypeContexts is depracated: It was widely considered a misfeature, and has been removed from the Haskell language. How can I clean this up? Cheers, Tom

5 6

combinator
by Christopher Howard 20 Sep '12

20 Sep '12

Is there some kind soul who would elaborate somewhat on what exactly a combinator is, and the significance they have in Haskell programming? Is there anything special about the way that we use the term in a Haskell programming context? Are combinators tied into everything we do in Haskell, or is it more of a special branch of study? A year or two ago I studied some lambda calculus, and I remember some interesting (but rather theoretical) little problems involving properties of certain combinators, and how they behaved when combined with others. But in some Haskell module documentation, it seems like everything and anything is referred to as a "combinator", so I'm getting a bit confused. -- frigidcode.com indicium.us

3 2

Algorithmic Advances by Discovering Patterns in Functions
by Costello, Roger L. 18 Sep '12

18 Sep '12

Hi Folks, This is a story about discovery. It is a story about advancing the state-of-the-art by discovering patterns in functions. Scientists look for recurring patterns in nature. Once a pattern is discovered, its essential ingredients are identified and formalized into a law or mathematical equation. Discovery of a pattern is important and those individuals who make such discoveries are rightfully acknowledged in our annals of science. Scientists are not the only ones who look for recurring patterns, so do functional programmers. Once a pattern is discovered, its essential ingredients are identified and formalized into a function. That function may then become widely adopted by the programming community, thus elevating the programming community to a new level of capability. The following is a fantastic example of discovering a pattern in multiple functions, discerning the essential ingredients of the pattern, and replacing the multiple functions with a single superior function. The example is from Richard Bird's book, Introduction to Functional Programming using Haskell. Before looking at the example let's introduce an important concept in functional programming: partial function application. A function that takes two arguments may be rewritten as a function that takes one argument and returns a function. The function returned also takes one argument. For example, consider the min function which returns the minimum of two integers: min 2 3 -- returns 2 Notice that min is a function that takes two arguments. Suppose min is given only one argument: min 2 [Definition: When fewer arguments are given to a function than it can accept it is called partial application of the function. That is, the function is partially applied.] min 2 is a function. It takes one argument. It returns the minimum of the argument and 2. For example: (min 2) 3 -- returns 2 To see this more starkly, let's assign g to be the function min 2: let g = min 2 g is now a function that takes one argument and returns the minimum of the argument and 2: g 3 -- returns 2 Let's take a second example: the addition operator (+) is a function and it takes two arguments. For example: 2 + 3 -- returns 5 To make it more obvious that (+) is a function, here is the same example in prefix notation: (+) 2 3 -- returns 5 Suppose we provide (+) only one argument: (+) 2 That is a partial application of the (+) function. (+) 2 is a function. It takes one argument. It returns the sum of the argument and 2. For example: ((+) 2) 3 -- returns 5 We can succinctly express (+) 2 as: (+2) Thus, (+2) 3 -- returns 5 Okay, now we are ready to embark on our journey of discovery. We will examine three functions and find their common pattern. The functions process values from this recursive data type: data Nat = Zero | Succ Nat Here are some examples of Nat values: Zero, Succ Zero, Succ (Succ Zero), Succ (Succ (Succ Zero)), ... The following functions perform addition, multiplication, and exponentiation on Nat values. Examine the three functions. Can you discern a pattern? -- Addition of Nat values: m + Zero = m m + Succ n = Succ(m + n) -- Multiplication of Nat values: m * Zero = Zero m * Succ n = (m * n) + m -- Exponentiation of Nat values: m ** Zero = Succ Zero m ** Succ n = (m ** n) * m For each function the right-hand operand is either Zero or Succ n: (+m) Zero (+m) Succ n (*m) Zero (*m) Succ n (**m) Zero (**m) Succ n So abstractly there is a function f that takes as argument either Zero or Succ n: f Zero f Succ n Given Zero as the argument, each function immediately returns a value: (+m) Zero = m (*m) Zero = Zero (**m) Zero = Succ Zero Let c denote the value. So, invoke f with a value for c and Zero: f c Zero = c For addition provide m as the value for c: m + Zero = f m Zero For multiplication provide Zero as the value for c: m * Zero = f Zero Zero For exponentiation provide (Succ Zero) as the value for c: m ** Zero = f (Succ Zero) Zero Next, consider how each of the functions (addition, multiplication, exponentiation) deals with Succ n. Given the argument Succ n, each function processes n and then applies a function to the result: (+m) Succ n = (Succ)((+m) n) (*m) Succ n = ((*m) n) (+m) (**m) Succ n = ((**m) n) (*m) Let h denote the function that is applied to the result. So, Succ n is processed by invoking f with a value for h and Succ n: f h (Succ n) = h (f n) For multiplication provide (+m) as the value for h: m * Succ n = f (+m) (Succ n) Recall that (+m) is a function: it takes one argument and returns the sum of the argument and m. Thus one of the arguments of function f is a function. f is said to be a higher order function. [Definition: A higher order function is a function that takes an argument that is a function or it returns a function.] Continuing on with the other values for h: For addition provide (Succ) as the value for h: m + Succ n = f (Succ) (Succ n) For exponentiation provide (*m) as the value for h: m ** Zero = f (*m) (Succ n) Recap: to process Nat values use these equations: f c Zero = c f h (Succ n) = h (f n) Actually we need to supply f with h, c, and the Nat value: f h c Zero = c f h c (Succ n) = h (f h c n) f has this type signature: its arguments are a function, a value, and a Nat value; the result is a value. So this is f's type signature: f :: function -> value -> Nat -> value That type signature is well-known in functional programming. It is the signature of a fold function. Here is some intuition on why it is called the fold function: Imagine folding a towel. You make your first fold. The second fold builds on top of the first fold. Each fold builds on top of the previous folds. That is analogous to what the function f does. "You make your first fold" is analogous to immediately returning c: f h c Zero = c "Each fold builds on top of the previous folds" is analogous to processing Succ n by applying h to the result of processing the n'th Nat value: f h c (Succ n) = h (f h c n) Recap: In analyzing the functions (addition, multiplication, exponentiation) on Nat we have discovered that they are all doing a fold operation. That is a remarkable discovery. Let's now see how to perform addition, multiplication, and exponentiation using f. However, since we now recognize that f is actually the fold function, let's rename it foldn (fold Nat). Here is its type signature and function definition: foldn :: (a -> a) -> a -> Nat -> a foldn h c Zero = c foldn h c (Succ n) = h (foldn h c n) The functions are implemented as: m + n = foldn Succ m n m * n = foldn (+m) Zero n m ** n = foldn (*m) (Succ Zero) n Let's take an example and trace its execution: Zero + Succ Zero = foldn Succ Zero (Succ Zero) = Succ (foldn Succ Zero Zero) = Succ (Zero) The holy trinity of functional programming is: 1. User-defined recursive data types. 2. Recursively defined functions over recursive data types. 3. Proof by induction: show that some property P(n) holds for each element of a recursive data type. Nat is a user-defined recursive data type. The addition, multiplication, and exponentiation functions are recursively defined functions over Nat. We saw that the fold function can be defined for the Nat data type. In fact, a suitable fold function can be defined for every recursive data type. Wow! There are two advantages of writing recursive definitions in terms of fold: 1. The definitions are shorted; rather than having to write down two equations, we have only to write down one. 2. It is possible to prove general properties of fold and use them to prove properties of specific instantiations. In other words, rather than having to write down many inductive proofs, we have only to write down one. Recap: we have approached programming like a scientist; namely, we have examined a set of algorithms (the addition, multiplication, and exponentiation functions), discovered that they have a recurring pattern, and then evolved the algorithms to a higher order algorithm. That is advancing the field. Incremental advancements such as this is what takes Computer Science to new heights. /Roger

4 3

Sending mail via SMTP
by Salil Wadnerkar 18 Sep '12

18 Sep '12

Hi, Does anybody know of any good libraries I can use to send a mail via google's SMTP? I found SMTPClient and HaskellNet. The former does not support TLS and the latter does not seem to have examples for using TLS to send an email via SMTP. Did anybody manage to do that? Thanks Salil

4 4

trouble with install SDL?
by Gregory Guthrie 17 Sep '12

17 Sep '12

I am trying to install SDL, and getting (typical?!) Haskell install troubles. I found one suggestion from SO to use a modified SDL.cabal, but that didn't work. I downloaded the current version (0.6.3) from HackageDB and tried to install using the enclosed Windows instructions. I get the error: D:\ftp\New\W7\SDL\SDL-0.6.3>runghc Setup.lhs configure Configuring SDL-0.6.2... configure: WARNING: unrecognized options: --with-compiler, --with-gcc configure: error: cannot find sources (includes/HsSDLConfig.h.in) in /e/plang/Libraries/wxWidgets2.9 or .. I downloaded the current version (0.6.3) from HackageDB. I spent several trips around the install problems with wxWin, and finally did get it working, only to have it alter fail on an upgrade in Haskell Platform version, but again finally got it reinstalled and working. -------------------------------------------

2 1

Comfortable handling of module hierarchies
by Christopher Howard 16 Sep '12

16 Sep '12

So, let's say I've got this hierarchy of modules: Plant `-- Vegetable | `-- Celery | `-- Lettuce `-- Fruit `-- Raspberry `-- Apple What I would like to be able to do is import and use modules like so: code: -------- import qualified Plant.Vegetable as V -- call a function in module Celery V.Celery.grow -------- and code: -------- import qualified Plant as P P.Fruit.Raspberry.jam -------- I tried using connecting modules, which I read about online: code (Plant.hs): -------- module Plant ( module Plant.Vegetable , module Plant.Fruit ) import Plant.Vegetable import Plant.Fruit -- (And likewise for Plant/Vegetable.hs and Plant/Fruit.hs.) However, this pools the functions from the sub-modules all into one name space, which does not allow me to make the sort of function calls I described above. Although sometime it is okay to have the functions all in one name space, it doesn't fit the style I'm aiming for, and it can be a real pain if multiple modules have a function of the same name (e.g., if all fruits and veggies have a "grow" function). Is it possible to do what I'm trying to do? -- frigidcode.com indicium.us

5 5

Reactive Banana Data Structures Sanity Check
by Michael Litchard 14 Sep '12

14 Sep '12

I'm making an implementation of Grand Theft Wumpus using reactive-banana. I'm using the slot machine example to work from. For now, I'm just building a simple graph where a Player can move from Node to Node. I'm not sure I have the Data Structures right, so I wanted to run it by the community. I'm conceptualizing each Node (a Street) and the Player as a Behavior. I reason that since the Graph won't change, just the values inside a Node, I can update any Node as needed, instead of creating a new Graph whenever a value in a Node changes. It seems though, as I scale up, I'd end up with a big union of Behaviors. Does it make sense to describe each Node as a Behavior? Even though I'm starting simply, I intend to write a complete implementiation. http://nostarch.com/download/Lisp08.pdf data StreetName = Baker | Main | Atlantic | Baltic | Connecticut deriving (Enum,Bounded,Show) type Player t = Behavior t Player_ type Street t = Behavior t Street_ data Player_ = Player {location :: StreetName } deriving Show data Street_ = Street_ {sName :: StreetName ,player :: Maybe Player_ } deriving Show data GameEvent = MovePlayer Street | Look does that look okay so far?

2 1