cgrand

(ns parquet-layout.core)

(defn destock
  ([stock] stock)
  ([stock board]
   (let [n (dec (stock board))]
     (if (zero? n)
       (dissoc stock board)
       (assoc stock board n)))))

cgrand

(ns workshop.main
  (:require ["package:flutter/material.dart" :as m]
            ["package:google_fonts/google_fonts.dart" :as fonts]
            #_["example.dart" :as ex]
            [cljd.flutter.alpha2 :as f]))

(def normal-text-style
  (fonts/GoogleFonts.sourceCodePro
    .fontSize 26
    .fontWeight m/FontWeight.w700

cgrand

(ns tensegritics.expressive.datalog
  "Putting expressions in datomic-flavored datalog :where clauses.")

;; I (cgrand) believes that datalog literally lacks expressivity because
;; it's not expression-based but clause-based and thus requires a lot of
;; gratuitous naming.
;; Here is an attempt to compiles expressions into clauses.

(defn- grounded? [[e a v]] (and (keyword? a) (not (symbol? v))))

cgrand

;; let's say you want to perform an action only when a state is true and returns true/false depending on the action success
;; typically I would write

(if @open ; check state
  (do
    (.put q bytes) ; action
    true)
  false)
  
;; or

cgrand

;; For ClojureDart in a bout of NIH syndrome we rewrote Clojure for
;; it seems to be faster because we don't use concat
(defmacro for
  "List comprehension. Takes a vector of one or more
   binding-form/collection-expr pairs, each followed by zero or more
   modifiers, and yields a lazy sequence of evaluations of expr.
   Collections are iterated in a nested fashion, rightmost fastest,
   and nested coll-exprs can refer to bindings created in prior
   binding-forms.  Supported modifiers are: :let [binding-form expr ...],
   :while test, :when test.

cgrand

log(String msg, x) {
  print(msg);
  return x;
}

var a = log("Init A", 1);
var b = log("Init B", 2);
var c = log("Init C", 3);

main() {

cgrand

Accessing super members in ClojureDart

In ClojureDart deftype (and reify) can extend abstract classes and, as a consequence, we need a way to call super implementations (even on fields because of getters/setters).

For example, this Dart

class WebViewExampleState extends State<WebViewExample> {
  @override
 void initState() {

cgrand

Quick notes on how the fallback pseudo-type is used in cljd (ClojureDart).

Like cljs, cljd is built on protocols. Like in clj, each protocol is backed by an interface for the fast path. Let's call this interface the direct interface.

Cljd protocols are also backed by a second interface used for extensions to 3rd-party classes. Let's call this interface the extension interface.

Protocols are reified as instances of an IProtocol interface:

// emitted code

cgrand

;; (cond-let 
;;   (odd? x) [x n] (inc x)  
;;   (< n 10) [y (inc n)] 10
;;   :else n))

;; we want the above to yield
;; (let [x n]
;;   (if (odd? x)
;;      (inc x)

cgrand

(ns enlivez.demo
  (:require [enlivez.core :as ez]
    [datascript.core :as d]))

(ez/deftemplate new-item []
  :state {:db/id self
          new-todo ""}
  [:li
    [:input {:value new-todo
             :on-change (doto [[:db/add self ::new-todo (-> % .-target .-value)]] prn)}]