Skip to main content

Home/ Haskell/ Group items tagged classes

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Javier Neira

Haskell: The Confusing Parts - 0 views

echo.rsmw.net/n00bfaq.html

haskell intro good syntax

shared by Javier Neira on 15 Nov 09 - Cached
  • f $ x = f x(f . g) x = f (g x)-- Some quick examples of using these. The following line...putStrLn (take 12 (map foo (bar ++ "ack")))-- ...can be rewritten as...putStrLn $ take 12 $ map foo $ bar ++ "ack"(putStrLn . take 12 . map foo) (bar ++ "ack")putStrLn . take 12 . map foo $ bar ++ "ack" In terms of good Haskell style, the last example above is preferable to the others. By the way, note that ($) has the lowest precedence (zero) of any operator, so you can almost always use arbitrary syntax on either side of it.
  • -- Actual definitions:f $ x = f x(f . g) x = f (g x)-- Some quick examples of using these. The following line...putStrLn (take 12 (map foo (bar ++ "ack")))-- ...can be rewritten as...putStrLn $ take 12 $ map foo $ bar ++ "ack"(putStrLn . take 12 . map foo) (bar ++ "ack")putStrLn . take 12 . map foo $ bar ++ "ack"
  • putStrLn (take 12 (map foo (bar ++ "ack")))-- ...can be rewritten as...putStrLn $ take 12 $ map foo $ bar ++ "ack"(putStrLn . take 12 . map foo) (bar ++ "ack")putStrLn . take 12 . map foo $ bar ++ "ack"
  • ...7 more annotations...
  • putStrLn (take 12 (map foo (bar ++ "ack")))
  • anywhere you might write \x -> foo x [1..10], you should instead write flip foo [1..10], where flip is a standard Prelude function that flips the first two arguments of whatever function you give it
  • two arguments of whatever
  • anywhere you might write \x -> foo x [1..10], you should instead write flip foo [1..10], where flip is a standard Prelude function that flips the first
  • The curry and uncurry functions stand in for \f x y -> f (x, y) and \f (x, y) -> f x y, respectively.
  • The curry and uncurry functions stand in for \f x y -> f (x, y)
  • I will point out that return is, in fact, not a return statement. It’s a function, and an inappropriately named function, at that. Writing return () in your do block will not cause the function to return.
  • Javier Neira on 15 Nov 09
     
    If you're used to the C family of languages, or the closely related family of "scripting languages," Haskell's syntax (mainly) is a bit baffling at first. For some people, it can even seem like it's sneaking out from under you every time you think you understand it. This is sort of a FAQ for people who are new to Haskell, or scared away by its syntax.
Javier Neira

Monads in 15 minutes: Backtracking and Maybe - 0 views

www.randomhacks.net/...monads-in-15-minutes

monads haskell backtracking howto

shared by Javier Neira on 09 Nov 09 - Cached
  • type Choice a = [a] choose :: [a] -> Choice a choose xs = xs
  • Because Haskell doesn’t compute answers until we ask for them, we get the actual backtracking for free!
  • The missing function is almost too trivial to mention: Given a single value of type a, we need a convenient way to construct a value of type Choice a:
  • ...5 more annotations...
  • More math trivia: return is also known as unit and η. That’s a lot of names for a very simple idea.)
  • makePairs = choose [1,2,3] >>= (\x -> choose [4,5,6] >>= (\y -> return (x,y)))
  • makePairs' = do x <- choose [1,2,3] y <- choose [4,5,6] return (x,y)
  • Every monad has three pieces: return, map and join.
  • Backtracking: The lazy way to code
Javier Neira

jaspervdj - Maybe, null, and boilerplate code - 0 views

jaspervdj.be/...04-maybe-null-boilerplate.html

haskell Maybe monad example

shared by Javier Neira on 05 Jan 10 - Cached
  • A first goal they serve is as "unassigned variables". I will not cover that here, instead I will focus on another use: abnormal return values.
  • So, null is some sort of "Not found" error here. But wait - they could have used an Exception here!
  • We see a similar behavior here: when the object is found, we get a Just a, and when it is not found, we get Nothing - comparable to a null pointer.
  • ...5 more annotations...
  • So, while we can get a null back from a function, we should never give it to a function.
  • Now, if you have written a lot of Java code, you know that checking for null is a vital part of the job, and fragments like the one above are pretty common.
  • In Haskell, however, Maybe is also a monad - and monads can be used to prevent common patterns in code - in other words, they assist you in the D.R.Y.-principle2. We can therefore write the above snippet again using do-notation3.
  • getPathMonth :: Map String String -> Maybe MonthgetPathMonth m = do p <- lookup "path" m d <- parseDate p return $ getMonth d
  • he whole "check-for-null-and-short-circuit" behavior is defined by the Maybe monad -
  • Javier Neira on 05 Jan 10
     
    getPathMonth :: Map String String -> Maybe Month getPathMonth m = case M.lookup "path" m of Nothing -> Nothing (Just p) -> case parseDate p of Nothing -> Nothing (Just d) -> Just (getMonth d) getPathMonth :: Map String String -> Maybe Month getPathMonth m = do p <- parseDate p return $ getMonth d
