June 2016 - Beginners

Multiline code in GHCi
by Shishir Srivastava 29 Aug '17

29 Aug '17

Hi, I am trying to run this basic multiline code in GHCi. I am not sure if this is even possible without writing it in a file and compiling it in a traditional way. ------- Prelude> :set +m Prelude> let main1 = do Prelude| a <- readLn Prelude| return a Prelude| Prelude> Prelude> main1 <interactive>:75:1: No instance for (Show (IO b0)) arising from a use of `print' In the first argument of `print', namely `it' In a stmt of an interactive GHCi command: print it ------- Could someone please confirm if the function can be defined and called like this in GHCi or point to where am going wrong. Thanks, Shishir Srivastava

5 9

Howto reverse a Data.Array
by Timothy Washington 03 Jul '16

03 Jul '16

I'm still trying to get an intuitive understanding of Haskell's Data.Array <http://hackage.haskell.org/package/array-0.5.1.1/docs/Data-Array.html#g:5>, in contrast to Data.List or Data.Vector. I very much want a nested array (a matrix), where the parent list (or rows) are reversed. But neither *A.array* nor *A.istArray* allow indicies to be reversed in their constructors, nor the list comprehensions that generate the elements The only reason I'm using an array, is for the *A.//* function (operating on a matrix). Otherwise, I'd use Data.Vector <https://hackage.haskell.org/package/vector-0.11.0.0/candidate/docs/Data-Vec…> which does have a reverse function, but a less powerful *V.//* , that doesn't accept coordinates in a matrix. Can I reverse a Data.Array? If not, then why. Thanks Tim

2 2

error writing FilePath to text file
by Dennis Raddle 29 Jun '16

29 Jun '16

Hello, I wrote a program that reads filenames using System.Directory "listDirectory", does some tests on them, and writes certain file names (as read into a FilePath variable by listDirectory) to a text file, which I later parse with Parsec. I am getting an error on writing to the text file: commitBuffer: invalid argument (invalid character) What can I do about this? If I am reading some kind of unusual characters from the FilePath, I want to choose some way of writing them so that the resulting file can still be parsed by Text.Parsec.ByteString. I hope that I can still rely on the "space" parser to find CR and LF, and don't want any other surprises. D

2 3

Generating Infinite List of Fibonacci Numbers
by Desonte Jolivet 29 Jun '16

29 Jun '16

Hi, Problem: I would like to generate an infinite list of Fibonacci numbers. Although the below code does not work. fibs :: [Integer]fibs = 0 : 1 : [ n | x <-[2..], let n = ((fibs !! x-1) + (fibs !! x-2))] Thought: I'm assuming that I'm ignorant on how ranges/generators work with a list comprehension, which is why this code is not working. ghci output: *Main> fibs !! 01*Main> fibs !! 12*Main> fibs !! 2 When I try and access the third element in the list ghci simply stalls. Can someone please give me a little more insight on why my code is not working. Thanks in advance. drjoliv

2 1

RDBMS like references?
by martin 28 Jun '16

28 Jun '16

Hello all, I recently tried to model "Items", where an Item can either be inside another Item or at a certain location. I started like this: data Location i l = At l | In (Item i l) deriving (Eq, Show) data Item i l = Itm i (Location i l) deriving (Eq, Show) type ItemDb i l = [Item i l] ex_itemdb = let i1 = Itm 1 (At "a") i2 = Itm 2 (In i1) in [i1, i2] Now I wanted to move Item 1 to a different location using this code: moved = fmap f ex_itemdb where f (Itm 1 (At "a")) = (Itm 1 (At "b")) f x = x Not this does not do what I want. I get -- *Main> ex_itemdb -- [Itm 1 (At "a"),Itm 2 (In (Itm 1 (At "a")))] -- *Main> moved -- [Itm 1 (At "b"),Itm 2 (In (Itm 1 (At "a")))] While Item 1 has moved to "b" Item 2 still claims to be in an "Itm 1 (At "a")". I understand what's going on here and coming from a DB background I can see that the redundant data is the root of the problem. I can model this in a relational way such that the redundancy is avoided. But maybe there is a more haskellish/idiomatic way to acomplish this. Is there?

