borkdude

;; Adapted from: https://thegeez.net/2023/03/01/pinball_scittle.html

#_(do #_:clj-kondo/ignore (warn-on-lazy-reusage!))

(defn element [tag id child-of prepend?]
  (or (js/document.getElementById id)
      (let [elt (js/document.createElement tag)
            parent (if child-of (js/document.querySelector child-of)
                       js/document.body)]
        (set! (.-id elt) id)

borkdude

(ns wordle)

(def board-state (atom []))
(def counter (atom 0))
(def attempt (atom 0))
(def word-of-the-day (atom "hello"))

(defn write-letter [cell letter]
  (set! (.-textContent cell) letter))

borkdude

(ns view.index
  (:require
    [hoplon.core  :as h]
    [javelin.core :as j]))

(defn my-list [& items]
  (h/div :class "my-list"
    (apply h/ul (map #(h/li (h/div :class "my-list-item" %)) items))))

(defonce clicks (j/cell 0))

borkdude

Here's a list of things I collected a conversation on partial. Personally I think using partial almost never has a benefit, while there are some downsides to using it. There are exceptional cases where partial has a benefit, e.g. if you want to "wrap" a multi-arity function or a function with an unknown amount of arguments.

Some reasons not to use partial:

• Some people find it harder to find out what's happening*
• https://ask.clojure.org/index.php/8373/when-should-prefer-comp-and-partial-to-anonymous-functions?show=8374#a8374
• https://www.tiagoespinha.net/2016/12/clojure-beware-of-the-partial/
• https://twitter.com/borkdude/status/796018276044247041
• Better stack traces from SCI (if your code runs through SCI)
• Better performance in some cases (inlining / intrinsics)

borkdude

(ns text-xform
  (:require [clojure.java.io :as io]
            [clojure.string :as str]
            [cheshire.core :as json])
  (:import [java.io BufferedReader]))

;;;; inspired by https://tech.grammarly.com/blog/building-etl-pipelines-with-clojure

(def db (atom 0))

borkdude

#!/bin/sh

#_(
   "exec" "clojure" "-Sdeps" "{:deps {org.clojure/clojurescript {:mvn/version \"1.10.520\"}}}" "$0" "$@"
   )

;; running js_parser.clj "function foo(x) { var y = x + 1; }" will print:
;; [{:type :function, :name "foo", :body [{:variable-statement [{:lvalue "y", :initializer {:type :binary-op, :left "x", :operator "+", :right "1"}}]}], :params ["x"]}]

borkdude

This shows how to require ES modules in a node script which is itself compiled as an ES module by shadow. I made this to verify if nbb's way of requiring ES modules aligns with other tools that accomplish the same using the CLJS compiler.

Build with npx shadow-cljs compile script. Run with node out/script.js. It will print something like:

#js {:columns 202, :rows 45}
[Function: Spinner]

borkdude

(defmacro <-
  [& טופסים]
  (let [[x & טופסים] (reverse טופסים)]
    (loop [x x, טופסים טופסים]
      (if טופסים
        (let [טופס (first טופסים)
              מתארגן (if (seq? טופס)
                       (with-meta `(~(first טופס) ~x ~@(next טופס)) (meta טופס))
                       (list טופס x))]
          (recur מתארגן (next טופסים)))

borkdude

;; {:deps {org.babashka/cli {:mvn/version "0.5.40"}
;;         babashka/fs {:mvn/version "0.1.11"}}}

(ns test-args
  {:clj-kondo/config '{:lint-as {test-args/deftest clojure.core/defn}}}
  (:require
   [babashka.cli :as cli]
   [clojure.test :as t :refer [is]]))

(def ^:dynamic *test-args* (cli/parse-opts *command-line-args*))

borkdude

(ns scrape
  (:require [babashka.pods :as pods]
            [clojure.walk :as walk]))

(pods/load-pod "bootleg") ;; installed on path, use "./bootleg" for local binary

(require '[babashka.curl :as curl])

(def clojure-html (:body (curl/get "https://en.wikipedia.org/wiki/Clojure")))