March 2015 - Beginners

Re: [Haskell-beginners] Dipping Toes Into Haskell
by Timothy Washington 25 Mar '15

25 Mar '15

So I've finally had a chance to revisit my tictactoe game. import Control.Lens data Piece = X | O | E deriving Show type Row = [Piece] type Board = [Row] *data Position = Int Int deriving Show* -- put an X or O in a position *move :: Board -> Piece -> Position -> Board* move board piece position = board main :: IO () main = putStrLn "Hello World" -- using Lenses -- https://github.com/ekmett/lens/wiki/Examples -- http://lens.github.io/tutorial.html -- http://blog.jakubarnold.cz/2014/07/14/lens-tutorial-introduction-part-1.html --let r1 = (E,E,E) --let r2 = (E,E,E) --let r3 = (E,E,E) --let board = (r1,r2,r3) Now, if I want to make a move, I'll want to set a *piece* on a *position*, on a *board*. Let's assume the board has the following shape. λ> let r1 = (E,E,E) λ> let r2 = (E,E,E) λ> let r3 = (E,E,E) λ> let board = (r1,r2,r3) ((E,E,E),(E,E,E),(E,E,E)) To return an updated board, I dug around and *i)* couldn't find a core Haskell equivalent to Clojure's update-in <http://clojuredocs.org/clojure.core/update-in>. *ii)* Zippers only deal with trees of left / right nodes. *iii)* So that left me with Control.Lens <https://github.com/ekmett/lens/wiki/Examples>. Now I can easily inspect and update the board like so. λ> board^*._**2._1* E λ> set (*_2._1*) 42 board ((E,E,E),(42,E,E),(E,E,E)) I can then parameterize _2 or _1 like so. λ> let a = _2 λ> board ^. a (E,E,E) But I can't figure out how to include that parameter's type into a *Position* type definition. I've tried these unsuccessfully. *data Position = Int Int deriving Show -- original type definition* *data Position = Simple Lens (Int a) (Int a) deriving Show -- failing try 1* move :: Board -> Piece -> Position -> Board move board piece position = set (position) piece board -- want to use this instead of "set (*_2._1*) 42 board" Any ideas? :) Tim Washington Interruptsoftware.com <http://interruptsoftware.com> On Thu, Mar 12, 2015 at 5:18 PM, Timothy Washington <twashing(a)gmail.com> wrote: > Veeery nice. Thanks for your insights. > > The Typeclass stuff making a lot more sense now. And hence ghc-mod's > (Interactive-Haskell's) behaviour makes more sense to me. It's working like > a charm. > > I'll play around with nested list manipulation this evening. > > > Cheers > > Tim Washington > Interruptsoftware.com <http://interruptsoftware.com> > > > On Thu, Mar 12, 2015 at 8:03 PM, Mike Meyer <mwm(a)mired.org> wrote: > >> On Thu, Mar 12, 2015 at 6:02 PM, Timothy Washington <twashing(a)gmail.com> >> wrote: >> >>> To get started, I'm trying to implement a simple *tictactoe* game. And >>> I would like to be able to represent a Piece on the board, as either the >>> string "X" or "O". This is what I have so far. >>> >>> module Main where >>> >>> data Piece = X | O >>> type Row = [Piece] >>> type Board = [Row] >>> >>> -- put an X or O in a position >>> move :: Board -> Piece -> Board >>> move board piece = board >>> >>> -- check win vertically >>> -- check win horizontally >>> -- check win diagonally >>> >>> main :: IO () >>> main = putStrLn "Hello World" >>> >>> >>> >>> *A)* Now, I'd like to be able to *load code interactively*, preferably >>> within emacs. However I don't have access to my types with *ghci* or *ghc-mod >>> (Interactive-Haskell)*. In either case, this call fails with the below >>> error. >>> >>> >>> let p = Piece X >>> <interactive>:20:9-13: Not in scope: data constructor `Piece' >>> >>> >> Piece is the data TYPE. It has two constructors, X, and O. If you load >> your module into ghci, you can do ":t X" to get the type of X, which is >> Piece. You want to do "let p = X" here. >> >> Check your mode docs while editing the haskell file. There should be a >> command to load the current buffer into a ghci running in an interactive >> emacs buffer. >> >> >>> *B)* And how do I make a *custom datatype* that's one of two strings >>> (enumeration of either "X" or "O"). Cabal builds and runs the abouve code, >>> so I know it can compile. But I'm confused as to where X or O is defined, >>> and how I would supply it as an input. >>> >> >> >> As noted, you can derive "Show" so that Piece types print as "X" and "O". >> Similarly, you can derive "Read": >> >> data Piece = X | O deriving (Show, Read) >> >> so that you can then read "X" and get back an X when the context calls >> for a Piece value: >> >> *Main> read "X" :: Piece >> >> X >> >> However, this isn't used a lot, as it tends to be slow and not very >> flexible for more complex types. For instance, it will let you read in >> lists of Pieces and lists of lists, but you'l lhave to use the list syntax, >> not something that looks like an actual board when printed. >> >>

