- Beginners - Haskell.org

parser comparison question
by Walck, Scott 25 Apr '09

25 Apr '09

I've been comparing Graham Hutton's simple parser with Parsec. Here is some example code. -- Comparison of Hutton's simple parser with Parsec -- Hutton's simple parser is available at -- http://www.cs.nott.ac.uk/~gmh/Parsing.lhs -- Hutton simple parser called H -- Parsec called P import qualified Parsing as H import qualified Text.ParserCombinators.Parsec as P exH = H.parse (H.string "hi") "hiho" exP = P.parse (P.string "hi") "" "hiho" charH = H.parse (H.char 'a' H.+++ H.char 'b') "bbb" charP = P.parse (P.char 'a' P.<|> P.char 'b') "" "bbb" choiceH = H.parse (H.string "hoo" H.+++ H.string "ho") "hono" choiceP1 = P.parse (P.string "bb" P.<|> P.string "ba") "" "bbb" choiceP2 = P.parse (P.string "ba" P.<|> P.string "bb") "" "bbb" choiceP22 = P.parse (P.try (P.string "ba") P.<|> P.string "bb") "" "bbc" I am interested if anyone could comment on the design of the Parsec 'try' function. For example, choiceP2 fails and returns Left error, while choiceP22 succeeds. Hutton's simple parser doesn't need try. It seems so simple and elegant. I'm wondering why Parsec requires me to use 'try' for a string parse that might fail. Thanks, Scott Scott N. Walck Associate Professor of Physics Lebanon Valley College

2 1

WWAAA... I hate monads
by Daniel Carrera 25 Apr '09

25 Apr '09

I hate monads. I love 90% of Haskell. The functional stuff is beautiful, easy to understand, crystal clear, elegant, etc. But I'm having a mighty hard time getting my head around monads. Consider the following explanation of a monad: "A monad is represented as a type constructor (call it m), a function that builds values of that type (a -> m a), and a function that combines values of that type with computations that produce values of that type to produce a new computation for values of that type". 1) I know what a type is, but not a "type constructor". I don't normally think of an Int or even a complex type as being "constructed" except in the sense of OOP which I know is not what the author means. 2) Just *read* the paragraph... "a type constructor, a function that builds value of that type, and a function that combines values of that type with computations that produce values of that type to produce a computation of values of that type" Ugh.... Can anyone recommend a simple and clear explanation of monads? You can assume that I know basic math and basic Haskell syntax. So, for example, "a -> b" is much more clear than "a function that takes input of one type and has an output of a different type". Any help would be appreciated. Daniel.

14 26

doing state right
by Floptical Logic 24 Apr '09

24 Apr '09

I am using a PPM library to generate a square image where each white pixel represents a prime number. The PPM library takes a function (Int -> Int -> Colour) to create the image. This interface isn't ideal but it is what I have to work with. I am convinced that using a sieve is faster than testing every pixel in the image for primality, but the (Int -> Int -> Colour) interface makes this awkward. The code below attempts to treat the list of prime numbers as a stack via global mutable state, popping the head whenever the pixel is prime. Obviously this is not idiomatic Haskell. What is the correct approach of dealing with state here? Thanks for reading. import ONeillPrimes import PPM6 import Colour import Data.IORef import System.IO.Unsafe limit = 2000 slimit = limit*limit primeList = takeWhile (<=slimit) primes p :: IORef [Int] p = unsafePerformIO (newIORef primeList) pcol n = unsafePerformIO $ do xs <- readIORef p if null xs then return black else if n == head xs then do writeIORef p (tail xs) return white else return black main = quick_ppm "foo.ppm" (\i j -> pcol ((i-1)*limit+j)) limit limit -- quick_ppm :: FilePath -> (Int -> Int -> Colour.Colour) -> Int -> Int -> IO ()

3 4

computation vs function
by Daniel Carrera 23 Apr '09

23 Apr '09

Hello, I have finished the tutorial at http://ertes.de/articles/monads.html and my understanding of monads has increased greatly. I still need to cement some concepts in my mind. What exactly is the difference between a computation and a function? Monads revolve around computations, so I'd like to understand computations better. Thanks for the help. Daniel.

6 10

Type families with kind * -> *
by Marco Túlio Gontijo e Silva 23 Apr '09

23 Apr '09

