- Beginners - Haskell.org

Type Class Woes ..
by Tom Poliquin 31 Aug '09

31 Aug '09

I've been writing Haskell programs (even useful ones :-) ) for awhile and I thought it was time to experiment with my own type classes. I chose the (contrived toy) problem of computing the volume of various fruits. First I wrote the code using algebraic data types .. (shown below); then I 'converted' it to use type classes (also shown below) The type class version gives me the errors .. Main.hs:12:16: Not in scope: type constructor or class `Banana' Main.hs:15:16: Not in scope: type constructor or class `Watermelon' .. which makes sense since Banana and Watermelon are 'data constructors' and not 'type constructors'. The problem is I'm not sure how to get around it .. If I try putting data Orange = Orange data Banana = Banana .. then what does 'initFruit' return .. ? it can't return [Fruit FruitType] anymore .. It seems like this should be a simple problem. I'm clearly not 'getting it'. Any help greatly appreciated, Tom ---------- Algegraic Data Type Version (works) ---------- module Main where data Fruit a = F {radius::Double, len::Double, fType::a} data FruitType = Orange | Apple | Banana | Watermelon deriving Show initFruit :: [Fruit FruitType] initFruit = [ (F 3.0 0.0 Orange), (F 3.0 0.0 Apple), (F 3.0 2.0 Banana), (F 40.0 20.0 Watermelon) ] volume :: Fruit FruitType -> Double volume F{radius=r,len=l,fType=Orange} = (4.0/3.0) * pi * r * r * r volume F{radius=r,len=l,fType=Apple} = (4.0/3.0) * pi * r * r * r volume F{radius=r,len=l,fType=Banana} = pi * (r * r) * l volume F{radius=r,len=l,fType=Watermelon} = (4.0/3.0) * pi * (2.0 * r) * l * (0.5 * l) ---------- -- Main -- ---------- main = do fruit <- return $ initFruit mapM (\f@(F{fType=t}) -> putStrLn ("Volume -> " ++ show t ++ " = " ++ show (volume f))) fruit Volume -> Orange = 113.09733552923255 Volume -> Apple = 113.09733552923255 Volume -> Banana = 56.548667764616276 Volume -> Watermelon = 67020.64327658225 ---------- Type Class Version (fails) ---------- module Main where data Fruit a = F {radius::Double, len::Double, fType::a} data FruitType = Orange | Apple | Banana | Watermelon class Volume a where volume :: (FruitType a) => Fruit a -> Double -- default spherical fruit .. volume F{radius=r,len=l} = (4.0/3.0) * pi * r * r * r instance Volume Banana where volume F{radius=r,len=l} = pi * (r * r) * l instance Volume Watermelon where volume F{radius=r,len=l} = (4.0/3.0) * pi * (2.0 * r) * l * (0.5 * l) initFruit :: [Fruit FruitType] initFruit = [ (F 3.0 0.0 Orange), (F 3.0 0.0 Apple), (F 3.0 2.0 Banana), (F 40.0 20.0 Watermelon) ] ---------- -- Main -- ---------- main = do fruit <- return $ initFruit mapM (\f@(F{fType=t}) -> putStrLn ("Volume -> " ++ show t ++ " = " ++ show (volume f))) fruit Main.hs:12:16: Not in scope: type constructor or class `Banana' Main.hs:15:16: Not in scope: type constructor or class `Watermelon'

6 8

pretty-printing data
by Michael Mossey 31 Aug '09

31 Aug '09

For debugging purposes I'm interested in pretty-printing data; to start with, lists of algebraic data types. Basically I'd like 'show' with the ability to put each entry of a list on a separate line, and indented. Note that the algebraic data might have an inner list as one of its elements, so this is a non-obvious formatting problem. I believe I can make instances of Show, can I not? Is there something called showList which I can use to code my own method of showing lists of a particular type? My understanding is that I can't make [a] an instance of Show; hence they provided showList. So basically, I'm wondering if a pretty-printing (for data!) library already exists, or whether I should try to make instances of Show. Thanks, Mike

3 2

partitions made of unique parts
by I. J. Kennedy 29 Aug '09

29 Aug '09

The following function finds all the partitions of an integer that are made of unique parts. It works, but I'm not happy with it--seems too complex. Is there a more haskelly (clever) way to implement this? -- parts n finds all the partitions of n having unique parts -- helper function parts' n r m finds partitions of n from a set r of remaining possible parts, -- with a minimum part of m. parts n = parts' n [1..n] 1 where parts' 0 _ _ = [[]] -- there's always one way ([]) to get a sum of 0 parts' n [] _ = [] -- if n /= 0, there are no possible partitions of the empty list parts' n remaining atleast = [(x:y) | x <- filter (>= atleast) remaining, y <- (parts' (n-x) (remaining \\ [x])) x] *Main> parts 11 [[1,2,3,5],[1,2,8],[1,3,7],[1,4,6],[1,10],[2,3,6],[2,4,5],[2,9],[3,8],[4,7],[5,6],[11]]

2 2

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