eboto

// This example produces a compiler error in Scala 2.9.1 and 2.9.2. It works fine in Scala 2.10M7.
// The error text is:  "java.lang.Error: symbol value blobKey does not exist in Crasher$$anonfun$1.apply"

object Crasher {
  def main(args: Array[String]) {
    println("This will never be printed because the compiler will crash")
  }
}

class Crasher { // this can be a trait, class, object, whatever

eboto

/*
 * Let's authenticate an attempted email and password against our database in two different ways
 * using scala. Authentication can fail due to: 
 *   (1) No account matching the e-mail (findByEmail(someEmail) can be either None or Some(Account))
 *   (2) No password being associated with the account (account.password can be either None 
 *       or Some(Password))
 *   (3) The password for the account was incorrect (password.is(attempt) returns true or false)
 *
 * We'll take two different approaches: one using a series of pattern matches and another using
 * for comprehensions. Which is more readable? Which is more idiomatic? <gruff military voice> I'm 

eboto

# make_git_test_tree.sh
#
# This script sets up a git repository with a particular branch layout. Playing around with rebasing and merging
# the branches should help your understanding of git.
#
# Make sure you're in a goddamned empty directory when you execute this script. The script
# shouldn't be in the same directory.
#
# Here's an example, assuming this file is in the current working directory:
#

eboto

//
// Demonstration on how to use Scala's Either[A, B] type to include error cases in function return values
// and eventually transform those domain errors into more useful end types, like Redirects.
//
// This demonstration uses the example of ordering a product, where ordering can fail for a variety
// of reasons including failure in our payment provider (Stripe) or failure due to insufficient
// product inventory.
//

object Main {

eboto

//
// A demonstration of using multiple traits to mix in multiple "Before" hooks,
// with an intended usage in test code.
//
// The demonstration shows that multiple traits inheriting BeforeEach (or more
// germanely scalatest's BeforeAndAfterEach) can be sufficiently composable to use
// in our testing toolchain without sewing our own strait jacket.
//

object Main {

eboto

// A demonstration of how to make composition a first (or 1.5th) class
// citizen in Scala OO code, as it is better to favor composition
// over inheritance.
//
// The basic idea is to create a sister trait named "MyTraitComposition" to your
// base trait. The composition trait specifies an abstract member "delegate"
// and delegates the full MyTrait interface to that delegate. Later on,
// concrete implementations can implement MyTrait with MyTraitComposition
// to easily extend the behavior of another existing concrete implementation
// via composition.