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