Javier Neira

Existential type - HaskellWiki - 0 views

www.haskell.org/...Existential_type

ghc type existential

shared by Javier Neira on 21 Dec 09 - Cached
  • First of all, it is now impossible for a function to demand a Worker having a specific type of buffer. Second, the type of foo can now be derived automatically without needing an explicit type signature. (No monomorphism restriction.) Thirdly, since code now has no idea what type the buffer function returns, you are more limited in what you can do to it.
  • This illustrates creating a heterogeneous list, all of whose members implement "Show", and progressing through that list to show these items: data Obj = forall a. (Show a) =&gt; Obj a &nbsp; xs :: [Obj] xs = [Obj 1, Obj "foo", Obj 'c'] &nbsp; doShow :: [Obj] -&gt; String doShow [] = "" doShow ((Obj x):xs) = show x ++ doShow xs With output: doShow xs ==&gt; "1\"foo\"'c'"
  • Existential types in conjunction with type classes can be used to emulate the dynamic dispatch mechanism of object oriented programming languages. To illustrate this concept I show how a classic example from object oriented programming can be encoded in Haskell.
J.A. Alonso

A tour of the Haskell monad functions - 1 views

members.chello.nl/...tourdemonad.html

Tutorial Haskell

shared by J.A. Alonso on 24 Jan 10 - Cached
  • ap module: Control.Monad type: ap :: (Monad m) =&gt; m (a -&gt; b) -&gt; m a -&gt; m b
J.A. Alonso

The Risks and Benefits of Teaching Purely Functional Programming in First Year - 0 views

www.cse.unsw.edu.au/...CK02a.html

artículo enseñanza programación haskell

shared by J.A. Alonso on 26 Nov 11 - Cached
  • J.A. Alonso on 26 Nov 11
     
    "We argue that teaching purely functional programming as such in freshman courses is detrimental to both the curriculum as well as to promoting the paradigm. Instead, we need to focus on the more general aims of teaching elementary techniques of programming and essential concepts of computing. We support this viewpoint with experience gained during several semesters of teaching large first-year classes (up to 600 students) in Haskell. These classes consisted of computer science students as well as students from other disciplines. We have systematically gathered student feedback by conducting surveys after each semester. This article contributes an approach to the use of modern functional languages in first year courses and, based on this, advocates the use of functional languages in this setting. "
Javier Neira

Monads as containers - HaskellWiki - 0 views

www.haskell.org/...Monads_as_Containers

haskell monads intro as container

shared by Javier Neira on 28 Dec 09 - Cached
  • A monad is a container type together with a few methods defined on it.
  • all the elements which a monadic container holds at any one time must be the same type (it is homogeneous).
  • map (fmap), return and join,
  • ...15 more annotations...
  • map, (but called fmap in Haskell 98) actually comes from the definition of a functor
  • That is, if f is a functor, and we are given a function of type (a -&gt; b), and a container of type (f a), we can get a new container of type (f b). This is expressed in the type of fmap: fmap :: (Functor f) =&gt; (a -&gt; b) -&gt; f a -&gt; f b If you will give me a blueberry for each apple I give you (a -&gt; b), and I have a box of apples (f a), then I can get a box of blueberries (f b). Every monad is a functor.
  • The second method, return, is specific to monads. If m is a monad, then return takes an element of type a, and gives a container of type (m a) with that element in it. So, its type in Haskell is return :: (Monad m) =&gt; a -&gt; m a If I have an apple (a) then I can put it in a box (m a).
  • takes a container of containers m (m a), and combines them into one m a in some sensible fashion. Its Haskell type is join :: (Monad m) =&gt; m (m a) -&gt; m a
  • If I have a box of boxes of apples (m (m a)) then I can take the apples from each, and put them in a new box (m a).
  • bind or extend, which is commonly given the symbol (&gt;&gt;=)
  • The function that does this for any monad in Haskell is called liftM -- it can be written in terms of return and bind as follows:
  • liftM :: (Monad m) =&gt; (a -&gt; b) -&gt; m a -&gt; m b liftM f xs = xs &gt;&gt;= (return . f) -- take a container full of a's, to each, apply f, -- put the resulting value of type b in a new container, -- and then join all the containers together.
  • Well, in Haskell, IO is a monad.
  • Lists are most likely the simplest, most illustrative example
  • The reason that bind is so important is that it serves to chain computations on monadic containers together.
  • You might notice a similarity here between bind and function application or composition, and this is no coincidence.
  • What bind does is to take a container of type (m a) and a function of type (a -&gt; m b). It first maps the function over the container, (which would give an m (m b)) and then applies join to the result to get a container of type (m b). Its type and definition in Haskell is the
  • xs &gt;&gt;= f = join (fmap f xs)
  • bind (&gt;&gt;=)
