jrudolph

/*
 * This is the Towers of Hanoi example from the prolog tutorial [1]
 * converted into Scala, using implicits to unfold the algorithm at
 * compile-time. 
 * 
 * [1] http://www.csupomona.edu/~jrfisher/www/prolog_tutorial/2_3.html
 */

object TowersOfHanoi {
  import scala.reflect.Manifest

retronym

class T {
  val t = "T"
}

class U
class V
 
object T {
  implicit def UToT[UU <% U](u: UU) = new T
}

retronym

class A
class A2 extends A
class B

trait M[X]

//
// Upper Type Bound
//
def upperTypeBound[AA <: A](x: AA): A = x

retronym

object test {

  case class L[A, B]() {
    def ToLub[AA >: A <: L, BB >: B <: L, L] = new { type LUB = L }
  }

  val intBoolLub = L[Int, Boolean].ToLub
                             
  (1: AnyVal) : intBoolLub.LUB
  1: intBoolLub.LUB

jorgeortiz85

type ¬[A] = A => Nothing
type ∨[T, U] = ¬[¬[T] with ¬[U]]
type ¬¬[A] = ¬[¬[A]]
type |∨|[T, U] = { type λ[X] = ¬¬[X] <:< (T ∨ U) }

class FoldUnion[T](t: T) {
  def boxClass(x: java.lang.Class[_]): java.lang.Class[_] = x.toString match {
    case "byte" => manifest[java.lang.Byte].erasure
    case "char" => manifest[java.lang.Character].erasure
    case "short" => manifest[java.lang.Short].erasure

aboisvert

object Union {
  type ¬[A] = A => Nothing
  type ¬¬[A] = ¬[¬[A]]
  type ∨[T, U] = ¬[¬[T] with ¬[U]]
  type |∨|[T, U] = { type λ[X] = ¬¬[X] <:< (T ∨ U) }

  def size[@specialized(Int) T : (Int |∨| String)#λ](t : T) = t match {
    case i : Int => i
    case s : String => s.length
  }

gclaramunt

package demo

class SafeUnsafe {

  def unsafe[T](x: =>T):Option[T]=  try {
    Option(x) 
  } catch { 
    case _ => None 
  }

kmizu

trait TF {
  type Apply[A]
}
type Curry2[F[_, _]] = TF { type Apply[X] = TF { type Apply[Y] = F[X, Y] } }
type Curry3[F[_, _, _]] = TF { type Apply[X] = Curry2[(TF { type Apply[Y, Z] = F[X, Y, Z] })#Apply] }
// ...

type CurriedMap = Curry2[Map]

val x: CMap#Apply[String]#Apply[Int] = Map("x" -> 1, "y" -> 1) //It is valid code.

gkossakowski

package test;

import java.lang.{reflect => jreflect}
import scala.reflect.mirror._

/**
 * Scala counterpart of java.lang.reflect.InvocationHandler
 */
trait InvocationHandler {
  def invoke(proxy: AnyRef, method: Symbol, args: Array[AnyRef]): AnyRef

copumpkin

module Prime where

open import Coinduction

open import Data.Empty
open import Data.Nat
open import Data.Nat.Properties
open import Data.Nat.Divisibility
open import Data.Fin hiding (pred; _+_; _<_; _≤_; compare)
open import Data.Fin.Props hiding (_≟_)