mrrodriguez’s gists

mrrodriguez / core.clj

Last active June 30, 2024 16:13

Simple Text Editor - Clojure

	(ns metasimple.simple-editor.core
	(:require
	[clojure.string :as str]))

	(defn- process-op-append
	[{:keys [text] :as ed-state}
	{:keys [op-type arg]}]
	(-> ed-state
	(update :text str arg)
	(update :undo-history conj {:op-type op-type :text text})))

mrrodriguez / huffman.clj

Last active June 27, 2024 13:59

Basic Huffman encoding example

mrrodriguez / clara-retract-external-fact-example.clj

Created June 21, 2024 19:50

Using unconditional-insert! with retract! in a high :salience (initialization) rule

	(require '[clara.rules :as r])
	(require '[clara.rules.accumulators :as acc])

	(defrecord ExternalFact [id code])
	(defrecord DerivedFact [ids])

	(r/defrule match-and-remove-it
	{:salience 1000000}
	[?fact <- ExternalFact (= ?id id) (= code "a")]
	=>

mrrodriguez / clara-batched-updates.clj

Created January 4, 2024 17:25

Externally batching and updating the working memory state

	(defrecord PrevFetchedItems [item-ids])
	(defrecord ToFetch [items])

	(r/defrule find-items-to-fetch
	[PrevFetchedItems (= ?item-ids item-ids)]
	[?items <- (acc/all) :from [Item (not (contains? ?items id))]]
	=>
	(r/insert! (->ToFetch ?items)))

	(r/defquery get-items-to-fetch []

mrrodriguez / clara-logical-loop.situation.clj

Last active September 24, 2021 13:00

Clara-rules typical logical loop

	;; Usually the solution is to reframe the problem you have in a way that avoids the logical contradiction,
	;; ie. 'not B => B'
	;; and continue to use the default inserts (not unconditional type) that participate in truth maintenance

	;; To avoid a rule like this:
	(r/defrule b-contradiction
	[A]
	[:not [B]]
	=>
	(r/insert! (->B))

mrrodriguez / failures.clj

Created May 3, 2019 19:09

Using `clojure.core/eval` at CLJS macroexpansion-time

	#error {
	:cause "Unable to resolve symbol: bar in this context"
	:via
	[{:type clojure.lang.ExceptionInfo
	:message "failed compiling file:src/example/foo.cljs"
	:data {:file #object[java.io.File 0x2766fb87 "src/example/foo.cljs"]}
	:at [clojure.core$ex_info invokeStatic "core.clj" 4739]}
	{:type clojure.lang.ExceptionInfo
	:message "java.lang.RuntimeException: Unable to resolve symbol: bar in this context, compiling:(thing:6:9) at line 6 src/example/foo.cljs"
	:data {:file "src/example/foo.cljs", :line 6, :column 1, :tag :cljs/analysis-error}

mrrodriguez / reagent-fix-cursor-jump.cljs

Created November 26, 2018 18:43

Reagent input cursor jumping

	;;;; Dealing with jumping cursors on controlled input (a classic React/Reagent problem).
	;;;; For rationale see
	;;;; https://github.com/reagent-project/reagent/issues/265#issuecomment-397895508
	;;;; &
	;;;; https://github.com/reagent-project/reagent/blob/e53be656073af9209c4fe8bc9119635953311d42/examples/material-ui/src/example/core.cljs#L34


	;; In the ns header...
	(:require [reagent.core :as r]
	[reagent.impl.template :as template])

mrrodriguez / clara_tiered_fact_update_rules.clj

Last active July 1, 2020 18:07

Clara tiered fact update rules

	(require '[clara.rules :as r])

	;;;; Define 3 rules, where the "priority" order is r1, r2, r3, where the highest priority is first
	;;;; and the rest is in descending order of priority.

	;;;; :type :rule/result "syntetic" fact is used to hold the final changes that can be queried out
	;;;; from a session after `r/fire-rules` via `r/query` on the `find-results` query.
	;;;; A namespace qualified keyword is used to avoid collision with externally given :type of
	;;;; "real" facts.

mrrodriguez / clj-data-fressian-serde.clj

Last active May 10, 2023 15:46

Clojure Serialization With Fressian


	;;;; Fressian dependency used in these examples
	;; [org.clojure/data.fressian "0.2.1"]

	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	;;;; Using only `org.clojure/data.fressian`

	(require '[clojure.data.fressian :as fres])

	(defn serde-obj

mrrodriguez / unindexing_durability.clj

Created August 19, 2016 18:56

Back when clara.rules.durability had the concept of "unindex"ing memory - was removed for efficiency

	(ns clara.rules.durability
	"Experimental namespace. This may change non-passively without warning.

	Support for persisting Clara sessions to an external store.

	See the serialize-session-state function to retrieve the full state of a session as a data structure that can
	be easily serialized via EDN or Fressian. Sessions can then be recovered with the restore-session-state function.

	TODO: diff support is pending -- functions for obtaining a diff of state from a previous point, allowing for a write-ahead log."
	(:require [clara.rules :refer :all]

Mike Rodriguez mrrodriguez