Gerard Paapu gerardpaapu

Calling methods from a constructor's prototype on objects of another type, is a common pattern in javascript: e.g. using Array::slice to use all or part of the arguments object as an array.

function (first/*, rest... */) {
    var rest = Array.prototype.slice.call(arguments, 1);
    ...
}

This snippet illustrates how you can allow your users to put your library into whatever global they see fit.

This technique currently relies on your script tag being the last on the page at time of execution. This means that it will not probably not play nicely with async or defer

	var Schemi = (function () {
	function NamedType(name) {
	this.name = name;
	}

	function Into(schema, convert) {
	this.schema = schema;
	this.convert = convert;
	}

	(var OrderedSet)
	(set! OrderedSet (function (arr ordered? uniq?)
	(set! this.items (arr or #[]))
	(if uniq?.not this.uniquify
	ordered?.not this.sort)
	this))

	(OrderedSet implement #{
	"length": (function () this.items.length)

	;;; OrderedSet
	;;; ----------
	;;;
	;;; A Collection class that wraps an Array.
	;;; It maintains immutability, an order, and
	;;; does not contain duplicates
	;;;
	;;; Items of the Ordered Set should implement 'Ord'
	(class OrderedSet
	(constructor (items ordered distinct)

	// ==UserScript==
	// @id dft-postion-unfixed
	// @name Remove position fixed
	// @version 1.0
	// @namespace dft
	// @author Matthew Goodall
	// @description Changes position:fixed to position:relative
	// @include *
	// @run-at document-idle
	// ==/UserScript==

	var Promise = (function () {
	function Promise() {
	this.isResolved = false;
	this.didSucceed = false;
	this.value = null;
	this.error = null;
	this.resolveListeners = [];
	this.progressHandlers = [];
	}
	Promise.prototype.then = function (successHandler, errorHandler, progressHandler) {

	// You have a sentence with several words with spaces
	// removed and words having their character order
	// shuffled. You have a dictionary. Write an algorithm
	// to produce the sentence back with spaces and words
	// with normal character order

	function Result(){}

	function Success(words, remaining) {
	this.words = words;

	(function () {
	// conceal the Thunk class to avoid
	// so that the only way to make one is
	// to call Function::thunk
	function Thunk(fn, args) {
	this.fn = fn;
	this.args = args;
	}

	Thunk.prototype.force = function () {

	class Tree
	constructor: ->
	throw new Error "Tree is an abstract class"

	hasKey: (key) ->
	(@lookup key).length is 1

	get: (key, _default=null) ->
	result = @lookup key
	if result.length is 0