runarorama

Subjectivist theory: The subjectivist theory holds that the good resides in consciousness, independent of reality. If the wish or feeling of value exists in the mind, then that constitutes value. Specific versions differ on whose mind is involved. It could be God's, society's (i.e. other people's), or one's own. Both "it is a value because God says so" and "it is a value because my feelings say so" are instances of this theory. The subjectivist theory holds that the value bears no relation to the facts of reality, that it is the product of consciousness, created by feelings, desires, intuitions, or whims. The irreducible primary in this theory is: desire.

Intrincisist theory: The intrinsicist theory holds that the good resides in reality, independent of consciousness. That is "the good" is good in, by, and of itself, regardless of its relationship with anyone or anything else. "Gold is inherently valuable", and "always indent five spaces", and "we must always serve our country", are instances of this theor

tonymorris

import annotation._

case class Pronunciation(pronounce: String) extends StaticAnnotation
case class Law(name: String, denotation: String) extends StaticAnnotation

trait ~>[F[_], G[_]] {
  def apply[A]: F[A] => G[A]
}

case class Id[A](x: A)

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)

t0d3a

def showTreeL(t: TL, depth: Int = 0): Unit = t match {
  case LL(i) => printf("%s- %d\n", " " * depth * 2, i)
  case FL(l) =>
    printf("%s-\n", " " * depth * 2)
    l.map((x) => showTreeL(x,depth + 1))
} 

var zL = 0
def fL(i: Int): TL = if (i > 0) FL(List(fL(i - 1), fL(i - 1))) else { zL = zL + 1; LL(zL) }

pthariensflame

The Indexed Privilege Monad in Haskell, Scala, and C#

We've already looked at two different indexed monads in our tour so far, so let's go for a third whose regular counterpart isn't as well known: the privilege monad.

Motivation

The regular privilege monad allows you to express constraints on which operations a given component is allowed to perform. This lets the developers of seperate interacting components be statically assured that other components can't access their private state, and it gives you a compile-time guarantee that any code that doesn't have appropriate permissions cannot do things that would require those permissions. Unfortunately, you cannot easily, and sometimes cannot at all, build code in the privilege monad that gains or loses permissions as the code runs; in other words, you cannot (in general) raise or lower your own privilege level, not even when it really should be a

stew

trait UnapplyMT[TC[_[_[_], _]], N[_], MTNA] {
  /** the type constructor */
  type MT[_[_], _]

  /** The type that MT is applied to */
  type A

  /** The instance of the type class */
  def TC: TC[MT]

pthariensflame

The Indexed Continuation Monad in Haskell, Scala, and C#

The indexed state monad is not the only indexed monad out there; it's not even the only useful one. In this tutorial, we will explore another indexed monad, this time one that encapsulates the full power of delimited continuations: the indexed continuation monad.

Motivation

The relationship between the indexed and regular state monads holds true as well for the indexed and regular continuation monads, but while the indexed state monad allows us to keep a state while changing its type in a type-safe way, the indexed continuation monad allows us to manipulate delimited continuations while the return type of the continuation block changes arbitrarily. This, unlike the regular continuation monad, allows us the full power of delimited continuations in a dynamic language like Scheme while still remaining completely statically typed.

YoEight

import com.clarifi.machines._

import play.api.libs.iteratee.{ Enumerator, Input, Iteratee }
import play.api.libs.concurrent.Execution.Implicits._

import scala.concurrent.Future

def simple[K, E](machine: Machine[K, E]): Enumerator[E] = new Enumerator[E] {
  def apply[A](start: Iteratee[E, A]): Future[Iteratee[E, A]] =   
     val result = machine.foldLeft(Future.successful(start)) { (future, value) ⇒

zvozin

import scalaz.concurrent.Actor
import collection.mutable.ArrayBuffer
import java.util.Timer

/**
 * Usage:
 *
 * <code>
 * val buffer = BufferActor[String](onFlush =  _ foreach (println(_), onError = println(_))
 * buffer ! "Now we're talking!"

halcat0x15a

import scala.language.higherKinds
import scala.language.implicitConversions
import scala.language.reflectiveCalls

trait Forall[M[_]] {
  def apply[A]: M[A]
}

object Maybe {