stonegao

import akka.actor.Actor
import akka.actor.ActorSystem
import akka.agent.Agent
import com.typesafe.config.ConfigFactory
import akka.event.Logging
import akka.actor.Props
import kafka.utils.Utils
import java.nio.ByteBuffer

patriknw

/**
 * Copyright (C) 2009-2014 Typesafe Inc. <http://www.typesafe.com>
 */
package akka.contrib.mailbox

import scala.concurrent.duration._
import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.atomic.AtomicLong
import com.typesafe.config.Config
import akka.actor.{ ActorContext, ActorRef, ActorSystem, ExtendedActorSystem }

RadoBuransky

#!/bin/bash
#
# =========================================================================
# Copyright 2014 Rado Buransky, Dominion Marine Media
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0

drstevens

import scalaz._, Scalaz._
 
def setS(i: Int): State[List[Int], Unit] = modify(i :: _)
 
val s = (1 to 10000).foldLeft(state[List[Int], Unit](()).lift[Free.Trampoline]) {
  case (st, i) => st *> setS(i).lift[Free.Trampoline]
}
 
s(Nil).run

colestanfield

// Create a new MergeStrategy for aop.xml files
val aopMerge: MergeStrategy = new MergeStrategy {
  val name = "aopMerge"
  import scala.xml._
  import scala.xml.dtd._

  def apply(tempDir: File, path: String, files: Seq[File]): Either[String, Seq[(File, String)]] = {
    val dt = DocType("aspectj", PublicID("-//AspectJ//DTD//EN", "http://www.eclipse.org/aspectj/dtd/aspectj.dtd"), Nil)
    val file = MergeStrategy.createMergeTarget(tempDir, path)

non

object Transducer {
  type RF[R, A] = (R, A) => R
  def apply[A, B](f: A => B) =
    new Transducer[B, A] {
      def apply[R](rf: RF[R, B]) = (r, a) => rf(r, f(a))
    }
}

import Transducer.RF

gigiigig

import shapeless._

import scalaz._
import Scalaz._

object console extends App {

  trait Foo[A] {
    type B
    def value: B

johnynek

import scala.language.experimental.macros
import scala.reflect.macros.Context

/**
 * you can try this in the REPL even
 */
object SafeEq {
  /**
   * eqv(1, "foo") won't compile

djspiewak

import scalaz.{Applicative, Bind, Functor, Monad, Traverse}
// > import scalaz.{Applicative, Bind, Functor, Monad, Traverse}
import scalaz.std.option._
// > import scalaz.std.option._
import scalaz.std.list._
// > import scalaz.std.list._

import scalaz.syntax.applicative._
// > import scalaz.syntax.applicative._

gkossakowski

Scala's "type T in class C as seen from a prefix type S" with examples

Introduction

Recently, I found myself in need to precisely understand Scala's core typechecking rules. I was particulary interested in understanding rules responsible for typechecking signatures of members defined in classes (and all types derived from them). Scala Language Specification (SLS) contains definition of the rules but lacks any examples. The definition of the rules uses mutual recursion and nested switch-like constructs that make it hard to follow. I've written down examples together with explanation how specific set of rules (grouped thematically) is applied. These notes helped me gain confidence that I fully understand Scala's core typechecking algorithm.

As Seen From

Let's quote the Scala spec for As Seen From (ASF) rules numbered for an easier reference: