paulp

/** Constructing "singleton types" from compile-time literals
  *
  * val x = Example.foo(42)
  * val y: x.T = 42 // compiles
  * val z: x.T = 43 // doesn't
  *
  */
package s

import scala.language.experimental.macros

milessabin

scala> def foo[A, B, C](a: SNat[A], b: SNat[B], c: SNat[C])(implicit ssum: SSum[A, B, C]) = ssum
foo: [A, B, C](a: shapeless.SNat[A], b: shapeless.SNat[B], c: shapeless.SNat[C])(implicit ssum: shapeless.SSum[A,B,C])shapeless.SSum[A,B,C]

scala> foo(2, 3, 5)
res0: shapeless.SSum[Int(2),Int(3),Int(5)] = $anon$1@53d76e96

scala> foo(2, 3, 7)
<console>:15: error: could not find implicit value for parameter ssum: shapeless.SSum[Int(2),Int(3),Int(7)]
              foo(2, 3, 7)
                 ^

folone

> shapeless-core/console
[warn] Credentials file /home/folone/.ivy2/.credentials does not exist
[info] Compiling 24 Scala sources to /home/folone/workspace/shapeless/core/target/scala-2.11/classes...
[info] Starting scala interpreter...
[info] 
Welcome to Scala version 2.11.0-20130205-141957-132e09fc2e (OpenJDK 64-Bit Server VM, Java 1.7.0_09).
Type in expressions to have them evaluated.
Type :help for more information.

scala> import shapeless.SingletonTypes._

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

joewiz

xquery version "3.0";

declare function local:trim-phrase-to-length($phrase, $length) {
    (: if the phrase is already short enough, we're done :)
    if (string-length($phrase) le $length) then 
        $phrase
    (: the phrase is too long, so... :)
    else
        (: we will split the phrase into words and look for the longest possible arrangement within our length limit, 
           that doesn't end with boring words :)

milessabin

scala> import shapeless._; import SingletonTypes._; import Record._
import shapeless._
import SingletonTypes._
import Record._

scala> val r = ("foo" ->> 23) :: ("bar" ->> true) :: ("baz" ->> 2.0) :: HNil
r: (String("foo"), Int) :: (String("bar"), Boolean) :: (String("baz"), Double) :: HNil =
   (foo,23) :: (bar,true) :: (baz,2.0) :: HNil

scala> r.head         // r is an HList of pairs of singleton-typed Strings and values ...

folone

def ackermann(m: Int, n: Int): Int = {
   (m, n) match {
     case (0, _)                   ⇒ n + 1
     case (m, 0) if m > 0          ⇒ ackermann(m - 1, 1)
     case (m, n) if m > 0 && n > 0 ⇒ ackermann(m - 1, ackermann(m, n - 1))
   }
 }
 
import scalaz._, Scalaz._, Free.{suspend ⇒ _, _}, Trampoline._
def ackermannTramp(m: Int, n: Int): Trampoline[Int] = {

milessabin

import shapeless._
import record._
import syntax.singleton._

object ScaldingPoC extends App {

  // map, flatMap
  val birds =
    List(
      "name" ->> "Swallow (European, unladen)" :: "speed" ->> 23 :: "weightLb" ->> 0.2 :: "heightFt" ->> 0.65 :: HNil,

channingwalton

case class Foo[T](x: T) {
  def map[B](f: T => B) = Foo(f(x))
}

object OldWay {

  def combineLatest[T1, T2](e1: Foo[T1], e2: Foo[T2]): Foo[(T1, T2)] = Foo((e1.x, e2.x))

  def combineLatest[T1, T2, T3](e1: Foo[T1], e2: Foo[T2], e3: Foo[T3]): Foo[(T1, T2, T3)] =
    combineLatest(combineLatest(e1, e2), e3) map {

milessabin

import shapeless._
import ops.record.{ Selector, Updater }
import record.{ FieldType, field }

trait PathLens[T, P] {
  type Elem
  def get(t : T) : Elem
  def set(t : T)(e : Elem) : T
}