nivekuil

(ns game.poker
  (:require [meander.epsilon :as mean]
	    [hyperfiddle.rcf :as rcf]))

(defn match [hand]
  (mean/find
   hand

   (mean/scan {::rank ?x} ..4)
   ::Quad

nivekuil

(deftype IdAttr [id attr ^:mutable ^number _hasheq]
  IEquiv
  (-equiv
    [this that]
    (boolean
     (or (identical? this that)
         (and (instance? IdAttr that)
              (= id (.-id ^IdAttr that))
              (= attr (.-attr ^IdAttr that))))))

nivekuil

;; Essentially we want to make a tee, passing through diffs for rendering but also taking advantage of missionary's supervision 
;; for mount/unmount effects. Thus the diffs have to have a concept of corresponding to an identity. 3rd try is the charm?

  (def sender (y/observe (fn [!] (def send! !) #(prn "sender dead"))))
  (defn boot [flow]((y/reduce {}nil flow) prn prn))

  (def !state (atom 0))
  (def flow (y/ap
              (let [diff (y/?= sender)
                    res (y/?> (y/observe (fn[!]

nivekuil

      (dom/div
        (let [!cs (atom [0 1 2 3 4]) cs (e/watch !cs)]
          (e/for [c cs]
            (ui/button
                (e/fn [] (reset! !cs (vec (remove #{c} cs))))
              (dom/props {:class "fade-in"})
              (dom/text "REMOVE " c)))
          (ui/button
              (e/fn [] (swap! !cs conj (inc (peek cs))))
            (dom/text "ADD"))))

nivekuil

#?(:cljs (def relative-time-formatter
           (js/Intl.RelativeTimeFormat. "en" #js{:numeric "auto"})))
(defn timeago [time]
  #?(:clj (str time)
     :cljs (let [seconds-ago (t/seconds (t/between (t/now) time))
                 [divide unit] (condp #(> %1 (abs %2)) seconds-ago
                                 60 [1 "second"]
                                 3600 [60 "minute"]
                                 86400 [3600 "hour"]
                                 [86460 "day"])]

nivekuil

(def timer*
  (->> e/<clock ;; produce time
       (y/sample e/-get-system-time-ms) ;; label time
       (y/reductions (fn([] {:t (e/-get-system-time-ms) :dt 0})
                       ([acc next] ;; produce difference
		        {:t (e/-get-system-time-ms)
			 :dt (- next (:t acc))})))))
       
(defn pid [<setpoint {:keys [<force error-threshold k <clock]
                      :or {<force (y/watch (atom 10))

nivekuil

(ns app.todo-list
  (:require contrib.str
            [hyperfiddle.electric :as e]
            [hyperfiddle.electric-dom2 :as dom]
            [hyperfiddle.electric-ui4 :as ui]
            [odoyle.rules :as o]
            [missionary.core :as y])
  #?(:clj (:import [clojure.lang IFn IDeref])))

(defn rule->subject [*s whats then]

nivekuil

;; port of https://blog.bruce-hill.com/a-faster-weighted-random-choice

(defn weighted-randomizer [weights]
  (let [N                     (count weights)
        avg                   (/ (reduce + weights) N)
        aliases               (volatile! (vec (repeat N [1 nil])))
        {:keys [smalls bigs]} (->> (map-indexed
                                    (fn [idx weight]
                                      (if (< weight avg)
                                        [[idx (/ weight avg)] :smalls]

nivekuil

(ns app.client.pathom-remote
  (:require [com.wsscode.pathom3.plugin :as p.plugin]
            [com.fulcrologic.fulcro.algorithms.transit :as fulcro-transit]
            [com.wsscode.pathom3.connect.runner :as pcr]
            [com.wsscode.pathom3.interface.async.eql :as p.a.eql]
            [com.wsscode.pathom3.connect.foreign :as pcf]
            [com.wsscode.transito :as transito]
            [promesa.core :as p]
            [com.fulcrologic.fulcro.algorithms.tx-processing :as txn]
            [taoensso.timbre :as log]

nivekuil

(defn merge-two-vecs
  "Takes a keyfn and two sorted vecs, peek-smallest, and returns one sorted vec.

  e.g. (merge-two-vecs identity [5 3 1] [6 4 2])"
  [keyfn xs ys]
  (let [keyfn (comp keyfn peek)]
    (loop [acc (transient [])
           xs  xs
           ys  ys]
      (let [x (keyfn xs) y (keyfn ys)]