jrudolph

import spray.json._

object TestJsonClassHierarchyFormat extends App {
  sealed trait Animal extends Product
  case class Dog(name: String, age: Int) extends Animal
  case class Cat(name: String, catchesBirds: Boolean)extends Animal

  import DefaultJsonProtocol._

  implicit val dogFormat = jsonFormat2(Dog)

lihaoyi

object ScalaJSExample extends js.JSApp{
  def main() = {
    val xs = Seq(1, 2, 3)
    println(xs.toString)
    val ys = Seq(4, 5, 6)
    println(ys.toString)
    val zs = for{
      x <- xs
      y <- ys
    } yield x * y

bistaumanga

package util

import scala.collection.mutable.HashMap
import scala.collection.mutable.ArrayBuffer

/*
 * Single Array Based Binary Min Heap
 */
class BinaryHeap[T]{

mkrcah

Spray routing (@agemooij)

• Spray should be run standalone in spray-can, since you don't want to encapsulate high-performant actor inside a low-performant container
• Spray natively supports Futures:

def getEmployees: Future[List[Employees]] = ???
route = get { complete(OK, getEmployees)}

pathikrit

val n = 9
val s = Math.sqrt(n).toInt
type Board = IndexedSeq[IndexedSeq[Int]]
 
def solve(board: Board, cell: Int = 0): Option[Board] = (cell%n, cell/n) match {
  case (r, `n`) => Some(board)
  case (r, c) if board(r)(c) > 0 => solve(board, cell + 1)
  case (r, c) =>
    def guess(x: Int) = solve(board.updated(r, board(r).updated(c, x)), cell + 1)  
    val used = board.indices.flatMap(i => Seq(board(r)(i), board(i)(c), board(s*(r/s) + i/s)(s*(c/s) + i%s)))

djspiewak

Actor Queue Notes

The first thing to understand is that the head field inside of scalaz.concurrent.Actor is not the "head" of the message queue in any traditional sense of the word. A better description would be "last". The there are no pointers to the head of the queue, which one of the very clever things about this implementation.

Empty Actor

Consider the case where the actor has no outstanding messages. This new message will go into the following code:

 def !(a: A): Unit = {

runarorama

trait λ {
  type α
}

trait Functor extends λ {
  type α <: λ

  def map[A,B](x: α { type α = A })(f: A => B): α { type α = B }
}

apangin

_hashCode                               java/lang/Object.hashCode()I
_getClass                               java/lang/Object.getClass()Ljava/lang/Class;
_clone                                  java/lang/Object.clone()Ljava/lang/Object;
_dabs                                   java/lang/Math.abs(D)D
_dsin                                   java/lang/Math.sin(D)D
_dcos                                   java/lang/Math.cos(D)D
_dtan                                   java/lang/Math.tan(D)D
_datan2                                 java/lang/Math.atan2(DD)D
_dsqrt                                  java/lang/Math.sqrt(D)D
_dlog                                   java/lang/Math.log(D)D

xuwei-k

#!/usr/bin/env scalas

/***
scalaVersion := "2.11.7"
libraryDependencies += "com.typesafe.play" %% "play-netty-server" % "2.4.6"
*/

import play.core.server._
import play.api.routing.sird._
import play.api.mvc._

paulp

package psp
package jtos

import java.{ util => ju }, ju.{ stream => jus, function => juf }, jus._
import scala.annotation.unchecked.{ uncheckedVariance => uV }

object generated {
  implicit final class BiConsumer[-T1, -T2](f: (T1, T2) => Unit)           extends juf.BiConsumer[T1 @uV, T2 @uV]         { def accept(x1: T1, x2: T2): Unit                  = f(x1, x2) }
  implicit final class BiFunction[-T1, -T2, +R](f: (T1, T2) => R)          extends juf.BiFunction[T1 @uV, T2 @uV, R @uV]  { def apply(x1: T1, x2: T2): R                      = f(x1, x2) }
  implicit final class BinaryOperator[T](f: (T, T) => T)                   extends juf.BinaryOperator[T]                  { def apply(x1: T, x2: T): T                        = f(x1, x2) }