ClaireNeveu

object TestConfig extends com.kinja.config.ConfigApi {
  val root = com.kinja.config.BootupErrors(com.kinja.config.LiftedTypesafeConfig(testConf, "root"));
  def <init>() = {
    super.<init>();
    ()
  };
  private val subConfig = getConfig("sub-config");
  val pureValue = 5;
  val otherPureValue: Int = 7;
  val somePureValue: Option[Int] = Some(8);

ClaireNeveu

import Prelude hiding (max)

data Tree
 = Alpha Int [Tree]
 | Beta String [Tree]
 | Gamma Bool [Tree]

children :: Tree -> [Tree]
children (Alpha _ ch) = ch
children (Beta _ ch) = ch

ClaireNeveu

A lot of people have difficulty understanding type-classes​. This has a lot more to do with the context of type-classes than type-classes themselves; Haskell, the foremost language with type-classes, also includes more complicated concepts enabled by type-classes. People often conflate these concepts with type-classes themselves.

Type-classes in Scala are similarly conflated with more complicated concepts and have the added detriment of being a pattern rather than a language feature.

In this post I'll explain type-classes by relating them to somehting everybody understands: the List interface in Java.

public interface List<E> {
   public E get(int index) = ...
   public int size() = ...

ClaireNeveu

Good name for a caching proxy: QuickMoney "fast cache" == "fast cash" == "quick money"

ClaireNeveu

 -Dproperty=value                Pass -Dproperty=value directly to the runtime system.
  -J<flag>                        Pass <flag> directly to the runtime system.
  -P:<plugin>:<opt>               Pass an option to a plugin
  -X                              Print a synopsis of advanced options.
  -bootclasspath <path>           Override location of bootstrap class files.
  -classpath <path>               Specify where to find user class files.
  -d <directory|jar>              destination for generated classfiles.
  -dependencyfile <file>          Set dependency tracking file.
  -deprecation                    Emit warning and location for usages of deprecated APIs.
  -encoding <encoding>            Specify character encoding used by source files.

ClaireNeveu

Instead of simple case classes we make use of a system of Extensible Virtual Models to describe our models. This has the practical advantage of making these models run-time extensible while maintaining type-safety. This document serves as a brief introduction to this system and explains how it relates to normal case classes.

Consider this simplified version of a Post and a function which operates on it:

case class Post(id : Id[Post], authorId : Id[Author], blogId : Id[Blog], title : String, body : Html)

def escapeBody(post : Post) : Post = ...

The model contains the Post's id, title, and body as well as foreign keys to its author and blog. This serves us well for many cases but sometimes we want to access properties of the author or blog of this post. Because retrieving these models requires API calls to the relevant service, we'd like to pass these models around with the post so we only retrieve them once.

ClaireNeveu

ADT fields should be strict in the general case. This usually reduces memory usage without impacting CPU usage. There are exceptions.

The standard indentation level is 4; indentation should always be done with spaces.

The following ADT definitions are acceptable.

data Foo 
  = Bar Int Int Int
  | Baz String String String
 | Qux Int String

ClaireNeveu

package versioning

case class Version(n : Int)

object Version {
	class CurriedVersion private[versioning] (v : Version, lb : Int) {
		def and(ub : Int) = v.n >= lb && v.n < ub
	}
	class CurriedVersion0 private[versioning] (v : Version, lb : Int) {
		def <(ub : Int) : Boolean = v.n >= lb && v.n < ub

ClaireNeveu

The standard indention level is 3 and indentation should be done with spaces.

if (true) {
   val foo = ...
   ...
}

Brackets should only be used when a block is required. If the block can be replaced by a single expression, the single expression is preferred.

ClaireNeveu

package com.serialization

trait CanSerialize[A] {
	def serialize0(a: A): String
}

package object compact {
	import com.model._

	val compactBlogSerializer = new CanSerialize[Blog] {