ghadishayban

(ns day3
  (:require [util]))

(defn adjacent-range
  "returns [(dec lo), (inc hi)], lo clamped by 0, hi clamped by arg"
  [lo hi hi-clamp]
  [(max (dec lo) 0)
   (min (inc hi) hi-clamp)])

(defn scan-adjacent

ghadishayban

;; differences from scheme unfold
;; even initial value is lazy
;; predicate sense reversed
;; internal state == produced value, no special mapper-fn
;; no tail-gen
(defn series
  "Produces a sequence of values.

   `f` is a function that given a value, returns the next value.
   `continue?` is a predicate that determines whether to produce

ghadishayban

(ns weighted-rand
  (:import clojure.lang.PersistentQueue))

(defprotocol Rand
  (nextr [_ rng]))

;; Vose's alias method
;; http://www.keithschwarz.com/darts-dice-coins/

(deftype Vose [n ^ints alias ^doubles prob]

ghadishayban

;; needs a refer-clojure exclude on iteration

(defn iteration
  "returns a channel of items given step!, a function of some (opaque continuation data) k
   step! calls can get bufsize ahead of consumption (asynchronously)

   step! - fn of k/nil to chan yielding (opaque) 'ret'

   :bufsize - buffer this many step! calls, default 1
   :some? - fn of ret -> truthy, indicating there is a value

ghadishayban

;;
;; Example usages at the bottom of the file
;;

(defn productions
  "Returns a sequence of values by repeatedly calling `produce!` until it
   returns `fin`. The sequence can be used lazily/caching or reducible/non-caching.

   The arity-2 variant's `produce!` takes no arguments and returns a value
     or the terminator.

ghadishayban

proto = <syntax> { import | package | option | message | enum | service | emptyStatement } <ws>

(* Header *)
syntax = ws "syntax" ws "=" ws ( "'proto3'" | '"proto3"' ) ws ";"

import = <ws "import" ws> [ "weak" | "public" ] <ws> strLit <ws ";">

package = <ws "package" ws> fullIdent <ws ";">

option = <ws "option" ws> optionName <ws "=" ws > constant <ws ";">

ghadishayban

(defmacro doseqs
  [seq-exprs & body]
  (let [stk   (gensym "stack__")
        level (gensym "level__")
        seq-exprs (partition 2 seq-exprs)
        bindings   (vec (map first seq-exprs))
        init-exprs (vec (map second seq-exprs))

        nbinds (count init-exprs)

ghadishayban

(ns poolboy.chanfut
  (:import [java.util.concurrent CompletableFuture Callable Future]
           [java.util.function BiConsumer]
           [java.util.concurrent Executor ExecutorService])
  (:require [clojure.core.async :as async]
            [clojure.core.async.impl.protocols :as async-impl]))
 
(def async-executor clojure.core.async.impl.exec.threadpool/the-executor)
 
(defprotocol Interruptible

ghadishayban

(ns retry
  (:import [java.util.function Supplier]
           [java.util.concurrent CompletableFuture TimeUnit]))

(defn with-retry
  "given an op wanting retries, and a strategy for backoff,
   returns a CompletableFuture that can be waited on
  
   op takes no args
   A backoff strategy is a function of an exception, returning nil or a number of milliseconds to backoff"

ghadishayban

(import '[java.lang.reflect Method Modifier])

(set! *warn-on-reflection* true)

(defn- samsig
  "Given a SAM interface, returns the j.l.reflect.Method of the abstract method"
  [sym]
  (let [kls (resolve sym)]
    (if (and (class? kls) (.isInterface ^Class kls))
      (let [mid (fn [^Method m] [(.getName m) (vec (.getParameterTypes m))])