2 4

Haskell Compiler
by Shishir Srivastava 24 Mar '15

24 Mar '15

Hi, What language is the Haskell compiler writter in ? Is it in Haskell itself just like gcc is written in 'C' ? Thanks, Shishir Srivastava

4 3

Derived data
by Mark Carter 24 Mar '15

24 Mar '15

I read inputs from files into various data types. Not all of the information is known at input time, so some of the data for a type needs to be derived. The question is: what is the best way of "guarding" between derived and underived data? By that I mean, there is a function which will derive missing data, and other functions can only work on derived data. Working on underived data would be a mistake.

2 1

Mastermind
by Mike Houghton 24 Mar '15

24 Mar '15

Hi All, I’m working through http://www.seas.upenn.edu/~cis194/hw/02-lists.pdf <http://www.seas.upenn.edu/~cis194/hw/02-lists.pdf> - the homework for the CIS 194 Haskell course. I ‘stuck’ on question 6! If anyone has done this I’d really appreciate a pointer to solving it. The problem is, given these colors colors = [Red, Green, Blue, Yellow, Orange, Purple] we first need to be able to generate a list of all the codes, ie all length n combinations of the 6 colors. In general, Mastermind games use codes of length 4, however in theory the code could be any length. We have not yet made any assumptions about the lengths of the codes, so why start now? Your function should take in a length and return all Codes of that length: allCodes :: Int -> [Code] Hint: This exercise is a bit tricky. Try using a helper function that takes in all the codes of length n − 1 and uses it to produce all codes of length n. You may find the concatMap function helpful. Now this [ [a,b,c,d] | a<-colors, b<-colors, c<-colors, d<-colors] will work for codes of length 4 but clearly doesn’t provide the general solution. I’m just not seeing it yet!!!! Thanks Mike

3 4

suggestions for re-implementing mapM
by Vale Cofer-Shabica 23 Mar '15

23 Mar '15

Hello all, I've been reading through "Tackling the Awkward Squad" [1] and am implementing the definitions "left as exercises" as I go. For section 2.2, I define: putLine :: [Char] -> IO () putLine :: mapM_ putChar where mapM_ :: Monad m => (a -> m b) -> a -> m () mapM_ f [] = return () mapM_ f (x:xs) = (f x) >> (mapM_ f xs) which works without difficulty. For the sake of learning, I decided to implement mapM as well. My definition (below) works, but seems really in-elegant. I checked the prelude source and found mapM defined in terms of sequence, which has some do-notation I'm not so clear on. I'm trying to avoid using do notation in my implementation because it still feels like magic. I'll work on de-sugaring do notation again once I have a solid handle on (>>=), (>>), and return. Any suggestions for cleaning this up would be much appreciated! mapM :: Monad m => (a -> m b) -> [a] -> m [b] mapM f [] = return [] mapM f (x:xs) = consMM (f x) (mapM f xs) consMM :: Monad m => m a -> m [a] -> m [a] consMM mx mxs = mx >>= ((flip consM) mxs) where consM x mxs = mxs>>=(\xs -> return (x:xs)) Thank you, vale [1] Suggested by apfelmus in a recent email to the list: http://research.microsoft.com/en-us/um/people/simonpj/papers/marktoberdorf/

2 2

Code review: Go challenge #1 in Haskell
by Ramakrishnan Muthukrishnan 23 Mar '15

23 Mar '15

