Even Guava doesn't make Java appealing anymore once you tasted Scala

I just hacked some small test case together to give an impression of how one could use Guava. Still I don't like the verbosity... sigh :(

	package com.pelssers.guava;
	import com.google.common.base.Function;
	public class Person {
	private String firstName;
	private String lastName;
	private Integer age;
	public Person(String firstName, String lastName, Integer age) {
	this.firstName = firstName;
	this.lastName = lastName;
	this.age = age;
	}
	/************ Extractor Functions *********************************/
	public static Function<Person, String> getFirstName() {
	return new Function<Person, String>() {
	@Override
	public String apply(Person person) {
	return person.firstName;
	}
	};
	}
	public static Function<Person, String> getLastName() {
	return new Function<Person, String>() {
	@Override
	public String apply(Person person) {
	return person.lastName;
	}
	};
	}
	public static Function<Person, Integer> getAge() {
	return new Function<Person, Integer>() {
	@Override
	public Integer apply(Person person) {
	return person.age;
	}
	};
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.guava;
	import com.google.common.base.Function;
	import com.google.common.base.Predicate;
	public final class GuavaHelper {
	private GuavaHelper() {
	}
	/**
	* Generic function that creates a predicate function from an extractor and predicate
	* return a predicate for the value returned by extractor
	* @param extractor a function that extracts a property from some input object
	* @param predicate a predicate operating on the extracted property
	* @return a new composed predicate
	*/
	public static <I,O> Predicate<I> getPredicate(final Function<I,O> extractor, final Predicate<O> predicate) {
	return new Predicate<I>() {
	@Override
	public boolean apply(I input) {
	return predicate.apply(extractor.apply(input));
	}
	};
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.guava;
	import static com.pelssers.guava.GuavaHelper.*;
	import java.util.Collection;
	import java.util.List;
	import junit.framework.Assert;
	import org.junit.Before;
	import org.junit.Test;
	import com.google.common.base.Predicate;
	import com.google.common.base.Predicates;
	import com.google.common.collect.Iterables;
	import com.google.common.collect.Lists;
	import com.google.common.collect.Range;
	public class PersonsTest {
	private List<Person> persons;
	@Before
	public void setUp() {
	Person person1 = new Person("Robin", "Walker", 35);
	Person person2 = new Person("Sander", "Peters", 20);
	Person person3 = new Person("Brian", "Maex", 30);
	Person person4 = new Person("Sander", "Tielens", 23);
	persons = Lists.newArrayList(person1, person2, person3, person4);
	}
	@Test
	public void testTransform() {
	//map the list of persons to a list of their ages
	List<Integer> ages = Lists.transform(persons, Person.getAge());
	Assert.assertEquals(Integer.valueOf(35), ages.get(0));
	}
	@Test
	public void testFilterInteger() {
	//filter all persons with age above 25
	List<Person> filtered = Lists.newArrayList(Iterables.filter(persons,
	getPredicate(Person.getAge(), Range.greaterThan(25))));
	int sizeExpected = 2;
	Assert.assertEquals(sizeExpected, filtered.size());
	}
	@Test
	public void testFilterString() {
	//filter all persons who's firstname is Sander
	List<Person> filtered = Lists.newArrayList(Iterables.filter(persons,
	getPredicate(Person.getFirstName(), Predicates.equalTo("Sander"))));
	int sizeExpected = 2;
	Assert.assertEquals(sizeExpected, filtered.size());
	Assert.assertEquals("Sander", Person.getFirstName().apply(filtered.get(0)));
	}
	@Test
	public void testFilterComposedPredicate() {
	//filter all Sanders older than 22
	Predicate<Person> isSanderPredicate = getPredicate(Person.getFirstName(), Predicates.equalTo("Sander"));
	Predicate<Person> olderThan22Predicate = getPredicate(Person.getAge(), Range.greaterThan(22));
	List<Person> filtered = Lists.newArrayList(Iterables.filter(persons,
	Predicates.and(isSanderPredicate, olderThan22Predicate)));
	int sizeExpected = 1;
	Assert.assertEquals(sizeExpected, filtered.size());
	Assert.assertEquals("Tielens", Person.getLastName().apply(filtered.get(0)));
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.guava
	import scala.beans.BeanProperty
	object ScalaVersion extends App {
	class ScalaPerson(@BeanProperty val firstName:String, @BeanProperty val lastName: String, @BeanProperty val age:Int)
	val person1 = new ScalaPerson("Robin", "Walker", 35);
	val person2 = new ScalaPerson("Sander", "Peters", 20);
	val person3 = new ScalaPerson("Brian", "Maex", 30);
	val person4 = new ScalaPerson("Sander", "Tielens", 23);
	val persons = List(person1, person2, person3, person4)
	//map persons to their ages
	val ages = persons.map(_.getAge())
	//find all persons older than 25
	val personsOlderThan25 = persons.filter(_.getAge() > 25)
	//find all Sanders
	val personsNamedSander = persons.filter(_.getFirstName().equals("Sander"))
	//find all Sanders older than 22
	val sandersolderThan22 = persons.filter(p => p.getFirstName().equals("Sander") && p.getAge() > 22)
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Reasoning about type inference

	(*
	f: T1 -> T2 [must be a function; all functions take 1 arg]
	x: T1
	y: T3
	z: T4
	T1 = T3 * T4 [else pattern match does not type-check]
	T3 = int [abs has type int -> int]
	T4 = int [because we added z to an int]
	So T1 = int * int
	So (abs y) + z: int, so let-expression: int, so body: int
	T2 = int
	f: int * int -> int
	*)
	fun f x =
	let val (y,z) = x in
	(abs y) + z
	end

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	sum: T1 -> T2
	xs: T1
	x: T3
	xs': T3 list [pattern match a T1]
	T1 = T3 list
	T2 = int [because 0 might be returned]
	T3 = int [because x:T3 and we add x to something]
	from T3 = int, we know T1 = int list
	from that and T2=int, we know f: int list -> int
	*)
	fun sum xs =
	case xs of
	[] => 0
	| x::xs' => x + (sum xs')

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	length: T1 -> T2
	xs: T1
	x: T3
	xs': T3 list
	T1 = T3 list
	T2 = int
	There are no more constraints, therefore
	T3 list -> int
	'a list -> int
	*)
	fun length xs =
	case xs of
	[] => 0
	| x::xs' => 1 + (length xs')

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	f: T1 * T2 * T3 -> T4
	x: T1
	y: T2
	z: T3
	T4 = T1 * T2 * T3
	T4 = T2 * T1 * T3
	only way those can both be true is if T1 = T2
	put it all together: f: T1 * T1 * T3 -> T1 * T1 * T3
	'a * 'a * 'b -> 'a * 'a * 'b
	*)
	fun f (x,y,z) =
	if true
	then (x,y,z)
	else (y,x,z)

view raw gistfile1.sml hosted with ❤ by GitHub

	(*
	compose: T1 * T2 -> T3
	f: T1
	g: T2
	x: T4
	body being a functoin has type T3 = T4 -> T5
	from g being passed x, T2 = T4 -> T6 for some T6
	from f being passed the result of g, T1 = T6 -> T7 for some T7
	from call to f being the body of anonmymous function T7 = T5
	put it all together: T1 = T6 -> T5, T2 = T4 -> T6, T3 = T4 -> T5
	(T6 -> T5) * (T4 -> T6) -> (T4 -> T5)
	('a -> 'b) * ('c -> 'a) -> ('c -> 'b)
	*)
	fun compose (f,g) = fn x => f (g x)

view raw gistfile1.sml hosted with ❤ by GitHub

Closure idioms without closures (ML version)

	datatype 'a mylist = Cons of 'a * ('a mylist) | Empty
	fun map f xs =
	case xs of
	Empty => Empty
	| Cons(x,xs) => Cons(f x, map f xs)
	fun filter f xs =
	case xs of
	Empty => Empty
	| Cons(x,xs) => if f x then Cons(x.filter f xs) else filter f xs
	fun lenght xs =
	case xs of
	Empty => 0
	| Cons(_,xs) => 1 + length xs
	(* a valid way to double all numbers in the list
	using partial application *)
	val doubleAll = map (fn x => x * 2)
	(* a way to count N's in a list using partial application *)
	val countNs (xs, n:int) = length (filter (fn x => x=n) xs)

view raw gistfile1.sml hosted with ❤ by GitHub

Mixing closures with abstract datatypes

	(* abstract data types with closures *)
	datatype set = S of { insert : int -> set,
	member : int -> bool,
	size : unit -> int }
	val empty_set =
	let
	fun make_set xs = (* xs is a private field in result *)
	let
	fun contains i = List.exists (fn j => i=j) xs
	in
	S { insert = fn i => if contains i
	then make_set xs
	else make_set (i::xs),
	member = contains,
	size = fn () => length xs
	}
	end
	in
	make_set []
	end
	(* example of using our newly described set *)
	fun use_sets() =
	let val S s1 = empty_set
	val S s2 = (#insert s1) 34
	val S s3 = (#insert s2) 34
	val S s4 = #insert s3 19
	in
	if (#member s4) 42
	then 99
	else if (#member s4) 19
	then 17 + (#size s3) ()
	else 0
	end

view raw gistfile1.sml hosted with ❤ by GitHub

Callbacks using mutable references (ML)

	val cbs: (int -> unit) list ref = ref []
	(*
	x = ref 4 means x has a reference to a value of type int with initial value 4
	x := 5 means update the value x refers to with value 5
	val y = (!x) means store the value x refers to in y
	*)
	fun onKeyEvent f = cbs := f :: (!cbs)
	fun onEvent i =
	let fun loop fs =
	case fs of
	[] => ()
	|f::fs' => (f i; loop fs')
	in loop (!cbs) end
	(* some client code *)
	val timesPressed = ref 0
	val _ = onKeyEvent (fn _ => timesPressed := (!timesPressed) + 1
	fun printIfPressed i =
	onKeyEvent (fn j =>
	if i=j
	then print ("you pressed " ^ Int.ToString i)
	else ()

view raw gistfile1.sml hosted with ❤ by GitHub

Currying (ML)

	(* old way to get the effect of multiple arguments *)
	fun sorted3_tupled (x,y,z) = z >= y andalso y >= x
	val t1 = sorted3_tupled (7,9,11)
	(* new way using currying *)
	val sorted3 = fn x => fn y => fn z => z >= y andalso y >= x
	val t2 = ((sorted3 7) 9) 11
	(* we can curry using syntactic sugar *)
	val t3 = sorted3 7 9 11
	(* declare a curried function by using spaces between multi arguments *)
	fun sorted3_nicer x y z = z >= y andalso y >= x
	(* now we can write a fold function using currying *)
	fun fold f acc xs = (* means fun fold f = fn acc => fn xs => *)
	case xs of
	[] => acc
	|x:xs' => fold f (f(acc,x)) xs'
	fun sum xs = fold (fn (x,y) => x + y) 0 xs

view raw gistfile1.sml hosted with ❤ by GitHub

Function composition (ML)

	(* 'b -> 'c) * ('a -> b') -> ('a -> 'c) *)
	fun compose(f,g) = fn x => f(g x)
	(* in ML you can compose functions like f o g *)
	fun sqrt_of_abs1 i = Math.sqrt (Real.fromInt (abs i))
	val sqrt_of_abs2 = Math.sqrt o Real.fromInt o abs
	(* we can also define our own infix operator to compose functions
	the other way around *)
	infix !>
	fun x !> f = f x
	fun sqrt_of_abs3 i = i !> abs !> Real.fromInt !> Math.sqrt
	fun backup1 (f,g) = fn x => case f x of
	NONE => g x
	| SOME => y

view raw gistfile1.sml hosted with ❤ by GitHub

A few examples of how lexical scope works (ML)

A function body is evaluated in the environment where the function was defined (created).

	val x = 1
	fun f y =
	let
	val x = y + 1
	in
	fn z => x + y + z (* will return 2y + 1 + z *)
	end
	val x = 3 (* irrelevant *)
	val g = f 4 (* return a function that ads 9 to its argument *)
	val y = 5 (* irrelevant *)
	val z = g 6 (* get 15 *)
	(* output of program
	- use "lexical1.sml";
	[opening lexical1.sml]
	val x = <hidden-value> : int
	val f = fn : int -> int -> int
	val x = 3 : int
	val g = fn : int -> int
	val y = 5 : int
	val z = 15 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

	fun f g =
	let
	val x = 3 (* irrelevant *)
	in
	g 2
	end
	val x = 4
	fun h y = x + y (* add 4 to its argument *)
	val z = f h (* get 6 *)
	(* output of program
	- use "lexical2.sml";
	[opening lexical2.sml]
	val f = fn : (int -> 'a) -> 'a
	val x = 4 : int
	val h = fn : int -> int
	val z = 6 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Higher order functions Map and Filter (ML)

	(* ('a -> 'b) * 'a list -> 'b list *)
	fun map(f,xs) =
	case xs of
	[] => []
	| x::xs' => (f x)::map(f,xs')
	val x1 = map((fn x => x + 1), [4,8,12,16])
	val x2 = map(hd, [ [1,2], [3,4], [5,6,7] ])
	(* ('a -> bool) * 'a list -> 'a list *)
	fun filter(f,xs) =
	case xs of
	[] => []
	| x::xs' => if f x
	then x::(filter (f, xs'))
	else filter(f,xs')
	fun is_even v =
	(v mod 2 = 0)
	fun filter_even xs = filter(is_even, xs)
	val x3 = filter_even([1,2,3,4,5,6])
	(* output of program
	- use "mapfilter.sml";
	[opening mapfilter.sml]
	val map = fn : ('a -> 'b) * 'a list -> 'b list
	val x1 = [5,9,13,17] : int list
	val x2 = [1,3,5] : int list
	val filter = fn : ('a -> bool) * 'a list -> 'a list
	val is_even = fn : int -> bool
	val filter_even = fn : int list -> int list
	val x3 = [2,4,6] : int list
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Using higher order and anonymous functions in ML

	fun increment_n_times (n,x) = (* computes n + x *)
	if n=0
	then x
	else 1 + increment_n_times(n-1,x)
	fun double_n_times (n,x) = (* computes 2^n * x *)
	if n=0
	then x
	else 2 * double_n_times(n-1,x)
	fun nth_tail (n,xs) = (* example 3,[4,8,12,16] -> [16] *)
	if n=0
	then xs
	else tl (nth_tail(n-1,xs))
	(* n_times is a higher-order function which takes a function, an int and a value and
	it's signature is ('a -> 'a) * int * 'a -> 'a
	*)
	fun n_times (f,n,x) =
	if n=0
	then x
	else f (n_times(f, n-1,x))
	fun increment x = x +1
	fun double x = x + x
	val x1 = n_times(double,4,7)
	val x2 = n_times(increment,4,7)
	val x3 = n_times(tl, 2, [4,8,12,16])
	fun addition (n,x) = n_times(increment, n, x)
	fun double_n_times (n,x) = n_times(double,n,x)
	fun nth_tail(n,xs) = n_times(tl, n, xs)
	(* example of using an anonymous function *)
	fun triple_n_times (n,x) = n_times((fn x => 3 *x),n,x)
	(* output of program
	- use "higherorder.sml";
	[opening higherorder.sml]
	val increment_n_times = fn : int * int -> int
	val double_n_times = <hidden-value> : int * int -> int
	val nth_tail = <hidden-value> : int * 'a list -> 'a list
	val n_times = fn : ('a -> 'a) * int * 'a -> 'a
	val increment = fn : int -> int
	val double = fn : int -> int
	val x1 = 112 : int
	val x2 = 11 : int
	val x3 = [12,16] : int list
	val addition = fn : int * int -> int
	val double_n_times = fn : int * int -> int
	val nth_tail = fn : int * 'a list -> 'a list
	val triple_n_times = fn : int * int -> int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Modeling a poker game in Scala

WORK IN PROGRESS. If I find the time ideally i'd like to develop a PLAY2.x app using AKKA actors to orchestrate the poker game. Would be a very nice exercise. :)

	package patterns
	object PokerGame {
	sealed trait Suit
	case object Clubs extends Suit
	case object Diamonds extends Suit
	case object Hearts extends Suit
	case object Spades extends Suit
	sealed trait Rank
	case object Jack extends Rank
	case object Queen extends Rank
	case object King extends Rank
	case object Ace extends Rank
	case class Numeric(value: Int) extends Rank
	sealed trait Color
	case object Red extends Color
	case object Black extends Color
	sealed trait Value
	case object StraightFlush extends Value
	case object FourOfKind extends Value
	case object FullHouse extends Value
	case object Flush extends Value
	case object Straight extends Value
	case object ThreeOfKind extends Value
	case object TwoPair extends Value
	case object Pair extends Value
	case class HighCard(value: Int) extends Value
	type Card = (Suit, Rank)
	type Hand = (Card, Card, Card, Card, Card)
	val D1 = (Diamonds, Numeric(1))
	val D2 = (Diamonds, Numeric(2))
	val D3 = (Diamonds, Numeric(3))
	val D4 = (Diamonds, Numeric(4))
	val D5 = (Diamonds, Numeric(5))
	val D6 = (Diamonds, Numeric(6))
	val D7 = (Diamonds, Numeric(7))
	val D8 = (Diamonds, Numeric(8))
	val D9 = (Diamonds, Numeric(9))
	val D10 = (Diamonds, Numeric(10))
	val DJ = (Diamonds, Jack)
	val DQ = (Diamonds, Queen)
	val DK = (Diamonds, King)
	val DA = (Diamonds, Ace)
	val S1 = (Spades, Numeric(1))
	val S2 = (Spades, Numeric(2))
	val S3 = (Spades, Numeric(3))
	val S4 = (Spades, Numeric(4))
	val S5 = (Spades, Numeric(5))
	val S6 = (Spades, Numeric(6))
	val S7 = (Spades, Numeric(7))
	val S8 = (Spades, Numeric(8))
	val S9 = (Spades, Numeric(9))
	val S10 = (Spades, Numeric(10))
	val SJ = (Spades, Jack)
	val SQ = (Spades, Queen)
	val SK = (Spades, King)
	val SA = (Spades, Ace)
	val H1 = (Hearts, Numeric(1))
	val H2 = (Hearts, Numeric(2))
	val H3 = (Hearts, Numeric(3))
	val H4 = (Hearts, Numeric(4))
	val H5 = (Hearts, Numeric(5))
	val H6 = (Hearts, Numeric(6))
	val H7 = (Hearts, Numeric(7))
	val H8 = (Hearts, Numeric(8))
	val H9 = (Hearts, Numeric(9))
	val H10 = (Hearts, Numeric(10))
	val HJ = (Hearts, Jack)
	val HQ = (Hearts, Queen)
	val HK = (Hearts, King)
	val HA = (Hearts, Ace)
	val C1 = (Clubs, Numeric(1))
	val C2 = (Clubs, Numeric(2))
	val C3 = (Clubs, Numeric(3))
	val C4 = (Clubs, Numeric(4))
	val C5 = (Clubs, Numeric(5))
	val C6 = (Clubs, Numeric(6))
	val C7 = (Clubs, Numeric(7))
	val C8 = (Clubs, Numeric(8))
	val C9 = (Clubs, Numeric(9))
	val C10 = (Clubs, Numeric(10))
	val CJ = (Clubs, Jack)
	val CQ = (Clubs, Queen)
	val CK = (Clubs, King)
	val CA = (Clubs, Ace)
	def valueOf(rank: Rank): Int = rank match {
	case Ace => 14
	case King => 13
	case Queen => 12
	case Jack => 11
	case Numeric(n) => n
	}
	def colorOf(suit: Suit): Color = suit match {
	case Clubs => Black
	case Spades => Black
	case _ => Red
	}
	def toRanks(hand: Hand): List[Rank] = {
	val ((suit1, rank1), (suit2, rank2), (suit3, rank3), (suit4, rank4), (suit5, rank5)) = hand
	List(rank1, rank2, rank3, rank4, rank5)
	}
	def toSuites(hand: Hand): List[Suit] = {
	val ((suit1, rank1), (suit2, rank2), (suit3, rank3), (suit4, rank4), (suit5, rank5)) = hand
	List(suit1, suit2, suit3, suit4, suit5)
	}
	def toColors(hand: Hand): List[Color] = toSuites(hand).map(colorOf _)
	def toRankValues(hand: Hand): List[Int] = toRanks(hand).map(valueOf _)
	def toRankSizes(hand: Hand): List[Int] =
	toRanks(hand).groupBy(identity).map { case (rank, listofranks) => listofranks.size } .toList
	def isSameSuit(hand: Hand): Boolean = toSuites(hand).forall(_ == hand._1._1)
	def isStraightFlush(hand: Hand): Boolean = isSameSuit(hand) && isStraight(hand)
	def isFourOfKind(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 4)
	def isFullHouse(hand: Hand): Boolean = {
	val rankSizes = toRankSizes(hand)
	rankSizes.exists(_ == 2) && rankSizes.exists(_ == 3)
	}
	def isFlush(hand: Hand): Boolean = isSameSuit(hand)
	def isStraight(hand: Hand): Boolean = {
	val rankValues = toRankValues(hand)
	val minimumRankValue = rankValues.min
	rankValues.toSet == minimumRankValue.to(minimumRankValue + 4).toSet
	}
	def isThreeOfKind(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 3)
	def isTwoPair(hand: Hand): Boolean = toRankSizes(hand).filter(_ >= 2).size == 2
	def isPair(hand: Hand): Boolean = toRankSizes(hand).exists(_ >= 2)
	def evaluate(hand: Hand): Value =
	if (isStraightFlush(hand)) StraightFlush
	else if (isFourOfKind(hand)) FourOfKind
	else if (isFullHouse(hand)) FullHouse
	else if (isFlush(hand)) Flush
	else if (isStraight(hand)) Straight
	else if (isThreeOfKind(hand)) ThreeOfKind
	else if (isTwoPair(hand)) TwoPair
	else if (isPair(hand)) Pair
	else HighCard(toRankValues(hand).sorted.reverse.toList(0))
	/** for unit testing
	val straightflush = (D10, DJ, DQ, DK, DA)
	val fourofkind = (H10, HQ, C10, S10, D10)
	val fullhouse = (H10, D10, SJ, C10, CJ)
	val flush = (D3, D5, D8, DJ, DA)
	val straight = (D6,H4, C3, H5, S7)
	val threeofkind = (H10, HQ, CK, S10, D10)
	val twopair = (H10, HQ, CK, S10, DQ)
	val pair = (H9, HQ, CK, S10, D10)
	val highcard = (HK, S5, S2, C7, D9)
	val test1 = evaluate(straightflush) == StraightFlush
	val test2 = evaluate(fourofkind) == FourOfKind
	val test3 = evaluate(fullhouse) == FullHouse
	val test4 = evaluate(flush) == Flush
	val test5 = evaluate(straight) == Straight
	val test6 = evaluate(threeofkind) == ThreeOfKind
	val test7 = evaluate(twopair) == TwoPair
	val test8 = evaluate(pair) == Pair
	val test9 = evaluate(highcard) == HighCard(13)
	**/
	}

view raw gistfile1.scala hosted with ❤ by GitHub

transforming non tail recursive functions in tail recursive ones

	(* non tail recursive *)
	fun sum xs =
	case xs of
	[] => 0
	| x::xs' => x + sum xs'
	fun sumtailrecursive xs =
	let fun aux(xs,acc) =
	case xs of
	[] => acc
	| x::xs' => aux(xs', x + acc)
	in
	aux(xs,0)
	end
	(* whenever recursive operations are commutative we can use this approach
	of defining an auxiliary function which takes an extra accumulator parameter
	e.g. for summing or multiplying because
	3 * 4 == 4 * 3
	3 + 5 == 5 + 3
	*)
	(* non tail recursive *)
	fun reverse xs =
	case xs of
	[] => []
	| x::xs' => (reverse xs') @ [x]
	(* tail recursive *)
	fun reverse xs =
	let fun aux(xs, acc) =
	case xs of
	[] => acc
	| x::xs' => aux(xs', x::acc)
	in
	aux(xs,[])
	end

view raw gistfile1.sml hosted with ❤ by GitHub

raising and handling exceptions in ML

	fun hd xs =
	case xs of
	[] => raise List.empty
	| x::_ => x
	exception MyUndesirableCondition
	exception MyOtherException of int * int
	fun mydiv (x,y) =
	if y=0
	then raise MyUndesirableCondition
	else x div y
	fun maxlist (xs,ex) =
	case xs of
	[] => raise ex
	| x::[] => x
	| x::xs' => Int.max(x, maxlist(xs',ex))
	(* val y = maxlist ([], MyUndesirableCondition) *)
	val z = maxlist([], MyUndesirableCondition) handle MyUndesirableCondition => 42

view raw gistfile1.sml hosted with ❤ by GitHub

Using nested pattern matching (ML)

	fun zip3 list_triple =
	case list_triple of
	([],[],[]) => []
	|(hd1:tl1, hd2:tl2, hd3:tl3) => (hd1,hd2,hd3) :: zip3 (tl1,tl2,tl3)
	| _ => raise ListLengthMismatch
	fun unzip lst =
	case lst of
	[] => ([],[],[])
	|(a,b,c)::tl => let val (l1,l2,l3) = unzip tl
	in
	(a::l1, b::l2, c::l3)
	end
	fun nondecreasing xs = (* int list -> bool *)
	case xs of
	[] => true
	| _::[] => true
	| head::(neck::rest) => head <= neck andalso nondecreasing (neck::rest)
	datatype sign = Positive | Negative | Zero
	fun multsign (x1, x2) = (* int * int -> sign *)
	let fun sgn x = if x = 0 then Zero else if x > 0 then Positive else Negative
	in
	case (sgn x, sgn y) of
	(Positive, Positive) => Positive
	| (Negative, Negative) => Positive
	| (Zero, _) => Zero
	| (_, Zero) => Zero
	| _ => Negative
	end

view raw gistfile1.sml hosted with ❤ by GitHub

Pattern matching on each-of types (bad vs good style) ML

	fun sum_triple_bad_style triple =
	case triple of (x,y,z) => x + y + z
	fun sum_triple_better_style triple =
	let val (x,y,z) = triple
	in
	x + y + z
	end
	fun sum_triple_best_style (x,y,z) = x + y + z
	(*
	assume a record looks like
	{ first="Robby", last="Pelssers"}
	*)
	fun full_name_bad_style r =
	case r of {first=f, last=l} => f ^ " " ^ l
	fun full_name_better_style r =
	let val {first=f, last=l} = r
	in
	f ^ " " ^ l
	end
	fun full_name_best_style {first=f, last=l} = f ^ " " ^ l
	val sum1 = sum_triple_bad_style (1,2,3)
	val sum2 = sum_triple_better_style (1,2,3)
	val sum3 = sum_triple_best_style (1,2,3)
	val fullname1 = full_name_bad_style({first="Robby", last="Pelssers"})
	val fullname2 = full_name_better_style({first="Robby", last="Pelssers"})
	val fullname3 = full_name_best_style({first="Robby", last="Pelssers"})
	(* output of program
	- use "patterns.sml";
	[opening patterns.sml]
	val sum_triple_bad_style = fn : int * int * int -> int
	val sum_triple_better_style = fn : int * int * int -> int
	val sum_triple_best_style = fn : int * int * int -> int
	val full_name_bad_style = fn : {first:string, last:string} -> string
	val full_name_better_style = fn : {first:string, last:string} -> string
	val full_name_best_style = fn : {first:string, last:string} -> string
	val sum1 = 6 : int
	val sum2 = 6 : int
	val sum3 = 6 : int
	val fullname1 = "Robby Pelssers" : string
	val fullname2 = "Robby Pelssers" : string
	val fullname3 = "Robby Pelssers" : string
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Examples of using polymorphic datatypes ML

	datatype 'a option = NONE | SOME of 'a
	datatype 'a mylist = EMPTY | Cons of 'a * 'a mylist
	datatype ('a,'b) tree =
	Node of 'a * ('a,'b) tree * ('a,'b) tree
	| Leaf of 'b
	val sometree = Node( 1, Leaf(2), Node(3, Leaf(4),Leaf(5)) );
	(* output of program
	- use "polymorphic.sml";
	[opening polymorphic.sml]
	datatype 'a option = NONE | SOME of 'a
	datatype 'a mylist = Cons of 'a * 'a mylist | EMPTY
	datatype ('a,'b) tree = Leaf of 'b | Node of 'a * ('a,'b) tree * ('a,'b) tree
	val sometree = Node (1,Leaf 2,Node (3,Leaf #,Leaf #)) : (int,int) tree
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Using pattern matching instead of using head or tail

	(* in a previous post we saw how we could define a max function by testing
	- if a list is empty with null
	- extracting a value from an option with valOf
	BUT that is considered bad practise so instead we will switch to using pattern matching
	Because both list AND option are defined as algebraic datatypes
	fun max(numbers: int list) =
	if null numbers
	then NONE
	else
	let val max_tail = max(tl numbers)
	in
	if max_tail = NONE orelse hd numbers >= valOf max_tail
	then SOME (hd numbers)
	else max_tail
	end;
	can be rewritten to
	*)
	fun max(numbers: int list): int option =
	case numbers of
	[] => NONE
	| x::xs =>
	case max xs of
	NONE => SOME x
	|SOME y => SOME (Int.max(x, y))
	val test1 = max([3,6,4,2])
	val test2 = max([])
	(* output of program
	[opening patternmatching.sml]
	val max = fn : int list -> int option
	val test1 = SOME 6 : int option
	val test2 = NONE : int option
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Simple example of using a recursive datatype (ML)

	datatype exp = Constant of int
	| Negate of exp
	| Add of exp * exp
	| Multiply of exp * exp
	fun eval e =
	case e of
	Constant i => i
	| Negate e2 => ~ (eval e2)
	| Add(e1,e2) => (eval e1) + (eval e2)
	| Multiply(e1,e2) => (eval e1) * (eval e2)
	fun max_constant e =
	case e of
	Constant i => i
	| Negate e1 => max_constant e1
	| Add(e1,e2) => Int.max(max_constant e1,max_constant e2)
	| Multiply(e1,e2) => Int.max(max_constant e1,max_constant e2)
	val example_exp = Add (Constant (10+9), Negate (Constant 4))
	val result = eval example_exp
	val maxconstant = max_constant example_exp
	(* output of program
	- use "expression.sml";
	[opening expression.sml]
	datatype exp
	= Add of exp * exp | Constant of int | Multiply of exp * exp | Negate of exp
	val eval = fn : exp -> int
	val max_constant = fn : exp -> int
	val example_exp = Add (Constant 19,Negate (Constant 4)) : exp
	val result = 15 : int
	val maxconstant = 19 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Datatypes in ML

	datatype mytype =
	TwoInts of int * int
	|Str of string
	|Pizza
	fun f(x: mytype) =
	case x of
	Pizza => 3
	|Str s => 8
	|TwoInts(i1,i2) => i1 + i2
	val a = Str "hi"
	val b = Pizza
	val c = TwoInts(2,3)
	val d = f c
	val e = f Pizza
	(* output of program
	use "datatypes.sml";
	[opening datatypes.sml]
	datatype mytype = Pizza | Str of string | TwoInts of int * int
	val f = fn : mytype -> int
	val a = Str "hi" : mytype
	val b = Pizza : mytype
	val c = TwoInts (2,3) : mytype
	val d = 5 : int
	val e = 3 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

Records and tuples as syntactic sugar for records (ML)

	val product1 = {name="Iphone 5", price=400, madeByApple=true};
	val productname = #name product1;
	(* tuples are just syntactic sugar for records *)
	val product2 = {1="GalaxyS4", 2=400};
	val price = #2 product2;
	(* output of program
	- use "records.sml";
	[opening records.sml]
	val product1 = {madeByApple=true,name="Iphone 5",price=400}
	: {madeByApple:bool, name:string, price:int}
	val productname = "Iphone 5" : string
	val product2 = ("GalaxyS4",400) : string * int
	val price = 400 : int
	val it = () : unit
	*)

view raw gistfile1.sml hosted with ❤ by GitHub

A taste of programming in ML

Taking a new course Proglang which started this week. So expect more to follow on what I learn.

	(* returns NONE if list is empty, else SOME (maxnumber) *)
	fun max(numbers: int list) =
	if null numbers
	then NONE
	else
	let val max_tail = max(tl numbers)
	in
	if max_tail = NONE orelse hd numbers >= valOf max_tail
	then SOME (hd numbers)
	else max_tail
	end;
	(* concatenates all strings using separator *)
	fun stringjoin(strings: string list, separator: string) =
	if null strings
	then ""
	else if null (tl strings)
	then hd strings
	else hd strings ^ separator ^ stringjoin(tl strings, separator);
	(* date is tuple of form (year, month, day) -> returns boolean *)
	fun isLeapYear(date: int*int*int) =
	#1 date mod 400 = 0 orelse (#1 date mod 4 = 0 andalso #1 date mod 100 <> 0)
	(* filter all even numbers *)
	fun filterEven(numbers: int list) =
	if null numbers
	then []
	else if hd numbers mod 2 = 0
	then hd numbers :: filterEven(tl numbers)
	else filterEven(tl numbers);

view raw gistfile1.sml hosted with ❤ by GitHub

Printing only numbers with non-repeating digits

	/**
	Print From 45 to 4578 Without Repeating Digits
	Write a method that prints all the numbers from 45 to 4578 to the console,
	with the constraint that you cannot print any number with repeating digits.
	This means the following numbers would be skipped:
	11, 22, ...., 122, 110,....
	**/
	package puzzlers
	object NumberPrinter {
	def nonRepeatingDigitNumbers(start:Int, end:Int): IndexedSeq[Int] = {
	(start to end).filterNot(x => x.toString.toCharArray().groupBy(identity).exists(_._2.size > 1))
	}
	def main(args: Array[String]): Unit = {
	for (number <- nonRepeatingDigitNumbers(45, 4578)) {
	println(number)
	}
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Finding string pairs

	package pelssers.io
	import scala.collection.mutable.Map
	import scala.math.abs
	/** TASK DESCRIPTION
	Create a method that takes a string parameter and looks for pairs of strings in the code,
	breaking the string up using spaces as the delimiter.
	There are two types of pairs, combinations and adjacent, and you'll need to find a count of each.
	Adjacent pairs appear alongside each other, while combination pairs cover every permutation
	that can be found of pairing the strings.
	So if you have a string
	dzone java dzone dzone javascript java
	the results would be
	dzone has 1 adjacent pair
	dzone has 3 combination pairs (0,2) (0,3) (2,3)
	java has 1 combination pair (1,5)
	USAGE of solution:
	val theText = "dzone java dzone dzone javascript java"
	//> theText : String = dzone java dzone dzone javascript java
	StringPairFinder.printStringPairs(theText) //> java has 1 combination pair(s): (1,5)
	//| dzone has 1 adjacent pair(s)
	//| dzone has 3 combination pair(s): (0,2) (0,3) (2,3)
	**/
	object StringPairFinder {
	def toCombinations(text: String): Map[String, List[(Int,Int)]] = {
	val wordMap: Map[String, List[Int]] = new scala.collection.mutable.HashMap[String, List[Int]]
	for ((word,index) <- text.split(" ").zipWithIndex) {
	wordMap.update(word, wordMap.getOrElseUpdate(word, List()) :+ index)
	}
	val result = wordMap.map {
	case (key, positions) => (key, positions.combinations(2).toList.map(ele => (ele(0), ele(1))))
	}
	result.filter(!_._2.isEmpty)
	}
	def printStringPairs(text: String): Unit = {
	for ((key, pairs) <- toCombinations(text)) {
	val adjacent = (pairs.map {case (index1, index2) => if (abs(index1 - index2) == 1) 1 else 0}).sum
	if (adjacent > 0) println(s"$key has $adjacent adjacent pair(s)")
	println(s"$key has ${pairs.size} combination pair(s): " + pairs.mkString(" "))
	}
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Spring batch demo

In this article I will show you how easy it is to create a batch job by configuring out-of-the-box components. Today we will read a [CSV file] and convert it to an [XML file] and while we are at it we filter out all persons who don't live in New York. I also stick with using annotations to configure my complete application context. Unfortunately this code currently runs into a nullpointer which I expect to be [this issue].

	<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.pelssers</groupId>
	<artifactId>batchdemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<properties>
	<spring.version>3.2.4.RELEASE</spring.version>
	</properties>
	<dependencies>
	<dependency>
	<groupId>cglib</groupId>
	<artifactId>cglib-nodep</artifactId>
	<version>2.2</version>
	<scope>compile</scope>
	</dependency>
	<!-- spring dependencies -->
	<dependency>
	<groupId>org.springframework.batch</groupId>
	<artifactId>spring-batch-core</artifactId>
	<version>2.2.1.RELEASE</version>
	<exclusions>
	<exclusion>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	</exclusion>
	<exclusion>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	</exclusion>
	</exclusions>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-tx</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-aop</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-oxm</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-jdbc</artifactId>
	<version>${spring.version}</version>
	</dependency>
	<!-- functional programming -->
	<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>14.0.1</version>
	</dependency>
	<!-- use in-memory database for batch -->
	<dependency>
	<groupId>hsqldb</groupId>
	<artifactId>hsqldb</artifactId>
	<version>1.8.0.10</version>
	</dependency>
	</dependencies>
	</project>

view raw gistfile1.xml hosted with ❤ by GitHub

	package com.pelssers.domain;
	import javax.xml.bind.annotation.XmlRootElement;
	import javax.xml.bind.annotation.XmlTransient;
	@XmlRootElement
	public class Person {
	private String firstName;
	private String lastName;
	private String email;
	private String state;
	public String getFirstName() {
	return firstName;
	}
	public void setFirstName(String firstName) {
	this.firstName = firstName;
	}
	public String getLastName() {
	return lastName;
	}
	public void setLastName(String lastName) {
	this.lastName = lastName;
	}
	public String getEmail() {
	return email;
	}
	public void setEmail(String email) {
	this.email = email;
	}
	public String getState() {
	return state;
	}
	@XmlTransient
	public void setState(String state) {
	this.state = state;
	}
	@Override
	public String toString() {
	return "Person {firstName: " + firstName + ", lastName: " + lastName
	+ ",state: " + state + ", email:" + email + "}";
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.processor;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import org.springframework.batch.item.ItemProcessor;
	import com.google.common.base.Predicate;
	public class FilterProcessor<S> implements ItemProcessor<S,S> {
	public static Logger logger = Logger.getLogger(FilterProcessor.class.getName());
	private Predicate<S> predicate;
	public FilterProcessor(Predicate<S> predicate) {
	this.predicate = predicate;
	}
	public S process(S item) throws Exception {
	boolean isValid = predicate.apply(item);
	if (!isValid) {
	logger.log(Level.INFO, "Skipping " + item.toString());
	}
	return isValid ? item : null;
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.configuration;
	import javax.sql.DataSource;
	import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseBuilder;
	import org.springframework.jdbc.datasource.embedded.EmbeddedDatabaseType;
	@Configuration
	@EnableBatchProcessing
	public class TestConfiguration {
	@Bean
	public DataSource dataSource() {
	EmbeddedDatabaseBuilder databaseBuilder = new EmbeddedDatabaseBuilder();
	return
	databaseBuilder
	.addScript("classpath:org/springframework/batch/core/schema-drop-hsqldb.sql")
	.addScript("classpath:org/springframework/batch/core/schema-hsqldb.sql")
	.setType(EmbeddedDatabaseType.HSQL)
	.build();
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.configuration.jobs;
	import org.springframework.batch.core.Job;
	import org.springframework.batch.core.Step;
	import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
	import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
	import org.springframework.batch.core.configuration.annotation.StepScope;
	import org.springframework.batch.item.ItemProcessor;
	import org.springframework.batch.item.ItemStreamWriter;
	import org.springframework.batch.item.file.FlatFileItemReader;
	import org.springframework.batch.item.file.LineMapper;
	import org.springframework.batch.item.file.ResourceAwareItemWriterItemStream;
	import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
	import org.springframework.batch.item.file.mapping.DefaultLineMapper;
	import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
	import org.springframework.batch.item.xml.StaxEventItemWriter;
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.beans.factory.annotation.Value;
	import org.springframework.context.annotation.Bean;
	import org.springframework.context.annotation.Configuration;
	import org.springframework.context.annotation.Import;
	import org.springframework.core.io.ClassPathResource;
	import org.springframework.core.io.FileSystemResource;
	import org.springframework.oxm.Marshaller;
	import org.springframework.oxm.jaxb.Jaxb2Marshaller;
	import com.google.common.base.Predicate;
	import com.pelssers.configuration.TestConfiguration;
	import com.pelssers.domain.Person;
	import com.pelssers.processor.FilterProcessor;
	@Configuration
	@Import(TestConfiguration.class)
	public class CsvToXMLJobConfiguration {
	/**
	* Attention:
	* You have to name these beans jobBuilders and stepbuilders respectively.
	* See http://docs.spring.io/spring-batch/reference/html/configureJob.html
	*/
	private static final String XML_FILEPATH_PLACEHOLDER = null;
	private static final String CLASSPATH_RESOURCE_PLACEHOLDER = null;
	public static final String JOBPARAM_XML_FILEPATH = "xmlFilePath";
	public static final String JOBPARAM_CLASSPATH_RESOURCE = "classPathResource";
	@Autowired
	private JobBuilderFactory jobBuilders;
	@Autowired
	private StepBuilderFactory stepBuilders;
	@Autowired
	private TestConfiguration testConfiguration;
	@Bean
	public Job csvToXmlJob() {
	return jobBuilders.get("csvToXmlJob")
	.start(step())
	.build();
	}
	@Bean
	public Step step() {
	//CLASSPATH_RESOURCE_PLACEHOLDER and XML_FILEPATH_PLACEHOLDER will be overriden
	//by injected jobparameter using late binding (stepscope)
	return stepBuilders.get("step")
	.<Person, Person>chunk(50)
	.reader(reader(CLASSPATH_RESOURCE_PLACEHOLDER))
	.processor(processor())
	.writer(writer(XML_FILEPATH_PLACEHOLDER))
	.build();
	}
	@Bean
	@StepScope
	public FlatFileItemReader<Person> reader(@Value("#{jobParameters[classPathResource]}") String classPathResource) {
	FlatFileItemReader<Person> itemReader = new FlatFileItemReader<Person>();
	itemReader.setLinesToSkip(1);
	itemReader.setLineMapper(lineMapper());
	itemReader.setResource(new ClassPathResource(classPathResource));
	return itemReader;
	}
	@Bean
	public LineMapper<Person> lineMapper() {
	DefaultLineMapper<Person> lineMapper = new DefaultLineMapper<Person>();
	DelimitedLineTokenizer lineTokenizer = new DelimitedLineTokenizer();
	//we are only interested in below 4 fields from this CSV file
	lineTokenizer.setNames(new String[]{"firstName","lastName", "state","email"});
	lineTokenizer.setIncludedFields(new int[]{0,1,6, 10});
	BeanWrapperFieldSetMapper<Person> fieldSetMapper = new BeanWrapperFieldSetMapper<Person>();
	fieldSetMapper.setTargetType(Person.class);
	lineMapper.setLineTokenizer(lineTokenizer);
	lineMapper.setFieldSetMapper(fieldSetMapper);
	return lineMapper;
	}
	@Bean
	@StepScope
	public ItemProcessor<Person, Person> processor() {
	return new FilterProcessor<Person>(new IsNewYorkerPredicate());
	}
	@Bean
	@StepScope
	public ResourceAwareItemWriterItemStream<Person> writer(@Value("#{jobParameters[xmlFilePath]}") String xmlFilePath) {
	StaxEventItemWriter<Person> writer = new StaxEventItemWriter<Person>();
	writer.setResource(new FileSystemResource(xmlFilePath));
	writer.setRootTagName("result");
	writer.setMarshaller(marshaller());
	writer.setEncoding("UTF-8");
	writer.setOverwriteOutput(true);
	return writer;
	}
	@Bean
	public Marshaller marshaller() {
	Jaxb2Marshaller marshaller = new Jaxb2Marshaller();
	marshaller.setClassesToBeBound(Person.class);
	return marshaller;
	}
	public class IsNewYorkerPredicate implements Predicate<Person> {
	public boolean apply(Person person) {
	return "NY".equals(person.getState());
	}
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	package com.pelssers.main;
	import org.springframework.batch.core.Job;
	import org.springframework.batch.core.JobParametersBuilder;
	import org.springframework.batch.core.JobParametersInvalidException;
	import org.springframework.batch.core.launch.JobLauncher;
	import org.springframework.batch.core.repository.JobExecutionAlreadyRunningException;
	import org.springframework.batch.core.repository.JobInstanceAlreadyCompleteException;
	import org.springframework.batch.core.repository.JobRestartException;
	import org.springframework.context.ApplicationContext;
	import org.springframework.context.annotation.AnnotationConfigApplicationContext;
	import com.pelssers.configuration.jobs.CsvToXMLJobConfiguration;
	public class CsvToXmlJobLauncher {
	/**
	* @param args
	* @throws JobParametersInvalidException
	* @throws JobInstanceAlreadyCompleteException
	* @throws JobRestartException
	* @throws JobExecutionAlreadyRunningException
	*/
	public static void main(String[] args) throws JobExecutionAlreadyRunningException,
	JobRestartException, JobInstanceAlreadyCompleteException, JobParametersInvalidException {
	ApplicationContext context = new AnnotationConfigApplicationContext(CsvToXMLJobConfiguration.class);
	JobLauncher jobLauncher = context.getBean(JobLauncher.class);
	Job job = context.getBean(Job.class);
	jobLauncher.run(
	job,
	new JobParametersBuilder()
	.addString(CsvToXMLJobConfiguration.JOBPARAM_XML_FILEPATH, "c:/tmp/persons.xml")
	.addString(CsvToXMLJobConfiguration.JOBPARAM_CLASSPATH_RESOURCE, "500.csv")
	.toJobParameters());
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

Unit testing with Mockito

In this article I created a realistic scenario of services depending on each other. This article shows you how you can easily test business logic in isolation.

	/************************************************/
	DOMAIN OBJECTS
	*************************************************/
	/*********** Coordinates.java *******************/
	package com.pelssers.domain;
	public class Coordinates {
	private Double latitude;
	private Double longitude;
	public Coordinates(Double latitude, Double longitude) {
	this.latitude = latitude;
	this.longitude = longitude;
	}
	public Double getLatitude() {
	return latitude;
	}
	public Double getLongitude() {
	return longitude;
	}
	}
	/*********** Weather.java *******************/
	package com.pelssers.domain;
	import java.util.Set;
	public class Weather {
	private Double temperature;
	private Set<WeatherType> weatherTypes;
	public Weather(Double temperature, Set<WeatherType> weatherTypes) {
	this.temperature = temperature;
	this.weatherTypes = weatherTypes;
	}
	public Double getTemperature() {
	return temperature;
	}
	public Set<WeatherType> getWeatherTypes() {
	return weatherTypes;
	}
	@Override
	public String toString() {
	return "{temperature: " + getTemperature().toString() +
	", weatherTypes: [" + weatherTypes.toString() + "]";
	}
	}
	/*********** WeatherType.java *******************/
	package com.pelssers.domain;
	public enum WeatherType {
	RAINY, DRY, SUNNY, CLOUDY
	}
	/************************************************/
	SERVICE INTERFACES
	*************************************************/
	/*********** IHumidityService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface IHumidityService {
	Double predictHumidity(Date date, Coordinates coordinates);
	}
	/*********** ISatteliteService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface ISatteliteService {
	boolean isCloudy(Date date, Coordinates coordinates);
	}
	/*********** ITemperatureService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	public interface ITemperatureService {
	Double predictTemperature(Date date, Coordinates coordinates);
	}
	/*********** IWeatherForecastService.java *************/
	package com.pelssers.services;
	import java.util.Date;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	public interface IWeatherForecastService {
	Weather getForecast(Date date, Coordinates coordinates);
	}
	/************************************************/
	SERVICE IMPLEMENTATION(S)
	*************************************************/
	/*********** WeatherForecastService.java *************/
	package com.pelssers.services.impl;
	import java.util.Date;
	import java.util.HashSet;
	import java.util.Set;
	import javax.inject.Inject;
	import org.springframework.stereotype.Component;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	import com.pelssers.domain.WeatherType;
	import com.pelssers.services.ISatteliteService;
	import com.pelssers.services.ITemperatureService;
	import com.pelssers.services.IWeatherForecastService;
	import com.pelssers.services.IHumidityService;
	@Component()
	public class WeatherForecastService implements IWeatherForecastService {
	@Inject
	private ITemperatureService temperatureService;
	@Inject
	private IHumidityService humidityService;
	@Inject
	private ISatteliteService satteliteService;
	@Override
	public Weather getForecast(Date date, Coordinates coordinates) {
	final Double predictedTemperature = temperatureService.predictTemperature(date, coordinates);
	final Double predictedHumidity = humidityService.predictHumidity(date, coordinates);
	final boolean isCloudy = satteliteService.isCloudy(date, coordinates);
	//here starts our actual business logic
	Set<WeatherType> weatherTypes = new HashSet<WeatherType>();
	weatherTypes.add(isCloudy? WeatherType.CLOUDY : WeatherType.SUNNY);
	weatherTypes.add(predictedHumidity > 50 ? WeatherType.RAINY : WeatherType.DRY);
	return new Weather(predictedTemperature, weatherTypes);
	}
	}
	/************************************************/
	UNIT TEST
	*************************************************/
	package com.pelssers.services.impl;
	import java.util.Date;
	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.Test;
	import org.mockito.InjectMocks;
	import org.mockito.Mock;
	import org.mockito.MockitoAnnotations;
	import static org.mockito.Matchers.*;
	import static org.mockito.Mockito.*;
	import com.google.common.collect.ImmutableSet;
	import com.pelssers.domain.Coordinates;
	import com.pelssers.domain.Weather;
	import com.pelssers.domain.WeatherType;
	import com.pelssers.services.IHumidityService;
	import com.pelssers.services.ISatteliteService;
	import com.pelssers.services.ITemperatureService;
	import com.pelssers.services.IWeatherForecastService;
	public class WeatherForecastServiceTest {
	/**
	* As our weather forecast service depends on lots of other services
	* we want to mock the services we depend on and test our business logic
	* in isolation. As you can see we no longer need setters and getters in
	* WeatherForecastService, not for dependency injection and neither for unit testing
	*/
	@InjectMocks
	private IWeatherForecastService weatherForecastService = new WeatherForecastService();
	@Mock
	private IHumidityService humidityService;
	@Mock
	private ITemperatureService temperatureService;
	@Mock
	private ISatteliteService satteliteService;
	private Coordinates coordinates;
	private Date forecastDate;
	private Double expectedTemperature;
	@Before
	public void setUp() {
	//instruct mockito to process all annotations
	MockitoAnnotations.initMocks(this);
	forecastDate = new Date(2013, 10 , 1);
	coordinates = new Coordinates(14.5, 123.4);
	expectedTemperature = 16D;
	when(temperatureService.predictTemperature(any(Date.class), any(Coordinates.class)))
	.thenReturn(expectedTemperature);
	}
	@Test
	public void testRainyAndCloudyWeather() {
	Weather expectedWeather = new Weather(expectedTemperature,
	ImmutableSet.of(WeatherType.RAINY, WeatherType.CLOUDY));
	when(humidityService.predictHumidity(any(Date.class), any(Coordinates.class)))
	.thenReturn(60D);
	when(satteliteService.isCloudy(any(Date.class), any(Coordinates.class)))
	.thenReturn(true);
	testWeather(expectedWeather);
	}
	@Test
	public void testDryAndSunnyWeather() {
	Weather expectedWeather = new Weather(expectedTemperature,
	ImmutableSet.of(WeatherType.DRY, WeatherType.SUNNY));
	when(humidityService.predictHumidity(any(Date.class), any(Coordinates.class)))
	.thenReturn(40D);
	when(satteliteService.isCloudy(any(Date.class), any(Coordinates.class)))
	.thenReturn(false);
	testWeather(expectedWeather);
	}
	private void testWeather(Weather expectedWeather) {
	Weather actualWeather = weatherForecastService.getForecast(forecastDate, coordinates);
	//verify our services are called once
	verify(humidityService, times(1)).predictHumidity(forecastDate, coordinates);
	verify(temperatureService, times(1)).predictTemperature(forecastDate, coordinates);
	verify(satteliteService, times(1)).isCloudy(forecastDate, coordinates);
	Assert.assertEquals(expectedWeather.getTemperature(), actualWeather.getTemperature());
	Assert.assertEquals(expectedWeather.getWeatherTypes(), actualWeather.getWeatherTypes());
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

	<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.pelssers</groupId>
	<artifactId>mockitodemo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Mockito Demo</name>
	<packaging>jar</packaging>
	<properties>
	<spring.version>3.1.2.RELEASE</spring.version>
	</properties>
	<dependencies>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-beans</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>${spring.version}</version>
	<scope>compile</scope>
	</dependency>
	<dependency>
	<groupId>javax.inject</groupId>
	<artifactId>javax.inject</artifactId>
	<version>1</version>
	</dependency>
	<dependency>
	<groupId>com.google.guava</groupId>
	<artifactId>guava</artifactId>
	<version>14.0.1</version>
	</dependency>
	<!-- Test Dependencies -->
	<dependency>
	<groupId>junit</groupId>
	<artifactId>junit</artifactId>
	<version>4.8.2</version>
	<scope>test</scope>
	</dependency>
	<dependency>
	<groupId>org.mockito</groupId>
	<artifactId>mockito-core</artifactId>
	<version>1.9.5</version>
	<scope>test</scope>
	</dependency>
	</dependencies>
	</project>

view raw gistfile1.xml hosted with ❤ by GitHub

Demo showing how to use views on Scala collections

	package views
	object ViewsDemo {
	/**
	* Default all transformations on collections are strict, except for Stream. But you can
	* turn any collection into a lazy one by calling .view on the collection.
	*
	* If you want to have lazy collection evaluated, you can call .force on it
	*/
	def main(args: Array[String]): Unit = {
	val numbers1 = List(1,5,8,10)
	val numbers2 = numbers1 map (_ * 2)
	println(numbers2)
	val numbers3 = numbers1.view map (_ * 3)
	println(numbers3)
	println(numbers3(0))
	println(numbers3(1))
	println (numbers3.force)
	}
	/** output console
	List(2, 10, 16, 20)
	SeqViewM(...)
	3
	15
	List(3, 15, 24, 30)
	**/
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Curried functions and partially applied functions

	package functions
	import scala.math.pow
	object CurriedFunctionDemo {
	/**
	* A partially applied function is a function where some of its arguments have
	* already been filled in.
	*/
	//a*x^2 + b*x + c
	def nonCurriedFormula(a:Int, b: Int, c:Int, x: Int): Double = a * pow(x, 2) + b * x + c
	//a*x^2 + b*x + c
	def curriedFormula(a:Int)(b:Int)(c:Int)(x:Int): Double = a * pow(x, 2) + b * x + c
	def main(args: Array[String]): Unit = {
	//3*x^2 + 4*x +5
	val formula1 = curriedFormula(3)(4)(5)(_)
	println(formula1(1)) //should print 12
	println(formula1(2)) //should print 25
	println(nonCurriedFormula(3,4,5,2)) //should print 25
	val nonCurriedToCurried = (nonCurriedFormula _).curried
	val formula2 = nonCurriedToCurried(3)(4)(5)
	println(formula2(1)) //should print 12
	}
	}
	/** output console
	12.0
	25.0
	25.0
	12.0
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Partial functions demo

	package functions
	/**
	What is a partial function? From the Scala API: "A partial function of type PartialFunction[A, B]
	is a unary function where the domain does not necessarily include all values of type A.
	The function isDefinedAt allows to test dynamically if a value is in the domain of the function."
	I think it's best compared to using a switch statement in Java or a match expression in Scala
	where you enumerate cases and execute the corresponding block of code. But the main difference
	is that a partial function is just one of those cases (which is why it only handles part
	of the domain) and the sum (orElse) of these partial functions should cover the entire domain.
	Let's assume we let males and females define their own rewarding strategy for work they deliver.
	Males receive a salary depending on the length of their name and females all receive the same salary.
	We can map humans to their respective salary by applying partial function(s)
	**/
	object PartialFunctionDemo {
	abstract class Human(name: String, gender: String)
	case class Male(name: String) extends Human(name, "Male")
	case class Female(name: String) extends Human(name, "Female")
	val maleSalary: PartialFunction[Human, Int] = {
	case Male(name) => name.length * 1000
	}
	val femaleSalary: PartialFunction[Human, Int] = {
	case h: Female => 3500
	}
	def main(args: Array[String]): Unit = {
	val humans = List(Male("Rob"), Female("Sarah"), Male("Thorsten"), Female("Demi"))
	println(humans map (maleSalary orElse femaleSalary))
	}
	}
	/** output printed to console
	List(3000, 3500, 8000, 3500)
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Using self-type (Scala)

	package types
	object SelfTypeDemo {
	/**
	* using the self-type we declare that any BigTimeSpender also must be a Millionaire
	*/
	trait BigTimeSpender {
	self: Millionaire =>
	def wasteMoney: Unit = println("I can waste money on champagne")
	}
	trait Millionaire
	//class RichEmployee extends BigTimeSpender
	/**
	* This does not compile and gives following error:
	* illegal inheritance; self-type types.SelfTypeDemo.RichEmployee
	* does not conform to types.SelfTypeDemo.BigTimeSpender's selftype
	* types.SelfTypeDemo.BigTimeSpender with types.SelfTypeDemo.Millionaire
	*/
	//we have to mixin Millionaire
	class RichEmployee extends BigTimeSpender with Millionaire
	//but the order in which the traits are mixed in does not matter for this particular case
	class OtherRichEmployee extends Millionaire with BigTimeSpender
	def main(args: Array[String]): Unit = {
	val employee1 = new RichEmployee
	employee1.wasteMoney
	val employee2 = new OtherRichEmployee
	employee2.wasteMoney
	//we can also create a similar type in runtime
	val employee3 = new Object with BigTimeSpender with Millionaire
	employee3.wasteMoney
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Some examples of working with case classes

	package matchers
	object MatcherDemo {
	abstract class Animal(val name: String)
	case class Fish(override val name: String) extends Animal(name)
	case class Mammal(override val name:String) extends Animal(name)
	case class Reptile(override val name:String) extends Animal(name)
	case class Bird(override val name:String) extends Animal(name)
	val animals: List[Animal] = List(Mammal("Whale"),Fish("Tuna"), Mammal("Human"),
	Bird("Owl"), Fish("Shark"), Reptile("Crocodile"), Fish("Shark"))
	//filter all fish
	val fishes = animals collect {case a: Fish => a }
	/**
	List(Fish(Tuna), Fish(Shark), Fish(Shark))
	**/
	//filter animals with letter 'o' in name
	val animalsWithLetterO = animals.filter(a => a.name.toLowerCase().contains("o"))
	/**
	List(Bird(Owl), Reptile(Crocodile))
	**/
	val animalsGrouped = animals groupBy identity
	/**
	Map(
	Fish(Shark) -> List(Fish(Shark), Fish(Shark)),
	Bird(Owl) -> List(Bird(Owl)),
	Mammal(Whale) -> List(Mammal(Whale)),
	Fish(Tuna) -> List(Fish(Tuna)),
	Mammal(Human) -> List(Mammal(Human)),
	Reptile(Crocodile) -> List(Reptile(Crocodile))
	)
	**/
	val animalsByType = animals.groupBy(a => a.getClass().getName())
	/**
	Map(
	matchers.MatcherDemo$Bird -> List(Bird(Owl)),
	matchers.MatcherDemo$Mammal -> List(Mammal(Whale), Mammal(Human)),
	matchers.MatcherDemo$Fish -> List(Fish(Tuna), Fish(Shark), Fish(Shark)),
	matchers.MatcherDemo$Reptile -> List(Reptile(Crocodile))
	)
	**/
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Finding second highest frequency of characters in String

Write a method that accepts a String and returns the character with the second highest frequency. For example "aabbbc" would return 'a'. If the string contains spaces, they can be disregarded from the count. Note: my implementation returns a tuple (char, count) but that is just a matter of only returning the char itself.

	package puzzlers
	import scala.collection.mutable.{Map => MMap}
	object HighestFrequencyPuzzle {
	def stringToCharFrequencyMap(source: String): MMap[Char, Int] = {
	source.filter(c => c!=' ').foldLeft(MMap[Char, Int]())((map, char) => {
	map.update(char, map.getOrElseUpdate(char, 0) + 1)
	map
	})
	}
	def getNthHighestFrequency(source: String, n: Int): (Char, Int) =
	stringToCharFrequencyMap(source).toList.sortBy(_._2).reverse.drop(n -1).take(1)(0)
	def main(args: Array[String]): Unit = {
	val highest = getNthHighestFrequency("abecbb cdcbef", 1)
	println(highest)
	val secondHighest = getNthHighestFrequency("abecbb cdcbef", 2)
	println(secondHighest)
	}
	}
	/** output
	(b,4)
	(c,3)
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Creating immutable datastructures in Scala

I decided to take a shot at creating a simplified version of an immutable list structure and this is the result.

	package lists
	abstract class MyList[+A] {
	def isEmpty: Boolean
	def head: A
	def tail: MyList[A]
	def elementsToString: String = head + (if (tail.isEmpty) "" else ", " + tail.elementsToString)
	def length: Int
	/**
	* prepend elements of list to this list
	*/
	def ++:[B >: A](list: MyList[B]): MyList[B] = {
	if (isEmpty) list
	else if (list.isEmpty) this
	else FilledList(list.head, list.tail ++: this)
	}
	/**
	* append elements of list to this list
	*/
	def :++[B >: A](list: MyList[B]): MyList[B] = this ++: list
	/**
	if (isEmpty) list else FilledList(head, tail ++: list)
	**/
	/**
	* prepend element to this list
	*/
	def +:[B >: A](ele: B): MyList[B] = FilledList(ele, this)
	/**
	* append element to this list
	*/
	def :+[B >: A](ele: B): MyList[B] = this ++: FilledList(ele, EmptyList)
	/**
	if (isEmpty) FilledList(ele, EmptyList) else FilledList(head, tail :+ ele)
	**/
	}
	case object EmptyList extends MyList[Nothing] {
	override def isEmpty = true
	override def head: Nothing = throw new NoSuchElementException("head of empty list")
	override def tail: MyList[Nothing] = throw new UnsupportedOperationException("tail of empty list")
	override def length: Int = 0
	}
	case class FilledList[B](hd: B, tl: MyList[B]) extends MyList[B] {
	override def head : B = hd
	override def tail : MyList[B] = tl
	override def isEmpty: Boolean = false
	override def toString: String = "FilledList(" + elementsToString + ")"
	override def length: Int = 1 + tl.length
	}
	object MyList {
	def apply[A](xs: A*): MyList[A] = {
	if (xs.isEmpty) EmptyList
	else FilledList(xs.head, apply(xs.tail: _*))
	/**
	var result: MyList[A] = EmptyList
	for (ele <- xs.reverse) {
	result = ele +: result
	}
	result
	**/
	}
	}
	/************ Below some examples from a worksheet ************/
	import lists.{MyList, EmptyList, FilledList}
	val list1 = FilledList(4, FilledList(5, FilledList(6, EmptyList)))
	val list2 = FilledList(8, FilledList(9, EmptyList))
	val list3 = 7 +: list2
	val list4 = list1 ++: list2 //prepending list1 to list2
	val list5 = list1 :+ 7
	val list6 = list1 :++ list2 //appending list2 to list1
	val list7 = MyList(5,6,7,8)
	val list8 = EmptyList
	/** output
	> list1: lists.FilledList[Int] = FilledList(4, 5, 6)
	> list2: lists.FilledList[Int] = FilledList(8, 9)
	> list3: lists.MyList[Int] = FilledList(7, 8, 9)
	> list4: lists.MyList[Int] = FilledList(4, 5, 6, 8, 9)
	> list5: lists.MyList[Int] = FilledList(4, 5, 6, 7)
	> list6: lists.MyList[Int] = FilledList(4, 5, 6, 8, 9)
	> list7: lists.MyList[Int] = FilledList(5, 6, 7, 8)
	> list8: lists.EmptyList.type = EmptyList
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Mimicking grep command in Scala

	package implicits
	import java.io.File
	import scala.io.Source
	object RichFileDemo {
	class RichFile(file: String) {
	def matchLines(source: Source, pattern: String): Iterator[(String, Int)] = {
	source.getLines.zipWithIndex.filter(l => pattern.r.findFirstIn(l._1) != None)
	}
	def grep(pattern: String): Unit = {
	val source = Source.fromFile(file)
	matchLines(source,pattern).foreach(x => println("line " + x._2 + ": " + x._1))
	source.close
	}
	}
	def main(args: Array[String]): Unit = {
	val file = new RichFile("c:/scalademo/news.txt")
	file.grep("com")
	}
	}
	//news.txt
	/**
	Working together with leaders of the Play Framework, Akka, and Scala open source communities,
	Typesafe seeks to give developers the modern tools they need to build the next generation of
	software applications for the era of multicore hardware and cloud computing workloads.
	**/
	//output program
	/**
	line 0: Working together with leaders of the Play Framework, Akka, and Scala open source communities,
	line 2: software applications for the era of multicore hardware and cloud computing workloads.
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

A taste of using implicits in scala

	package implicits
	import java.io.File
	object ImplicitsDemo {
	trait Composite[T] {
	def value: T
	def isComposite: Boolean
	def children: List[Composite[T]]
	def descendants: List[Composite[T]] =
	children.map(child => child +: (if (child.isComposite) child.descendants else Nil)).flatten
	def print: Unit = print(0)
	def print(level: Int): Unit = {
	val indent = " " * level
	println(indent + "|_" + this)
	if (isComposite) children.foreach(_.print(level + 1))
	}
	}
	implicit def fileToComposite(file: File): Composite[File] = new Composite[File] {
	def value: File = file
	override def isComposite = file.isDirectory()
	override def children: List[Composite[File]] = file.listFiles().toList.map(fileToComposite)
	override def toString = file.getName()
	}
	def main(args: Array[String]): Unit = {
	println("*********************printing descendants**************************************************")
	new File("C:/scala-2.10.2").descendants.foreach(composite => println(composite.value.getAbsolutePath()))
	println("*********************printing descendants as TREE ******************************************")
	new File("C:/scala-2.10.2").print
	}
	}
	/**
	*********************printing descendants**************************************************
	C:\scala-2.10.2\bin
	C:\scala-2.10.2\bin\fsc
	C:\scala-2.10.2\bin\fsc.bat
	C:\scala-2.10.2\bin\scala
	C:\scala-2.10.2\bin\scala.bat
	C:\scala-2.10.2\bin\scalac
	C:\scala-2.10.2\bin\scalac.bat
	C:\scala-2.10.2\bin\scaladoc
	C:\scala-2.10.2\bin\scaladoc.bat
	C:\scala-2.10.2\bin\scalap
	C:\scala-2.10.2\bin\scalap.bat
	C:\scala-2.10.2\doc
	C:\scala-2.10.2\doc\LICENSE
	C:\scala-2.10.2\doc\README
	C:\scala-2.10.2\doc\tools
	C:\scala-2.10.2\doc\tools\css
	C:\scala-2.10.2\doc\tools\css\style.css
	C:\scala-2.10.2\doc\tools\fsc.html
	C:\scala-2.10.2\doc\tools\images
	C:\scala-2.10.2\doc\tools\images\external.gif
	C:\scala-2.10.2\doc\tools\images\scala_logo.png
	C:\scala-2.10.2\doc\tools\index.html
	C:\scala-2.10.2\doc\tools\scala.html
	C:\scala-2.10.2\doc\tools\scalac.html
	C:\scala-2.10.2\doc\tools\scaladoc.html
	C:\scala-2.10.2\doc\tools\scalap.html
	C:\scala-2.10.2\examples
	C:\scala-2.10.2\examples\actors
	C:\scala-2.10.2\examples\actors\auction.scala
	C:\scala-2.10.2\examples\actors\boundedbuffer.scala
	C:\scala-2.10.2\examples\actors\channels.scala
	C:\scala-2.10.2\examples\actors\fringe.scala
	C:\scala-2.10.2\examples\actors\links.scala
	C:\scala-2.10.2\examples\actors\looping.scala
	C:\scala-2.10.2\examples\actors\message.scala
	C:\scala-2.10.2\examples\actors\pingpong.scala
	C:\scala-2.10.2\examples\actors\producers.scala
	C:\scala-2.10.2\examples\actors\seq.scala
	C:\scala-2.10.2\examples\boundedbuffer.scala
	C:\scala-2.10.2\examples\computeserver.scala
	C:\scala-2.10.2\examples\fors.scala
	C:\scala-2.10.2\examples\futures.scala
	C:\scala-2.10.2\examples\gadts.scala
	C:\scala-2.10.2\examples\iterators.scala
	C:\scala-2.10.2\examples\maps.scala
	C:\scala-2.10.2\examples\monads
	C:\scala-2.10.2\examples\monads\callccInterpreter.scala
	C:\scala-2.10.2\examples\monads\directInterpreter.scala
	C:\scala-2.10.2\examples\monads\errorInterpreter.scala
	C:\scala-2.10.2\examples\monads\simpleInterpreter.scala
	C:\scala-2.10.2\examples\monads\stateInterpreter.scala
	C:\scala-2.10.2\examples\oneplacebuffer.scala
	C:\scala-2.10.2\examples\package.scala
	C:\scala-2.10.2\examples\parsing
	C:\scala-2.10.2\examples\parsing\ArithmeticParser.scala
	C:\scala-2.10.2\examples\parsing\ArithmeticParsers.scala
	C:\scala-2.10.2\examples\parsing\JSON.scala
	C:\scala-2.10.2\examples\parsing\lambda
	C:\scala-2.10.2\examples\parsing\lambda\Main.scala
	C:\scala-2.10.2\examples\parsing\lambda\test
	C:\scala-2.10.2\examples\parsing\lambda\test\test-01.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-02.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-03.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-04.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-05.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-06.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-07.kwi
	C:\scala-2.10.2\examples\parsing\lambda\test\test-08.kwi
	C:\scala-2.10.2\examples\parsing\lambda\TestParser.scala
	C:\scala-2.10.2\examples\parsing\lambda\TestSyntax.scala
	C:\scala-2.10.2\examples\parsing\ListParser.scala
	C:\scala-2.10.2\examples\parsing\ListParsers.scala
	C:\scala-2.10.2\examples\parsing\MiniML.scala
	C:\scala-2.10.2\examples\patterns.scala
	C:\scala-2.10.2\examples\sort.scala
	C:\scala-2.10.2\examples\sort1.scala
	C:\scala-2.10.2\examples\sort2.scala
	C:\scala-2.10.2\examples\tcpoly
	C:\scala-2.10.2\examples\tcpoly\monads
	C:\scala-2.10.2\examples\tcpoly\monads\Monads.scala
	C:\scala-2.10.2\examples\xml
	C:\scala-2.10.2\examples\xml\phonebook
	C:\scala-2.10.2\examples\xml\phonebook\embeddedBook.scala
	C:\scala-2.10.2\examples\xml\phonebook\phonebook.scala
	C:\scala-2.10.2\examples\xml\phonebook\phonebook1.scala
	C:\scala-2.10.2\examples\xml\phonebook\phonebook2.scala
	C:\scala-2.10.2\examples\xml\phonebook\phonebook3.scala
	C:\scala-2.10.2\examples\xml\phonebook\verboseBook.scala
	C:\scala-2.10.2\lib
	C:\scala-2.10.2\lib\akka-actors.jar
	C:\scala-2.10.2\lib\diffutils.jar
	C:\scala-2.10.2\lib\jline.jar
	C:\scala-2.10.2\lib\scala-actors-migration.jar
	C:\scala-2.10.2\lib\scala-actors.jar
	C:\scala-2.10.2\lib\scala-compiler.jar
	C:\scala-2.10.2\lib\scala-library.jar
	C:\scala-2.10.2\lib\scala-partest.jar
	C:\scala-2.10.2\lib\scala-reflect.jar
	C:\scala-2.10.2\lib\scala-swing.jar
	C:\scala-2.10.2\lib\scalap.jar
	C:\scala-2.10.2\lib\typesafe-config.jar
	C:\scala-2.10.2\man
	C:\scala-2.10.2\man\man1
	C:\scala-2.10.2\man\man1\fsc.1
	C:\scala-2.10.2\man\man1\scala.1
	C:\scala-2.10.2\man\man1\scalac.1
	C:\scala-2.10.2\man\man1\scaladoc.1
	C:\scala-2.10.2\man\man1\scalap.1
	C:\scala-2.10.2\misc
	C:\scala-2.10.2\misc\scala-devel
	C:\scala-2.10.2\misc\scala-devel\plugins
	C:\scala-2.10.2\misc\scala-devel\plugins\continuations.jar
	C:\scala-2.10.2\src
	C:\scala-2.10.2\src\fjbg-src.jar
	C:\scala-2.10.2\src\msil-src.jar
	C:\scala-2.10.2\src\scala-actors-src.jar
	C:\scala-2.10.2\src\scala-compiler-src.jar
	C:\scala-2.10.2\src\scala-library-src.jar
	C:\scala-2.10.2\src\scala-partest-src.jar
	C:\scala-2.10.2\src\scala-reflect-src.jar
	C:\scala-2.10.2\src\scala-swing-src.jar
	C:\scala-2.10.2\src\scalap-src.jar
	********************* printing file as TREE ******************************************
	|_scala-2.10.2
	|_bin
	|_fsc
	|_fsc.bat
	|_scala
	|_scala.bat
	|_scalac
	|_scalac.bat
	|_scaladoc
	|_scaladoc.bat
	|_scalap
	|_scalap.bat
	|_doc
	|_LICENSE
	|_README
	|_tools
	|_css
	|_style.css
	|_fsc.html
	|_images
	|_external.gif
	|_scala_logo.png
	|_index.html
	|_scala.html
	|_scalac.html
	|_scaladoc.html
	|_scalap.html
	|_examples
	|_actors
	|_auction.scala
	|_boundedbuffer.scala
	|_channels.scala
	|_fringe.scala
	|_links.scala
	|_looping.scala
	|_message.scala
	|_pingpong.scala
	|_producers.scala
	|_seq.scala
	|_boundedbuffer.scala
	|_computeserver.scala
	|_fors.scala
	|_futures.scala
	|_gadts.scala
	|_iterators.scala
	|_maps.scala
	|_monads
	|_callccInterpreter.scala
	|_directInterpreter.scala
	|_errorInterpreter.scala
	|_simpleInterpreter.scala
	|_stateInterpreter.scala
	|_oneplacebuffer.scala
	|_package.scala
	|_parsing
	|_ArithmeticParser.scala
	|_ArithmeticParsers.scala
	|_JSON.scala
	|_lambda
	|_Main.scala
	|_test
	|_test-01.kwi
	|_test-02.kwi
	|_test-03.kwi
	|_test-04.kwi
	|_test-05.kwi
	|_test-06.kwi
	|_test-07.kwi
	|_test-08.kwi
	|_TestParser.scala
	|_TestSyntax.scala
	|_ListParser.scala
	|_ListParsers.scala
	|_MiniML.scala
	|_patterns.scala
	|_sort.scala
	|_sort1.scala
	|_sort2.scala
	|_tcpoly
	|_monads
	|_Monads.scala
	|_xml
	|_phonebook
	|_embeddedBook.scala
	|_phonebook.scala
	|_phonebook1.scala
	|_phonebook2.scala
	|_phonebook3.scala
	|_verboseBook.scala
	|_lib
	|_akka-actors.jar
	|_diffutils.jar
	|_jline.jar
	|_scala-actors-migration.jar
	|_scala-actors.jar
	|_scala-compiler.jar
	|_scala-library.jar
	|_scala-partest.jar
	|_scala-reflect.jar
	|_scala-swing.jar
	|_scalap.jar
	|_typesafe-config.jar
	|_man
	|_man1
	|_fsc.1
	|_scala.1
	|_scalac.1
	|_scaladoc.1
	|_scalap.1
	|_misc
	|_scala-devel
	|_plugins
	|_continuations.jar
	|_src
	|_fjbg-src.jar
	|_msil-src.jar
	|_scala-actors-src.jar
	|_scala-compiler-src.jar
	|_scala-library-src.jar
	|_scala-partest-src.jar
	|_scala-reflect-src.jar
	|_scala-swing-src.jar
	|_scalap-src.jar
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Scala Streams demo

	package streams
	import scala.util.Random
	/**
	* The class Stream implements lazy lists where elements are only evaluated when they are needed.
	* The Stream class also employs memoization such that previously computed values are converted
	* from Stream elements to concrete values of type A.
	*
	* So a Stream needs an initial object and a function to compute the rest of the objects
	*/
	object StreamDemo {
	/**
	* a stream of all positive integers
	*/
	def naturalnumbers: Stream[Int] = Stream.from(1)
	/**
	* A stream of factorials. There are multiple ways to compute this stream but I particularly like
	* this implementation as it maps another stream to the desired stream. Let this one sink in for a bit,
	* it took me more than 1 minute to come up with this solution :)
	*
	*/
	def factorials: Stream[Int] = 1 #:: Stream.from(2).map((x:Int) => x * factorials(x-2))
	/**
	factorials(0) returns first element which is 1 (not lazy evaluated)
	next starts our Stream.from(2) --> {value} which we map to x * factorials(x-2)
	The reason why it has to be factorials(x-2) is because our stream starts at 2 and factorials(2-2)
	returns the first factorial number.
	factorials(1) returns {2} * factorials(2-2) = {2} * 1 = 2
	factorials(2) returns {3} * factorials(3-2) = {3} * 2 = 6
	factorials(3) returns {4} * factorials(4-2) = {4} * 6 = 24
	**/
	sealed trait CoinFlip {
	val outcome: String
	override def toString = outcome
	}
	object Head extends { val outcome = "HEAD" } with CoinFlip
	object Tail extends { val outcome = "TAIL" } with CoinFlip
	val outcomes = List(Head, Tail)
	def flip: CoinFlip = Random.shuffle(outcomes).apply(0)
	def coinflips: Stream[CoinFlip] = flip #:: coinflips
	def main(args: Array[String]): Unit = {
	println(naturalnumbers.take(5).mkString("first 5 natural numbers: [", ",", "]"))
	println(factorials.take(5).mkString("first 5 factorial numbers: [", ",", "]"))
	println(coinflips.take(10).mkString("first 10 coinflips : [", ",", "]"))
	}
	/**
	* This will print:
	* first 5 natural numbers: [1,2,3,4,5]
	* first 5 factorial numbers: [1,2,6,24,120]
	* first 10 coinflips : [TAIL,TAIL,HEAD,TAIL,HEAD,TAIL,HEAD,TAIL,TAIL,TAIL]
	*/
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Some observations on performance (Scala)

	package performance
	import java.util.Date
	/**
	* In this little demo we try to calculate the sum of a list of numbers (0,1,... ,1000.000)
	* using various approaches. As we will see Java outperforms the Scala versions with just
	* a few milliseconds at the expense of readability, maintainability and productivity.
	*
	* However, I noticed that passing a method instead of a function comes with a performance penalty.
	* In that case the method is converted to a function using ETA expansion.
	*/
	object SumUp extends App {
	val numbers = (0 to 1000000).toList
	def sumJava(numbers: List[Int]):Int = {
	var total = 0
	for (number <- numbers) {
	total = total + number
	}
	total
	}
	def sumScala1(numbers: List[Int]):Int = numbers.foldLeft(0)((a,b) => a + b)
	def sumScala2(numbers: List[Int]):Int = numbers.foldLeft(0)(sum)
	def sumScala3(numbers: List[Int]):Int = numbers.foldLeft(0)(sumAsFunction)
	def sumScala4(numbers: List[Int]):Int = numbers.foldLeft(0)(new SumFunction)
	def sum(a: Int, b: Int): Int = a + b
	val sumAsFunction = sum _ //here we convert the method to a function
	class SumFunction extends Function2[Int,Int, Int] {
	def apply(a: Int, b: Int): Int = a + b
	}
	/**
	* profile method works like an Around Advice in AspectOriented programming
	*/
	def profile[T](body: => T) = {
	val start = new Date()
	val result = body
	val end = new Date()
	println("Execution took " + (end.getTime() - start.getTime()) + " milliseconds")
	result
	}
	profile(sumJava(numbers)) //using imperative Java
	profile(sumScala1(numbers)) //using inline function
	profile(sumScala2(numbers)) //using method
	profile(sumScala3(numbers)) //using method converted to function before passing it to foldleft
	profile(sumScala4(numbers)) //using a function class
	}
	/**
	Execution took 14 milliseconds //using imperative Java
	Execution took 17 milliseconds //using inline function
	Execution took 95 milliseconds //using method
	Execution took 17 milliseconds //using method converted to function
	Execution took 18 milliseconds //using a function class
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

CSVReader (Scala)

	/**
	I wanted to find out how much lines of code a simple easy to use CSVReader would take in Scala.
	So here is a quick first try-out.
	**/
	package csv
	import java.lang.Boolean
	import scala.util.Try
	import scala.io.Source
	trait LineTokenizer {
	def tokenize(line: String, separator: String): Array[String] =
	line.split(separator).map(value => value.trim())
	def tokenize(line: String, separator: String, labels: List[String]): FieldSet =
	new FieldSet(labels, tokenize(line, separator))
	}
	trait LineMapper[T] {
	def mapLine(fieldSet: FieldSet): T
	}
	class CSVReader[T](file: String, separator: String, labels: List[String], hasHeader: Boolean,
	lineMapper: LineMapper[T]) extends LineTokenizer {
	val lines = Source.fromFile(file).getLines()
	val header = if (hasHeader) lines.next() else ""
	def hasNext: Boolean = lines.hasNext
	def next: T = lineMapper.mapLine(tokenize(lines.next(), separator, labels))
	}
	class FieldSet(labels: List[String], values: Array[String]) {
	val fields = labels.zip(values).toMap
	def readString(field: String): Option[String] = fields.get(field)
	def readBoolean(field: String): Option[Boolean] =
	convert(field, (s: String) => Boolean.valueOf(s))
	def readInt(field: String): Option[Int] = convert(field, (s: String) => s.toInt)
	def readLong(field: String): Option[Long] = convert(field, (s: String) => s.toLong)
	def readBigDecimal(field: String): Option[BigDecimal] =
	convert(field, (s: String) => BigDecimal.valueOf(s.toDouble))
	def convert[T](field: String, f: String => T): Option[T] = {
	readString(field) match {
	case None => None
	case Some(x) => Try[Option[T]](Some(f(x))).getOrElse(None)
	}
	}
	override def toString =
	List("FieldSet([", labels.mkString(","), "],[", values.mkString(","), "])").mkString
	}
	/***************** persons.csv ******************************************/
	name, age, male
	Robby, 36, true
	Valerie, 6, false
	Lindsey, 10, false
	/**************** USAGE *************************************************/
	import csv.{FieldSet, LineMapper, CSVReader}
	import java.lang.Boolean
	case class Person(name: String, age: Int, isMale: Boolean)
	val NAME = "NAME"
	val AGE = "AGE"
	val IS_MALE = "IS_MALE"
	val lineMapper = new LineMapper[Person] {
	override def mapLine(fieldSet: FieldSet): Person = {
	val name = fieldSet.readString(NAME).getOrElse("")
	val age = fieldSet.readInt(AGE).getOrElse(0)
	val isMale = fieldSet.readBoolean(IS_MALE).getOrElse(Boolean.FALSE)
	Person(name, age , isMale)
	}
	}
	val csvReader = new CSVReader[Person](
	"/Users/robbypelssers/Documents/persons.csv",
	",", List(NAME, AGE, IS_MALE),
	true,
	lineMapper
	)
	while (csvReader.hasNext) {
	println(csvReader.next)
	}

view raw gistfile1.scala hosted with ❤ by GitHub

Reading, Processing and Writing... sounds batch

	package batch
	import scala.xml.Elem
	trait ItemReader[A] {
	def read: Option[A]
	def hasNext: Boolean
	}
	trait ItemProcessor[A,B] {
	def process(x: A): B
	}
	trait ItemWriter[B] {
	def write(items: List[B]): Unit
	}
	trait BatchProcessor[S,T] {
	val itemReader: ItemReader[S]
	val itemProcessor: ItemProcessor[S,T]
	val itemWriter: ItemWriter[T]
	def execute: Unit = {
	while(itemReader.hasNext) {
	for (item <- itemReader.read){
	itemWriter.write(List(itemProcessor.process(item)))
	}
	}
	}
	}
	class ListReader[A](list: List[A]) extends ItemReader[A] {
	val iterator:Iterator[A] = list.iterator
	override def read: Option[A] = {
	new Some(iterator.next)
	}
	override def hasNext: Boolean = {
	iterator.hasNext
	}
	}
	/**
	* Our simple batchprogram will
	* - read cities one by one from a list of cities
	* - process them (transform from scala to xml)
	* - write each list containing 1 city to the console
	*
	* I left out chunking for simplicity
	*/
	object BatchProgram {
	case class City(name: String, population: Long) {
	def marshal: Elem = {
	<city>
	<name>{name}</name>
	<population>{population}</population>
	</city>
	}
	}
	val cities = List(City("Paris", 2234000000L), City("London", 8174000000L))
	val cityReader: ListReader[City] = new ListReader(cities)
	val cityProcessor:ItemProcessor[City,Elem] = new ItemProcessor[City,Elem]() {
	override def process(city: City): Elem = {
	city.marshal
	}
	}
	val cityWriter: ItemWriter[Elem] = new ItemWriter[Elem]() {
	override def write(items: List[Elem]): Unit = {
	println("*****************BATCH START*************")
	for (item <- items) println(item)
	println("*****************BATCH END***************")
	}
	}
	val batchProcessor: BatchProcessor[City, Elem] = new {
	val itemReader = cityReader
	val itemProcessor = cityProcessor
	val itemWriter = cityWriter
	} with BatchProcessor[City, Elem]
	def main(args: Array[String]) {
	batchProcessor.execute
	}
	}
	/**
	This will print the following to the console:
	*****************BATCH START*************
	<city>
	<name>Paris</name>
	<population>2234000000</population>
	</city>
	*****************BATCH END***************
	*****************BATCH START*************
	<city>
	<name>London</name>
	<population>8174000000</population>
	</city>
	*****************BATCH END***************
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Creating a random program in Scala

	import scala.collection.mutable.ListBuffer
	import scala.util.Random
	object RandomProgram {
	def process1(): Unit = {
	println("This is process 1 executing")
	}
	def process2(): Unit = {
	println("This is process 2 executing")
	}
	def process3(): Unit = {
	println("This is process 3 executing")
	}
	def main(args: Array[String]): Unit = {
	val processes = new ListBuffer[() => Unit]
	processes += (process1, process2, process3)
	for (process <- Random.shuffle(processes)) process()
	}
	}
	/**
	The program will print all 3 strings but we cannot predict in which order.
	My second run of this program resulted in below output:
	This is process 1 executing
	This is process 3 executing
	This is process 2 executing
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Understanding Functions in Scala

	/**
	Functions are first class citizens in Scala and a function that takes a single argument
	obeys below interface (trait in scala). It should have a method called apply which takes
	an argument of type T1 and returns a value of type R.
	**/
	trait Function1[-T1, +R] extends AnyRef { self =>
	/** Apply the body of this function to the argument.
	* @return the result of function application.
	*/
	def apply(v1: T1): R
	}
	/**
	In Scala there are 2 ways to indicate that a class implements a function Trait:
	[1] extends Function1[Int,Int]
	[2] extends (Int => Int)
	You can also write a function using the def keyword
	**/
	object FuncFun {
	class DoubleFunction extends (Int => Int) {
	def apply(x:Int): Int = x * 2
	}
	def timesFour(x: Int): Int = x * 4
	def doSomethingWithNumber(x: Int, f: Int => Int): Int = f(x)
	def main(args: Array[String]): Unit = {
	//this will print 6
	println(doSomethingWithNumber(3, new DoubleFunction()))
	//this will print 8
	println(doSomethingWithNumber(2, timesFour))
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

factorial function (Scala)

	/**
	Typical example of a recursive function taught at school.
	But in practice implementing factorial recursively leads to a stackoverlow. And we can't use @tailrec for
	n! = n * (n-1)!
	BUT !! We don't really need recursion, do we?!
	**/
	package numbers
	object Numbers {
	/**
	1! = 1
	2! = 2 * 1! = 2 * 1 = 2
	3! = 3 * 2! = 3 * 2 = 6
	4! = 4 * 3! = 4 * 6 = 24
	5! = 5 * 4! = 5 * 24 = 120
	**/
	def factStackOverflow(num: Int): BigDecimal = {
	if (num == 1) 1
	else num * factStackOverflow(num-1)
	}
	/**
	1! = 1
	2! = 1! * 2 = 1 * 2 = 2
	3! = 2! * 3 = 2 * 3 = 6
	4! = 3! * 4 = 6 * 4 = 24
	5! = 4! * 5 = 24 * 5 = 120
	**/
	def factNonRecursive(num: Int): BigDecimal = {
	(1 to num).map(x => BigDecimal.valueOf(x)).foldLeft(BigDecimal.valueOf(1)) ((a,b) => (a * b))
	}
	}
	/**
	val x1 = Numbers.factNonRecursive(1) //> x1 : BigDecimal = 1.00
	val x2 = Numbers.factNonRecursive(10) //> x2 : BigDecimal = 3628800.00000000000
	val x3 = Numbers.factNonRecursive(10000) //> x3 : BigDecimal = 2.846259680917054518906413212119839E+35659
	val x4 = Numbers.factStackOverflow(1) //> x4 : BigDecimal = 1
	val x5 = Numbers.factStackOverflow(10) //> x5 : BigDecimal = 3628800
	val x6 = Numbers.factStackOverflow(10000) //> java.lang.StackOverflowError
	//| at java.math.MathContext.equals(Unknown Source)
	//| at scala.math.BigDecimal$.apply(BigDecimal.scala:61)
	//| at scala.math.BigDecimal$.apply(BigDecimal.scala:59)
	//| at scala.math.BigDecimal$.int2bigDecimal(BigDecimal.scala:146)
	//| Output exceeds cutoff limit.
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

constructing simple pipelines in Scala

Playing a bit with constructing pipelines logically in Scala. A pipeline MUST start with a generator, folllowed by 0 to many transformers and MUST end with a serializer.

	trait PipelineComponent {
	def execute: Unit
	}
	trait Generator extends PipelineComponent {
	override def execute: Unit = print("Generator executing\n")
	}
	trait Transformer extends PipelineComponent {
	override def execute: Unit = print("Transformer executing\n")
	}
	trait Serializer extends PipelineComponent {
	override def execute: Unit = print("Serializer executing\n")
	}
	abstract class AbstractPipeline(pipelineComponents: List[PipelineComponent])
	case class EmptyPipeline extends AbstractPipeline(List()) {
	def add(generator: Generator): NonEmptyPipeline = new NonEmptyPipeline(List(generator))
	}
	case class NonEmptyPipeline(pipelineComponents: List[PipelineComponent]) extends AbstractPipeline(pipelineComponents) {
	def add(transformer: Transformer): NonEmptyPipeline = new NonEmptyPipeline(pipelineComponents :+ transformer)
	def add(serializer: Serializer): FinishedPipeline = new FinishedPipeline(pipelineComponents :+ serializer)
	}
	case class FinishedPipeline(pipelineComponents: List[PipelineComponent]) extends AbstractPipeline(pipelineComponents) {
	def execute(): Unit = pipelineComponents.foreach(_.execute)
	}
	/**
	object PipelineApp extends App {
	val generator = new Object with Generator
	val transformer1 = new Object with Transformer
	val transformer2 = new Object with Transformer
	val serializer = new Object with Serializer
	new EmptyPipeline().add(generator).add(transformer1).add(transformer2).add(serializer).execute
	}
	this will print:
	Generator executing
	Transformer executing
	Transformer executing
	Serializer executing
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Simple Word Counter in Scala

	package pelssers.io
	import scala.collection.mutable.Map
	class WordCounter(file: String, ignoredChars: List[Char]) {
	override def toString = s"WordCounter(File=$file, ignoredChars=$ignoredChars)"
	def count:Map[String, Int] = {
	import scala.io.Source
	val result: Map[String, Int] = new scala.collection.mutable.HashMap[String, Int]
	val source = Source.fromFile(file);
	for (line <- source.getLines) {
	for (word <- prepareLine(line).split(" ")) {
	result.update(word, result.getOrElseUpdate(word, 0) + 1)
	}
	}
	result
	}
	def top(number: Int): Seq[(String,Int)] = {
	count.toList.sortBy(r => r._2).reverse.take(number)
	}
	private def prepareLine(line: String): String = {
	val sb = new StringBuffer();
	for (c <- line) {
	sb.append(if (ignoredChars.contains(c)) " " else c)
	}
	sb.toString()
	}
	}
	/** contents of sample.txt
	Working together with leaders of the Play Framework, Akka, and Scala open source communities,
	Typesafe seeks to give developers the modern tools they need to build the next generation of
	software applications for the era of multicore hardware and cloud computing workloads.
	**/
	/** worksheet test
	val wordCounter = new WordCounter("c:/scalademo/sample.txt", List('.', '!', '?'))
	//> wordCounter : pelssers.io.WordCounter = WordCounter(File=c:/scalademo/sample.txt, ignoredChars=List(., !, ?))
	val top3words = wordCounter.top(3)
	//> top3words : Seq[(String, Int)] = List((the,4), (of,3), (and,2))
	**/

view raw gistfile1.scala hosted with ❤ by GitHub

Fun exercices Scala vs Java

	import scala.math.pow
	object StringUtils {
	/**
	*
	* @param source
	* @param char
	* @param interval
	* @return a new string with char c appended after each interval of characters
	*/
	def interleave(source: String, char:Char, interval: Int): String = {
	if (source.length < interval + 1) source
	else source.take(interval).concat(String.valueOf(char)
	.concat(interleave(source.drop(interval), char, interval)))
	}
	/**
	*
	* @param source
	* @return a Double representation of a binary string
	*/
	def binaryString2Double(source: String): Double = {
	source.reverse.map(c => Integer.valueOf(String.valueOf(c)))
	.zipWithIndex.map(zipped => zipped._1 * pow(2, zipped._2)).sum
	}
	}

view raw gistfile1.scala hosted with ❤ by GitHub

	import static java.lang.Math.pow;
	public class JavaStringUtils {
	/**
	*
	* @param source
	* @param c
	* @param interval
	* @return a new string with char c appended after each interval of characters
	*/
	public static String interleave(String source, char c, int interval) {
	return
	source.length() < interval + 1
	? source
	: source.substring(0, interval).concat(String.valueOf(c))
	.concat(interleave(source.substring(interval), c, interval));
	}
	/**
	*
	* @param source
	* @return a Double representation of a binary string
	*/
	public static Double binaryString2Double(String source) {
	Double result = 0D;
	int length = source.length();
	for (int index = length - 1; index > -1; index--) {
	int numAtIndex = Integer.valueOf(String.valueOf(source.charAt(index)));
	result = result + numAtIndex * pow(2, index);
	}
	return result;
	}
	}

view raw gistfile1.java hosted with ❤ by GitHub

Using Bootstrap with Play 2

The easiest way to get bootstrap working with Play 2 is not to separate the bootstrap files in the corresponding stylesheets, javascripts and images folders but just drop the sources in like shown below.

Loading ....

Notes on building Restful Services

	Building Restful services (Notes)Definitions:
	An idempotent operation produces the same result, whether it is invoked 1 or multiple times.
	PUT, GET, DELETE and HEAD are idempotent operations
	******************************
	* GET as Read *
	******************************
	******************************
	* DELETE as Delete *
	******************************
	******************************
	* HEAD as Headers, no body *
	******************************
	******************************
	* PUT as Create *
	******************************
	- Identifier is known upfront by client.
	- The client must provide all properties/data of that resource
	PUT /users/{robbypelssers}
	{
	"firstname": "Robby",
	"lastname": "Pelssers",
	"age": 36,
	"phone": "phonenumberOld"
	}
	******************************
	* POST as Create *
	******************************
	- On a parent resource (typicaly a collection)
	POST /users
	{
	"firstname": "Robby",
	"lastname": "Pelssers",
	"age": 36,
	"phone": "phonenumberOld"
	}
	Response: 201 created
	Location: http://www.mycompany.com/users/{robbypelssers}
	******************************
	* POST as Update *
	******************************
	- partial or full update
	- saves bandwidth
	POST /users/{robbypelssers}
	{
	"phone": "phonenumberNew"
	}
	Response: 200 OK
	******************************
	* Media Types *
	******************************
	- Format specification + parsing rules
	- Request: Accept header
	- Response: Content-Type header
	application/json
	******************************
	* Designing Rest Services *
	******************************
	* Pick an easy to remember base URL, e.g. http(s)://api.mycompany.nl
	* Versioning:
	http(s)://api.mycompany.nl/v1
	or
	Media-Type
	application/json;application,v=1
	* Resource Formats:
	Date / Time / Timestamps: use ISO 8601
	* Content Negotiation (2 ways of negotiation)
	[1] Header
	- Acccept Header
	- Header values comma delimited in order of preference
	GET /user/robbypelssers
	Accept: application/json, text-plain
	[2] Resource extension (conventionally overrides Accept header)
	/users/robbypelssers.json
	/users/robbypelssers.xml
	/users/robbypelssers.csv
	* Resource referencing (aka linking)
	- Hypermedia is paramount
	- Linking is fundamental to scalability
	- Tricky in JSON
	- XML has it (XLink), JSON doesn't
	Instance reference:
	GET users/robbypelssers
	200 OK
	{
	"href": "http://api.mycompany.nl/users/robbypelssers",
	"firstname": "Robby",
	"lastname": "Pelssers",
	"age": 36,
	"phone": "phonenumberNew",
	"children": [
	{"href": "http://api.mycompany.nl/users/lindseypelssers"},
	{"href": "http://api.mycompany.nl/users/valeriepelssers"}
	]
	}
	* Reference expansion (aka Entity expansion, Link expansion)
	- reduce number of requests by allowing clients to specify expansion of specific properties
	GET users/robbypelssers?expand=children
	{
	"href": "http://api.mycompany.nl/users/robbypelssers",
	"firstname": "Robby",
	"lastname": "Pelssers",
	"age": 36,
	"phone": "phonenumberNew",
	"children": [
	{
	"href": "http://api.mycompany.nl/users/lindseypelssers",
	"firstname": "Lindsey",
	"lastname": "Pelssers",
	"age": 10
	},
	{
	"href": "http://api.mycompany.nl/users/valeriepelssers",
	"firstname": "Valerie",
	"lastname": "Pelssers",
	"age": 6
	}
	]
	}
	GET users/robbypelssers?expand=* --> expand everything 1 level deep
	* Partial representation
	GET users/robbypelssers?fields=firstname, lastname
	* Pagination
	Collection resource supports query params offset and limit
	GET /users?offset=50&limit=25
	GET /users
	Response: 200 OK
	{
	"href": "http://api.mycompany.nl/users"
	"limit": 25
	"offset": 0,
	"first": {"href": "http://api.mycompany.nl/users?offset=0"},
	"previous": null,
	"next": {"href": "http://api.mycompany.nl/users?offset=25"},
	"last": {"href": "http://api.mycompany.nl/users?offset=145"},
	"items": [
	{...},
	{...}
	]
	}
	* Errors
	- As descriptive as possible
	- As much information as possible
	- Developers are your customers
	POST /users
	Response: 409 conflict
	{
	"status": 409,
	"code": 40912,
	"exception": "UserAlreadyExistsException",
	"message: "A user 'robbypelssers' already exists",
	"href": "http://api.mycompany.nl/docs/api/errors/40912"
	}
	* IDs
	- should be opaque
	- Should be globally unique
	- Avoid sequential numbers (contention)
	- Good candidates (UUID, Url64)
	* HTTP Method overrides
	POST /user/robbypelssers?_method=DELETE
	* Caching and concurrency control
	- Server (initial response)
	Etag: "678988546345a76b"
	- Client (later request)
	If-None-Match: "678988546345a76b"
	- Server (later response)
	304: Not Modified
	* Security
	- Avoid sessions when possible
	- Authenticate every request if necessary
	- Stateless
	- Authorize based upon resource content, not URL
	- Use existing protocols: OAuth, Basic over SSL only
	- Use custom scheme
	- only if you provide client code / SDK
	- only if you really know what you're doing
	* Maintenance
	- Use HTTP Redirects
	- Create abstraction layer/ endpoints when migrating
	- Use well defined custom Media Types

view raw gistfile1.txt hosted with ❤ by GitHub

Using the loan pattern in Java

	In Java you often deal with a lot of boilerplate code. A typical example is
	opening an inputstream, using the inputstream and next closing it. But this
	simple use case takes writing quite a bit of code.Some of this boilerplate
	can be factored out by using the loan pattern, where the bank connects a
	producer and consumer and takes care of the heavy lifting. This code can be
	further generalized using generics but for illustrating purposes it serves
	as a nice example.
	**************************************************
	Consumer Interface *
	**************************************************
	public interface InputStreamConsumer {
	void consume(InputStream in) throws Exception;
	}
	**************************************************
	Producer Interface *
	**************************************************
	public interface InputStreamProducer {
	InputStream produce() throws Exception;
	}
	**************************************************
	Lender which connects producer and consumer *
	**************************************************
	public class InputStreamLender {
	public static void lend(InputStreamProducer producer, InputStreamConsumer consumer)
	throws Exception {
	InputStream in = null;
	try {
	in = producer.produce();
	consumer.consume(in);
	} finally {
	if (in != null) {
	in.close();
	}
	}
	}
	}
	**************************************************
	Util class providing implementation for *
	a InputstreamProvider *
	**************************************************
	public class InputStreamUtils {
	public static InputStreamProducer fromClassPath(final String path) {
	return new InputStreamProducer() {
	@Override
	public InputStream produce() throws Exception {
	return InputStreamUtils.class.getClassLoader().getResourceAsStream(path);
	}
	};
	}
	}
	**************************************************
	Small test class testing we get indeed an *
	inputstream to work with *
	**************************************************
	public class InputStreamLenderTest {
	@Test
	public void testInputStreamLender() throws Exception {
	InputStreamLender.lend(
	InputStreamUtils.fromClassPath("test.properties"),
	new InputStreamConsumer() {
	@Override
	public void consume(InputStream in) throws Exception {
	Assert.assertNotNull(in);
	}
	});
	}
	}
	**************************************************
	A class using our newly developed loan pattern *
	**************************************************
	public class PropertyLoader {
	public static Properties loadFromClassPath(String path) throws Exception{
	final Properties props = new Properties();
	InputStreamLender.lend(
	InputStreamUtils.fromClassPath(path),
	new InputStreamConsumer() {
	@Override
	public void consume(InputStream in) throws Exception {
	props.load(in);
	}
	});
	return props;
	}
	}
	**************************************************

view raw gistfile1.java hosted with ❤ by GitHub

XQuery3.0: Mimicking a FLWOR expression with higher-order functions

	xquery version "3.0";
	declare function local:flwor(
	$ctxt as item(),
	$find as function(item()) as item()*,
	$predicate as function(item()) as xs:boolean,
	$orderBy as function(item()) as item()) as item()* {
	for $result in $find($ctxt)
	where $predicate($result)
	order by $orderBy($result)
	return $result
	};
	declare function local:isMale($person as element(person)) as xs:boolean {
	$person/@gender = 'male'
	};
	declare function local:getPersons($persons as element(persons)) as element(person)* {
	$persons/person
	};
	let $persons :=
	<persons>
	<person gender="male">
	<country>Belgium</country>
	<name>John</name>
	<age>10</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Robby</name>
	<age>20</age>
	</person>
	<person gender="female">
	<country>Belgium</country>
	<name>Linda</name>
	<age>80</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>Davy</name>
	<age>40</age>
	</person>
	<person gender="female">
	<country>Netherlands</country>
	<name>Alice</name>
	<age>30</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Albert</name>
	<age>36</age>
	</person>
	</persons>
	let $getPersons := local:getPersons#1
	let $isMale := local:isMale#1
	return local:flwor(
	$persons,
	$getPersons,
	$isMale,
	function($person as element(person)) as item() { $person/name}
	)
	(:
	****************************************************************
	XQuery output: We expect a sequence of all males ordered by name
	****************************************************************
	<person gender="male">
	<country>Netherlands</country>
	<name>Albert</name>
	<age>36</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>Davy</name>
	<age>40</age>
	</person>
	<person gender="male">
	<country>Belgium</country>
	<name>John</name>
	<age>10</age>
	</person>
	<person gender="male">
	<country>Netherlands</country>
	<name>Robby</name>
	<age>20</age>
	</person>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Higher-Order functions (Functional composition)

	xquery version "3.0";
	declare function local:compose($f1 as function(item()) as item(), $f2 as function(item()) as item())
	as function(item()) as item() {
	function($item) as item() {
	$f2($f1($item))
	}
	};
	(: 5 * x - 2 :)
	let $linearFunction :=
	local:compose(
	function($number) {$number * 5},
	function($number) {$number - 2})
	(: 3 * x^2 - 4 :)
	let $quadraticFunction :=
	local:compose(
	function($number) {$number * $number * 3},
	function($number) {$number - 4})
	return
	<result>
	<test1>{$linearFunction(5)} should equal 5 * 5 - 2 = 23</test1>
	<test2>{$quadraticFunction(4)} should equal 3 * 4^2 - 4 = 44</test2>
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<test1>23 should equal 5 * 5 - 2 = 23</test1>
	<test2>44 should equal 3 * 4^2 - 4 = 44</test2>
	</result>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Higher-Order functions (Filtering)

	(:
	Below I show 2 different ways of using the filter function. Both do exactly the same but one uses
	an inline function expression while the other uses a named function reference
	:)
	(:
	*********************************************************************
	Example of using filter with inline function expression
	*********************************************************************
	:)
	return fn:filter(function($person) { $person/@gender = 'female'}, $persons/person)
	(:
	*********************************************************************
	Example of using filter with named function reference (predicate)
	*********************************************************************
	:)
	declare function local:isFemale($person as element(person)) as xs:boolean {
	$person/@gender = 'female'
	};
	let $isFemale := local:isFemale#1
	return fn:filter($isFemale, $persons/person)
	(:
	**********************************************
	XQuery output:
	**********************************************
	<person gender="female">
	<country>Belgium</country>
	<name>Person C</name>
	<age>80</age>
	</person>
	<person gender="female">
	<country>Netherlands</country>
	<name>Person E</name>
	<age>30</age>
	</person>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0: Partial function example

	xquery version "3.0";
	declare function local:increase($nums as xs:integer*, $by as xs:integer) as xs:integer* {
	$nums ! (. + $by)
	};
	let $numbers := (2,3,6,8,12,14)
	let $increaseByThree := local:increase(?, 3)
	let $increaseByFour := local:increase(?, 4)
	return
	<result>
	<test1>{$increaseByThree($numbers)}</test1>
	<test2>{$increaseByFour($numbers)}</test2>
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<test1>5 6 9 11 15 17</test1>
	<test2>6 7 10 12 16 18</test2>
	</result>
	:)

view raw gistfile1.txt hosted with ❤ by GitHub

XQuery3.0: Using simple map operator

	let $persons :=
	<persons>
	<person gender="male" country="Belgium">
	<name>Person A</name>
	<age>10</age>
	</person>
	<person gender="male" country="Netherlands">
	<name>Person B</name>
	<age>20</age>
	</person>
	<person gender="female" country="Belgium">
	<name>Person C</name>
	<age>80</age>
	</person>
	</persons>
	return
	<result>
	{
	for $person in $persons/person
	return
	<person>{$person ! (@gender, data(@country), '-', translate(name, 'Person ', ''))}</person>
	}
	</result>
	(:
	**********************************************
	XQuery output:
	**********************************************
	<result>
	<person gender="male">Belgium - A</person>
	<person gender="male">Netherlands - B</person>
	<person gender="female">Belgium - C</person>
	</result>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

XQuery3.0 Group by example

	return
	<groups>
	{
	for $person in $persons/person
	group by
	$country := $person/country,
	$gender := $person/@gender
	return
	<group country="{$country}" gender="{$gender}">
	<averageAge>{avg($person/age)}</averageAge>
	</group>
	}
	</groups>
	(:
	**********************************************
	Logical result
	**********************************************
	Belgium Netherlands
	Male Female Male Female
	---------------------------------------------
	A 10 C 80 B 20 E 30
	D 40 F 36
	---- ---- ---- -----
	25 80 28 30
	**********************************************
	XQuery output:
	**********************************************
	<groups>
	<group country="Belgium" gender="male">
	<averageAge>25</averageAge>
	</group>
	<group country="Belgium" gender="female">
	<averageAge>80</averageAge>
	</group>
	<group country="Netherlands" gender="male">
	<averageAge>28</averageAge>
	</group>
	<group country="Netherlands" gender="female">
	<averageAge>30</averageAge>
	</group>
	</groups>
	:)

view raw gistfile1.xquery hosted with ❤ by GitHub

Normalizing Unicode

	import java.text.Normalizer
	/**
	* Problem: Characters with accents or other adornments can be encoded in several different ways in Unicode
	* However, from a user point of view if they logically mean the same, text search should make no distinction
	* between the different notations. So it's important to store text in normalized unicode form. Code below shows
	* how to check if text is normalized and how you can normalize it.
	**/
	object NormalizationTest {
	def main(args: Array[String]) {
	val text = "16-bit transceiver with direction pin, 30 Ω series termination resistors;"
	println(text)
	println(Normalizer.isNormalized(text, Normalizer.Form.NFC))
	val normalizedText = Normalizer.normalize(text, Normalizer.Form.NFC)
	println(normalizedText)
	println(Normalizer.isNormalized(normalizedText, Normalizer.Form.NFC))
	}
	}
	/**
	* Output printed to console:
	* -------------------------------
	*
	* 16-bit transceiver with direction pin, 30 Ω series termination resistors;
	* false
	* 16-bit transceiver with direction pin, 30 Ω series termination resistors;
	* true
	*/

view raw gistfile1.scala hosted with ❤ by GitHub

Finding duplicate values with XQuery

As I'm always interested in benchmarks and optimized solutions I compared 3 strategies of finding duplicate values in a big sequence. This test will use 5000 randomly generated numbers and compare performance.
The first thing I needed to do was creating a sequence of 5000 randomly generated numbers. Scala comes to the rescue

Loading ....

This generates a file with following content. Remark: in reality that sequence contains 5000 numbers.

let $values := (1012,5345,2891,3833,2854, 2236)

Now I ran the following XQueries on Zorba to get a feeling about how fast they are.

XQuery 1: (takes about 5 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)
let $distinctvalues := distinct-values($values)
let $nonunique := for $value in $distinctvalues return if (count(index-of($values, $value)) > 1) then $value else ()
return $nonunique

XQuery 2: (takes about 5 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)
return $values[index-of($values, .)[2]]

XQuery 3: (takes about 1 seconds for 5000 numbers)

let $values := (1012,5345,2891,3833,2854, 2236)

return distinct-values(for $value in $values
  return if (count($values[. eq $value]) > 1)
         then $value
         else ())

Of course I got intrigued how Sedna would perform. I only tried XQuery1 (3 to 4 seconds) and XQuery3 (around 13 seconds) on my local machine, which only shows that you cannot always take the same approach while trying to optimize.

Debugging circular references in Maps

Today I learned another useful feature to debug circular references which can cause stackoverflows when not handled with caution. The below render method takes a parameter of type Map. In some cases the value is again a HashMap. Invoking entry.getValue() implicitly invokes the toString method in the Log.debug. When there are any circular references, you will get a nice stackoverflow.

    public String render(final String template,
            final Map<String, Object> parameters)
            throws IOException {

        final ST stringTemplate = new ST(template, '$', '$');

        if (parameters == null || parameters.isEmpty()) {
            LOG.warn("There are not any parameters passed to the template.");
        } else {
            for (Map.Entry<String, Object> entry : parameters.entrySet()) {
                stringTemplate.add(entry.getKey().replace(".", "_"),
                        (entry.getValue() instanceof String)
                        ? StringEscapeUtils.escapeXml(
                        entry.getValue().toString())
                        : entry.getValue());

                LOG.debug("Passing pipeline parameter as attribute: key={}"
                        + ", value={}", entry.getKey(), entry.getValue());
            }
        }

        return stringTemplate.render();
   

So you could e.g. write your own routine to find a clue where the problem is located but by following the Cocoon mailinglist I learned from Francesco that Commons Collections has a nice method to print a Map's content verbose. So I decided to experiment myself a bit to see how quickly I would find the issue using this approach and modified the code a bit.

for (Map.Entry<String, Object> entry : parameters.entrySet()) {
    stringTemplate.add(entry.getKey().replace(".", "_"),
        (entry.getValue() instanceof String)
         ? StringEscapeUtils.escapeXml(
         entry.getValue().toString())
         : entry.getValue());

     if (entry.getKey() == "cocoon")   MapUtils.verbosePrint(System.out, "cocoon", (Map) entry.getValue());
}

Now the output that got logged is listed below. I indented it a bit more properly but we can quickly see that "cocoon" has a "controller" which points back to "cocoon". --> (ancestor[0] Map)

cocoon = 
{
  response = org.apache.cocoon.servletservice.HttpServletResponseBufferingWrapper@12b13004
  settings = Settings:
      running mode : dev
      org.apache.cocoon.reload-delay : 1000
      org.apache.cocoon.reloading : false
      org.apache.cocoon.classloader.load.classes : 
      org.apache.cocoon.cache.directory : C:\workspaces\..\target\work\cache-dir
      org.apache.cocoon.work.directory : C:\workspaces\..\target\work
      org.apache.cocoon.formencoding : null
      org.apache.cocoon.containerencoding : UTF-8
  request = org.apache.cocoon.servlet.util.ObjectModelProvider$ObjectModelRequest@77d67cee
  context = org.apache.cocoon.servletservice.ServletServiceContext@7d91ec17
  controller = 
  {
    baseUrl = file:/C:/workspaces/apache/../src/main/resources/COB-INF/
    id = abc
    javax.servlet.http.HttpServletResponse = org.apache.cocoon.servletservice.HttpServletResponseBufferingWrapper@12b13004
    testProperty = test
    source = file:/C:/workspaces/apache/cocoon/cocoon3/trunk/cocoon-sample/src/main/resources/COB-INF/controller/demo.html
    javax.servlet.ServletContext = org.apache.cocoon.servletservice.ServletServiceContext@7d91ec17
    javax.servlet.http.HttpServletRequest = org.apache.cocoon.servletservice.util.ServletServiceRequest@5513fab7
    org.apache.cocoon.configuration.Settings = Settings:
        Running mode : dev
        org.apache.cocoon.reload-delay : 1000
        org.apache.cocoon.reloading : false
        org.apache.cocoon.classloader.load.classes : 
        org.apache.cocoon.cache.directory : C:\workspaces\..\target\work\cache-dir
        org.apache.cocoon.work.directory : C:\workspaces\..\target\work
        org.apache.cocoon.formencoding : null
        org.apache.cocoon.containerencoding : UTF-8
    name = foo
    cocoon = (ancestor[0] Map)
    reqparam = 1
  }
}

Constraints and Triggers - RDBMS

This article is meant as a quick lookup of constraints and trigger syntax. Besides most RDBMS's don't even implement the full SQL standard. Sqlite should be able to run below statements.

---------------------------------------------------------------------------
-----------------------------  CONSTRAINTS---------------------------------
---------------------------------------------------------------------------

***************************************************************************
create table Apply(sID int, cName text, major text, decision text, 
check(decision = 'N' or cName <> 'Stanford' or major <> 'CS'));


insert into Apply values(123, 'Stanford', 'CS', 'N');
insert into Apply values(123, 'MIT', 'CS', 'Y');
insert into Apply values(123, 'Stanford', 'CS', 'Y');

***************************************************************************
create table Student(sID int, sName text, GPA real, sizeHS int);

/* check constraints are not supported currently and neither are subqueries in constraints */
create table Apply(sID int, cName text, major text, decision text, 
  check(sID in (select sID from Student))); 
 
/* But this is an example of referential integrity */
  
  
***************************************************************************
/* Using assertions -- Currently not supported by RDBMS's */

create assertion Key
check ((select count(distinct A) from T) = (select count(*) from T)));

create assertion ReferentialIntegrity
check (not exists (select * from Apply where sID not in (select sID from Student)));

check assertion AvgAccept
check (3.0 < (select avg(GPA) from Student where sID in (select sID from Apply where decision = 'Y')));


***************************************************************************
create table College(cName text primary key, state text, enrollment int);
create table Student(sID int primary key, sName text, GPA real, sizeHS int);
create table Apply(sID int references Student(sID), cName text references College(cName), major text, decision text);

//using cascading update
create table Apply(sID int references Student(sID) on delete set null, 
                   cName text references College(cName) on update cascade, 
                   major text, decision text);
***************************************************************************

---------------------------------------------------------------------------
-----------------------------  TRIGGERS  ----------------------------------
---------------------------------------------------------------------------
***************************************************************************
create trigger R1
after insert on Student
for each row
when New.GPA > 3.3 and New.GPA <= 3.6
begin
  insert into Apply values (New.sID, 'Stanford', 'geology', null);
  insert into Apply values (New.sID, 'MIT', 'biology', null);
end;  
***************************************************************************
create trigger R2
after delete on Student
for each row 
begin
  delete from Apply where sID = Old.sID;
end;
***************************************************************************
create trigger R3
after update of cName on College
for each row
begin
  update Apply
  set cName = New.cName
  where cName = Old.cName;
end;
***************************************************************************
create trigger R4
before insert on College
for each row
when exists (select * from College where cName = New.cName)
begin
  select raise(ignore);
end;
***************************************************************************
create trigger R5
before update of cName on College
for each row 
when exists (select * from College where cName = New.cName)
begin
  select raise(ignore);
end;
***************************************************************************
create trigger R6
after insert on Apply
for each row
when (select count(*) from Apply where cName  = New.cName) > 10
begin
  update College set cName = cName || '-Done'
  where cName = New.cName;
end;  

***************************************************************************
create trigger R7
before insert on Student
for each row 
when New.sizeHS < 100 or New.sizeHS > 5000
begin
  select raise(ignore);
end;
***************************************************************************
create trigger AutoAccept
after insert on Apply
for each row 
when (New.cName = 'Berkeley' and
      3.7 < (select GPA from Student where sID = New.sID) and
      1200 < (select sizeHS from Student where sID = New.sID))
begin
  update Apply
  set decision = 'Y'
  where sID = New.sID
  and cName = New.cName;
end;
***************************************************************************
create trigger TooMany
after update of enrollment on College
for each row
when (Old.enrollment <= 16000 and New.enrollment > 16000)
begin
  delete from Apply where cName = New.cName and major = 'EE';
  update Apply
  set decision = 'U'
  where cName = New.cName
  and decision = 'Y';
end;
     

Using sqlite with Firefox sqlite-manager extension

The Stanford database course is using sqlite to experiment with SQL, Constraints, Triggers and so on. As the downloadable executable from this site only has a command line interface I decided to search for a GUI manager for sqlite. I am currently trying the firefox add-on which seems to work just fine.

/* First we create a table with a tuple constraint */
create table Apply(sID int, cName text, major text, decision text, 
check(decision = 'N' or cName <> 'Stanford' or major <> 'CS'));

/* next we try to insert a few tuples but the 3rd one should throw a constraint violation exception */
insert into Apply values(123, 'Stanford', 'CS', 'N');
insert into Apply values(123, 'MIT', 'CS', 'Y');
insert into Apply values(123, 'Stanford', 'CS', 'Y');

Merging CSV and XML data with fast performance

This blogpost will show a simple demo of how you can merge XML data with additional data coming from a Comma Separated File. Again I just made up some testdata for demo purpose. But just to give some numbers, my real use case merged data from a 242MB XML file and a CSV file in less than 5 seconds using of course Saxon.

nxp10009@NXL01366 /c/xsltdemo
$ ls -la
total 4786
drwxr-xr-x    6 nxp10009 Administ        0 Feb 15 16:35 .
drwxr-xr-x    1 nxp10009 Administ    12288 Feb 15 16:19 ..
-rw-r--r--    1 nxp10009 Administ  9788993 Oct 30 13:42 Saxon-HE-9.4.jar
drwxr-xr-x    4 nxp10009 Administ        0 Feb 15 16:34 input
drwxr-xr-x    4 nxp10009 Administ        0 Feb 15 17:18 output
drwxr-xr-x    4 nxp10009 Administ        0 Feb 15 17:03 xslt


nxp10009@NXL01366 /c/xsltdemo/input
$ ls -la
total 1
drwxr-xr-x    4 nxp10009 Administ        0 Feb 15 16:34 .
drwxr-xr-x    6 nxp10009 Administ        0 Feb 15 16:35 ..
-rw-r--r--    1 nxp10009 Administ       47 Feb 15 16:46 studentinfo.csv
-rw-r--r--    1 nxp10009 Administ      576 Feb 15 17:13 students.xml

studentinfo.csv

1, m, developer
2, m, developer
3, f, model

students.xml

<?xml version="1.0" encoding="UTF-8" ?>
<students>
  <student>
    <firstname>Robby</firstname>
    <lastname>Pelssers</lastname>
    <dateofbirth>1977-02-07</dateofbirth>
    <studentid>1</studentid>
  </student>
  <student>
    <firstname>Ivan</firstname>
    <lastname>Lagunov</lastname>
    <dateofbirth>1987-04-30</dateofbirth>
    <studentid>2</studentid>
  </student>
  <student>
    <firstname>Pamela</firstname>
    <lastname>Anderson</lastname>
    <dateofbirth>1967-07-01</dateofbirth>
    <studentid>3</studentid>
  </student>  
</students>

So the first thing I did was creating an XML representation of that CSV file using below xslt.
studentinfo.xslt

<?xml version="1.0" encoding="UTF-8"?>
<!--
Author: Robby Pelssers

Transforms studentinfo.csv into XML representation

Usage from DOS-Shell:
java -jar Saxon-HE-9.4.jar -o:C:/xsltdemo/output/studentinfo.xml -it:main -xsl:C:/xsltdemo/xslt/studentinfo.xslt studentinfoCSV=file:/C:/xsltdemo/input/studentinfo.csv

-->

<xsl:stylesheet version="2.0" 
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  
  <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
  <xsl:param name="studentinfoCSV" />
  

  <xsl:variable name="linefeed" select="'\r?\n'"/>
  <xsl:variable name="csv" select="unparsed-text($studentinfoCSV)"/>  

  
  <xsl:template match="/" name="main">
    <info>
      <xsl:for-each select="tokenize($csv, $linefeed)">
        <xsl:variable name="fields" select="tokenize(., ',')"/>
        <studentinfo id="{normalize-space($fields[1])}">
          <gender><xsl:sequence select="normalize-space($fields[2])"/></gender>
          <profession><xsl:sequence select="normalize-space($fields[3])"/></profession>
        </studentinfo>  
      </xsl:for-each>
    </info>
  </xsl:template>

</xsl:stylesheet>

So after the transformation a new file studentinfo.xml gets generated as below.

<?xml version="1.0" encoding="UTF-8"?>
<info>
   <studentinfo id="1">
      <gender>m</gender>
      <profession>developer</profession>
   </studentinfo>
   <studentinfo id="2">
      <gender>m</gender>
      <profession>developer</profession>
   </studentinfo>
   <studentinfo id="3">
      <gender>f</gender>
      <profession>model</profession>
   </studentinfo>
</info>

So now we need to execute a second transform using as input students.xml and studentinfo.xml.
student_addinfo.xslt

<?xml version="1.0" encoding="UTF-8"?>
<!--
Author: Robby Pelssers

java -Xmx1024m -jar Saxon-HE-9.4.jar -s:C:/xsltdemo/input/students.xml -o:C:/xsltdemo/output/students-full.xml -xsl:C:/xsltdemo/xslt/student_addinfo.xslt studentinfoXML=file:/C:/xsltdemo/output/studentinfo.xml
-->

<xsl:stylesheet version="2.0"
  xmlns:xsl="http://www.w3.org/1999/XSL/Transform">

  <xsl:output method="xml" version="1.0" encoding="UTF-8" indent="yes"/>
  <xsl:param name="studentinfoXML" />

  <xsl:variable name="studentinfoDocument" select="document($studentinfoXML)"/>

  <xsl:key name="student-lookup" match="studentinfo" use="@id"/>

  <xsl:template match="/">
    <xsl:apply-templates/>
  </xsl:template>

  <xsl:template match="student">
    <student>
      <!-- we copy all present attributes and children -->
      <xsl:apply-templates select="@* | node()"/>
      <!-- now we also want to add the additional information as children --> 
      <xsl:apply-templates select="key('student-lookup', studentid, $studentinfoDocument)/*"/>
    </student>
  </xsl:template>
 
  <xsl:template match="@*|node()">
    <xsl:copy>
      <xsl:apply-templates select="@*"/>
      <xsl:apply-templates/>
    </xsl:copy>
  </xsl:template> 


</xsl:stylesheet>

And finally we get the merged result:

<?xml version="1.0" encoding="UTF-8"?>
<students>
  <student>
      <firstname>Robby</firstname>
      <lastname>Pelssers</lastname>
      <dateofbirth>1977-02-07</dateofbirth>
      <studentid>1</studentid>
      <gender>m</gender>
      <profession>developer</profession>
   </student>
  <student>
      <firstname>Ivan</firstname>
      <lastname>Lagunov</lastname>
      <dateofbirth>1987-04-30</dateofbirth>
      <studentid>2</studentid>
      <gender>m</gender>
      <profession>developer</profession>
   </student>
  <student>
      <firstname>Pamela</firstname>
      <lastname>Anderson</lastname>
      <dateofbirth>1967-07-01</dateofbirth>
      <studentid>3</studentid>
      <gender>f</gender>
      <profession>model</profession>
   </student>  
</students>

XQuery demo using Zorba for Stanford DBClass

I decided to build a more appealing demo showing the potential of XQuery for building webpages. In this demo I render a table showing countries with a population greater than 100 million and which have languages listed. The languages are listed as pie charts using the Google Chart API.

XQuery used on countries XML data.

import module namespace http = "http://expath.org/ns/http-client";

declare %an:sequential function local:doc($href as xs:string) {
  http:send-request(<http:request href="{$href}" method="GET" />)[2] 
};


let $doc := local:doc("http://prod-c2g.s3.amazonaws.com/db/Winter2013/files/countries.xml")
let $bigCountries := $doc/countries/country[@population > 100000000 and exists(language)]

return
<html>
  <head>
    <title>Visualization of languages for countries with population greater than 100 million</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> </meta>
    <style type="text/css">
      table {{
        border-collapse: collapse;
      }}
      caption {{
        background-color: #ADAEAF;
        text-align: left;
      }}
      .header {{
        background-color: #E6F1F3;
      }}
      td, th {{
        border: 1px dotted #B3D4DB;
        padding: 2px;
        vertical-align: top;
        text-align: left;
      }}
    </style>
    <script type="text/javascript" src="https://www.google.com/jsapi"> </script>
    <script type="text/javascript">

      // Load the Visualization API and the piechart package.
      google.load('visualization', '1.0', {{'packages':['corechart']}});
  
      // Set a callback to run when the Google Visualization API is loaded.
      google.setOnLoadCallback(drawCharts);

      function drawChart(percentages, countryName) {{
        // Create the data table.
        var data = new google.visualization.DataTable();
        data.addColumn('string', 'Country');
        data.addColumn('number', 'percentage');
        data.addRows(percentages);

        // Set chart options
        var options = {{'title':'Languages',
                       'width':400,
                       'height':300}};

        // Instantiate and draw our chart, passing in some options.
        var chart = new google.visualization.PieChart(document.getElementById(countryName));
        chart.draw(data, options);
      }}
   
      function drawCharts() {{
        {
           for $country in $bigCountries
           let $data := string-join(for $lang in $country/language return concat('["', data($lang), '",', data($lang/@percentage), ']'), ',')
           return concat('drawChart([', $data, '],  "', data($country/@name),'");
')
        }
      }}  
    </script> 
  </head>
  <body>
    <table>
      <caption>Countries with population greater than 100 million</caption>
      <thead>
        <tr class="header">
          <th>Name</th>
          <th>Population</th>
          <th>Area</th>
          <th>Languages</th>
        </tr>
      </thead>
      <tbody>
        {
           for $country in $bigCountries
           order by count($country/language) descending
           return
             <tr>
               <td>{data($country/@name)}</td>
               <td>{data($country/@population)}</td>
               <td>{data($country/@area)}</td>
               <td><div id="{data($country/@name)}"></div></td>
             </tr>
        }
      </tbody>
    </table>
  </body>
</html>

Result from executing XQuery on Zorba

<html>
  <head>
    <title>Visualization of languages for countries with population greater than 100 million</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
    <style type="text/css">
      table {
        border-collapse: collapse;
      }
      caption {
        background-color: #ADAEAF;
        text-align: left;
      }
      .header {
        background-color: #E6F1F3;
      }
      td, th {
        border: 1px dotted #B3D4DB;
        padding: 2px;
        vertical-align: top;
        text-align: left;
      }
    </style>
    <script type="text/javascript" src="https://www.google.com/jsapi"> </script>
    <script type="text/javascript">

      // Load the Visualization API and the piechart package.
      google.load('visualization', '1.0', {'packages':['corechart']});
  
      // Set a callback to run when the Google Visualization API is loaded.
      google.setOnLoadCallback(drawCharts);

      function drawChart(percentages, countryName) {
        // Create the data table.
        var data = new google.visualization.DataTable();
        data.addColumn('string', 'Country');
        data.addColumn('number', 'percentage');
        data.addRows(percentages);

        // Set chart options
        var options = {'title':'Languages',
                       'width':400,
                       'height':300};

        // Instantiate and draw our chart, passing in some options.
        var chart = new google.visualization.PieChart(document.getElementById(countryName));
        chart.draw(data, options);
      }
   
      function drawCharts() {
        drawChart([["Hindi",30]],  "India");
        drawChart([["Japanese",100]],  "Japan");
        drawChart([["Pashtu",8],["Urdu",8],["Punjabi",48],["Sindhi",12],["Balochi",3],["Hindko",2],["Brahui",1],["Siraiki",10]],  "Pakistan");
        drawChart([["Russian",100]],  "Russia");
      }  
    </script>
  </head>
  <body>
    <table>
      <caption>Countries with population greater than 100 million</caption>
      <thead>
        <tr class="header">
          <th>Name</th>
          <th>Population</th>
          <th>Area</th>
          <th>Languages</th>
        </tr>
      </thead>
      <tbody>
        <tr>
          <td>Pakistan</td>
          <td>129275664</td>
          <td>803940</td>
          <td>
            <div id="Pakistan"/>
          </td>
        </tr>
        <tr>
          <td>India</td>
          <td>952107712</td>
          <td>3287590</td>
          <td>
            <div id="India"/>
          </td>
        </tr>
        <tr>
          <td>Japan</td>
          <td>125449704</td>
          <td>377835</td>
          <td>
            <div id="Japan"/>
          </td>
        </tr>
        <tr>
          <td>Russia</td>
          <td>148178480</td>
          <td>17075200</td>
          <td>
            <div id="Russia"/>
          </td>
        </tr>
      </tbody>
    </table>
  </body>
</html>

So what does this page look like in a browser?

Generating HTML and Excel with Xquery

I just wanted to share a small sample how you can generate a table in both HTML and Excel with one XQuery. Just in case the sample gets lost I will still share the code in this article as well.
A few remarks. You can save the result to a file test.html and test.xls. For the excel file you will need to remove the xml declaration (first line).

let $orders :=
<orders>
  <order id="1231">
    <product>Samsung Galaxy S3</product>
    <price valuta="EURO">467</price>
    <quantity>3</quantity>
  </order>
  <order id="1232">
    <product>iPhone 5</product>
    <price valuta="EURO">689</price>
    <quantity>5</quantity>
  </order>
  <order id="1233">
    <product>LG E610 Optimus L5</product>
    <price valuta="EURO">140</price>
    <quantity>2</quantity>
  </order>   
</orders>

return
<html xmlns:x="urn:schemas-microsoft-com:office:excel">
  <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"> </meta>
    <meta http-equiv="Content-Type" content="application/vnd.ms-excel; charset=utf-8"> </meta>
    <style type="text/css">
      table {{
        border-collapse: collapse;
      }}
      .header {{
        background-color: #E6F1F3;
        text-align: left;
      }}
      td, th {{
        border: 1px dotted #B3D4DB;
        padding: 2px;
      }}
      .number {{
        text-align: right;
      }}
      .subtotal {{
        background-color: #E3E4E5; 
        text-align: right;
        font-weight: bold;
      }}
      .total {{
        background-color: #ADAEAF;
        text-align: right;
        font-weight: bold;        
      }}
    </style>
  </head>
  <body>
    <table>
      <colgroup>
        <col style="width: 100px;"/>
        <col style="width: 200px;"/>
        <col style="width: 100px;"/>
        <col style="width: 100px;"/>
      </colgroup>          
      <thead>
        <tr>
          <th class="header">Order No</th>
          <th class="header">Product</th>
          <th class="header">Price</th>
          <th class="header">Quantity</th>
        </tr>
      </thead>
      <tbody>
      {
        for $order in $orders/order
        let $price := data($order/price)
        let $quantity := data($order/quantity)
        let $subtotal := $price * $quantity
        return
        (
        <tr>
          <td>{data($order/@id)}</td>
          <td>{data($order/product)}</td>
          <td class="number">{$price}</td>
          <td class="number">{$quantity}</td>
        </tr>,
        <tr>
          <td class="subtotal"/>
          <td class="subtotal"/>
          <td class="subtotal">Subtotal</td>
          <td class="subtotal">{$subtotal}</td>
        </tr>
        )
      }
        <tr>
          <td class="total"/>
          <td class="total"/>
          <td class="total">Total</td>
          <td class="total">{sum(for $order in $orders/order return data($order/price) * data($order/quantity))}</td>
        </tr>
      </tbody>
    </table>
  </body>
</html>  

You will get a warning from Excel but I already looked into this and there is no workaround available at this moment. I also noticed that when opening such a file from Internet Explorer it seems to hang the first time. A workaround it to Save the file the first time and open it. From that moment on Internet Explorer will be able to open the files correctly.

Rendering tweets with Play2.1

Tweet Controller

package controllers

import play.api.mvc.{Action, Controller}
import play.api.libs.functional.syntax._

import play.api.libs.json._
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.ws.WS

case class Tweet(from: String, text: String)

object Tweets extends Controller {

  implicit val tweetReads = (
    (__ \ "from_user_name").read[String] and
    (__ \ "text").read[String]
    )(Tweet)


  def tweetList(query: String) = Action {
    Async {
      val results = 10
      val responsePromise =
        WS.url("http://search.twitter.com/search.json")
          .withQueryString("q" -> query, "rpp" -> results.toString).get
      responsePromise.map {
        response =>
          val tweets = Json.parse(response.body).\("results").as[Seq[Tweet]]
          Ok(views.html.tweetlist(tweets))
      }
    }
  }
}

routes

GET     /tweets/:query              controllers.Tweets.tweetList(query: String)

scala template:

@(tweets: Seq[Tweet])
@main("Tweets!") {
    
Tweets:
    @tweets.map { tweet =>
      

        
@tweet.from: @tweet.text
      
    }
}

So invoking following URL http://localhost:9000/tweets/playframework now gives me the last 10 tweets containing playframework (case insensitive). I think it's pretty slick how little code is needed.