News aggregator

Haskell and Web

del.icio.us/haskell - Thu, 01/29/2015 - 4:15pm
Categories: Offsite Blogs

Haskell and Web

del.icio.us/haskell - Thu, 01/29/2015 - 4:15pm
Categories: Offsite Blogs

foobarcode.me

del.icio.us/haskell - Thu, 01/29/2015 - 2:10pm
Categories: Offsite Blogs

Roman Cheplyaka: Recognizing lists

Planet Haskell - Thu, 01/29/2015 - 2:00pm
import Data.Monoid import Data.List (isSuffixOf) import Control.Applicative import Control.Applicative.Permutation as Perm import Control.Monad.Trans.State

You are given the following Haskell data type:

data T = A Int | B String

Your task is to write a function

recognize :: [T] -> Bool

that would accept a list iff it contains exactly three elements, of which:

  1. one is an A with a value between 3 and 7
  2. one is an A with an even value
  3. one is a B with a value ending in .hs

The A elements mentioned in conditions (1) and (2) have to be distinct, so [A 4, A 17, B "Prelude.hs"] should not be accepted, even though A 4 satisfies both (1) and (2).

This problem often arises in blackbox testing. You do something to a system; you wait for some time while gathering all events that the system generates. Then you want to check that the system generated all the events it had to generate, and no extra ones. However, the order of events may be non-deterministic. If the system concurrently makes a web request, updates a database and sends a message to a message bus, the order in which these events will be observed by your test suite is arbitrary.

A similar problem arises in input validation.

Interface

We want to solve this problem in a general and scalable way. What would an interface to such solution look like? There are two principal options.

One is a simple function

recognize :: [t -> Bool] -> [t] -> Bool

that takes individual predicates and combines them into a recognizer.

Another is to split the process into the build and use phases by the means of an intermediate data type:

data Parser t instance Monoid Parser toParser :: (t -> Bool) -> Parser t runParser :: Parser t -> [t] -> Bool

In this approach, you convert individual recognizers to monoidal values, combine those values and extract the result.

Semantically, the two are equivalent: if you have one of these interfaces available, you can implement the other one. In a way, this is a consequence of lists being the free monoid, but writing this down explicitly is a good exercise nevertheless.

The advantages of a build-use interface are:

  1. When the cost of the build phase is non-trivial, it can be amortized over multiple uses and/or incremental builds. (This won’t be the case here.)
  2. The use of a specialized type is generally good for the type system hygiene.

We’ll start with the build-use interface because I find it more instructive.

The Parser

To build the monoidal parser, we’ll use the action-permutations library. You may remember it from the article on JSON parsing.

newtype Parser t = Parser { getParser :: Perms (StateT [t] Maybe) () }

StateT [t] Maybe a is the familiar type of parser combinators, [t] -> Maybe (a, [t]), that return the left-over input. We wrap it in Perms to achieve the order independence, and then newtype it to convert its Applicative instance to a Monoid one:

instance Monoid (Parser t) where mempty = Parser (pure ()) mappend (Parser a) (Parser b) = Parser $ a *> b

The build and use functions are straightforward:

toParser :: (t -> Bool) -> Parser t toParser isX = Parser $ Perm.atom $ StateT $ \ts -> case ts of (t:ts') | isX t -> Just ((), ts') _ -> Nothing runParser :: Parser t -> [t] -> Bool runParser p ts = case (flip execStateT ts . runPerms . getParser) p of Just [] -> True _ -> False Usage

First, let’s express our conditions in Haskell code.

isA1, isA2, isB :: T -> Bool isA1 x | A n <- x, 3 <= n, n <= 7 = True | otherwise = False isA2 x | A n <- x, even n = True | otherwise = False isB x | B s <- x, ".hs" `isSuffixOf` s = True | otherwise = False

Combine them together:

parser :: Parser T parser = (mconcat . map toParser) [isA1, isA2, isB]

(we could replace mconcat . map toParser with foldMap toParser from Data.Foldable)

recognize :: [T] -> Bool recognize = runParser parser

Now try it out:

ex1 = recognize [A 4, A 17, B "Prelude.hs"] -- => False ex2 = recognize [A 4, A 18, B "Prelude.hs"] -- => True ex3 = recognize [B "Prelude.hs", A 18, A 4] -- => True ex4 = recognize [B "Prelude.hs", A 18, A 4, A 1] -- => False
Categories: Offsite Blogs

