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.

kafecho

package org.kafecho.learning.monad

import java.util.UUID

/** My attempt at implementing the Reader Monad concept.
  * The Reader Monad encapsulates a computation which:
  * - requires a dependency of type D
  * - produces values of type A.
  */
case class Reader[D, A](computation: D => A) {

MishaelRosenthal

package com.liveperson.predictivedialer.examples.misc

import scala.annotation.tailrec
import scala.util.Try

/**
 * Created with IntelliJ IDEA.
 * User: mishaelr
 * Date: 5/14/14
 * Time: 5:18 PM

zackthehuman

case class Identifier(id: Long)
case class Rectangle(x: Int, y: Int, width: Int, height: Int)

object QuadTree {
  private val MAX_OBJECTS = 2
  private val MAX_LEVELS = 5

  private val PARENT_NODE = -1
  private val TOP_RIGHT = 0
  private val TOP_LEFT = 1

runarorama

sealed trait Interact[A]

case class Ask(prompt: String)
  extends Interact[String]

case class Tell(msg: String)
  extends Interact[Unit]

trait Monad[M[_]] {
  def pure[A](a: A): M[A]

ahoy-jon

package ahoy

import scala.collection.mutable


object transducer {

  type Reducer[A, R] = R => A => R

  trait Transducer[A, B] {

Klasu

// Simple monad to deal with multiple database transactions with same connection, their commits and rollbacks
// Something similar done in http://advorkovyy.blogspot.com.au/2010/10/transactional-monad-for-scala.html
 
import java.sql.Connection
 
trait DbTransaction[A] {
  def unit: Connection => A
  def map[B](f: A => B): DbTransaction[B] = DbTransaction {
    connection => f(unit(connection))
  }

odersky

package scalax.collection
import scala.collection.mutable.ListBuffer

/** FoldTransformers and the views based on them are a Scala
 *  adaptation, and to some degree an extension, of Rich Hickey's
 *  transducers for Clojure. They show that the concepts can be
 *  implemented in a type-safe way, and that the implementation is
 *  quite beautiful.
 */
object FoldingViews {

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

paulp

object TransducerUniversal {
  type Reduct[-A, R] = (R, A) => R
  trait Trans[+A, -B] { def apply[R](f: Reduct[A, R]): Reduct[B, R] }

  def map[A, B](f: A => B): Trans[B, A]                            = new Trans[B, A] { def apply[R](rf: Reduct[B, R]) = (r, a) => rf(r, f(a)) }
  def filter[A](p: A => Boolean): Trans[A, A]                      = new Trans[A, A] { def apply[R](rf: Reduct[A, R]) = (r, a) => if (p(a)) rf(r, a) else r }
  def comp[A,B,C](t1 : Trans[A, B], t2 : Trans[C, A]): Trans[C, B] = new Trans[C, B] { def apply[R](rf: Reduct[C, R]) = t1(t2(rf)) }
  def sequence[A, B](t: Trans[B, A], data: Seq[A])                 = data.foldLeft(Seq[B]())(t(_ :+ _))

  implicit class Compable[A,B](t1: Trans[A, B]) {