dwijnand

package t

import sbt._

object Main {
  def simpleFileFilterFnClass(ff: FileFilter) = ff.asInstanceOf[SimpleFileFilter].acceptFunction.getClass
  def simpleFilterFnClass(ff: FileFilter)     = ff.asInstanceOf[SimpleFilter].acceptFunction.getClass

  sealed abstract class Extractor {
    def fnClass: Class[_ <: (Nothing => Boolean)]

dwijnand

/** Your task is to reason your way to which compiler
 *  options which will be passed for each of
 *    1) sbt root/compile
 *    2) sbt   p1/compile
 */

scalacOptions in Global                          += "-D1"
scalacOptions in ThisBuild                       += "-D0"

scalacOptions                                    := Seq("-DSBT")

dwijnand

def buildFiles(b: File) = ((b * "*.sbt") +++ ((b / "project") ** ("*.scala" | "*.sbt")) filter (_.isFile))
def genBuildFilesHashesAt(base: File) = buildFiles(base).get.map(f => f -> (Hash toHex Hash(f))).toMap
def genBuildFilesHashes(units: Map[URI, LoadedBuildUnit]) =
  (units.values flatMap (_.defined) map (_._2.base) flatMap genBuildFilesHashesAt).toMap.##

val buildFilesHashes = settingKey[Int]("") in Global

buildFilesHashes := genBuildFilesHashes(loadedBuild.value.units)

shellPrompt in Global := (s =>

dwijnand

# In order for gpg to find gpg-agent, gpg-agent must be running, and there must be an env
# variable pointing GPG to the gpg-agent socket. This little script, which must be sourced
# in your shell's init script (ie, .bash_profile, .zshrc, whatever), will either start
# gpg-agent or set up the GPG_AGENT_INFO variable if it's already running.

# Add the following to your shell init to set up gpg-agent automatically for every shell
if [ -f ~/.gnupg/.gpg-agent-info ] && [ -n "$(pgrep gpg-agent)" ]; then
    source ~/.gnupg/.gpg-agent-info
    export GPG_AGENT_INFO
else

dwijnand

////////////////////////////// SCALA SYNTAX SPEC //////////////////////////////

// NEWLINE, SEMI-COLON, COMMENT
                        nl ::=  “new line character”
                      semi ::=  ‘;’ |  nl {nl}
                   comment ::=  ‘/*’ “any sequence of characters; nested comments are allowed” ‘*/’
                             |  ‘//’ “any sequence of characters up to end of line”

// NUMBERS
              nonZeroDigit ::=  ‘1’ | … | ‘9’

dwijnand

package p

/** Decodes strings into Ts */
trait Decoder[T] {
  def decode(s: String): Either[String, T]
}

object Decoder {
  def apply[T](f: String => Either[String, T]): Decoder[T] =
    new Decoder[T] { def decode(s: String) = f(s) }

dwijnand

class Thingy(val unThingy: String) extends AnyVal
class Rocket(val unRocket: Thingy) extends AnyVal

dwijnand

final case class MapWithTabularLite[K, V](private val xs: TraversableOnce[(K, V)]) extends AnyVal {
  def showkv() = if (xs.nonEmpty) {
    val len = xs.toIterator.map(_._1.toString.length).max
    val fmt = s"%${len}s %s"
    xs foreach (kv => println(fmt format (kv._1, kv._2)))
  }
}

final case class MultimapWithTabularLite[K, V](private val xs: TraversableOnce[(K, TraversableOnce[V])]) extends AnyVal {
  def showkvs() = if (xs.nonEmpty) {

dwijnand

// Quasiquoted excerpt 

  def cdef = q"""
    class $ClassName[..$classTypeParams](..$primaryParams) extends ..$classParents {
      ..$primaryAccessors

      def get = this
      def isEmpty = ${quasi.isEmpty}
      def copy(..$primaryWithDefaults) = $ObjectName(..$primaryNames)

dwijnand

import scalaz.\/
import scalaz.concurrent.Task

import scala.concurrent.{ ExecutionContext, Future, Promise }
import scala.util.Try

class TaskCompat(private val T: Task.type) extends AnyVal {

  def fromScala[A](future: Future[A])(implicit ec: ExecutionContext): Task[A] =            
    Task async (handlerConversion andThen future.onComplete)