Coding Standards

Don't's

• Using null in Scala code is not idiomatic at all.

  • private var author:Author = null

• If you can't give a default value, you really should use

  • var author: Option[Author] = None

• Don't rebind names for different uses:

  • Use vals

• Avoid using 's to overload reserved names:

  • typ instead of 'type'

• Don't prefix getters with get

  • money.count not money.getCount

• Do not use relative imports from other packages :

     Avoid

          import com.twitter

          import concurrent

    In favor of the unambiguous

          import com.twitter.concurrent

• The return keyword exits from the enclosing method, not the enclosing function. It behaves like a restricted throw, so don't use return unless it's in an exceptional situation where an API mandates error codes.  In all other situations, prefer Option, Either, case classes, or, if necessary, exceptions.
  
  
• Do not use structural types in normal use.

private type FooParam = {
 val baz: List[String => String]
 def bar(a: Int, b: Int): String
}
def foo(a: FooParam) = ...

Do's

• Use short names for small scopes:
  • is,js and ks are all but expected in loops
• Use longer names for larger scopes:
  • External API's should have longer and explanatory names that confer meaning,  Future.collect not Future.all.
• Use common abbreviations:
  • Ex: ok, err
• Use active names for operations with side effects:
  • user.activate() not user.setActive()
• Use descriptive names for methods that return values:
  • file.isDir not file.dir
• Use private[this] = visibility to the particular instance. Sometimes it aids performance optimizations.

• In singleton class types , visibility can be constrained by declaring the returned type:  

def foo(): Foo with Bar = new Foo with Bar with Baz {
            ...
      }

Traits

• Traits that contain implementation are not directly usable from Java: extend an abstract class with the trait instead.

// Not directly usable from Java
        trait Animal {
           def eat(other: Animal)
           def eatMany(animals: Seq[Animal) = animals foreach(eat(_))
         }
// But this is:
abstract class JavaAnimal extends Animal

• Keep traits short and orthogonal: don’t lump separable functionality into a trait, think of the smallest related ideas that fit together.   

  For example, imagine you have an something that can do IO:

  trait IOer {
          def write(bytes: Array[Byte])
          def read(n: Int): Array[Byte]
   }

separate the two behaviors:

  trait Reader {
        def read(n: Int): Array[Byte]
    }
   trait Writer {
       def write(bytes: Array[Byte])
   }

and mix them together to form what was an IOer:

new Reader with Writer…

Names

Don't repeat names that are already encapsulated in package or object name.
Prefer:

object User{
	def user(id: Int): Option[User]
}

Instead of:

object User{
	def getUser(id: Int): Option[User]
}

Pattern Matching

• Use pattern matching directly in function definitions whenever applicable

        Use this :    

   list map {
                 case Some(x) => x
                 case None => default
            }

  Instead of :

  list map { item =>
                  item match {
                      case Some(x) => x
                      case None => default
                 } }

  
  

• Pattern matching works best when also combined with destructuring

  Use this:

  animal match {
  	case Dog(breed) => "dog (%s)".format(breed)
  	case other => other.species
  }

  Instead of:

   animal match {
          case dog: Dog => "dog (%s)".format(dog.breed)
          case _ => animal.species
       }

Don't use pattern matching for conditional execution when defaults make more sense.

Use:

val x = list.headOption getOrElse default

NOT:

 val x = list match {
             case head :: _ => head
             case Nil => default
         }

• Scala provides an exception facility, but do not use it for commonplace errors, Instead, encode such errors explicitly: using Option

Use: 

trait Repository[Key, Value] {
          def get(key: Key): Option[Value]
     }

Instead of:

trait Repository[Key, Value] {
          def get(key: Key): Value
      }

• Use the following style:    

/**
     * ServiceBuilder builds services
     * ...
*/

/** ServiceBuilder builds services
     * ...
*/

def make(): Service = new Service{}

trait Service
def make() = new Service {
  def getId = 123
}

import scala.collection.mutable
val set = mutable.Set()

  val stream = getClass.getResourceAsStream("someclassdata")
               assert(stream != null)

def fib(n: Int) = {
require(n > 0)
  ...
  }

  try {
        operation()
      } catch {
          case _ => ...
      }    // almost always wrong, as it would catch fatal errors that need to be propagated.

import scala.util.control.NonFatal
...
  try {
      operation()
     } catch {
          case NonFatal(exc) => ...
    }

import scala.util.{Try, Success, Failure}
...
  val result: Try[ResultType] = Try( operation() )
  result match {
    case Success(v) => ... //do something with the return value
    case Failure(ex) => ... //non-fatal error handling here
  }

if (cond) {
  result
} else {
  otherResult
}

for (x <- y if cond) yield {
  operation(x)
}

while (notDone()) {
  doTheThing()
}