YoEight

import scala.language.higherKinds

trait Functor[F[_]] {
  def map[A, B](fa: F[A])(f: A => B): F[B]
}

object Functor {
  def apply[F[_], A, B](fa: F[A])(f: A => B)(implicit F: Functor[F]): F[B] =
    F.map(fa)(f)
}

jrudolph

object Test extends App {
  import DefaultJsonProtocol._

  trait ToLowerCase
  object ToLowerCase {
    def apply(str: String): String with ToLowerCase = str.toLowerCase.asInstanceOf[String with ToLowerCase]

    implicit val strWithToLowerCaseFormat: JsonFormat[String with ToLowerCase] =
      new JsonFormat[String with ToLowerCase] {
        def write(obj: String with ToLowerCase): JsValue = JsString(obj)

wsargent

303 See Other

Location: https://github.com/wsargent/docker-cheat-sheet

Hi there!

The docker cheat sheet has moved to a Github project under https://github.com/wsargent/docker-cheat-sheet.

Please click on the link above to go to the cheat sheet.

deiu

#!/bin/sh

# RWW.IO Web app deployer. Simply run `sh deploy.sh` inside your Web app dir and follow the steps.

CERTCMD=""

# get target URI
read -p "Please provide the URI of the target dir (ex: http://example.org/apps/myapp/): " HOST
if [ "$HOST" = "" ]
then

raichoo

package Vect

import scala.language.higherKinds

sealed trait Nat
sealed trait Z extends Nat
sealed trait S[N <: Nat] extends Nat

trait Exists[A, +B[_ <: A]] {
  type fst <: A

jbenet

a simple git branching model (written in 2013)

This is a very simple git workflow. It (and variants) is in use by many people. I settled on it after using it very effectively at Athena. GitHub does something similar; Zach Holman mentioned it in this talk.

Update: Woah, thanks for all the attention. Didn't expect this simple rant to get popular.

mathieuancelin

package play.api.libs.ws

import play.api.libs.iteratee.{Enumeratee, Concurrent, Enumerator}

import play.api.libs.concurrent.Execution.Implicits._
import com.ning.http.client._
import com.ning.http.client.AsyncHandler.STATE
import play.api.Logger
import scala.concurrent.{Future, Promise}

YoEight

package deiko

import java.nio.charset.Charset
import java.util.concurrent.CancellationException
import org.jboss.netty.buffer.ChannelBuffers
import org.jboss.netty.channel.{ Channel, ChannelFuture, ChannelFutureListener }
import org.jboss.netty.handler.codec.http.{ DefaultHttpChunk, HttpChunk }
import scalaz.stream.{ Process, process1, processes }
import scalaz.concurrent.Task
import Process.{ Process1, Sink }

etorreborre

class Outer {
  class Inner
  type Type
}
trait Trait
object Object extends Outer {
  val inner = new Inner
}
class OuterP[A] {
  class InnerP[B]

ochafik

// Author: Olivier Chafik (http://ochafik.com)
// Feel free to modify and reuse this for any purpose ("public domain / I don't care").
package scalaxy.pretyping.example

import scala.reflect.internal._
import scala.tools.nsc.CompilerCommand
import scala.tools.nsc.Global
import scala.tools.nsc.Phase
import scala.tools.nsc.plugins.Plugin
import scala.tools.nsc.plugins.PluginComponent