| /** | |
| * "Select" off the first future to be satisfied. Return this as a | |
| * result, with the remainder of the Futures as a sequence. | |
| * | |
| * @param fs a scala.collection.Seq | |
| */ | |
| def select[A](fs: Seq[Future[A]])(implicit ec: ExecutionContext): Future[(Try[A], Seq[Future[A]])] = { | |
| @tailrec | |
| def stripe(p: Promise[(Try[A], Seq[Future[A]])], | |
| heads: Seq[Future[A]], |
As compiled by Kevin Wright a.k.a @thecoda
(executive producer of the movie, and I didn't even know it... clever huh?)
please, please, please - If you know of any slides/code/whatever not on here, then ping me on twitter or comment this Gist!
This gist will be updated as and when I find new information. So it's probably best not to fork it, or you'll miss the updates!
Monday June 16th
| package scalaz.example | |
| object Reader extends App { | |
| /** | |
| * Manual propagation of the environment (in the example, `contextRoot`.) | |
| */ | |
| object Config0 { | |
| def fragment1(contextRoot: String) = <a href={contextRoot + "/foo"}>foo</a> |
| import org.apache.commons.lang3.Validate; | |
| import org.slf4j.Logger; | |
| import org.slf4j.LoggerFactory; | |
| import java.util.concurrent.Callable; | |
| /** | |
| * A database session and transaction-aware Callable | |
| */ | |
| class DatabaseCallable<T> implements Callable<T> |
| import scala.concurrent._ | |
| import scala.concurrent.duration._ | |
| import scala.concurrent.ExecutionContext.Implicits.global | |
| import scala.util.Random | |
| import java.util.{Timer, TimerTask} | |
| object Util { | |
| sealed trait BaseResponse | |
| case class Response1(res: Int) extends BaseResponse | |
| case class Response2(res: String) extends BaseResponse |
| import java.util.concurrent.ConcurrentLinkedQueue | |
| import java.util.concurrent.atomic.AtomicInteger | |
| import scala.concurrent.ExecutionContext | |
| import scala.util.control.NonFatal | |
| import scala.annotation.tailrec | |
| //inspired by https://gist.github.com/viktorklang/4552423 | |
| object ThrottledExecutionContext { | |
| def apply(maxConcurrents: Int)(implicit context: ExecutionContext): ExecutionContext = { |
| #!/usr/bin/env ruby | |
| # Synchronizes ZFS filesystems. | |
| # | |
| # Takes three args: source pool, destination pool, and filesystem name. | |
| # | |
| # Syncs most recent snapshot of filesystem from source to destination pool, | |
| # using incremental transfer if possible. | |
| # Take a snapshot line from zfs list -t snapshot and emit a struct |
| /* | |
| Copyright 2018 Viktor Klang | |
| Licensed under the Apache License, Version 2.0 (the "License"); | |
| you may not use this file except in compliance with the License. | |
| You may obtain a copy of the License at | |
| http://www.apache.org/licenses/LICENSE-2.0 | |
| Unless required by applicable law or agreed to in writing, software |
| package com.rr.experiment | |
| import org.specs2.ScalaCheck | |
| import org.specs2.mutable._ | |
| import org.scalacheck._ | |
| import scalaz._ | |
| import scodec._ |
