pvlugter

Keybase proof

I hereby claim:

• I am pvlugter on github.
• I am pvlugter (https://keybase.io/pvlugter) on keybase.
• I have a public key ASBpEAyNLHcKDskxCVc7hGmqHehEKmbS-j6MW0Ma6yy5cwo

To claim this, I am signing this object:

pvlugter

import sbt._
import Keys._
import play.Project._

// plugins

import com.typesafe.sbt.packager.universal.Keys.{ stage, dist }
import com.typesafe.sbt.SbtNativePackager._
import eu.henkelmann.sbt._

pvlugter

object Format {
  import com.typesafe.sbtscalariform.ScalariformPlugin
  import ScalariformPlugin._

  lazy val settings = scalariformSettings ++ Seq(
    ScalariformKeys.preferences := formattingPreferences
  )

  lazy val formattingPreferences = {
    import scalariform.formatter.preferences._

pvlugter

package reactive

import scala.collection.SeqLike
import scala.collection.generic._
import scala.collection.mutable.{Builder, ListBuffer}

trait TransformedSeq[+A] extends Seq[A]
                         with GenericTraversableTemplate[A, TransformedSeq]
                         with SeqLike[A, TransformedSeq[A]] {
  override def companion: GenericCompanion[TransformedSeq] = TransformedSeq

pvlugter

package reactive

import scala.collection.SeqLike
import scala.collection.generic._
import scala.collection.mutable.{Builder, ListBuffer}

trait TransformedSeq[+A] extends Seq[A]
                         with GenericTraversableTemplate[A, TransformedSeq]
                         with SeqLike[A, TransformedSeq[A]] {
  override def companion: GenericCompanion[TransformedSeq] = TransformedSeq

pvlugter

object TemperatureScale extends Enumeration {
  val Celsius, Fahrenheit, Kelvin = Value
}

object TemperatureConvert {
  def celsiusToFahrenheit(d: Double) = round(d * 9 / 5 + 32)
  def celsiusToKelvin(d: Double) = round(d + 273.15)
  def fahrenheitToCelsius(d: Double) = round((d - 32) * 5 / 9)
  def fahrenheitToKelvin(d: Double) = round((d + 459.67) * 5 / 9)
  def kelvinToCelsius(d: Double) = round(d - 273.15)

pvlugter

(defmacro timer [expr]
  `(let [start# (. System (nanoTime))
         ret# ~expr
         end# (. System (nanoTime))]
     (/ (- end# start#) 1000000.0)))
 
(defmacro timed [n expr]
  `(loop [i# 0 total# 0]
    (if (< i# ~n)
      (recur (inc i#) (+ total# (timer ~expr)))

pvlugter

def timer(expr: => Unit): Double = {
  val start = System.nanoTime
  expr
  val end = System.nanoTime
  (end - start) / 1000000.0
}
 
def timed(n: Int)(expr: => Unit): Double = {
  var i = 0
  var total = 0.0