Christophe Grand cgrand

Carry

Frequently I want to use reductions only to quickly realize that I'm not interested in the successive values of the state.

A simple example is to imagine one wants to increment a number represented by a sequence of its binary digits:

(inc '()) is (1)
(inc '(1)) is (0 1) ; yes the list is inversed, the lowest significant bit is the first item
(inc '(0 1)) is (1 1)

Monotonic logic is eventually consistent. Eventual Consistency (https://www.voltdb.com/blog/2016/07/21/6265/) has clear limits. It doesn't matter while you are pure. It matters when you go impure (FP). So boundaries must be clear. Boundaries implies coordination. Impure snapshots are expensive.

Monotonicity is ~ relativity. Impure is ~ absolute

clojure.pprint

=> (binding [clojure.pprint/*print-right-margin* 30]
     (clojure.pprint/pprint {:a :b :c {:e :f :g :h :i :j :k :l} :m :n :o {:p {:q :r :s :t}}}))
{:a :b,
 :c
 {:e :f,
  :g :h,
  :i :j,
 :k :l},


	;; (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)

	(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)}]

	package doubetrouble;

	import java.util.concurrent.Callable;

	public class Main implements Callable<Object> {

	private static class Constants {
	final static Object constant;

	static {

	(require '[clojure.string :as s])

	;; Maze GENERATION

	(defn north-of [[row col]] [(dec row) col])
	(defn south-of [[row col]] [(inc row) col])
	(defn west-of [[row col]] [row (dec col)])
	(defn east-of [[row col]] [row (inc col)])

	(defn neighbours [rows cols cell]

	(defn heredoc []
	(let [delim (.readLine in)]
	(->> (repeatedly #(.readLine in))
	(take-while #(not= delim %))
	(interpose \newline)
	(apply str))))

	; The following lines are read (by the reader) as:
	; "Look )(\"\\T\na here doc!\n"
	#=(heredoc)"""

	(defn lambda-model
	"Crude model. rps is requests per second, len is a function that returns the
	execution length in seconds, until is the number of seconds to run the simulation,
	spawn is a function returning the number of ping sub requests, duty is the max age
	for a container, keep-alive is the number of seconds before decommissioning a
	container.
	Returns a map with: the number of user perceived cold starts and the number of
	billable seconds."
	[{:keys [rps len until spawn duty keep-alive]
	:or {rps 10

	(ns ssh-repl.client
	(:require [clojure.java.io :as io]))

	(defn connect
	([user host repl-port {:as options
	:keys [ssh-port repl-host key password]
	:or {ssh-port 22
	repl-host "localhost"}}]
	(let [client (doto (org.apache.sshd.client.SshClient/setUpDefaultClient) .start)
	session (-> client (.connect user host ssh-port) (doto .await) .getSession)]