<?xml version="1.0" encoding="UTF-8"?><!-- generator="wordpress/2.0.5" -->
<rss version="0.92">
<channel>
	<title>λ Tony's  blog λ</title>
	<link>http://blog.tmorris.net</link>
	<description>The weblog of Tony Morris</description>
	<lastBuildDate>Thu, 17 Jul 2008 20:15:37 +0000</lastBuildDate>
	<docs>http://backend.userland.com/rss092</docs>
	<language>en</language>
	
	<item>
		<title>Haskell exercises for beginners</title>
		<description>The exercises below are similar to my previous 'Scala exercises for beginners', except the rules a little clearer. For those of who have emailed me or submitted responses here on the blog, I will get around to providing you feedback, however, I'd prefer to do so on the revised version ...</description>
		<link>http://blog.tmorris.net/haskell-exercises-for-beginners/</link>
			</item>
	<item>
		<title>Scala exercises for beginners</title>
		<description>The following exercises have come from of a course that I give on Functional Programming. I have assigned them difficulty ratings to make it a bit more exciting. Download the compilable source code from here or find it below. Enjoy :)

These exercises can be translated into any language powerful enough ...</description>
		<link>http://blog.tmorris.net/scala-exercises-for-beginners/</link>
			</item>
	<item>
		<title>Just an observation</title>
		<description>When some programmers pick up a functional programming language like Microsoft Excel, they stop caring about identifier names.


A1 = blah
B1 = function(A1, C2)
...


Can this observation be explained while maintaining consistency? I think it can. </description>
		<link>http://blog.tmorris.net/just-an-observation/</link>
			</item>
	<item>
		<title>Implicits for the Fearless</title>
		<description>Some programmers are married to the imperative, side-effecting mindset. This makes them fearful of Scala's implicit keyword (among many other high-level programming constructs and abstractions). You can read all sorts of amateurish criticism of this language construct on various websites, but I plan to show why they are a necessity ...</description>
		<link>http://blog.tmorris.net/implicits-for-the-fearless/</link>
			</item>
	<item>
		<title>Applicative Functor laws using Reductio (Scala)</title>
		<description>Here is the Applicative functor type-class (see Applicative Programming with Effects, Conor McBride, Ross Paterson):


class Applicative f where
  pure :: a -> f a
  () :: f (a -> b) -> f a -> f b


Here are the laws for the Applicative functor type-class:


  identity pure id ...</description>
		<link>http://blog.tmorris.net/applicative-functor-laws-using-reductio-scala/</link>
			</item>
	<item>
		<title>Just what the funk is a Functor anyway?</title>
		<description>Runar recently made mention of these so-called Functors and Monads in his excellent post about concurrency/actors in Java. There are all sorts of tutorials out there for understanding what a Monad is, however, I am of the opinion that one must first understand what a Functor is. This is because ...</description>
		<link>http://blog.tmorris.net/just-what-the-funk-is-a-functor-anyway/</link>
			</item>
	<item>
		<title>Monad Laws using Reductio (Scala)</title>
		<description>In the spirit of yesterday's post that denoted the Functor Laws using Reductio, I will also give the Monad Laws. Before I do however, here is an example use of the FunctorLaws object that runs 600 unit tests when testing a Functor implementation for scala.Option[A], scala.List and finally, for the ...</description>
		<link>http://blog.tmorris.net/monad-laws-using-reductio-scala/</link>
			</item>
	<item>
		<title>Functor Laws using Reductio (Scala)</title>
		<description>A somewhat intricate and extremely useful code snippet using Reductio for testing the laws of any Functor instance (note that the Functor type is part of Scalaz):


import reductios.Property._
import reductios.Arbitrary
import reductio.Coarbitrary
import reductios.Arbitrary._

object FunctorLaws {
  def identity[F[_], A](implicit f: Functor[F], af: Arbitrary[F[A]]) = 
    prop((fa: F[A]) => f.fmap((a: ...</description>
		<link>http://blog.tmorris.net/functor-laws-using-reductio-scala/</link>
			</item>
	<item>
		<title>You&#8217;d naturally write flatMap yourself if asked the question</title>
		<description>Many people struggle to understand those fluffy things called Monads and why they are important. I'm not going to attempt to alleviate this to a large degree, but I have had a recent success with a friend in having them attempt to write a familiar Scala function as a method. ...</description>
		<link>http://blog.tmorris.net/youd-naturally-write-flatmap-yourself-if-asked-the-question/</link>
			</item>
	<item>
		<title>ABC Learning Centres required for adults</title>
		<description>From http://www.news.com.au/comments/0,23600,23907216-462,00.html on the recent price rise by ABC Learning Centres (i.e. child care):


ABC Learing centres have now increased there fees three times since early 2007. There justification for these raises in no way benefit the children in they're care or they're staff!.

 </description>
		<link>http://blog.tmorris.net/abc-learning-centres-required-for-adults/</link>
			</item>
</channel>
</rss>
