Nada Amin namin

Miles Sabin implemented a nice selection sort example in Scala's type system. See:

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).

	(* 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:

	(ns overtone-playground.heart-murmur
	(:use overtone.core
	overtone.inst.sampled-piano
	overtone.samples.piano))

	;; (boot-server)
	;; (sampled-piano)

	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; Reproducible randomness

	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])

	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]

	;; 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])))

	//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)