Hello, I read the type families example at http://haskell.org/haskellwiki/GHC/Indexed_types and I wanted to do something similar to the Collects example, but using a type of kind * -> *: > class StateFunctor sf where > type SFMonad sf > type SFValue sf > sfmap :: (SFValue sf -> SFValue sf) -> sf -> SFMonad sf () I wrote the instance as: > instance StateFunctor (ListStore a) where > type SFMonad (ListStore a) = IO > type SFValue (ListStore a) = a > sfmap function listStore > = listStoreGetSize listStore >>= listStoreSfmap function listStore > listStoreSfmap :: (a -> a) -> ListStore a -> Int -> IO () > listStoreSfmap _function _listStore 0 = [] > listStoreSfmap function listStore size > = listStoreGetValue listStore index > >>= listStoreSetValue listStore index . function > >> listStoreSfmap function listStore index > where > index :: Int > index = pred size I'm getting: DistroCreator/GUI/List.hs:51:47: Kind error: `SFMonad' is applied to too many type arguments In the type `SFMonad sf ()' In the type `sf -> SFMonad sf ()' In the type `(SFValue sf -> SFValue sf) -> sf -> SFMonad sf ()' Failed, modules loaded: none. How can I use type families with types * -> *? Greetings. -- marcot http://marcot.iaaeee.org/

3 2

Help with types
by Daniel Carrera 23 Apr '09

23 Apr '09

Hi, I want to make a simple "average" function: average xs = (sum xs)/(length xs) When I try that on ghci I get the following error: No instance for (Fractional Int) arising from a use of `/' at <interactive>:1:17-36 Possible fix: add an instance declaration for (Fractional Int) In the expression: (sum xs) / (length xs) In the definition of `average': average xs = (sum xs) / (length xs) Ok, so 'sum' is of type (Num a => [a] -> a), length is of type ([a] -> Int) and (/) is of type (Fractional a => a -> a -> a). Can someone explain how I can "add an instance declaration" to my function so as to make all these types compatible? Thanks, Daniel.

5 11

generating the set of all finite-valued functions on a finite space
by Erik Quaeghebeur 23 Apr '09

23 Apr '09

Hi, I'd like to lazily generate the set of all {-1,0,1}-valued functions on {'a','b','c'}? How should I best approach this. I was thinking about generalizing the power set definition powerset :: [a] -> [[a]] powerset = filterM (const [True, False]) but clearly don't know enough about filterM and the like to do it this way. Erik

1 0

problem cabal install'ing hmatrix
by Erik Quaeghebeur 22 Apr '09

22 Apr '09

$ cabal install hmatrix Resolving dependencies... Configuring hmatrix-0.5.1.1... Preprocessing library hmatrix-0.5.1.1... running dist/build/Numeric/GSL/Special/Internal_hsc_make failed command was: dist/build/Numeric/GSL/Special/Internal_hsc_make >dist/build/Numeric/GSL/Special/Internal.hs cabal: Error: some packages failed to install: hmatrix-0.5.1.1 failed during the building phase. The exception was: exit: ExitFailure 1 What should I do to diagnose/resolve this problem? I'm on Gentoo/amd64 and have also posted this question in the gentoo forums. TIA for any help and pointers, Erik

2 1

Design questions for a Pascal interpreter
by Giuliano Vilela 21 Apr '09

21 Apr '09

Hello, I've been doing some research for a upcoming homework project, a Pascal interpreter written in Haskell. As a beginner to the language, I have a few design questions I'd like to share with you. I started playing with Parsec, getting a feel for parsing with monadic combinators. My assumption here is that i'm going to take the source, transform it in an AST (built with normal data constructors present in Haskell), maybe build a symbol table while doing that (using the implicity state in Parsec), do some checking (mainly type checking I think), and the evaluation itself. Here are a few questions I had so far: - Keeping the whole AST in memory for the evalution phase seems overkill. Is there a better way? - The evalution, I think, would be a set of nice pure mutually recursive functions that do some pattern matching on the program AST. I would pass the current stack and heap for those functions to use and modify. Is the State monad a good fit for this task? Wouldn't the code become "too imperative"? - And finally, the big question. Consider the following pascal source: program HelloWorld; begin writeln('Hello World'); end. To evaluate the AST, I would eventually arrive at something like: eval (FunctionCall func_name func_args) = ... Obviously, to evaluate writeln I need to be in the IO monad. Here, my whole scheme went down. Do I really have to mix my own state (stack, heap) within the IO monad along my evaluation functions? PS: I could keep a list of things to print, that I would eventually do after I traversed the whole tree, but that wouldn't be "realistic". Thank you! -- []'s Giuliano Vilela.

3 2

typeclass error
by Amitava Shee 21 Apr '09

21 Apr '09

I have the following code -- foo.hs module Foo where class Foo a where bar :: a -> a instance Foo Int where bar i = i + 10 ------------------ It fails to compile withe following error *Foo> bar 10 <interactive>:1:4: Ambiguous type variable `t' in the constraints: `Num t' arising from the literal `10' at <interactive>:1:4-5 `Foo t' arising from a use of `bar' at <interactive>:1:0-5 Probable fix: add a type signature that fixes these type variable(s) *Foo> - Thanks Amitava Shee

3 4