Paul Chiusano pchiusano

From The Selfish Gene, pg 260:

The complicated organs of an advanced animal like a human or a woodlouse have evolved by gradual degrees from the simpler organs of ancestors. But the ancestral organs did not literally change themselves into the descendant organs, like swords being beaten into ploughshares. Not only did they not. The point I want to make is that in most cases they could not. There is only a limited amount of change that can be achieved by direct transformation in the 'swords to ploughshares' manner. Really radical change can be achieved only by going 'back to the drawing board', throwing away the previous design and starting afresh. When engineers go back to the the drawing board and create a new design, they do not necessarily throw away the ideas from the old design. But they don't literally try to deform the old physical object into the new one. The old object is too weighed down with the clutter of history. Maybe you can beat a sword into a ploughshare, but try 'beating' a propelle

Much of this is out of date, but leaving it here for posterity. See the scodec-stream and scodec-bits projects, where all the details got worked out.

Current signature of Codec in scodec is:

trait Codec[A] {
  /** Attempts to encode the specified value in to a bit vector. */
 def encode(a: A): String \/ BitVector

	package pru.write

	import scala.xml.Utility.{escape => esc}

	case class Action(f: StringBuilder => Unit) extends (StringBuilder => Unit) {
	def ++(other: Action): Action =
	Action(sb => { apply(sb); other(sb) })
	def apply(sb: StringBuilder): Unit = f(sb)

	override def toString: String =

	package cjmx.cli
	package actions

	import scala.concurrent.duration._
	import scalaz.stream.Process

	// previous version:
	// https://github.com/cjmx/cjmx/blob/7ab4adebc784701d2de83c2552bae6acb2bf2e2c/src/main/scala/cjmx/cli/actions/Sample.scala
	case class Sample(query: Query, periodSeconds: Int, durationSeconds: Int) extends Action {
	def apply(context: ActionContext) = {

	// This bombs with a SOE
	object Main extends App {
	val F = Nondeterminism[Future]
	val N = 10000
	val worstCaseScenario =
	(0 until N).foldLeft(Future { Thread.sleep(50000) })((a,b) =>
	F.both(a, F.point(b)).map(_._1)
	)
	worstCaseScenario.run
	}

	object Merge {

	def merge[A](p: Process[Task,A]*): Process[Task,A] = {
	var idle = IntMap() ++ p.zipWithIndex.map(_.swap)
	var rem = p.size; def kill: Boolean = { rem -= 1; rem <= 0 }
	val q = async.localQueue[Seq[A]]._1

	trait M
	case class Get(cb: Throwable \/ Seq[A] => Unit) extends M
	case class Recv(ind: Int, step: Step[Task,A]) extends M

	trait Applicative[F[_]] {

	/** 'Balanced' sequencing, to avoid SOE. */
	def bsequence[A](ms: Seq[F[A]]): F[IndexedSeq[A]] = {
	if (ms.isEmpty) point(Vector())
	else if (ms.size == 1) ms.head.map(Vector(_))
	else {
	val (l,r) = ms.toIndexedSeq.splitAt(ms.length / 2)
	apply2(bsequence(l), bsequence(r))(_ ++ _)
	}

	// The default behavior - errors fail fast, normal termination is ignored
	def awaitEither[A,B]: Wye[A,B,A \/ B] =
	awaitBoth[A,B].flatMap {
	case ReceiveL(a) => emit(left(a))
	case ReceiveR(b) => emit(right(b))
	case HaltL(End) => awaitEither[A,B]
	case HaltL(err) => fail(err)
	case HaltR(End) => awaitEither[A,B]
	case HaltR(err) => fail(err)
	}

	def wye[A,B,C](p1: Process[Task,A], p2: Process[Task,B])(y: Wye[A,B,C]): Process[Task,C] = Process.suspend {
	val kill = async.signal[Boolean]; interrupt.value.set(false)
	wyeImpl(p1.interrupt(kill.discrete), p2.interrupt(kill.discrete))(y onComplete (eval_(kill.set(true))))
	}

	private[stream] def wyeImpl[A,B,C](p1: Process[Task,A], p2: Process[Task,B])(y: Wye[A,B,C]): Process[Task,C] =
	<as before>

	// FYI: some comments below refer to old version of this gist: https://gist.github.com/pchiusano/7894696/12201b92db57dff8ed6689fc55c15c3f1a136f86
	package scalaz.stream

	import scalaz.\/
	import scalaz.concurrent.Task

	object retries {

	def dropWhileUnlessAtEnd[I](f: I => Boolean): Process1[I,I] = {
	def go(prev: Option[I]): Process1[I,I] =