pygments.rb-jruby 0.5.4

data/vendor/pygments-main/tests/examplefiles/robotframework.txt

@@ -0,0 +1,39 @@
+*** Settings ***
+Documentation    Simple example demonstrating syntax highlighting.
+Library          ExampleLibrary
+Test Setup       Keyword    argument   argument with ${VARIABLE}
+
+*** Variables ***
+${VARIABLE}      Variable value
+@{LIST}          List    variable    here
+
+*** Test Cases ***
+Keyword-driven example
+    Initialize System
+    Do Something
+    Result Should Be    42
+    [Teardown]    Cleanup System
+
+Data-driven example
+    [Template]    Keyword
+    argument1   argument2
+    argument    ${VARIABLE}
+    @{LIST}
+
+Gherkin
+    Given system is initialized
+    When something is done
+    Then result should be "42"
+
+| Pipes |
+|  | [Documentation] | Also pipe separated format is supported. |
+|  | Log | As this example demonstrates. |
+
+*** Keywords ***
+Result Should Be
+    [Arguments]    ${expected}
+    ${actual} =    Get Value
+    Should be Equal    ${actual}    ${expected}
+
+Then result should be "${expected}"
+    Result Should Be    ${expected}

data/vendor/pygments-main/tests/examplefiles/ruby_func_def.rb

@@ -0,0 +1,11 @@
+class (get_foo("blub"))::Foo
+  def (foo("bar") + bar("baz")).something argh, aaahaa
+    42
+  end
+end
+
+class get_the_fuck("out")::Of::My
+  def parser_definition
+    ruby!
+  end
+end

data/vendor/pygments-main/tests/examplefiles/rust_example.rs

