- Beginners - Haskell.org

definition of combinator
by Michael Mossey 25 Aug '09

25 Aug '09

Although I can use libraries like Parsec, I don't really understand what a combinator is, theoretically. There is an article here http://en.wikipedia.org/wiki/Combinator with the statement "A combinator is a higher-order function that uses only function application and earlier defined combinators to define a result from its arguments." Okay, so I believe a "higher-order function" is a function that takes function(s) as its argument(s). I don't know what "uses only function application" means. Application of what functions to what? Can someone give a concrete example that's simple? Thanks, Mike

4 4

type inference question
by I. J. Kennedy 23 Aug '09

23 Aug '09

Given a sort function that works on numbers, you can sort in reverse order by first negating the list, then sorting, then negating again: Prelude Data.List> let revsort = (map negate) . sort . (map negate) The function sort takes any list of Ord; negate works on any Num. Prelude Data.List> :t negate negate :: (Num a) => a -> a Prelude Data.List> :t sort sort :: (Ord a) => [a] -> [a] I'd therefore expect my revsort function to work on any type that is both an Ord and a Num. However: Prelude Data.List> :t revsort revsort :: [Integer] -> [Integer] I was expecting something like revsort :: (Ord a, Num a) => [a] -> [a] instead. Question: Why did the GHCI's type inference mechanism jump to the conclusion that revsort should only work with Integer lists?

2 1

my ugly code and the Maybe monad
by Simon Parry 20 Aug '09

20 Aug '09

