Send Beginners mailing list submissions to beginners@haskell.org To subscribe or unsubscribe via the World Wide Web, visit http://www.haskell.org/mailman/listinfo/beginners or, via email, send a message with subject or body 'help' to beginners-requ...@haskell.org
You can reach the person managing the list at beginners-ow...@haskell.org When replying, please edit your Subject line so it is more specific than "Re: Contents of Beginners digest..." Today's Topics: 1. Re: Reactive Banana Data Structures Sanity Check (Heinrich Apfelmus) 2. Comfortable handling of module hierarchies (Christopher Howard) 3. Algorithmic Advances by Discovering Patterns in Functions (Costello, Roger L.) ---------------------------------------------------------------------- Message: 1 Date: Fri, 14 Sep 2012 15:45:49 +0200 From: Heinrich Apfelmus <apfel...@quantentunnel.de> Subject: Re: [Haskell-beginners] Reactive Banana Data Structures Sanity Check To: beginners@haskell.org Message-ID: <k2vcec$du1$1...@ger.gmane.org> Content-Type: text/plain; charset=UTF-8; format=flowed Michael Litchard wrote: > 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 = [...] > > 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? That's hard to say. It certainly doesn't look wrong, but whether it's a good idea or not depends on what you will do later. My process for programming with Functional Reactive Programming (FRP) is usually this: * What is the "end product", i.e. the thing that users ultimately interact with? In your case, it's probably the drawing of a map of the city. * Does the end product "vary in time"? Yes? Then it's going to be a Behavior City , i.e. a data structure that describes the evolution of the city in time. * How does the city evolve in time? Here I start to think of the events and other behaviors that I use to define the behavior, for instance by writing bcity :: Behavior City bcity = stepper ... -- step function from events or bcity = (++) <$> bsuburbs <*> bcenter -- combine other behaviors and so on. The process is a bit like thinking as a physicist in god-mode: for each object in my little universe, I specify where it should be at any particular time, like 5 o'clock. That said, I found it useful to decouple the interaction of individual parts -- city, node, player -- from their time evolution. Have a look at the Asteroids.hs example http://www.haskell.org/haskellwiki/Reactive-banana/Examples#asteroids The bottom part of the source contains function like advanceRocks or collide that specify more complicated interactions between different objects. The FRP part of the source file just specifies *when* these interactions take place, i.e. advanceRocks happens when etick happens while the player moves when eleft or eright happen. In other words, my rule of thumb is How does it happen? => ordinary functions When does it happen? => events and behaviors In particular, you can write your Wumpus game logic by asking the "how" questions first and only then ask the "when" questions. Thus, I would rename Player_ to Player for the "how" part and simply use Behavior t Player for the fairly small "when" part. Hope that helps. Best regards, Heinrich Apfelmus -- http://apfelmus.nfshost.com ------------------------------ Message: 2 Date: Fri, 14 Sep 2012 17:23:45 -0800 From: Christopher Howard <christopher.how...@frigidcode.com> Subject: [Haskell-beginners] Comfortable handling of module hierarchies To: Haskell Beginners <beginners@haskell.org> Message-ID: <5053d8a1.7030...@frigidcode.com> Content-Type: text/plain; charset="iso-8859-1" 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 -------------- next part -------------- A non-text attachment was scrubbed... Name: signature.asc Type: application/pgp-signature Size: 551 bytes Desc: OpenPGP digital signature URL: <http://www.haskell.org/pipermail/beginners/attachments/20120914/81fac387/attachment-0001.pgp> ------------------------------ Message: 3 Date: Sat, 15 Sep 2012 08:36:38 +0000 From: "Costello, Roger L." <coste...@mitre.org> Subject: [Haskell-beginners] Algorithmic Advances by Discovering Patterns in Functions To: "beginners@haskell.org" <beginners@haskell.org> Message-ID: <b5fee00b53cf054aa8439027e8fe17751e65b...@imcmbx04.mitre.org> Content-Type: text/plain; charset="us-ascii" 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 ------------------------------ _______________________________________________ Beginners mailing list Beginners@haskell.org http://www.haskell.org/mailman/listinfo/beginners End of Beginners Digest, Vol 51, Issue 22 *****************************************