2 2

Strorable and incomplete type
by PICCA Frederic-Emmanuel 27 Jun '16

27 Jun '16

Hello, I would like to use Storable and declare an instance for a struct available in a C library instance Storable Parameter where sizeOf _ = #{size HklParameter} peek ptr = alloca $ \pmin -> alloca $ \pmax -> do cname <- c_hkl_parameter_name_get ptr name <- peekCString cname value <- c_hkl_parameter_value_get ptr unit c_hkl_parameter_min_max_get ptr pmin pmax unit min <- peek pmin max <- peek pmax return (Parameter name value (Range min max)) but when I try to compile this, I get this error message C.hsc:507:15: error: invalid application of ‘sizeof’ to incomplete type ‘HklParameter’ Indeed the C library do not expose this struct internal. So I would like to know how to handle this kind of C struct with Storable. thanks for your help Frédéric

1 0

Functions as containers; implications on being a Monad ((->) r)
by Raja 24 Jun '16

24 Jun '16

Everyone agrees ((->) r) is a Functor, an Applicative and a Monad but I've never seen any good writeup going into details of explaining this. So I was trying to brainstorm with my brother and went pretty far into the concept for quite a few hours, but still got stuck when it came to Monads. Before I showcase the question/problem I wanted to share our thinking process. Lets stick with common types like Maybe a, [a], simple function (a -> b) **Everything is a Container** Just 4 => this is a container wrapping some value [1,2,3] => this is a container wrapping bunch of values (+3) => this is a container wrapping domains & ranges (infinite dictionary) **When is a Container a Functor** If we can peek inside a container and apply a simple function (a->b) to each of its values and wrap the result back inside the container, then it becomes a Functor. Let's use (\x -> x+7) as simple function along with above three Containers (\x -> x+7) <$> Just 4 => Just 11 (\x -> x+7) <$> [1,2,3] => [8,9,10] (\x -> x+7) <$> (+3) => (+10) -- well there is no Show defined but you get the idea **When is a Container an Applicative** The simple function from above is also now wrapped inside a container and we should be able to peek to use it just like functor. Also lets simplify (\x -> x+7) to (+7). Just (+7) <*> Just 4 => Just 11 [(+7)] <*> [1,2,3] => [8,9,10] (\x -> (+7)) <*> (+3) => (+10) -- again no Show defined but works when pass a number -- but (+7) still needs to be wrapped in a Container though **When is a Container a Monad** This time we don't have a simple function (a->b) instead we have a non-simple function (a -> Container). But rest stays almost the same. We have to first peek inside a container and apply non-simple function to each of its values. Since its a non-simple function we need to collect all the returned Containers, unwrap them and wrap them all back in a Container again. (it almost feels like unwrap and wrapping them back is going to complicate things) Also Non-simple function cannot be reused as is for all three Containers like in Functors & Applicatives. Just 4 >>= (\x -> Just (x+7)) => Just 11 [1,2,3] >>= (\x -> [x+7]) => [8,9,10] (+3) >>= (\x -> (+7)) => (+7) Wait a minute ... the last line doesn't look right. Or should I say it doesn't feel right to discard the `x' altogether. OK let's jump to do this: (+3) >>= (\x -> (+x)) => ??? -- apparently this solves for the equation: f(x) = 2x + 3 (is 2x + 3 obvious for anyone??? it took us way longer to derive it) (Does it have anything to do with Monad laws by any chance?) This is where it feels like "Functions as containers" concept starts to breakdown; its not the right analogy for Monads. What does it even mean to unwrap a bunch of functions and wrap them back again? Hope this intrigues some of you as it did to us. Any thoughts and comments greatly appreciated. Thanks, Raja

