... jonjack

Deploy your site with git

This gist assumes:

you have a local git repo
with an online remote repository (github / bitbucket etc)
and a cloud server (Rackspace cloud / Amazon EC2 etc)
- your (PHP) scripts are served from /var/www/html/
- your webpages are executed by apache
apache's home directory is /var/www/

This post aims to document a practical design implementation we came up with when designing some APIs in Scala. Of course the concept is not Scala specific and applies to other functional languages.

If you don't want to go into the full introduction, this post talks about how Applicatives are too restrictive and breaking them into two independent components can be interesting for Contravariant and Invariant Functors. Jump to implementation attached.

We are taking JSON serialization/deserialization as a motivating example.

JsValue is the name of the type that represents the JSON AST. What we need is to be able to read a JsValue and produce an A:

trait Reads[A]{

Scala for comprehension translation helper

"For comprehension" is a another syntaxe to use map, flatMap and withFilter (or filter) methods.

yield keyword is used to aggregate values in the resulting structure.

This composition can be used on any type implementing this methods, like List, Option, Future...

Asynchronicity is the price to pay, you better know what you're paying for...

Let's share some vocabulary first:

Thread: The primitive responsible of executing code on the processor, you can give an existing (or a new) Thread some code, and it will execute it. Normally you can have a few hundreds on a JVM, arguments that you can tweak your way out to thousands. Worth noting that multitasking is achieved when using multiple Threads. Multiple Threads can exist for a single processor in which case multitasking happens when this processor switches between threads, called context switching, which will give the impression of things happenning in parallel. An example of a direct, and probably naive, use of a new Thread in Java:

public class MyRunnable implements Runnable {
  public void run(){
 System.out.println("MyRunnable running");

Chunck by chunk

def  transform = Action {
    
     val fileStream: Enumerator[Array[Byte]] = {
         Enumerator.fromFile(new File("data.txt"))
     }
     
     val transfo = Enumeratee.map[Array[Byte]]{byteArray =>

	// Question at http://stackoverflow.com/q/7084212/53013
	// Results at https://gist.github.com/1152764

	import scala.collection.mutable.{ArrayBuffer, ListBuffer}
	import scala.util.Random

	object BenchCode extends scala.testing.Benchmark with Algorithms {
	var xs: List[Int] = Nil
	var acc = 0
	var code: List[Int] => List[Int] = (identity _)

	dcs@ayanami:~/tmp$ scala BenchCode 100000 5 100
	Warming up Adrian, functional/indexOf
	Warming up Adrian, functional/span
	Warming up Adrian, imperative/ArrayBuffer
	Warming up Adrian, imperative/ListBuffer
	Warming up user unknown, recursive
	Warming up user unknown, fold
	Warming up paradigmatic, recursive
	Warming up paradigmatic, fold
	Warming up soc

	def Secured[A](username: String, password: String)(action: Action[A]) = Action(action.parser) { request =>
	request.headers.get("Authorization").flatMap { authorization =>
	authorization.split(" ").drop(1).headOption.filter { encoded =>
	new String(org.apache.commons.codec.binary.Base64.decodeBase64(encoded.getBytes)).split(":").toList match {
	case u :: p :: Nil if u == username && password == p => true
	case _ => false
	}
	}.map(_ => action(request))
	}.getOrElse {
	Unauthorized.withHeaders("WWW-Authenticate" -> """Basic realm="Secured"""")

	scala> :javap MongoDB
	public class MongoDB$ extends java.lang.Object {
	public static final MongoDB$ MODULE$; // actual instance of our `object`
	public static {};
	public MongoDB$();
	// ...
	}

	# Compiled source #
	###################
	*.com
	*.class
	*.dll
	*.exe
	*.o
	*.so

	# Packages #