disco0

/**
 * class for limiting the rate of function calls.
 * Thanks to Pat Migliaccio.
 * see https://medium.com/@pat_migliaccio/rate-limiting-throttling-consecutive-function-calls-with-queues-4c9de7106acc
 * @example let l = new limit(); let logMessageLimited = l.throttleAndQueue(msg => { console.log(msg); }, 500);
 */
class limit{
    public callQueue = []

    /**

disco0

How to use

Let's say you want to limit some event to 5 occurrences every 20 seconds, you would set up the RateLimit like so:

var limit = new RateLimit(20); // Initialize a 20 second ticklog

// For events that we initiate...
if (limit.count('myevent_id') <= 5)) {

// Do some stuff

disco0

// Substrate Watercolor
// j.tarbell   June, 2004
// Albuquerque, New Mexico
// complexification.net

// Processing 0085 Beta syntax update
// j.tarbell   April, 2005

int dimx = 250;
int dimy = 250;

disco0

//

struct TerminalCell
{
    // cell index into GlyphTexture, should be two 16-bit (x,y) values packed: "x | (y << 16)"
    uint GlyphIndex;

    // 0xAABBGGRR encoded colors, nonzero alpha for Foreground indicates to render colored-glyph
    // which means use RGB values from GlyphTexture directly as output, not as  ClearType blending weights
    uint Foreground;

disco0

function makeThunk(f, args)
    return { tag = "thunk", f = f, args = args }
end

function evalThunk(t)
    return t.f(unpack(t.args))
end

function cons(first, rest)
    return { first = first,

disco0

(fn comprehend [init update ...]
    (let [clauses [...] n (length clauses) result (gensym)]
      (tset clauses n (update result (. clauses n)))
      (for [i (- n 1) 1 -1] (table.insert (. clauses i) (. clauses (+ i 1))))
      `(do (var ,result ,init) ,(. clauses 1) ,result)))

(fn tbl [...]
    (comprehend {}
                (fn [result expr] `(match ,expr (k# v#) (tset ,result k# v#)))
                ...))

disco0

; vim:set ft=fnl:

(fn filter-map [pred iter inv start-control]
  (var control start-control)
  (fn filter-map-inter []
    (let [(new-control value) (iter inv control)]
      (set control new-control)
      (if (= value nil)
          nil
          ; else

disco0

(macros
  {:list-map
   (fn list-map [mapper tgt]
     (when (not (list? tgt)) (error (.. "Invalid form: " (tostring tgt) " is not a list")))
     (let [new-list (list)]
       (each [i v (ipairs tgt)]
         (table.insert new-list (mapper v i tgt)))
       new-list))

   :list-map-recursive

disco0

;; this, https://gist.github.com/nikneym/b7422a73c91d632e95ad34a813aad105
;; but stuffed in a Fennel macro.

(macro class [mother]
  `(let [o# {}
         mother# (or ,mother nil)]
     (tset o# :__index o#)
     (when mother#
       (tset o# :super mother#)
       (each [k# v# (pairs mother#)]

disco0

; lie and say it's clojure for highlighting
; vim: ft=clojure

; this is a hack that won't be necessary if/when we add `get-option` to the macro environment
(local meta-enabled (-> _SCOPE.specials.doc
                        (pcall (list (sym :doc) (sym :doc)) _SCOPE _CHUNK)))

(fn meta/when-enabled [...]
  "Execute body in an implicit `do` when metadata is enabled. Otherwise,
contents are excluded from compiled output."