xian

You need to add the files below, and do this once in your base test runner:

ActionBarSherlock.registerImplementation(ActionBarSherlockRobolectric.class);
ActionBarSherlock.unregisterImplementation(ActionBarSherlockNative.class);
ActionBarSherlock.unregisterImplementation(ActionBarSherlockCompat.class);

shangaslammi

import Control.Exception
import Control.Monad
import Control.Monad.IO.Class
import Data.ByteString.Lazy (ByteString)
import Data.ByteString.Lazy.UTF8 (toString)
import Data.Function
import Data.Enumerator
import Data.List
import Data.Maybe

arosien

import scalaz._
import Scalaz._
import Free._

/** "Pure" interactions with a console. */
sealed trait Console[+A]
case class GetLine[A](k: String => A) extends Console[A]
case class PutLine[A](s: String, a: A) extends Console[A]

object Console {

nponeccop

{-# LANGUAGE DeriveFunctor #-}
import Data.Functor.Foldable
import Data.Function

unfold1 :: Unfold Int [Int]
unfold1 = xana coalgebra1

xana :: Unfoldable b => Coalgebra a b -> Unfold a b
xana = ana

holoed

{-#LANGUAGE DeriveFunctor#-}

module Main where

fix :: ((a -> b) -> a -> b) -> a -> b
fix f = f (fix f)

newtype Fix f = In { out :: f (Fix f) }

type Algebra f a = f a -> a

zraffer

package object types {

  import scala.language.reflectiveCalls
  import scala.language.higherKinds

  // quantifiers aka (co)ends
  type Forall[+F[_]] = { def apply[X]: F[X] }
  type Exists[+F[_]] = F[_]

  // basic categorical notions

Mzk-Levi

  trait Functor[F[_]] {
    def map[A, B](as: F[A])(f: A => B): F[B]
  }
  
  object Functor {
    def apply[F[_]](implicit e: Functor[F]): Functor[F] = e
  }
  
  trait ~>[F[_], G[_]] {
    def apply[A](x: F[A]): G[A]

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:

JasonSwindle

{
    "containerDefinitions": [
        {
            "volumesFrom": null,
            "memory": 32,
            "extraHosts": null,
            "dnsServers": null,
            "disableNetworking": true,
            "dnsSearchDomains": null,
            "portMappings": [],

kdrakon

import java.util.concurrent.atomic.AtomicInteger
import java.util.concurrent.{Executors, TimeUnit}

import akka.actor.{ActorSystem, Props}
import akka.routing.ConsistentHash
import akka.stream.actor._
import akka.stream.scaladsl.{Flow, GraphDSL, RunnableGraph, Sink, Source}
import akka.stream.{ActorMaterializer, ClosedShape, ThrottleMode}
import com.kifi.franz.{MessageId, SQSMessage}