reborg

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats.

How to use:

• The link in the table of content jumps at the copy of the answer on this page.
• The link on the answer itself points back at the original post.

Table of Content

paulirish

// see for screenshot:
//     https://twitter.com/paul_irish/status/829090506084749312 

const http = require('http');

function requestHandler(request, response) {
	const headers = {
		'Server-Timing': `
		  sql-1;desc="MySQL lookup Server";dur=100,
		  sql-2;dur=900;desc="MySQL shard Server #1",

tcoupland

(defn -bool?
  [x]
  (cond
    (boolean? x) x
    (string? x) (case x
                  ("true" "TRUE" "t" "T") true
                  ("false" "FALSE" "f" "F") false
                  :clojure.spec/invalid)
    :else :clojure.spec/invalid))

halgari

The question was asked why I (as a programmer who prefers dynamic languages) don't consider static types "worth it". Here
is a short list of what I would need from a type system for it to be truely useful to me: 

1) Full type inference. I would really prefer to be able to write: 

(defn concat-names [person]
  (assoc person :full-name (str (:first-name person)
                                (:second-name person))))

And have the compiler know that whatever type required and produced from this function was acceptible as long as the 

bgdnlp

#!/bin/bash
#
# efsaz         Set availability zone for EFS mounts in fstab
#
# chkconfig: 345 24 74
# description:  Replaces the availability zone for EFS mount points in fstab \
#               with the proper value for the current instance, which it gets \
#               from instance metadata. This script must run before the \
#               netfs script, which mounts network filesystems. It is useful \
#               in autoscaling groups, where the instance starting might \

robert-stuttaford

(ns cognician.db.translate
  (:require [datomic.api :as d])
  (:import [clojure.lang MapEntry]
           [datomic.query EntityMap]))

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; Language

(def default-language :en-GB)

ohpauleez

;; Let's start with a simple conditional interceptor that works with functions...

(defn conditional-context                                                                                       
  "Given a keyword name and any variable predicate and terminator function pairs,                               
  return an interceptor that will apply the terminator function paired to the first                             
  truthy predicate.  Predicates and terminators are both given the context as                                   
  the only argument.                                                                                            
  If all predicates fail, the original context is returned."                                                    
  [name-kw & pred-terms]                                                                                        

bhauman

(ns cljs.compiler-options-schema
  (:require
   [clojure.spec :as s]
   [clojure.string :as string]
   ;; for initial dev
   [clojure.test :refer [deftest is testing]]))

(defn non-blank-string? [x] (and (string? x) (not (string/blank? x))))

(defonce ^:private registry-ref (atom {}))

Conaws

;  In case anyone else is interested, here are a few specter functions I wrote that will 
;  find all the nested maps inside a composite datastructure, 
;  assign each of them a temporary id
;  then it'll pull it apart into a list, 
;  and replace all references to the map with its id

(ns extract-maps
  (:require [datascript.core    :as d]
            [com.rpl.specter    :as sp
                                :refer [ALL LAST MAP-VALS FIRST subselect

Engelberg

(ns utils.cond
  "A collection of variations on Clojure's core macros. Let's see which features
   end up being useful."
  {:author "Christophe Grand"}
  (:refer-clojure :exclude [cond when-let if-let]))

(defmacro if-let
  "A variation on if-let where all the exprs in the bindings vector must be true.
   Also supports :let."
  ([bindings then]