jcracknell

class Animal
class Cat extends Animal

abstract class Whisperer[-A <: Animal] extends (A => Unit)

object Whisperer {
  implicit def animalWhisperer: Whisperer[Animal] =
    new Whisperer[Animal] { def apply(a: Animal): Unit = { println("animal") } }

  implicit def catWhisperer: Whisperer[Cat] =

jcracknell

object LiteralEncoding {
  private val Hex = "0123456789abcdef".toArray

  private val StringEscapes = {
    val escapes = Map(
      '\b' -> 'b', // backspace
      '\t' -> 't', // tab
      '\n' -> 'n', // linefeed
      '\f' -> 'f', // formfeed
      '\r' -> 'r', // carriage return

jcracknell

public static string RemoveDiacritics(this string str) {
  var formD = str.Normalize(NormalizationForm.FormD);

  var bp = 0;
  var buffer = new char[formD.Length];
  for(var i = 0; i < formD.Length; i++)
    if(UnicodeCategory.NonSpacingMark != CharUnicodeInfo.GetUnicodeCategory(formD[i]))
      buffer[bp++] = formD[i];

  return new string(buffer, 0, bp);

jcracknell

using System;
using System.Text;
using System.Linq;

public static class StringLiteralEncoding {
  private static readonly char[] HEX_DIGIT_LOWER = "0123456789abcdef".ToCharArray();
  private static readonly char[] LITERALENCODE_ESCAPE_CHARS;

  static StringLiteralEncoding() {
    // Per http://msdn.microsoft.com/en-us/library/h21280bw.aspx

jcracknell

using System;
using System.Web;

namespace SslRedirection {
  public class SslRedirectionHttpHandler : IHttpHandler {
		public bool IsReusable { get { return true; } }

		public void ProcessRequest(HttpContext context) {
			if ("GET".Equals(context.Request.HttpMethod, StringComparison.Ordinal)) {
				context.Response.StatusCode = 301;

jcracknell

// Compute the Levenshtein distance between `Array`-like sequences `a` and `b`; the minimum number of
// single-element insertions, deletions and substitutions necessary to transform `a` into `b`.
// Strict equality semantics are used by default to compare sequence elements; a function `equal` can
// optionally be provided to alter this behavior.
function levenshtein(a, b, equal) {
	// `aii` and `bii` are used to track `ai - 1` and `bi - 1` more or less free of charge.
	// `d0` and `d1` are used to store the 'previous' and 'current' rows respectively.
	// `x`, `y` and `z` are used to permit the implementation of an optimized `min` using a ternary expression.
	var ai, aii, ae, al, bi, bii, bl, d0, d1, dd, x, y, z;
	if(a === b) return 0;