petitviolet

object StringFormatter {
  private val spacesPattern = "[-\\s]".r
  private val firstPattern = "([A-Z]+)([A-Z][a-z])".r
  private val secondPattern = "([a-z\\d])([A-Z])".r
  private val replacementPattern = "$1_$2"

  implicit class stringFormatter(val word: String) extends AnyVal {
    def snakenize: String = {
      spacesPattern
        .replaceAllIn(secondPattern.replaceAllIn(

petitviolet

class Deferred() {
  private var fs: Seq[() => Any] = Nil

  def apply(f: => Any): Unit = {
    fs = { () =>
      f
    } +: fs
  }

  def runDeferred(): Unit = fs.reverse foreach { _.apply }

petitviolet

import scalaz._
import scalaz.concurrent.Task

object TaskPrac extends App {
  private def task(i: Int) = Task {
    println(s"sleeping: $i")
    Thread.sleep(i * 100)
    println(s"wakeup: $i")
    i
  }

petitviolet

object DateTimeConverters {
  implicit class DateTimeConverter(val ldt: LocalDateTime) extends AnyVal {
    def asJoda: DateTime = {
      val instant = ldt.atZone(ZoneId.systemDefault()).toInstant
      new DateTime(instant.toEpochMilli)
    }
  }
  implicit class JodaConverter(val jdt: DateTime) extends AnyVal {
    def asLocalDateTime: LocalDateTime = {
      LocalDateTime.of(

petitviolet

class Conf(private var host: String, private var port: Int) {
 def setHost(host: String): Unit = this.host = host
 def setPort(port: Int): Unit = this.port = port
 override def toString: String = s"Conf($host, $port)"
}

> "hoge" |> { _.size } |> { i => 1 to i } |> { _.mkString(",") }

petitviolet

import Resolvers._

val res = Resolver.Http(
    "Bintray typesafe ivy-releases",
    "http://repo.typesafe.com/typesafe/releases/",
    IvyPattern,
    false)

interp.resolvers() = interp.resolvers() :+ res

petitviolet

what is this?

scala.concurrent.Future let asynchronous programming easily. We can process a code block asynchronously by providing it to Future.apply. The timing to start processing is just Future.apply invoked. (also, needs a idling thread.) Therefore, pay attention to the timing to call it.

not in parallel

petitviolet

trait Hoge {
  def receive: String
}

trait HogeChild extends Hoge {
  abstract override def receive: String = {
    println(s"child")
    super.receive
  }
}

petitviolet

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   target.scala


public interface Foo
{

    public abstract Utility utility();

petitviolet

ThreadLocalRandom is faster than Random

val n = 100
Random.nextInt(n)
ThreadLocalRandom.current().nextInt(n)

why ThreadLocalRandom is faster