Skip to main content

Home/ Haskell/ Group items tagged Haskell

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
mountain

DData - 3 views

www.cs.uu.nl/ddata.html

del.icio.us haskell imported

shared by mountain on 24 Jun 07 - Cached
N N liked it
  • mountain on 24 Jun 07
     
    basic data structure in haskell
mountain

Pipes: del.icio.us popular links for programming - 0 views

pipes.yahoo.com/...pipe.info

c++ calm del.icio.us dsl erlang haskell imported javascript meta metaprograming ml ocaml perl php rails ruby schema smalltalk stm

shared by mountain on 24 Jun 07 - Cached
  • mountain on 24 Jun 07
     
    del.icio.us popular links for programming, inculding java, c++, smalltalk, ruby, haskell, ml, schema, calm, ocaml, php, erlang, rails, perl, STM, metaprograming, and DSL
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 '>>=', and it does the 'unpacking' involved with the <- 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

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
« First ‹ Previous 81 - 100 of 157 Next › Last »
Showing 20▼ items per page