@@ -0,0 +1,233 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// based on:
+// http://shootout.alioth.debian.org/u32/benchmark.php?test=nbody&lang=java
+
+extern mod std;
+
+use core::os;
+
+// Using sqrt from the standard library is way slower than using libc
+// directly even though std just calls libc, I guess it must be
+// because the the indirection through another dynamic linker
+// stub. Kind of shocking. Might be able to make it faster still with
+// an llvm intrinsic.
+#[nolink]
+extern mod libc {
+    #[legacy_exports];
+    fn sqrt(n: float) -> float;
+}
+
+fn main() {
+    let args = os::args();
+    let args = if os::getenv(~"RUST_BENCH").is_some() {
+        ~[~"", ~"4000000"]
+    } else if args.len() <= 1u {
+        ~[~"", ~"100000"]
+    } else {
+        args
+    };
+    let n = int::from_str(args[1]).get();
+    let mut bodies: ~[Body::props] = NBodySystem::make();
+    io::println(fmt!("%f", NBodySystem::energy(bodies)));
+    let mut i = 0;
+    while i < n {
+        NBodySystem::advance(bodies, 0.01);
+        i += 1;
+    }
+    io::println(fmt!("%f", NBodySystem::energy(bodies)));
+}
+
+mod NBodySystem {
+    use Body;
+
+    pub fn make() -> ~[Body::props] {
+        let mut bodies: ~[Body::props] =
+            ~[Body::sun(),
+              Body::jupiter(),
+              Body::saturn(),
+              Body::uranus(),
+              Body::neptune()];
+
+        let mut px = 0.0;
+        let mut py = 0.0;
+        let mut pz = 0.0;
+
+        let mut i = 0;
+        while i < 5 {
+            px += bodies[i].vx * bodies[i].mass;
+            py += bodies[i].vy * bodies[i].mass;
+            pz += bodies[i].vz * bodies[i].mass;
+
+            i += 1;
+        }
+
+        // side-effecting
+        Body::offset_momentum(&mut bodies[0], px, py, pz);
+
+        return bodies;
+    }
+
+    pub fn advance(bodies: &mut [Body::props], dt: float) {
+        let mut i = 0;
+        while i < 5 {
+            let mut j = i + 1;
+            while j < 5 {
+                advance_one(&mut bodies[i],
+                            &mut bodies[j], dt);
+                j += 1;
+            }
+
+            i += 1;
+        }
+
+        i = 0;
+        while i < 5 {
+            move_(&mut bodies[i], dt);
+            i += 1;
+        }
+    }
+
+    pub fn advance_one(bi: &mut Body::props,
+                       bj: &mut Body::props,
+                       dt: float) unsafe {
+        let dx = bi.x - bj.x;
+        let dy = bi.y - bj.y;
+        let dz = bi.z - bj.z;
+
+        let dSquared = dx * dx + dy * dy + dz * dz;
+
+        let distance = ::libc::sqrt(dSquared);
+        let mag = dt / (dSquared * distance);
+
+        bi.vx -= dx * bj.mass * mag;
+        bi.vy -= dy * bj.mass * mag;
+        bi.vz -= dz * bj.mass * mag;
+
+        bj.vx += dx * bi.mass * mag;
+        bj.vy += dy * bi.mass * mag;
+        bj.vz += dz * bi.mass * mag;
+    }
+
+    pub fn move_(b: &mut Body::props, dt: float) {
+        b.x += dt * b.vx;
+        b.y += dt * b.vy;
+        b.z += dt * b.vz;
+    }
+
+    pub fn energy(bodies: &[Body::props]) -> float unsafe {
+        let mut dx;
+        let mut dy;
+        let mut dz;
+        let mut distance;
+        let mut e = 0.0;
+
+        let mut i = 0;
+        while i < 5 {
+            e +=
+                0.5 * bodies[i].mass *
+                (bodies[i].vx * bodies[i].vx + bodies[i].vy * bodies[i].vy
+                 + bodies[i].vz * bodies[i].vz);
+
+            let mut j = i + 1;
+            while j < 5 {
+                dx = bodies[i].x - bodies[j].x;
+                dy = bodies[i].y - bodies[j].y;
+                dz = bodies[i].z - bodies[j].z;
+
+                distance = ::libc::sqrt(dx * dx + dy * dy + dz * dz);
+                e -= bodies[i].mass * bodies[j].mass / distance;
+
+                j += 1;
+            }
+
+            i += 1;
+        }
+        return e;
+
+    }
+}
+
+mod Body {
+    use Body;
+
+    pub const PI: float = 3.141592653589793;
+    pub const SOLAR_MASS: float = 39.478417604357432;
+    // was 4 * PI * PI originally
+    pub const DAYS_PER_YEAR: float = 365.24;
+
+    pub type props =
+        {mut x: float,
+         mut y: float,
+         mut z: float,
+         mut vx: float,
+         mut vy: float,
+         mut vz: float,
+         mass: float};
+
+    pub fn jupiter() -> Body::props {
+        return {mut x: 4.84143144246472090e+00,
+             mut y: -1.16032004402742839e+00,
+             mut z: -1.03622044471123109e-01,
+             mut vx: 1.66007664274403694e-03 * DAYS_PER_YEAR,
+             mut vy: 7.69901118419740425e-03 * DAYS_PER_YEAR,
+             mut vz: -6.90460016972063023e-05 * DAYS_PER_YEAR,
+             mass: 9.54791938424326609e-04 * SOLAR_MASS};
+    }
+
+    pub fn saturn() -> Body::props {
+        return {mut x: 8.34336671824457987e+00,
+             mut y: 4.12479856412430479e+00,
+             mut z: -4.03523417114321381e-01,
+             mut vx: -2.76742510726862411e-03 * DAYS_PER_YEAR,
+             mut vy: 4.99852801234917238e-03 * DAYS_PER_YEAR,
+             mut vz: 2.30417297573763929e-05 * DAYS_PER_YEAR,
+             mass: 2.85885980666130812e-04 * SOLAR_MASS};
+    }
+
+    pub fn uranus() -> Body::props {
+        return {mut x: 1.28943695621391310e+01,
+             mut y: -1.51111514016986312e+01,
+             mut z: -2.23307578892655734e-01,
+             mut vx: 2.96460137564761618e-03 * DAYS_PER_YEAR,
+             mut vy: 2.37847173959480950e-03 * DAYS_PER_YEAR,
+             mut vz: -2.96589568540237556e-05 * DAYS_PER_YEAR,
+             mass: 4.36624404335156298e-05 * SOLAR_MASS};
+    }
+
+    pub fn neptune() -> Body::props {
+        return {mut x: 1.53796971148509165e+01,
+             mut y: -2.59193146099879641e+01,
+             mut z: 1.79258772950371181e-01,
+             mut vx: 2.68067772490389322e-03 * DAYS_PER_YEAR,
+             mut vy: 1.62824170038242295e-03 * DAYS_PER_YEAR,
+             mut vz: -9.51592254519715870e-05 * DAYS_PER_YEAR,
+             mass: 5.15138902046611451e-05 * SOLAR_MASS};
+    }
+
+    pub fn sun() -> Body::props {
+        return {mut x: 0.0,
+             mut y: 0.0,
+             mut z: 0.0,
+             mut vx: 0.0,
+             mut vy: 0.0,
+             mut vz: 0.0,
+             mass: SOLAR_MASS};
+    }
+
+    pub fn offset_momentum(props: &mut Body::props,
+                       px: float, py: float, pz: float) {
+        props.vx = -px / SOLAR_MASS;
+        props.vy = -py / SOLAR_MASS;
+        props.vz = -pz / SOLAR_MASS;
+    }
+
+}