Hello Haskellers: A few weeks ago, there was this thing called "Go challenge" and a problem was posted¹ on decoding a binary format and printing out the drum sequences in the input binary file. I made a Haskell solution and would love to get some code reviews. <https://github.com/vu3rdd/drum> One of the input files given does not have the full bitstream and my program cannot parse that yet. I had been thinking about using a Monad transformer to make a `Get (Maybe) a' and output whatever it could parse and leave the rest behind, instead of failing completely. ¹ http://golang-challenge.com/go-challenge1/ (fwiw, the challenge is over.) Thanks in advance, Ramakrishnan

2 2

Support for Maildir
by Elias Diem 22 Mar '15

22 Mar '15

Hi there Am I right that there are no up-to-date packages/libraries to process email in Maildir format? -- Greetings Elias

1 0

Re: [Haskell-beginners] [Haskell-cafe] Multi-parameter type classes and ambiguous type variables...
by Stuart Hungerford 21 Mar '15

21 Mar '15

On Sat, Mar 21, 2015 at 7:31 PM, Chris Wong <lambda.fairy(a)gmail.com> wrote: > [...] >>> check :: (Eq g, M r g) => g -> Bool >>> check x = sca one x == x >>> >>> The problem I have is that GHC is finding the "r" type variable in the >>> "check" function ambiguous. Given my still limited Haskell knowledge >>> I'm not surprised this is happening. What I would like to know is how >>> experienced Haskellers handle this situation in practice: is there an >>> idiomatic way of disambiguating "r" or is it a sign of poor type class >>> design? > > In the type signature: > > check :: (Eq g, M r g) => g -> Bool > > you fix the type `g`, but not the type `r`. This causes an ambiguity > in the program because if you had e.g. > > instance M Float Vector where ... > instance M Int Vector where ... > > both in the same program, and you passed a Vector to `check`, GHC > won't know which instance to choose. > > To solve this ambiguity, either fix `r` with an extra parameter: > > check :: (Eq g, M r g) => r -> g -> Bool > check one' x = sca one' x == x > > Or declare that `r` is uniquely determined by `g` using a *functional > dependency*: > > class (R r, AG g) => M r g | g -> r where > sca :: r -> g -> g > > Or equivalently, using *associated types*: > > class (AG g, R (Scalar g)) => M g where > type Scalar g :: * > sca :: Scalar g -> g -> g > > check :: (Eq g, M g) => g -> Bool > check x = -- as before > > A Google search for these two terms should yield plenty of tutorials > and examples. Thanks for this excellent explanation. > (By the way, I'd suggest using longer names like "Ring" and > "AdditiveGroup" instead, as they're easier to read.) Yes -- I stripped the example down, including the full names of the type classes, for explaining the issue. I could well have left the full names though. Stu

1 0

Multi-parameter type classes and ambiguous type variables...
by Stuart Hungerford 21 Mar '15

21 Mar '15

Hi, As a learning exercise I'm modelling some algebraic structures as Haskell typeclasses. Some of these are multi-parameter type classes. Here's a very simplified version of the type class relationships: class MM a where one :: a class AM a where zero :: a class (AM a, MM a) => SR a class (AM a) => AG a where inv :: a -> a class (SR a) => R a where neg :: a -> a class (R r, AG g) => M r g where sca :: r -> g -> g check :: (Eq g, M r g) => g -> Bool check x = sca one x == x The problem I have is that GHC is finding the "r" type variable in the "check" function ambiguous. Given my still limited Haskell knowledge I'm not surprised this is happening. What I would like to know is how experienced Haskellers handle this situation in practice: is there an idiomatic way of disambiguating "r" or is it a sign of poor type class design? Thanks, Stu

2 1

Finding the lowest element greater or equal than
by martin 18 Mar '15

18 Mar '15

Hello all, I want to find the lowest element in a collection of items which is greatet or equal to a given element. There can be more than one such element in which case I wouldn't care which one I get. I still want to be able to iterate over the elements following the found element. In a way I want the equivalent of select ... from table where table.x > n How would I do this efficiently? I tried using an ordered list, but I would still have to traverse half the list on average. I suppose I can do this with some sort of tree, but i don't want to write all the code myself. But I couldn't find anything off the shelf.

3 2