loosechainsaw

using NUnit.Framework;
using System;

namespace Monads
{
   
    public class Unit{

        private Unit(){
           

loosechainsaw

j = {
    context : {}
};

j.namepsace = (function(){

    var createnamespace = function(parent, remainder){
        if(remainder.length === 0){
            return;
        }

loosechainsaw

window.application = {};
window.application.search = (function(){


    function searchwikipedia(term) {
        return $.ajaxAsObservable({
            url: 'http://en.wikipedia.org/w/api.php',
            data: { action: 'opensearch',
                search: term,
                format: 'json' },

loosechainsaw

namespace RegularLanguages
open System
open NUnit.Framework

[<AutoOpen>]
module Internals =
    
    let private (|Char|_|) x =
        if Char.IsLetter(x) then
            Some(x)

loosechainsaw

namespace PerthCodeDojo
open System
open NUnit.Framework

[<AutoOpen>]
module Internals =
    
    type Quantity = int

    type Product =

loosechainsaw

namespace RegularLanguages
open System
open NUnit.Framework

[<AutoOpen>]
module Internals =
    
    let private (|Char|_|) x =
        if Char.IsLetter(x) then
            Some(x)

loosechainsaw

namespace JsonParser
open System
open NUnit.Framework


module Json = 

    type Token = 
        | String of string
        | Number of string

loosechainsaw

module Encryption = 
	module private Helpers =
		let rec encrypt s = 
			match s with
			| [] -> []
			| h :: t -> ( char ((int h) + 13)) :: (encrypt t)
		
	let rot13 (s: string) = 
		let characters = s.ToCharArray ()
		let enc = characters |> List.ofArray |> Helpers.encrypt |> List.toArray

loosechainsaw

module Extensions = 
    type System.Collections.Generic.List<'a> with
        member this.Split (first: int, last: int) = 
            let count = (last - first) + 1
            let result = this.GetRange(first, count)
            result


module Algorithms = 
    open Extensions

loosechainsaw

module Algorithms = 
    let binary_search list value =
        let rec impl(list: 'a list) (value :'a) (hi: int) (low:int)  =
            let index = (hi + low) / 2
            match compare value (list.Item(index)) with
            | 0  -> Some(index)
            | 1 -> impl list value hi index
            | -1 ->  impl list value index low
            | _ -> None
        match list with