| object game { | |
| case class Lens[S, A](set: A => S => S, get: S => A) { self => | |
| def >>> [B](that: Lens[A, B]): Lens[S, B] = | |
| Lens[S, B]( | |
| set = (b: B) => (s: S) => self.set(that.set(b)(self.get(s)))(s), | |
| get = (s: S) => that.get(self.get(s)) | |
| ) | |
| } | |
| case class Prism[S, A](set: A => S, get: S => Option[A]) { self => |
Copyright © 2016-2018 Fantasyland Institute of Learning. All rights reserved.
A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.
val square : Int => Int = x => x * x
| scala> class Foo { self: Singleton => } | |
| defined class Foo | |
| scala> class Bar extends Foo | |
| <console>:12: error: illegal inheritance; | |
| self-type Bar does not conform to Foo's selftype Foo with Singleton | |
| class Bar extends Foo | |
| ^ | |
| scala> object Bar extends Foo |
| // http://slid.es/julientournay/a-monad-is-just-a-monoid-in-the-category-of-endofunctors-what-s-the-problem | |
| trait Functor[F[_]] { | |
| def map[Y, Z](x: F[Y])(f: Y => Z): F[Z] | |
| } | |
| trait ListFunctor extends Functor[List] { | |
| def map[Y, Z](xs: List[Y])(f: Y => Z) = xs.map(f) | |
| } | |
| object ListFunctor extends ListFunctor |
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");
| def breakIf[T: ClassTag](assertion: => Boolean, args: NamedParam*): Unit = | |
| if (assertion) break[T](args.toList) | |
| // start a repl, binding supplied args | |
| def break[T: ClassTag](args: List[NamedParam]): Unit = savingContextLoader { | |
| val msg = if (args.isEmpty) "" else " Binding " + args.size + " value%s.".format( | |
| if (args.size == 1) "" else "s" | |
| ) |
One of the goals of Play2 architecture is to provide a programming model for what is called Realtime Web Applications.
Realtime Web Applications are applications that make use of Websockets, Server Sent Events, Comet or other protocols offering/simulating an open socket between the browser and the server for continuous communication. Basically, these applications let users work with information as it is published - without having to periodically ping the service.
There are quite a few web frameworks that target the development of this type of application: but usually the solution is to simply provide an API that allows developers to push/receive messages from/to an open channel, something like:
| Latency Comparison Numbers (~2012) | |
| ---------------------------------- | |
| L1 cache reference 0.5 ns | |
| Branch mispredict 5 ns | |
| L2 cache reference 7 ns 14x L1 cache | |
| Mutex lock/unlock 25 ns | |
| Main memory reference 100 ns 20x L2 cache, 200x L1 cache | |
| Compress 1K bytes with Zippy 3,000 ns 3 us | |
| Send 1K bytes over 1 Gbps network 10,000 ns 10 us | |
| Read 4K randomly from SSD* 150,000 ns 150 us ~1GB/sec SSD |
| #!/usr/bin/env sh | |
| ## | |
| # This is script with usefull tips taken from: | |
| # https://github.com/mathiasbynens/dotfiles/blob/master/.osx | |
| # | |
| # install it: | |
| # curl -sL https://raw.github.com/gist/2108403/hack.sh | sh | |
| # |