malcolmgreaves

object FunctionToFlow {

  import akka.stream._
  import akka.stream.scaladsl.{ FlowGraph, Flow }

  def apply[A, B](f: A => B): Graph[FlowShape[A, B], Unit] =
    FlowGraph.partial() { implicit b =>
      val transformation = b.add(Flow[A].map(f))
      new FlowShape[A, B](
        transformation.inlet,

malcolmgreaves

language: scala
scala:
- 2.10.4
jdk:
- oraclejdk8
- oraclejdk7
services: mongodb
script:
- sbt scoverage:test
- sbt coveralls

malcolmgreaves

object DiffieHellmanMerkle {

  import java.math.BigInteger
  import scala.language.implicitConversions
  import scala.util.Random

  def main(args: Array[String]): Unit =
    println(
      diffieHellmanMerkle(generator = 3, modulus = 17, alicePrivateKey = 54, bobPrivateKey = 24)
    )

malcolmgreaves

#Scala for comprehension translation helper

"For comprehension" is a another syntaxe to use map, flatMap and withFilter (or filter) methods.

yield keyword is used to aggregate values in the resulting structure.

This composition can be used on any type implementing this methods, like List, Option, Future...

malcolmgreaves

// create file:
sudo vim /usr/share/applications/intellij.desktop

// add the following
[Desktop Entry]
Version=13.0
Type=Application
Terminal=false
Icon[en_US]=/home/rob/.intellij-13/bin/idea.png
Name[en_US]=IntelliJ

malcolmgreaves

implicit class AddSideEffectOpToOption[T](private val x: Option[T]) extends AnyVal {
  
  @inline def sideEffectOnly(ifNone: => Unit, ifSome: T => Unit): Option[T] = {
    x match {
      case None => ifNone
      case Some(value) => ifSome(value)
    }
    x
  }

malcolmgreaves

implicit class TryToDisjunction[T](private val x: Try[T]) extends AnyVal {
  @inline def toOr: \/[Throwable, T] =
    x match {
      case Success(value) => \/-(value)
      case Failure(e)     => -\/(e)
    }
}

malcolmgreaves

implicit class ChainSideEffect[T](private val x: T) extends AnyVal {
  @inline def sideEffect(op: () => Unit): T = {
    val _: Unit = op()
    x
  }
}

malcolmgreaves

#!/usr/bin/env bash

# Quinn Comendant <quinn@strangecode.com>
# https://gist.github.com/quinncomendant/3be731567e529415d5ee
# Since 25 Jan 2015
# Version 1.1

CMD=$1;

if [[ `id -u` = 0 ]]; then

malcolmgreaves

import scala.language.implicitConversions

/**
 * SPECIAL SEMANTICS - USE WITH CAUTION
 *
 * Nullable is a class whose type safety is _intentionally_ compromised. In
 * performance-critical code, we do not want to allocate an Option wrapper
 * around our value of type T. Here we use an extension of AnyVal to ensure
 * we do not allocate and provide inlined helper functions to check the
 * underlying value's nullity.