raybellis

(function($) {
    $.fn.queued = function() {
        var self = this;
        var func = arguments[0];
        var args = [].slice.call(arguments, 1);
        return this.queue(function() {
            $.fn[func].apply(self, args).dequeue();
        });
    }
}(jQuery));

raybellis

(function($) {
    $.loop = function(n, cb, ctx) {
        for (var i = 0; i < n; ++i) {
            if (cb.call(ctx, i) === false) break;
        }
    };
})(jQuery);

raybellis

/*global jQuery */
;(function($) {

	/*global document */
	"use strict";

	if (typeof document !== 'undefined' && ('classList' in document.createElement('a'))) {

		var $ = jQuery;

raybellis

;(function($) {

  "use strict";

  $.memoize = function(factory, ctx) {
    var cache = {};
    return function(key) {
      if (!(key in cache)) {
        cache[key] = factory.call(ctx, key);
      }

raybellis

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <stddef.h>

int main(int argc, char *argv[])
{
	const size_t	bufsize = 4096;
	uint8_t			buf_a[bufsize];

raybellis

function memoize(factory, ctx, mapper) {
    const cache = new Map();
    return function(...keys) {
        const key = mapper ? mapper(keys) : keys[0];
        if (!cache.has(key)) {
            cache.set(key, factory.apply(ctx, keys));
        }
        console.debug(cache);
        return cache.get(key);
    }

raybellis

; input value location
.exportzp	X0 := $10
.exportzp	X1 := X0 + 1

; final result appears in [R3:R2]
.exportzp	R0 := X1 + 1
.exportzp	R1 := R0 + 1
.exportzp	R2 := R0 + 2
.exportzp	R3 := R0 + 3

raybellis

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

extern void lcddata(unsigned char n);

static inline uint16_t
display_uint16_t_digit(
  uint16_t n, uint16_t div,

raybellis

class UInt48 {

	constructor(n) {
		if (n instanceof UInt48) {
			Object.assign(this, n);
		} else if (typeof n === 'number') {
			let w0 = n & 0xffff;
			n /= 0x10000;
			let w1 = n & 0xffff;
			n /= 0x10000;

raybellis

extension Array where Element : Hashable {
    
    func modalValue() -> Self.Element? {
        
        // populate a dictionary of element vs count
        var dict: [Self.Element : Int] = [:]
        self.forEach { v in
            if let count = dict[v] {
                dict[v] = count + 1
            } else {