vvvvalvalval

{:db/ident :bsu.fns/reset-to-many-by,
 :db/doc "Resets the set of entities which are related to `eid` via `ref-attr` to the set given by `val-maps`.
          Assumptions:
          * `ref-attr` is a cardinality-many, ref attribute.
          * `e` is an entity identifier for an _existing_ entity
          (you have to know whether an entity exists before using this function,
          and it's pointless to use it on a non-existing entity as opposed to just asserting all the new values.)
          * `val-maps` is a seq of transaction maps, all of which have the `v-id-attr` key provided.
          * `retract-target-entity?`: whether to call :db.fn/retractEntity on the old entities which get removed from the relationship.
          * the old values of the relationship all have the `id-attr` attribute."

egmontkob

Hyperlinks (a.k.a. HTML-like anchors) in terminal emulators

[ Update 2020-05-31: I won't be maintaining this page or responding to comments anymore (except for perhaps a few exceptional occasions). ]

---

Most of the terminal emulators auto-detect when a URL appears onscreen and allow to conveniently open them (e.g. via Ctrl+click or Cmd+click, or the right click menu).

It was, however, not possible until now for arbitrary text to point to URLs, just as on webpages.

rgdelato

Forms in React.js

Controlled Change

Lets say you want to make form input that shows the user an error message if they leave it blank. If you typically write controlled inputs, you might do something like this simplified example:

class ControlledInput extends Component {
  state = { fields: { username: "" }, errors: {} };

plexus

(defvar-local unrepl-repl-input-start-mark nil)
(defvar-local unrepl-hello-payload nil)

(edn-add-reader :unrepl/param (lambda (x) `(:unrepl/param . ,x)))
(edn-add-reader :unrepl/ns (lambda (x) `(:unrepl/ns . ,x)))
(edn-add-reader :unrepl/ratio (lambda (x) `(:unrepl/ratio . ,x)))
(edn-add-reader :unrepl/meta (lambda (x) `(:unrepl/meta . ,x)))
(edn-add-reader :unrepl/pattern (lambda (x) `(:unrepl/pattern . ,x)))
(edn-add-reader :unrepl/object (lambda (x) `(:unrepl/object . ,x)))
(edn-add-reader :unrepl.java/class (lambda (x) `(:unrepl.java/class . ,x)))

YurySolovyov

(defn class-names [& args]
  (clojure.string/join " "
    (mapv name
      (reduce (fn [arr arg]
        (cond
          (or (string? arg)
              (symbol? arg)
              (keyword? arg)) (conj arr arg)
          (vector? arg) (vec (concat arr arg))
          (map? arg) (vec (concat arr

thheller

(defn my-component [props context updater]
  (cljs.core/this-as this
    (js/React.Component.call this props context updater)
    ;; anything else you want to set-up. use goog.object/set on this
    this))

(gobj/extend
  (.. my-component -prototype)
  js/React.Component.prototype)

lmakarov

'use strict';
exports.handler = (event, context, callback) => {

    // Get request and request headers
    const request = event.Records[0].cf.request;
    const headers = request.headers;

    // Configure authentication
    const authUser = 'user';
    const authPass = 'pass';

rauhs

(def kw-cache #js{})

(defn cached-kw [fqn]
  (if-some [kw (unchecked-get kw-cache fqn)]
    kw
    (let [kw (keyword fqn)]
      (unchecked-set kw-cache fqn kw)
      kw)))

(defn js->clj-fast

OliverJAsh

/*

In JavaScript, objects can be used to serve various purposes.

To maximise our usage of the type system, we should assign different types to our objects depending
on the desired purpose.

In this blog post I will clarify two common purposes for objects known as records and dictionaries
(aka maps), and how they can both be used with regards to the type system.

bhb

Friendly

A beginner-friendly REPL that combines

• rebel-readline
• Expound
• Speculative

Usage