4 3

Programming in Haskell - 2nd Edition
by Graham Hutton 21 Jun '16

21 Jun '16

Dear all, I'm delighted to announce that the 2nd edition of Programming in Haskell will be published in August 2016! The new edition has been extensively updated and expanded to include recent and more advanced features of Haskell, new examples and exercises, selected solutions, and freely downloadable lecture slides and example code. Further details, including how to preorder and obtain inspection copies, are provided below. Best wishes, Graham ================================================================= *** BOOK ANNOUNCEMENT *** Programming in Haskell - 2nd Edition Graham Hutton, University of Nottingham Cambridge University Press, August 2016 320 pages, 120 exercises, ISBN 9781316626221 http://tinyurl.com/PIH-2e ================================================================= DESCRIPTION: Haskell is a purely functional language that allows programmers to rapidly develop clear, concise, and correct software. The language has grown in popularity in recent years, both in teaching and in industry. This book is based on the author's experience of teaching Haskell for more than twenty years. All concepts are explained from first principles and no programming experience is required, making this book accessible to a broad spectrum of readers. While Part I focuses on basic concepts, Part II introduces the reader to more advanced topics. This new edition has been extensively updated and expanded to include recent and more advanced features of Haskell, new examples and exercises, selected solutions, and freely downloadable lecture slides and example code. The presentation is clean and simple, while also being fully compliant with the latest version of the language, including recent changes concerning applicative, monadic, foldable, and traversable types. ================================================================= CONTENTS: Foreword Preface Part I. Basic Concepts: 1. Introduction 2. First steps 3. Types and classes 4. Defining functions 5. List comprehensions 6. Recursive functions 7. Higher-order functions 8. Declaring types and classes 9. The countdown problem Part II. Going Further: 10. Interactive programming 11. Unbeatable tic-tac-toe 12. Monads and more 13. Monadic parsing 14. Foldables and friends 15. Lazy evaluation 16. Reasoning about programs 17. Calculating compilers Appendix A. Selected solutions Appendix B. Standard prelude Bibliography Index ================================================================= AUTHOR: Graham Hutton is Professor of Computer Science at the University of Nottingham. He has taught Haskell to thousands of students and received numerous best lecturer awards. Hutton has served as an editor of the Journal of Functional Programming, Chair of the Haskell Symposium and the International Conference on Functional Programming, and Vice-Chair of the ACM Special Interest Group on Programming Languages, and he is an ACM Distinguished Scientist. ================================================================= FURTHER DETAILS: The following web page includes details for how the book can be preordered, and how lecturers can obtain inspection copies: http://tinyurl.com/PIH-2e ================================================================= This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please send it back to me, and immediately delete it. Please do not use, copy or disclose the information contained in this message or in any attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. This message has been checked for viruses but the contents of an attachment may still contain software viruses which could damage your computer system, you are advised to perform your own checks. Email communications with the University of Nottingham may be monitored as permitted by UK legislation.

2 1

default(Int)
by Imants Cekusins 16 Jun '16

16 Jun '16

default(Int) allows to use integers anywhere in this module without specifying their ambiguous type each time, like this: (3::Int) https://www.haskell.org/tutorial/numbers.html section 10.4 some other default types may be specified too somehow I was not aware of this

2 1

State Monad in constant space?
by martin 14 Jun '16

14 Jun '16

Hello all, the State Monad wraps around a computation s -> (s,a). Inside a do block I am actually assembling such a computation. Now when I do this many times, i.e. in a recursice call, I am builing a huge expression m a >>= (\a -> mb) >>= (\b -> mc) ... The result of this expression is a function s -> (s,a). But I cannot see how the space for this expression can be reclaimed, and how it could ever run in constant space. Once I call runState and I provide an initial s, I have some hope, but before? How is this supposed to work? How do I avoid allocating space for this huge expression?

3 2