Javier Neira

Understanding Monads Via Python List Comprehensions « All Unkept - 0 views

lukeplant.me.uk/...via-python-list-comprehensions

haskell monads tutorial python

shared by Javier Neira on 02 Mar 10 - Cached
  • But here we have taken it to a higher level -- the Monad interface is like an abstraction of any kind of container.
  • This in turn leads to the concept that a monadic value represents a computation -- a method for computing a value, bound together with its input value.
  • Writing monads is hard, but it pays off as using them in Haskell is surprisingly easy, and allows you to do some very powerful things.
  • ...3 more annotations...
  • One of them you have seen explicitly -- it's the 'return' method, responsible for packing things up into the monad. The other is called 'bind' or '&gt;&gt;=', and it does the 'unpacking' involved with the &lt;- arrow in the do notation.
  • the 'bind' method doesn't really unpack and return the data. Instead, it is defined in such a way that it handles all unpacking 'internally', and you have to provide functions that always have to return data inside the monad.
  • It looks very much like 'unpack this data from the monad so I can use it', so it helps conceptually. In fact, together with the rest of the body of the 'do' block it forms an anonymous lambda function,
Javier Neira

Learn You a Haskell for Great Good! - Types and Typeclasses - 0 views

learnyouahaskell.com/types-and-typeclasses

type classes haskell tutorial intro

shared by Javier Neira on 22 Dec 09 - Cached
  • That's why we can use explicit type annotations. Type annotations are a way of explicitly saying what the type of an expression should be. We do that by adding :: at the end of the expression and then specifying a type.
Javier Neira

Learning Haskell Notes - 0 views

www.ninebynine.org/...Learning-Haskell-Notes.html

haskell learning notes

shared by Javier Neira on 09 Dec 09 - Cached
  • 8. Functors
  • A "functor" is a structured collection (or container) type with a method (fmap) that accepts a method and applies that method to the members of the collection yielding an isomorphic collection of values of a (possibly) new type. Is this right?
  • Every monad is a functor, but not the other way around; a monad is a functor PLUS functions &gt;&gt;= and return satisfying some laws
  • ...4 more annotations...
  • a functor is a type constructor PLUS a function fmap satisfying some laws.
  • I think it's better to use existentials, as they let you define multiple instances for the same type.
  • People tend to forget that the major difference between ADT's and OO-style classes is really only that with a class you can have many instances in the same program simultaneously, whereas with an ADT you can have only one; but the ADT implementation is still interchangeable.
  • sequence :: Monad m =&gt; [m a] -&gt; m [a]
J.A. Alonso

A History of Haskell: being lazy with class - 0 views

research.microsoft.com/...index.htm

artículo Haskell historia

shared by J.A. Alonso on 27 Dec 11 - No Cached
  • J.A. Alonso on 27 Dec 11
     
    This long (55-page) paper describes the history of Haskell, including its genesis and principles, technical contributions, implementations and tools, and applications and impact.
Javier Neira

What is (functional) reactive programming? - Stack Overflow - 0 views

stackoverflow.com/...1028250

reactive programming functional definition stackoverflow

shared by Javier Neira on 07 Jan 10 - Cached
  • Semantically, FRP's concurrency is fine-grained, determinate, and continuous.
  • Dynamic/evolving values (i.e., values "over time") are first class values in themselves. You can define them and combine them, pass them into &amp; out of functions. I called these things "behaviors".
  • Each occurrence has an associated time and value.
  • ...3 more annotations...
  • In software design, I always ask the same question: "what does it mean?".
  • It's been quite a challenge to implement this model correctly and efficiently, but that's another story.
  • The basic idea behind reactive programming is that there are certain datatypes that represent a value "over time". Computations that involve these changing-over-time values will themselves have values that change over time.
J.A. Alonso

Foundations of Functional Programming - bu Robin Cockett - 0 views

pages.cpsc.ucalgary.ca/...webnotes.html

curso haskell i1m

shared by J.A. Alonso on 06 Oct 11 - No Cached
  • J.A. Alonso on 06 Oct 11
     
    The purpose of the course is to explore various aspects of functional programming using Haskell. In particular, the course provides an introduction to the lambda calculus, types in programming, and the role of these in the implementation of functional programming.
Javier Neira

99 questions/1 to 10 - HaskellWiki - 0 views

www.haskell.org/...1_to_10

haskell questions howto 99

shared by Javier Neira on 10 Nov 09 - Cached
  • data NestedList a = Elem a | List [NestedList a] &nbsp; flatten :: NestedList a -&gt; [a] flatten (Elem x) = [x] flatten (List x) = concatMap flatten x
  • compress :: Eq a =&gt; [a] -&gt; [a] compress = map head . group We simply group equal values together (group), then take the head of each. Note that (with GHC) we must give an explicit type to compress otherwise we get:
1 - 14 of 14
Showing 20▼ items per page