jboner

import akka.actor._
  import java.net.InetSocketAddress
  import akka.util.ByteString

  class SimpleClient(destAddress: InetSocketAddress) extends Actor {

    val socket = IOManager(context.system) connect (destAddress)

    val state = IO.IterateeRef.sync()

dscleaver

import scalaz._
import Scalaz._

object monads {

  def fix[A](f: (=> A) => A): A = f(fix(f))       //> fix: [A](f: => A => A)A
  
  type Gen[A] = (=> A) => A
  
  def gFib: Gen[Int => Int] = (self) => n =>

nraychaudhuri

//routes file
GET    /ping/:message               controllers.Application.restCall(message: String) 


//Then my controller
object Application extends Controller {

  case class SomeMessage(m: String)
  implicit val someMessageFormat: Format[SomeMessage] = Json.format[SomeMessage]
  

guillaumebort

package controllers

import play.api._
import play.api.mvc._
import play.api.templates._

import reactivemongo.api._

import play.modules.reactivemongo._
import play.modules.reactivemongo.json.collection.JSONCollection

johnynek

// Run this with scala <filename>

/**
 * A Two-phase commit Monad
 */
trait Transaction[+T] {
  def map[U](fn: T => U): Transaction[U] = flatMap { t => Constant(fn(t)) }
  def flatMap[U](fn: T => Transaction[U]): Transaction[U] =
    FlatMapped(this, fn)

rxaviers

People

:bowtie:	😄 :smile:	😆 :laughing:
😊 :blush:	😃 :smiley:	☺️ :relaxed:
😏 :smirk:	😍 :heart_eyes:	😘 :kissing_heart:
😚 :kissing_closed_eyes:	😳 :flushed:	😌 :relieved:
😆 :satisfied:	😁 :grin:	😉 :wink:
😜 :stuck_out_tongue_winking_eye:	😝 :stuck_out_tongue_closed_eyes:	😀 :grinning:
😗 :kissing:	😙 :kissing_smiling_eyes:	😛 :stuck_out_tongue:

jboner

# How Akka maps to EAI Patterns

Might be up for debate or just plain wrong. Just some notes I scribbled down some time ago. 

-----------------------------------------------------------------------------------------------------------------
EAI PATTERN                     AKKA PATTERN                  REFERENCE
-----------------------------------------------------------------------------------------------------------------
Point to Point Channel          Regular Actor Communication   http://www.eaipatterns.com/PointToPointChannel.html
Event-Driven Consumer           Regular Actor Receive         http://www.eaipatterns.com/EventDrivenConsumer.html
Message Selector                Actor with Stash              http://www.eaipatterns.com/MessageSelector.html

viktorklang

import scala.concurrent.duration._
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import akka.pattern.after
import akka.actor.Scheduler

/**
 * Given an operation that produces a T, returns a Future containing the result of T, unless an exception is thrown,
 * in which case the operation will be retried after _delay_ time, if there are more possible retries, which is configured through
 * the _retries_ parameter. If the operation does not succeed and there is no retries left, the resulting Future will contain the last failure.

ezhulenev

package pellucid.data.util

import java.util.concurrent.Executors
import java.util.concurrent.atomic.AtomicInteger

import org.joda.time.format.DateTimeFormat

import scala.util.Random

import scalaz.concurrent.Task

milessabin

scala> :paste
// Entering paste mode (ctrl-D to finish)

case class Address(street : String, city : String, postcode : String)
case class Person(name : String, age : Int, address : Address)

// Exiting paste mode, now interpreting.

defined class Address
defined class Person