- Beginners - Haskell.org

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

List combination function?
by Ian Duncan 15 Aug '09

15 Aug '09

Hello all, I'm trying to build a function that takes a string such as "123" and gives me permutations including permutations with lesser list lengths. I'm not sure how to phrase it, but here is what the output could look like: foo "123" => ["123","213","321","231","312","132", "12", "13", "21", "23", "31", "32", "1", "2", "3", ""] The ordering doesn't matter, and that null list at the end doesn't particularly matter, but I don't really know the mathematical phrasing of what I'm asking for. I'm trying to build a scrabble helper that can find the optimal score given a set of letters to work with. Thanks for your help, Ian Duncan

2 1

monad transformers
by Michael P Mossey 14 Aug '09

14 Aug '09

In Martin Grabmuller's tutorial "Monad Transformers Step by Step", found here http://user.cs.tu-berlin.de/~magr/pub/Transformers.pdf he gives an example of composing ErrorT, StateT, ReaderT, and WriterT. Early in the paper, where he composes just ErrorT and ReaderT type Eval3 a = ReaderT Env (ErrorT String Identity) a he uses 'ask' and 'throwError' in some example code. I notice that he doesn't have to lift throwError into the ErrorT monad. Why is this? Do I misunderstand something about monad transformers? Is it a convenience definition of throwError? Same thing the rest of the paper. I don't see anywhere he lifts anything. Thanks, Mike

3 3

some terminology
by Michael P Mossey 13 Aug '09

13 Aug '09

I was looking at some code, saw a variable x, and said to myself, "Ah that variable is a monad." Then I realized "Monad" is the name of a type class. So maybe x should be called "an instance of a Monad." I think the word "instance" in this case is OO-like; but in Haskell "instance" refers to a type that is an instance of a type class. Or maybe it can refer to both? And Monad is a type class, not a type. Maybe I need the phrase "monadic type" to refer to an instance of a type class. So maybe x is just "a variable of a monadic type"? Thanks, Mike

4 3