hello all, Intro: I'm fairly new to Haskell, read some tutorials/books, this is my first real attempt at making something rather than doing tutorial problems - I thought I'd recode some financial maths up in Haskell...see below. It seems to work ok (I haven't properly tested it yet) but I feel the pvs function is just ugly. However it seems like its a fairly common requirement for maths modelling ie using Maybe or Error or such to represent conditions on the input variables and then later having to combine those 'wrapped' values with other things. Basically it seems inelegant and I feel like I'm confusing the monadic and non-monadic parts? help/criticism welcome, thanks Simon module TimeValueMoney1 where --taken from Financial Numerical Recipes in C++ by B A Odegaard (2006): --Chapter 3 import Control.Monad --time periods - assumes now is time 0-- times :: [Int] times = [0..] minusOne :: Double minusOne = -1.0 --can have eg discrete or continuous compounding type Compounding = Double -> Int -> Maybe Double --discounting and present value-- discreteCompounding :: Compounding discreteCompounding yield elapsed | yield > minusOne = Just ( 1.0/ (1.0 + yield)^elapsed ) | otherwise = Nothing continuousCompounding :: Compounding continuousCompounding yield elapsed | yield > minusOne = Just (exp( minusOne * yield * fromIntegral elapsed ) ) | otherwise = Nothing pvs :: Compounding -> Double -> [Double] -> Maybe [Double] pvs df yield cashflow = zipWithM ( \c -> (>>= \d -> return $ c*d ) ) cashflow discounts where discounts = map discount times discount = df yield

2 3

Ambigous Types with Haskell Functional Graph Library
by Joe Schafer 19 Aug '09

19 Aug '09

Hey all, New to Haskell and I'm trying to use the FGL but I keep running into the same error. If I load Data.Graph.Inductive.Example and use one of the example functions such as ucycle I get: Ambiguous type variable `gr' in the constraint: `Graph gr' arising from a use of `ucycle' at <interactive>:1:0-7 Probable fix: add a type signature that fixes these type variable(s) Here's the type of ucycle for reference. ucycle :: Graph gr => Int -> gr () () I'm using GHC 6.10.1 and FGL 5.4.2.2 Thanks, Joe

2 1

Start file with associated prog (windows only?)
by Bernhard Lehnert 18 Aug '09

18 Aug '09

Hello list, I believe I am looking for a haskell equivalent to a python library function called os.startfile(...) which starts any given file with its associated program. http://docs.python.org/library/os.html#os.startfile says: "...this acts like double-clicking the file in Windows Explorer, or giving the file name as an argument to the start command from the interactive command shell: the file is opened with whatever application (if any) its extension is associated. [...] startfile() returns as soon as the associated application is launched." So to show a readme you just write: import os os.startfile("README.rtf") to show your programs documentation you just write os.startfile("documentation.pdf") and windows will decide which program to use to open a PDF. The must urgent thing I actually want to do is open an Internet Browser with my sponsors URL. Any good ideas? Thanks in advance, Bernhard

3 4

Re: learning to use Haskell types
by Heinrich Apfelmus 18 Aug '09

18 Aug '09

Michael Mossey wrote: > Heinrich Apfelmus wrote: >> This would be an example where I think that the Reader monad is an >> implementation detail, not a model of the problem domain. (Not to >> mention that I think that the Reader monad has very limited >> applications.) The latter would be about trying to eliminate the need >> for a context altogether, to group the many details so that they >> can be >> "polymorphized away", etc. > > Can you explain more about what it means to "polymorphize away" > details? I'm not clear about that. > > You mention "grouping" details. Does this mean creating data which > types that hold all the details, and the data type itself is some > kind of larger concept? For example, you could say a note has many > details such as time, duration, dynamic, etc. And you could also > create > > data Note = Note { time :: Ratio, duration :: Ratio, dyn :: Dynamic } > > and work with Notes as much as possible without peering inside them. Yes, the goal is to avoid peering inside. Creating a new abstraction (= no peeking inside) is the only way to make things elegant. Using record data types are a first step towards that goal. Another technique is to use parametric polymorphism, that's what I intend to convey with the phrase "polymorphize away". The idea is that the type system can make sure that you don't peek inside. Consider the following (almost too trivial) example: length :: [Note] -> Int This function is intended to calculate the length of a list of notes. But of course, it's wholly unimportant that the lists consists of notes, it could as well be a list of apples or integers. In fact, the specialization to notes is a mental burden, and it's much simpler to write a length function that does not care about the contents length :: [a] -> Int The key point is that the type alone already ensures that length *cannot* peek inside the list elements, because it's polymorphic in a . Another example is the function sortBy :: (a -> a -> Ordering) -> [a] -> [a] which does not want to know anything about the list elements except that they can be compared. Of course, these were rather general and well-known examples; the key is to find similar patterns in your own code and problem domain. For instance, notes in staff notation don't really care about velocities, notes in a piano roll are actually just rectangles in a grid, etc. The goal is to focus solely on the relevant details and hide the unimportant details behind a type variable a . Regards, apfelmus -- http://apfelmus.nfshost.com

1 0

learning to use Haskell types
by Michael Mossey 17 Aug '09

17 Aug '09

This is really a general question, but any advice is welcome. I'm currently working through Typeclassopedia and all the tutorials it links to. I'm really enjoying it, but a kind of scary question is: when I begin to write "real" software in Haskell, how will I find natural places to use the types and how will I make the transition to idiomatic Haskell? [Note: the main application I have for Haskell is my music composition hobby. I plan to use Haskell to write software for editing music and for computer-assisted composition (CAC). CAC means the computer does some of the tedious work involved in searching for, and evaluation of, combinations of musical themes. All my algorithms are personal to my own process. There is no off-the-shelf software that can help me. That's why it's fortunate I'm a programmer. The CAC features need to be tightly integrated into a musical score editor, hence I have to write that too. Really quite a fun project, and even if it takes two years, I will get years and years of enjoyment from it!] Then it occurred to me that a common theme in Haskell is to provide a way to express a solution to a problem in an expressive form that is natural to that problem. So maybe what I need to do is stop thinking, "Where can I use this type," and instead dream up ways to express ideas in a simple and natural form, then make use of Haskell types and type classes to make that expressive form a reality. For example, in a music editor, there are many actions that create new notes. A note needs many pieces of information to describe it: the note's place in time, its duration, dynamics, whether tied to successive notes, type of flag or beam... Much of this information can be inferred from the context in which the note is created, and so a natural expressive language would bring a new note into existence with a minimal need for providing details. Those details would be inferred from the context. So that's a Reader monad right there. Thanks, Mike

2 1

Re: [Haskell-beginners] Closure
by Matthew J. Williams 16 Aug '09

16 Aug '09

>Williams<matthewjwilliams1(a)googlemail.com> wrote: > > Good morning > > > > What is a closure and, what purpose does it serve? > >This seems like a good explanation: http://www.haskell.org/haskellwiki/Closure > >/M > >Williams<matthewjwilliams1(a)googlemail.com> wrote: How does a closure differ from a binding? An example or two would be nice. :-) Sincerely, MJW

6 12

A rigid type and a better pattern
by Javier M Mora 16 Aug '09

16 Aug '09

(I had problems sending this email and I don't know if earlier arrived to mail list. I'm going to send again. Sorry if you get it duplicate) Hi All, this is my first email to beginners list. I'm ending my Master Degree in Robotics (in Spain). One of my assignment is about Motion Planning and I thought solve with Haskell. This is my problem: * Every robot has a local state. I can get the position of the robot from the state. The state can be rect coords or polar coords or distance moved on a fixed path or whatever. * I have a global state witch keep the local state of each robot. * Every state has a different system to action over it. So, in distance over fixed path we can "stop" or "go". In polar coords we can increase and decrease the radius and phi. And in rect coords we can move in x and y direction * I have several robots at same time. But every robot has the same state and the same action. So, all robots in the run of my program has same local state and action. So, I split the algorithm in a common part (used in all states and actions) and other for each specific state-action. This is the structure (abstract): class Robot a where ... class State a where getpos a -> [Position] ... class Action a where ... later I have instances for concrete cases. In phase 1, local state is a Int for each robot and action is a Bool (stop or run). data State1 = State1 [Int] instance State State1 where getpos (State1 a) = ... ... data Action1 = Action1 [Bool] instance Action Action1 where ... I have a function "newstate" to calculate the new state from an old state and the action. This is the type signature: newstate:: (State a,Action b) => a -> b -> a and my instantiation in phase 1 is newstate (State1 s) (Action1 u) = State1 $ zipWith (\x y -> if y then succ x else x) s u I want to use polymorphism in newstation because I need use newstate (State2 s) (Action2 u) in the future (phase 2) so I tried include newstate in a typeclass. But if I write: class State a where newstate:: (Action b)=> a -> b -> a ... or class Action a where newstate:: (State b) => b -> a -> b ... (and move newstate definition to correct instance block) I get similar errors in both cases: (this is the first case): Couldn't match expected type `b' against inferred type `Action1' `b' is a rigid type variable bound by the type signature for `newstate' at Tipos.hs:17:24 In the pattern: Action1 u In the definition of `newstate': newstate (State1 s) (Action1 u) = State1 $ zipWith (\ x y -> if y then succ x else x) s u In the instance declaration for `State State1' My questions: * How can I fix this error? * the point is associate every instance of Robot with one instance of State and with one instance of Action. So when I select the Robot I'm goint to use I get "automagically" the correct instances of newstate and others. Is there a pattern to this behaviour? My ideal is associate every function related with a Robot with a general typeclass "Robot" (I don't tested this) : class Robot a where initstate:: (State a) => a newstate:: (State a,Action b) => a-> b-> a And the instance: instance Robot Robot1 where initstate = State1 [0,0,0] newstate (State1 a) (Action1 b) = ... and instance Robot Robot2 where initstate = State2 [(0,0),(1,1),(2,2)] -- i.e. newstate (State2 a) (Action2 b) = ... and so on. But I think It can't work because neither initstate or newstate use Robot1. Any tips? Javier M Mora.

2 1

Circular programming
by Maciej Piechotka 16 Aug '09

16 Aug '09

I'm not understending circular programming. What it is used for? Where feedback variable came from (yes - I know it's wrong question as Haskell is lazy)? I've read http://www.haskell.org/haskellwiki/Circular_programming but I didn't understend the concept and pattern. Regards

2 3