Skip to main content

Home/ Haskell/ Group items tagged tutorial

Rss Feed Group items tagged

Filter: All | Bookmarks | Topics Simple Middle
Xiaobin Huang

'Cannot justify constraints in explicitly typed binding ', Hugs complained. - 10 views

Now I know, it should be 'permutation :: Eq a => [a]->[[a]]'. Xiaobin Huang wrote: > hi all, > > I'm new to Haskell. > > I wrote a permutation prog. > > permutation [] = [[]] > p...

started by Xiaobin Huang on 14 Nov 08 1 follow-up, last by Xiaobin Huang on 16 Nov 08
J.A. Alonso

Programming with effects - 0 views

www.cs.nott.ac.uk/monads

Tutorial Haskell

shared by J.A. Alonso on 01 Feb 12 - No Cached
  • J.A. Alonso on 01 Feb 12
     
    Introducción a las mónadas en Haskell.
J.A. Alonso

Tips on Haskell - 0 views

www.cl.cam.ac.uk/...thips.pdf

Haskell Tutorial

shared by J.A. Alonso on 28 Feb 12 - No Cached
  • J.A. Alonso on 28 Feb 12
     
    Visión panorámica de Haskell.
mesbah095

Guest Post Online - 0 views

guestpostonline.com

haskell del.icio.us imported Tutorial functional programming reference intro monads howto

shared by mesbah095 on 03 Apr 14 - No Cached
  • mesbah095 on 03 Apr 14
     
    Article Writing & Guestpost You Can Join this Site for Your Article & guest post, Just Easy way to join this site & total free Article site. This site article post to totally free Way. Guest Post & Article Post live to Life time only for Current & this time new User. http://guestpostonline.com
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

Understanding Haskell Monads - 0 views

ertes.de/monads.html

haskell monads tutorial learning

shared by Javier Neira on 16 Dec 09 - Cached
  • The opposite of referentially transparent is referentially opaque. A referentially opaque function is a function that may mean different things and return different results each time, even if all arguments are the same.
  • a function that just prints a fixed text to the screen and always returns 0, is referentially opaque, because you cannot replace the function call with 0 without changing the meaning of the program.
  • n fact, a function, which doesn't take any arguments, isn't even a function in Haskell. It's simply a value. A number of simple solutions to this problem exist. One is to expect a state value as an argument and produce a new state value together with a pseudorandom number: random :: RandomState -> (Int, RandomState)
  • ...12 more annotations...
  • A general purpose language is almost useless, if you can't develop user interfaces or read files. We would like to read keyboard input or print things to the terminal.
  • We have seen that we can solve this problem by expecting a state argument. But what's our state? The state of the terminal?
  • We seem to have found a useful solution to our problem. Just pass the state value around. But there is a problem with this approach.
  • A very special feature of Haskell is the concept of generalization. That means, instead of implementing an idea directly, you rather try to find a more general idea, which implies your idea as a special case.
  • However, the traditional programmer never had to face generalization. At most they faced abstraction,
  • they are a very abstract structure, which allows implementing functionality at an incredibly general level.
  • Haskell [1] is a purely functional programming language. Functions written in it are referentially transparent. Intuitively that means that a function called with the same arguments always gives the same result.
  • askell takes another approach. Instead of passing the world state explicitly, it employs a structure from category theory called a monad.
  • They are an abstract structure, and at first it can be difficult to understand where they are useful. The two main interpretations of monads are as containers and as computations.
  • The ⊥ value is a theoretical construct. It's the result of a function, which never returns, so you can't observe that value directly. Examples are functions, which recurse forever or which throw an exception. In both cases, there is no ordinary returning of a value.
  • Now that Nothing is a valid result, our function handles all cases.
  • You have some computation with a certain type of result and a certain structure in its result (like allowing no result, or allowing arbitrarily many results), and you want to pass that computation's result to another computation.
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) => m (a -> b) -> m a -> m b
J.A. Alonso

Apprendre Haskell vous fera le plus grand bien ! - 0 views

lyah.haskell.fr

libro haskell tutorial

shared by J.A. Alonso on 25 Sep 11 - No Cached
  • J.A. Alonso on 25 Sep 11
     
    Traducción francesa del libro "Learn You a Haskell for Great Good!".
J.A. Alonso

Functional Programming in Haskell (Part 2 : Abstract dataypes and ``infinite'' structures) - 0 views

www.cmi.ac.in/...lecture2.pdf

Haskell tutorial

shared by J.A. Alonso on 14 Sep 11 - No Cached
  • J.A. Alonso on 14 Sep 11
     
    Introducción a la programación en Haskell por Madhavan Mukund
1 - 20 of 24 Next ›
Showing 20▼ items per page