data/vendor/pygments-main/tests/examplefiles/scilab.sci

@@ -0,0 +1,30 @@
+// Scilab ( http://www.scilab.org/ )
+// Copyright (C) INRIA - Serge STEER
+// 
+
+function I=sub2ind(dims,varargin)
+//sub2ind is used to determine the equivalent single index
+//corresponding to a given set of subscript values.
+ 
+//I = sub2ind(dims,i1,i2,..) returns the linear index equivalent to the
+//row,  column, ... subscripts in the arrays i1,i2,..  for an matrix of
+//size dims.
+ 
+//I = sub2ind(dims,Mi) returns the linear index
+//equivalent to the n subscripts in the columns of the matrix Mi for a matrix
+//of size dims.
+ 
+  d=[1;cumprod(matrix(dims(1:$-1),-1,1))]
+  for i=1:size(varargin)
+    if varargin(i)==[] then I=[],return,end
+  end
+
+  if size(varargin)==1 then //subindices are the columns of the argument
+    I=(varargin(1)-1)*d+1
+  else //subindices are given as separated arguments
+    I=1
+    for i=1:size(varargin)
+      I=I+(varargin(i)-1)*d(i)
+    end
+  end
+endfunction

data/vendor/pygments-main/tests/examplefiles/session.dylan-console

@@ -0,0 +1,9 @@
+? 7 * 52;
+=> 364
+? define variable *your-variable* = $foo;
+? begin
+   let yours = "apple";
+   let mine = yours;
+   mine == yours;
+ end;
+=> #t

data/vendor/pygments-main/tests/examplefiles/sibling.prolog

@@ -0,0 +1,19 @@
+/* Comments /* can nest */
+still a comment
+*/
+
+:- module(maplist, maplist/3)
+
+assert(world:done). % asserts
+
+sibling(X, Y)      :- parent_child(Z, X), parent_child(Z, Y).
+
+parent_child(X, Y) :- father_child(X, Y).
+parent_child(X, Y) :- mother_child(X, Y).
+
+mother_child(trude, sally).
+
+father_child(tom, sally).
+father_child(tom, erica).
+father_child(mike, tom).
+

data/vendor/pygments-main/tests/examplefiles/simple.md

