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 {

helena

import java.lang.System.{ currentTimeMillis ⇒ newTimestamp }
 
import scala.util.Try
import scala.collection.immutable
import scala.collection.JavaConverters._
import akka.actor._
import akka.japi.Util.immutableSeq
import com.typesafe.config._
 

non

package spire.examples

import spire.algebra._
import spire.math.{Natural, UInt}

import scala.collection.mutable

object SetUtil {
  def powerStream[A](members: Stream[A]): Stream[Set[A]] = {
    val done = Stream.empty[Set[A]]

macintux

• https://dancres.github.io/Pages/
• https://ferd.ca/a-distributed-systems-reading-list.html
• http://the-paper-trail.org/blog/distributed-systems-theory-for-the-distributed-systems-engineer/
• https://github.com/palvaro/CMPS290S-Winter16/blob/master/readings.md
• http://muratbuffalo.blogspot.com/2015/12/my-distributed-systems-seminars-reading.html
• http://christophermeiklejohn.com/distributed/systems/2013/07/12/readings-in-distributed-systems.html
• http://michaelrbernste.in/2013/11/06/distributed-systems-archaeology-works-cited.html
• http://rxin.github.io/db-readings/
• http://research.microsoft.com/en-us/um/people/lamport/pubs/pubs.html
• http://pdos.csail.mit.edu/dsrg/papers/

tonyg

#lang racket/base
(require data/queue)
(provide fork yield done run-threads)

(define current-runqueue (make-parameter #f))

(define (fork thunk)
  (enqueue! (current-runqueue) (lambda () (thunk) (done))))

(define (yield)

tylerneylon

-- Two dashes start a one-line comment.

--[[
     Adding two ['s and ]'s makes it a
     multi-line comment.
--]]

----------------------------------------------------
-- 1. Variables and flow control.
----------------------------------------------------

gigasquid

(ns brackets.core-test
  (:use clojure.test
        brackets.core
        instaparse.core))

(def my-parser
  (parser
   "S = func-apply | vector | integer
    integer = #'[0-9]+'
    <space> = <' '>

vmarquez

import java.util.concurrent.atomic.AtomicReference
import java.util.concurrent.CountDownLatch
import scala.concurrent.Future
import scala.concurrent.ExecutionContext
import ExecutionContext.Implicits.global

object TxMapTest {
  /*
   *  Example Usage
   *  We want to show two threads working with the same data source having both of their effects succeed

mrb

#lang plai/collector

;; A tri-color mark and sweep algorithm. There are three sets of heap nodes:
;; gray, white, and black. Black nodes are known to not be garbage or hold 
;; references to garbage, gray nodes are known to not be garbage but their
;; references have not been checked, and white nodes, the rest, are garbage.
;; * The black set begins empty
;; * The gray set begins with the roots
;; * All non root nodes begin in the white set
;; * Iterate over the gray set. "Blacken" each node by "graying" the nodes

debasishg

Apples-MacBook-Pro:~ debasishg$ scala
Welcome to Scala version 2.10.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.6.0_45).
Type in expressions to have them evaluated.
Type :help for more information.

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

implicit class RContext(sc: StringContext) {
  def r =