Miles Sabin implemented a nice selection sort example in Scala's type system. See:
http://www.chuusai.com/2012/01/27/type-level-sorting-in-shapeless/
To get a better understanding how that works I ported the algorithm to Prolog.
selectleast([H|T], TM, [H|TRem]):-
selectleast(T, TM, TRem), TM < H.
selectleast([H|T], H, T).
| //scalac -P:continuations:enable | |
| import scala.util.continuations._ | |
| object Amb{ | |
| def amb[T](elements: T*):T @suspendable = shift{k:(T=>Unit) => elements.foreach(k)} | |
| def block(body : => Unit @suspendable): Unit = reset(body) | |
| def main(args: Array[String]) { | |
| block { | |
| val a = amb(1, 2, 3) | |
| val b = amb("A", "B", "C") | |
| println(a, b) |
| ;; based on core.logic 0.8-alpha2 or core.logic master branch | |
| (ns sudoku | |
| (:refer-clojure :exclude [==]) | |
| (:use clojure.core.logic)) | |
| (defn get-square [rows x y] | |
| (for [x (range x (+ x 3)) | |
| y (range y (+ y 3))] | |
| (get-in rows [x y]))) |
| import language.experimental.macros | |
| import language.dynamics | |
| import scala.reflect.macros._ | |
| case class Rep[+T](x:String) | |
| implicit def anyToRep[T](x:T) = new Rep[T](x.toString) | |
| class ShouldLift[T] |
| class ClojureWrap(ns: String, objName: String) { | |
| import clojure.lang.{RT,Var} | |
| import scala.collection.mutable.HashMap | |
| RT.loadResourceScript(objName+".clj") | |
| val obj = ns+"."+objName | |
| val funcs = new HashMap[String, Var] | |
| def /(func: String, a: Any): Object = | |
| funcs.getOrElseUpdate(func, RT.`var`(obj, func)).invoke(a.asInstanceOf[Object]) |
| Check out README.md to get started editing Clojure with Emacs. |
| (ns overtone-playground.heart-murmur | |
| (:use overtone.core | |
| overtone.inst.sampled-piano | |
| overtone.samples.piano)) | |
| ;; (boot-server) | |
| ;; (sampled-piano) | |
| ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reproducible randomness |
| (* This is a demonstration of the use of the SML module system to | |
| encode (Generalized Algebraic Datatypes) GADTs via Church | |
| encodings. The basic idea is to use the Church encoding of GADTs in | |
| System Fomega and translate the System Fomega type into the module | |
| system. As I demonstrate below, this allows things like the | |
| singleton type of booleans, and the equality type, to be | |
| represented. | |
| This was inspired by Jon Sterling's blog post about encoding proofs | |
| in the SML module system: |
| scala> trait Assoc[K] { type V ; val value: V } | |
| defined trait Assoc | |
| scala> def mkAssoc[V0](k: String, v: V0): Assoc[k.type] { type V = V0 } = | |
| | new Assoc[k.type] { type V = V0 ; val value = v } | |
| mkAssoc: [V0](k: String, v: V0)Assoc[k.type]{type V = V0} | |
| scala> implicit def nameAssoc = mkAssoc("Name", "Mary") | |
| nameAssoc: Assoc[String("Name")]{type V = String} |
| miles@frege:~$ scala | |
| Welcome to Scala version 2.11.0 (Java HotSpot(TM) 64-Bit Server VM, Java 1.7.0_55). | |
| Type in expressions to have them evaluated. | |
| Type :help for more information. | |
| scala> import scala.language.dynamics | |
| import scala.language.dynamics | |
| scala> case class Assoc[K, V](value: V) | |
| defined class Assoc |