@@ -0,0 +1,747 @@
+module simple;
+
+// Importing stuff.
+{
+	function loadMod(name, ns)
+	{
+		assert(name == "mod");
+		
+		ns.x = "I'm x";
+	
+		ns.foo = function foo()
+		{
+			writefln("foo");
+		};
+	
+		ns.bar = function bar(x)
+		{
+			return x[0];
+		};
+	
+		ns.baz = function baz()
+		{
+			writefln(x);
+		};
+		
+		foreach(k, v; ns)
+			if(isFunction(v))
+				v.environment(ns);
+	}
+	
+	setModuleLoader("mod", loadMod);
+	
+	import mod : foo, bar;
+	foo();
+	writefln(bar([5]));
+	mod.baz();
+
+	writefln();
+}
+
+// Super calls.
+{
+	class Base
+	{
+		function fork()
+		{
+			writefln("Base fork.");
+		}
+	}
+
+	class Derived : Base
+	{
+		function fork()
+		{
+			writefln("Derived fork!");
+			super.fork();
+		}
+	}
+	
+	local d = Derived();
+	d.fork();
+	
+	writefln();
+}
+
+// Coroutines and coroutine iteration.
+{
+	local countDown = coroutine function countDown(x)
+	{
+		yield();
+		
+		while(x > 0)
+		{
+			yield(x);
+			x--;
+		}
+	};
+	
+	foreach(v; countDown, 5)
+		writefln(v);
+		
+	writefln();
+	
+	local forEach = coroutine function forEach(t)
+	{
+		yield();
+	
+		foreach(k, v; t)
+			yield(k, v);
+	};
+	
+	foreach(_, k, v; forEach, {hi = 1, bye = 2})
+		writefln("key: ", k, ", value: ", v);
+	
+	writefln();
+}
+
+// Testing tailcalls.
+{
+	function recurse(x)
+	{
+		writefln("recurse: ", x);
+	
+		if(x == 0)
+			return toString(x);
+		else
+			return recurse(x - 1);
+	}
+	
+	writefln(recurse(5));
+	writefln();
+	
+	class A
+	{
+		function f(x)
+		{
+			writefln("A.f: ", x);
+
+			if(x == 0)
+				return toString(x);
+			else
+				return this.f(x - 1); // call it as this.f to force a 'method' instruction to be generated
+		}
+	}
+	
+	local a = A();
+	writefln(a.f(5));
+	writefln();
+}
+
+{
+	// A function which lets us define properties for a class.
+	// The varargs should be a bunch of tables, each with a 'name' field, and 'getter' and/or 'setter' fields.
+	function mixinProperties(classType, vararg)
+	{
+		classType.mProps = { };
+	
+		classType.opIndex = function opIndex(key)
+		{
+			local prop = mProps[key];
+	
+			if(prop is null)
+				throw format(classType, ".opIndex() - Property '%s' does not exist", key);
+	
+			local getter = prop.getter;
+	
+			if(getter is null)
+				throw format(classType, ".opIndex() - Property '%s' has no getter", key);
+	
+			return getter(with this);
+		};
+	
+		classType.opIndexAssign = function opIndexAssign(key, value)
+		{
+			local prop = mProps[key];
+	
+			if(prop is null)
+				throw format(classType, ".opIndexAssign() - Property '%s' does not exist", key);
+	
+			local setter = prop.setter;
+	
+			if(setter is null)
+				throw format(classType, ".opIndexAssign() - Property '%s' has no setter", key);
+	
+			setter(with this, value);
+		};
+	
+		foreach(i, prop; [vararg])
+		{
+			if(!isTable(prop))
+				throw format("mixinProperties() - property ", i, " is not a table");
+	
+			if(prop.name is null)
+				throw format("mixinProperties() - property ", i, " has no name");
+	
+			if(prop.setter is null && prop.getter is null)
+				throw format("mixinProperties() - property '%s' has no getter or setter", prop.name);
+	
+			classType.mProps[prop.name] = prop;
+		}
+	}
+	
+	// Create a class to test out.
+	class PropTest
+	{
+		mX = 0;
+		mY = 0;
+		mName = "";
+		
+		function constructor(name)
+		{
+			mName = name;
+		}
+	
+		function toString()
+		{
+			return format("name = '", mName, "' x = ", mX, " y = ", mY);
+		}
+	}
+	
+	// Mix in the properties.
+	mixinProperties
+	(
+		PropTest,
+	
+		{
+			name = "x",
+			
+			function setter(value)
+			{
+				mX = value;
+			}
+	
+			function getter()
+			{
+				return mX;
+			}
+		},
+	
+		{
+			name = "y",
+	
+			function setter(value)
+			{
+				mY = value;
+			}
+	
+			function getter()
+			{
+				return mY;
+			}
+		},
+	
+		{
+			name = "name",
+	
+			function getter()
+			{
+				return mName;
+			}
+		}
+	);
+	
+	// Create an instance and try it out.
+	local p = PropTest("hello");
+	
+	writefln(p);
+	p.x = 46;
+	p.y = 123;
+	p.x = p.x + p.y;
+	writefln(p);
+	
+	// Try to access a nonexistent property.
+	try
+		p.name = "crap";
+	catch(e)
+	{
+		writefln("caught: ", e);
+		writefln(getTraceback());
+	}
+	
+	writefln();
+}
+
+// Some container classes.
+{
+	class PQ
+	{
+		mData;
+		mLength = 0;
+	
+		function constructor()
+		{
+			mData = array.new(15);
+		}
+	
+		function insert(data)
+		{
+			resizeArray();
+			mData[mLength] = data;
+	
+			local index = mLength;
+			local parentIndex = (index - 1) / 2;
+	
+			while(index > 0 && mData[parentIndex] > mData[index])
+			{
+				local temp = mData[parentIndex];
+				mData[parentIndex] = mData[index];
+				mData[index] = temp;
+	
+				index = parentIndex;
+				parentIndex = (index - 1) / 2;
+			}
+			
+			mLength += 1;
+		}
+	
+		function remove()
+		{
+			if(mLength == 0)
+				throw "PQ.remove() - No items to remove";
+	
+			local data = mData[0];
+			mLength -= 1;
+			mData[0] = mData[mLength];
+			
+			local index = 0;
+			local left = 1;
+			local right = 2;
+	
+			while(index < mLength)
+			{
+				local smaller;
+				
+				if(left >= mLength)
+				{
+					if(right >= mLength)
+						break;
+					else
+						smaller = right;
+				}
+				else
+				{
+					if(right >= mLength)
+						smaller = left;
+					else
+					{
+						if(mData[left] < mData[right])
+							smaller = left;
+						else
+							smaller = right;
+					}
+				}
+	
+				if(mData[index] > mData[smaller])
+				{
+					local temp = mData[index];
+					mData[index] = mData[smaller];
+					mData[smaller] = temp;
+					
+					index = smaller;
+					left = (index * 2) + 1;
+					right = left + 1;
+				}
+				else
+					break;
+			}
+			
+			return data;
+		}
+		
+		function resizeArray()
+		{
+			if(mLength >= #mData)
+				mData.length((#mData + 1) * 2 - 1);
+		}
+		
+		function hasData()
+		{
+			return mLength != 0;
+		}
+	}
+	
+	class Stack
+	{
+		mHead = null;
+	
+		function push(data)
+		{
+			local t = { data = data, next = mHead };
+			mHead = t;
+		}
+		
+		function pop()
+		{
+			if(mHead is null)
+				throw "Stack.pop() - No items to pop";
+	
+			local item = mHead;
+			mHead = mHead.next;
+			
+			return item.data;
+		}
+	
+		function hasData()
+		{
+			return mHead !is null;
+		}
+	}
+	
+	class Queue
+	{
+		mHead = null;
+		mTail = null;
+	
+		function push(data)
+		{
+			local t = { data = data, next = null };
+	
+			if(mTail is null)
+			{
+				mHead = t;
+				mTail = t;
+			}
+			else
+			{
+				mTail.next = t;
+				mTail = t;
+			}
+		}
+		
+		function pop()
+		{
+			if(mTail is null)
+				throw "Queue.pop() - No items to pop";
+				
+			local item = mHead;
+			mHead = mHead.next;
+			
+			if(mHead is null)
+				mTail = null;
+				
+			return item.data;
+		}
+		
+		function hasData()
+		{
+			return mHead !is null;
+		}
+	}
+	
+	writefln("Priority queue (heap)");
+	
+	local prioQ = PQ();
+	
+	for(i : 0 .. 10)
+		prioQ.insert(math.rand(0, 20));
+	
+	while(prioQ.hasData())
+		writefln(prioQ.remove());
+		
+	writefln();
+	writefln("Stack");
+	
+	local stack = Stack();
+	
+	for(i : 0 .. 5)
+		stack.push(i + 1);
+	
+	while(stack.hasData())
+		writefln(stack.pop());
+	
+	writefln();
+	writefln("Queue");
+	
+	local queue = Queue();
+	
+	for(i : 0 .. 5)
+		queue.push(i + 1);
+	
+	while(queue.hasData())
+		writefln(queue.pop());
+	
+	writefln();
+}
+
+// opApply tests.
+{
+	class Test
+	{
+		mData = [4, 5, 6];
+	
+		function opApply(extra)
+		{
+			if(isString(extra) && extra == "reverse")
+			{
+				local function iterator_reverse(index)
+				{
+					index--;
+					
+					if(index < 0)
+						return;
+						
+					return index, mData[index];
+				}
+	
+				return iterator_reverse, this, #mData;
+			}
+			else
+			{
+				local function iterator(index)
+				{
+					index++;
+	
+					if(index >= #mData)
+						return;
+		
+					return index, mData[index];
+				}
+	
+				return iterator, this, -1;
+			}
+		}
+	}
+	
+	local test = Test();
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; test, "reverse")
+		writefln("test[", k, "] = ", v);
+		
+	writefln();
+	
+	test =
+	{
+		fork = 5,
+		knife = 10,
+		spoon = "hi"
+	};
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	test = [5, 10, "hi"];
+	
+	writefln();
+	
+	foreach(k, v; test)
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; test, "reverse")
+		writefln("test[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; "hello")
+		writefln("str[", k, "] = ", v);
+	
+	writefln();
+	
+	foreach(k, v; "hello", "reverse")
+		writefln("str[", k, "] = ", v);
+	
+	writefln();
+}
+
+// Testing upvalues in for loops.
+{
+	local arr = array.new(10);
+	
+	for(i : 0 .. 10)
+		arr[i] = function() { return i; };
+	
+	writefln("This should be the values 0 through 9:");
+	
+	foreach(func; arr)
+		writefln(func());
+	
+	writefln();
+}
+
+// Testing nested functions.
+{
+	function outer()
+	{
+		local x = 3;
+	
+		function inner()
+		{
+			x++;
+			writefln("inner x: ", x);
+		}
+	
+		writefln("outer x: ", x);
+		inner();
+		writefln("outer x: ", x);
+	
+		return inner;
+	}
+	
+	local func = outer();
+	func();
+	
+	writefln();
+}
+
+// Testing Exceptions.
+{
+	function thrower(x)
+	{
+		if(x >= 3)
+			throw "Sorry, x is too big for me!";
+	}
+	
+	function tryCatch(iterations)
+	{
+		try
+		{
+			for(i : 0 .. iterations)
+			{
+				writefln("tryCatch: ", i);
+				thrower(i);
+			}
+		}
+		catch(e)
+		{
+			writefln("tryCatch caught: ", e);
+			throw e;
+		}
+		finally
+			writefln("tryCatch finally");
+	}
+	
+	try
+	{
+		tryCatch(2);
+		tryCatch(5);
+	}
+	catch(e)
+		writefln("caught: ", e);
+	
+	writefln();
+}
+
+// Testing arrays.
+{
+	local array = [7, 9, 2, 3, 6];
+	
+	array.sort();
+	
+	foreach(i, v; array)
+		writefln("arr[", i, "] = ", v);
+	
+	array ~= ["foo", "far"];
+	
+	writefln();
+	
+	foreach(i, v; array)
+		writefln("arr[", i, "] = ", v);
+	
+	writefln();
+}
+
+// Testing vararg functions.
+{
+	function vargs(vararg)
+	{
+		local args = [vararg];
+	
+		writefln("num varargs: ", #args);
+	
+		foreach(i, v; args)
+			writefln("args[", i, "] = ", v);
+	}
+	
+	vargs();
+	
+	writefln();
+	
+	vargs(2, 3, 5, "foo", "bar");
+	
+	writefln();
+}
+
+// Testing switches.
+{
+	foreach(v; ["hi", "bye", "foo"])
+	{
+		switch(v)
+		{
+			case "hi":
+				writefln("switched to hi");
+				break;
+				
+			case "bye":
+				writefln("switched to bye");
+				break;
+				
+			default:
+				writefln("switched to something else");
+				break;
+		}
+	}
+	
+	writefln();
+	
+	foreach(v; [null, false, 1, 2.3, 'x', "hi"])
+	{
+		switch(v)
+		{
+			case null: writefln("null"); break;
+			case false: writefln("false"); break;
+			case 1: writefln("1"); break;
+			case 2.3: writefln("2.3"); break;
+			case 'x': writefln("x"); break;
+			case "hi": writefln("hi"); break;
+		}
+	}
+	
+	writefln();
+	
+	class A
+	{
+		mValue;
+		
+		this(value)
+		{
+			mValue = value;
+		}
+	
+		function opCmp(other)
+		{
+			assert(other as A);
+			return mValue <=> other.mValue;
+		}
+	}
+	
+	local a1 = A(1);
+	local a2 = A(2);
+	local a3 = A(3);
+	
+	for(s : 1 .. 4)
+	{
+		local ss = A(s);
+	
+		switch(ss)
+		{
+			case a1:
+				writefln(1);
+				break;
+	
+			case a2:
+				writefln(2);
+				break;
+	
+			case a3:
+				writefln(3);
+				break;
+		}
+	}
+}