JP Moresmau: EclipseFP 2.6.4 released!

Planet Haskell - Thu, 01/29/2015 - 11:13am
Hello all. I've just released EclipseFP 2.6.4, to provide a fix for people that could not create projects due to a NullPointerException. Unfortunately I am at the moment the only contributor to EclipseFP which means nobody else than myself tests it before a release, so regressions happen. I would love to see more people contribute and build from source!

A couple of fixes and small enhancements have been made, the release note are here.

Just update by pointing your Eclipse update feature to http://eclipsefp.sf.net/updates.

Happy Haskell Hacking!
Categories: Offsite Blogs

York Haskell Meetup TONIGHT

Haskell on Reddit - Thu, 01/29/2015 - 8:57am
Categories: Incoming News

Tranversable instance for Trie

Haskell on Reddit - Thu, 01/29/2015 - 8:33am

Hey!

I've got the following data type for Trie:

data Trie a = Trie { value :: Maybe a , children :: M.Map Char (Trie a) } deriving (Show)

How would I go about making a transversable instance for this data type? So far I have:

instance Traversable Trie where traverse f t | isJust (value t) = Trie {value = f (value t), children = traverse (traverse f) (children t)} | otherwise = Trie {value = Nothing, children = traverse (traverse f) (children t)}

Which is not working and I get the error:

C:\trie.hs:24:82: Couldn't match type `M.Map Char' with `Trie' Expected type: Trie (Trie a) Actual type: M.Map Char (Trie a) In the second argument of `traverse', namely `(children t)' In the `children' field of a record C:\Users\Matias\Downloads\trie.hs:26:78: Couldn't match type `M.Map Char' with `Trie' Expected type: Trie (Trie a) Actual type: M.Map Char (Trie a) In the second argument of `traverse', namely `(children t)' In the `children' field of a record Failed, modules loaded: none. submitted by GrimBeast
[link] [6 comments]
Categories: Incoming News

Recognizing lists

Haskell on Reddit - Thu, 01/29/2015 - 7:11am
Categories: Incoming News

Any Haskell enthusiasts from Bangalore India?

Haskell on Reddit - Thu, 01/29/2015 - 4:17am

I am a newbie to Haskell programming. I would like to know if there are any Haskell enthusiasts that would like to work on Haskell projects. My focus is currently on learning Haskell and eventually develop side projects in Haskell.

submitted by vrbala
[link] [11 comments]
Categories: Incoming News

www.macs.hw.ac.uk

del.icio.us/haskell - Thu, 01/29/2015 - 3:30am
Categories: Offsite Blogs

Pure functional and pure logical language at thesame time

haskell-cafe - Wed, 01/28/2015 - 7:22pm
This question was bugging me for quite a long time. Can we have a language which uses the functional logic while being both pure functional and pure logical? Do we get any advantages from maintaining both both of this purities at the same time? P.S.: I have feeling the answer is no, but I am not sure. _______________________________________________ Haskell-Cafe mailing list Haskell-Cafe< at >haskell.org http://www.haskell.org/mailman/listinfo/haskell-cafe
Categories: Offsite Discussion

Haskell Project Ideas?

Haskell on Reddit - Wed, 01/28/2015 - 5:14pm

Hey everyone! First time post on here, and I have a request that hopefully you guys can help me with. I'm currently in a programming language studies class, where we are having to pick a language, learn it, and develop some sort of project within around 3 months during the semester. I chose haskell because it seemed like the most interesting, having never worked in a functional language before.

My request is if you guys could throw out some ideas for me! Not gonna lie, I am not the most creative guy when it comes to school projects, so hopefully someone here can point me in the right direction! The project does not need to be 100% haskell, but it does need to be focused primarily around the use of it. Any and all help will be greatly appreciated!

submitted by Endeejay
[link] [10 comments]
Categories: Incoming News

Need to understand "Type Constructor"

Haskell on Reddit - Wed, 01/28/2015 - 4:58pm

In LYAH (http://learnyouahaskell.com/making-our-own-types-and-typeclasses#type-parameters), while citing an example of type constructors, Maybe is referred to as type-constructor.

data Maybe a = Nothing | Just a

If I follow definition, given in the same section for type-parameters, Just, seems to be the type-constructor. For example, in Just "Hello" - Just takes a String and returns a "Maybe [Char]".

Can anyone explain, which one is the type-constructor Maybe a or Just and why?

submitted by KuldeepSinh
[link] [15 comments]
Categories: Incoming News