Clojure

本页使用了标题或全文手工转换，现处于中国大陆简体模式
求闻百科，共笔求闻
Clojure
编程范型多重编程范型:
设计者里奇·希基（Rich Hickey）
发行时间2007年，​17年前​（2007）
稳定版本
1.10.1[8]
（2019年6月6日，​4年前​（2019-06-06） ）
类型系统
系统平台
许可证Eclipse公共许可证
文件扩展名
  • .clj
  • .cljs
  • .cljc
  • .edn
网站clojure.org
受启发于
施影响于

Clojure（/ˈkloʊʒər/）[15][16]是Lisp编程语言在Java平台上的现代、动态及函数式方言。[17][18]与其他Lisp一样，Clojure视代码为数据且拥有一套Lisp宏系统。[19]其开发过程目前由社区驱动，[20]其作者里奇·希基（Rich Hickey）则以终身仁慈独裁者（BDFL）的身份进行监督。[21]

Clojure提倡不可变性（immutability）与持久数据结构（persistent data structures）并鼓励程序员显式地管理标识（identity）及其状态（state）。[22]对利用不可变值（immutable values）及显式时间进展构造（explicit progression-of-time constructs）进行编程的专注旨在促进更加健壮的（尤其是并发）程序的开发。[15][23][24]Clojure的类型系统是完全动态的，但人们近期也开始探索其基于渐进类型化（gradual typing）的实现。[25]

对Clojure的商业支持由Cognitect公司提供。[26]每年都会在全球范围内举办年度Clojure会议，其中最著名的是Clojure/conj[27]。

历史与开发过程

里奇·希基，Clojure的创造者
里奇·希基，Clojure的创造者

里奇·希基（Rich Hickey）是Clojure语言的创造者。[17]在Clojure之前，他开发过类似但基于.NET平台的项目——dotLisp。[28]在那之前，他还有过三次旨在在Lisp与Java之间提供互操作（interoperability）的尝试：“Common Lisp的Java外语接口”［Java foreign language interface for Common Lisp (jfli)］[29]、“Lisp的外语对象接口”［Foreign Object Interface for Lisp (FOIL)］[30]以及“Lisp友好的Java Servlet接口”［Lisp-friendly interface to Java Servlets (Lisplets)］[31]。

在公开发布之前，里奇·希基在Clojure的工作上花了大约两年半的时间。期间，在没有外部资金的情况下，他将其大部分时间都专门投入到了Clojure的工作上。在这段时间结束时，里奇·希基以电子邮件的形式向他在Common Lisp社区里的一些朋友宣布了该语言。

Clojure的开发过程由社区驱动[20]并且在Clojure JIRA项目网页上进行管理。[32]该网站可用于提交问题报告（issue）。一般的开发讨论是在“Clojure谷歌网上论坛”（Clojure Google Group）上进行的。[33]任何人都可以提交错误报告和想法，而贡献补丁（patches）则需要先签署“Clojure贡献者协议”（Clojure Contributor Agreement）。[34]JIRA错误报告（JIRA ticket）由一个筛选者（screener）团队进行处理并最终由里奇·希基批准更改。[35]

设计理念

里奇·希基开发Clojure的原因是因为他想要一款适合函数式编程的现代Lisp。该语言既需要与已创建的Java平台共生又需要有适合并发性的设计。[15][23][24][36]

Clojure对待变化（change）的方式以标识（identity）的概念为特征。[22]标识是指随着时间的推移而产生的一系列状态（state）。而状态则是指标识在某一特定时间点上的值（value）。需要强调的是，这里的值是不可变的（immutable）。由此引申，由于状态是不可变的值，任意数量的工作单位（workers）都可以在其上以并行（parallel）的方式实施操作。因此，并发性（concurrency）就成为一道管理状态间变化的问题［注意，这里的“变化”是指从一个状态到另外一个状态的跃迁（transition）而不是状态本身的变化（mutation）。］为此，Clojure提供了几个可变的（mutable）引用类型（reference type）。每个引用类型都有其明确定义的语义用于控制状态之间的跃迁。[22]

语言概述

版本 发布日期 主要功能/改进
2007年10月16日 首次公开发布
1.0 2009年5月4日 首个稳定版
1.1 2009年12月31日 将来（future）
1.2 2010年8月19日[37] 协议（protocol）
1.3 2011年9月23日[38] 增强对原始类型（primitive type）的支持
1.4 2012年4月15日[39] 读取器字面量（reader literal）
1.5 2013年3月1日[40] 归纳器（reducer）
1.5.1 2013年3月10日[41] 修复内存泄漏
1.6 2014年3月25[42] Java API、经过改进的哈希算法
1.7 2015年6月30日[43] 变换归纳器（transducer）、读取器条件表达式（reader conditionals）
1.8 2016年1月19日[44] 附加的字符串函数、直接连接（direct linking）、套接字服务器（socket server）
1.9 2017年12月8日[45] 集成spec、命令行工具
1.10 2018年12月17日[46] 经过改进的错误报告、Java兼容性
当前版本： 1.10.1 2019年6月6日[8] 解决Java性能回归问题并改进clojure.main的错误报告
格式：
旧版本
旧版本，仍被支持
当前版本
最新的预览版
未来版本

Clojure执行于Java平台之上，因此，与Java紧密集成并完全支持从Clojure调用Java代码。[15][47]与此同时，也可以从Java调用Clojure代码。[48]Leiningen是社区中普遍使用的项目自动化工具。Leiningen为Maven集成提供支持，处理项目包管理和依赖项。Leiningen的配置使用的则是Clojure语法。[49]

与其他大多数Lisp一样，Clojure的语法创建在S-表达式之上。S-表达式在被编译之前先由读取器（reader）解析为数据结构。[15][50]除了列表（list）之外，Clojure的读取器还支持映射（map）、集合（set）及向量（vector）等的字面量（literal）语法。这些字面量随后会被直接编译成上述数据结构。[50]Clojure是Lisp-1且有一套与其它Lisp不兼容的数据结构，因此，Clojure不支持与Lisp的其它方言之间的代码级兼容性。[19]

作为一门Lisp方言，函数在Clojure中是一等公民。此外，Clojure还支持读取﹣求值﹣输出循环（REPL）以及一套宏系统。[6]Clojure的Lisp宏系统与Common Lisp的系统极为相似。唯一不同的是，Clojure的重音符［称为“语法引用”（syntax quote）］用名字空间（namespace）来限定符号（symbol）。这有助于防止意外的名字捕获（unintended name capture），因为Clojure禁止绑定（binding）到用名字空间限定的名字（namespace-qualified name）上。如果需要强制捕获宏扩展（capturing macro expansion，）那么就需要显示地完成该过程。Clojure不支持用户定义的读取器宏（reader macro，）但Clojure的读取器支持更具约束力的语法扩展（syntactic expansion）形式。[51]Clojure支持多方法（multimethods。）[52]对于类似接口的抽象，Clojure提供基于协议[53]的多态性（polymorphism）以及基于记录（record）[54]的数据类型系统。 Clojure通过这些设计来提供高性能且动态的多态性以避免所谓的“表达式问题”（"expression problem"。）

Clojure支持惰性序列，并鼓励不可变性（immutability）与持久数据结构（persistent data structure。）Clojure作为一门函数式编程语言将重点放在递归与高阶函数上而不是基于副作用的循环流程上。Clojure不支持自动尾调用优化，因为JVM还不支持该项优化，[55][56]但是，可以用recur关键字显式地进行该项优化。[57]对于并行与并发计算，Clojure提供软件事务内存、[58]响应式代理系统[1]及基于通道（channel）的并发编程。[59]

Clojure 1.7引入了读取器条件表达式（reader conditional）从而允许在同一名字空间中嵌入Clojure与ClojureScript代码。[43][50]变换归纳器（transducer）的加入则提供了另一种组合变换的方法。变换归纳器可以使高阶函数（如，map和fold）更加抽象从而使之独立于其输入数据源。传统地说，这些函数一般被应用于序列（sequence）上，而变换归纳器允许这些函数被应用于通道（channel）上并让用户定义她们自己的变换归纳（transduction）模型。[60]

平台

Clojure的主要平台是Java[18][47]但也存在其他目标平台上的实现。其中，最值得关注的是ClojureScript[61]（可被编译成ECMAScript 3[62]）和ClojureCLR[63]（.NET平台上的完整移植版，可与其生态系统互操作。）2013年对1,060名受访者进行的Clojure社区调查[64]发现，47％的受访者在使用Clojure的同时也使用ClojureScript。2014年，这一数字增长到了55％，[65]而到了2015年，则达到了66％（根据2,445名受访者）。[66]人气较高的ClojureScript项目包括React实现，如Reagent[67]、re-frame[68]、Rum[69]及Om[70][71]。

人气

随着对函数式编程的兴趣的持续升温，Clojure也越来越多地受到Java平台上的软件开发人员的青睐。该语言也一度成为知名软件开发老将，如Brian Goetz[72][73][74]、Eric Evans、詹姆斯·高斯林（James Gosling）、保罗·格雷厄姆（Paul Graham）及Robert C. Martin（俗称“鲍勃大叔（Uncle Bob）”）[75][76][77]等，的首选或推荐语言。

在由Snyk和Java Magazine合作编写的“JVM生态系统报告2018”（据称是“Java开发人员有史以来规模最大的调查”）中，Clojure被评为用于“主要应用程序”的第二大人气编程语言（仅次于Java）。[78]

业内使用Clojure的公司有苹果公司[79]、Atlassian、Funding Circle[80]、Netflix[81]、 Puppet [82]、沃尔玛[83]及其他大型软件公司[84]与美国国家航空航天局[85]等政府机构。Clojure也一度被用于创意计算，包括视觉艺术、音乐、游戏和诗歌。[86]

美国知名软件咨询公司ThoughtWorks在为其“技术雷达”[87]评估函数式编程语言时表达了他们对Clojure的青睐，称其为“Lisp在JVM上的简单及优雅实现”，并在2012年将其状态提升为“采用”（“ADOPT”）[88]。

越来越多的非官方和/或实验性的其他平台实现也验证了该语言的人气：

  • CljPerl[89]：Clojure的Perl实现
  • Clojerl[90]：BEAM（Erlang虚拟机）上的Clojure
  • clojure-py[91]：Clojure的纯Python实现
  • Ferret[92]：可被编译成运行于微控制器的自包含（self-contained）C++11
  • Joker[93]：用Go实现的解释器（interpreter）和linter
  • Las3r[94]：执行于ActionScript虚拟机（Adobe Flash Player平台）的Clojure子集
  • Pixie[95]：受Clojure启发并用RPython实现的Lisp方言
  • Rouge[96]：Clojure基于YARV的Ruby实现

开发工具

Clojure的开发工具在近几年得到了显著的改善。以下是目前最具人气的集成开发环境（IDE）/编辑器及其Clojure插件。[97]这些工具的结合为Clojure编程提供了出色的支持。

集成开发环境/编辑器及其Clojure插件
集成开发环境/编辑器 Clojure插件
Atom Chlorine[98]
Emacs CIDER[99]
IntelliJ IDEA Clojure-Kit[100]或Cursive[101]（提供免费的非商业许可证）
Light Table[102] （不适用）
Vim fireplace.vim[103][104], vim-iced[105]或Conjure（仅限Neovim）[106][107]
Visual Studio Code Calva[108]

除了社区提供的开发工具之外，官方的命令行界面（CLI）工具[109]也随着Clojure 1.9一起发布并可在GNU/Linux、macOS及Windows上使用。[110]

功能示例

以下示例均可在Clojure REPL中运行（如，使用Clojure命令行界面工具[109]启动的REPL或在REPL.it[111]上提供的在线REPL。）

简单性

由于强调简单性，典型的Clojure程序主要包括函数和简单的数据结构（即列表，向量，映射和集合）： 

;; 一个典型的Clojure程序的入口
(defn -main ; 函数名
  [& args] ; 参数向量 (`&`表示可变参数)
  (println "Hello, World!")) ; 函数体

REPL编程

与其他Lisp一样，Clojure的标志性特征之一是基于REPL的交互式编程。[112]在以下示例中，;;表示一行注释的开始，而;; =>则表示输出： 

;; 定义一个var
(def a 42)
;; => #'user/a

;; 调用名为`+`的函数
(+ a 8)
;; => 50

;; 调用名为`even?`的函数
(even? a)
;; => true

;; 定义一个函数以返回n除10之余
(defn foo [n] (rem n 10))
;; => #'user/foo

;; 调用该函数
(foo a)
;; => 2

;; 打印`rem`的文档字符串（docstring）
(doc rem)
;; =>
-------------------------
clojure.core/rem
([num div])
 remainder of dividing numerator by denominator.

;; 打印`rem`的源代码
(source rem)
;; =>
(defn rem
  "remainder of dividing numerator by denominator."
  {:added "1.0"
   :static true
   :inline (fn [x y] `(. clojure.lang.Numbers (remainder ~x ~y)))}
  [num div]
    (. clojure.lang.Numbers (remainder num div)))

运行时可用的名字

与Clojure不同，其他语言的编译器会将程序中的名字编译掉使得它们在运行时不可用。而在Clojure中，可以用普通的数据结构对其运行时进行观察： 

;; 定义一个var
(def a 42)
;; => #'user/a

;; 以映射（map）的形式获取在`user`名字空间中捕获的（interned）所有var
(ns-publics 'user)
;; => {a #'user/a}

;; 用`#'`（读取器宏）及其关联的、名字空间限定的符号`user/a`引用该var
#'user/a
;; => #'user/a

;; 解引用该var（获取其值）
(deref #'user/a)
;; => 42

;; 定义（并附加文档字符串）一个函数以返回n除10之余
(defn foo "返回`(rem n 10)`" [n] (rem n 10))
;; => #'user/foo

;; 获取var `#'user/foo`的元数据
(meta #'user/foo)
;; =>
{:arglists ([n]),
 :doc "返回`(rem n 10)`",
 :line 1,
 :column 1,
 :file "user.clj",
 :name foo,
 :ns #namespace[user]}

代码即数据（同像性）

与其他Lisp类似，Clojure也具有同像性［又被称为“代码即数据”（code as data）］。从下面的示例中可以看到，用Clojure编写代码从而修改代码本身是非常容易的： 

;; 调用一个函数 （代码）
(+ 1 1)
;; => 2

;; 引用该函数调用
;;（将代码转换成数据，此处为含一组符号的列表）
(quote (+ 1 1))
;; => (+ 1 1)

;; 获取该列表上的首个元素
;; （视代码为数据并对其进行操作）
(first (quote (+ 1 1)))
;; => +

;; 获取该列表上的最后一个元素
;; （视代码为数据并对其进行操作）
(last (quote (+ 1 1)))
;; => 1

;; 替换原列表上的符号从而获取一个新列表
;; （视代码为数据并对其进行操作）
(map (fn [form]
       (case form
         1 'one
         + 'plus))
     (quote (+ 1 1)))
;; => (plus one one)

富有表现力的数据变换操作符

穿梭宏（threading macro，如，->、->>等）可以在语法上表达一个数据集在一系列变换间穿梭的抽象： 

(->> (range 10)
     (map inc)
     (filter even?))
;; => (2 4 6 8 10)

利用变换归纳器（transducer）也可以更有效地实现该过程： 

(sequence (comp (map inc)
                (filter even?))
          (range 10))
;; => (2 4 6 8 10)

标识及其状态的线程安全管理

线程安全的唯一序列号生成器（然而，和许多其他Lisp方言一样，Clojure内部使用其内置的gensym函数）： 

(def i (atom 0))

(defn generate-unique-id
  "每次调用会返回一个唯一数字ID。"
  []
  (swap! i inc))

宏

java.io.Writer的一个匿名子类（不写任何内容）和一个宏（使用该类来静音其中打印的所有内容）: 

(def bit-bucket-writer
  (proxy [java.io.Writer] []
    (write [buf] nil)
    (close []    nil)
    (flush []    nil)))

(defmacro noprint
  "在对给定的`forms`求值的同时静音所有向`*out*`打印的内容。"
  [& forms]
  `(binding [*out* bit-bucket-writer]
     ~@forms))

(noprint
  (println "Hello, nobody!"))
;; => nil

Java互操作

作为其主要设计目标之一，Clojure从一开始就将其宿主平台（host platforms）视为其不可分割的一部分。Clojure与Java之间出色的互操作即得益于此： 

;; 调用一个实例方法
(.toUpperCase "apple")
;; => "APPLE"

;; 调用一个静态方法
(System/getProperty "java.vm.version")
;; => "12+33"

;; 创建`java.util.HashMap`的一个实例
;; 并加入一些键值对（key-value pairs）
(doto (java.util.HashMap.)
  (.put "apple" 1)
  (.put "banana" 2))
;; => {"banana" 2, "apple" 1}

;; 创建`java.util.ArrayList`的一个实例
;; 并用`clojure.core/map`递增（increment）其元素
(def al (doto (java.util.ArrayList.)
          (.add 1)
          (.add 2)
          (.add 3)))

(map inc al)
;; => (2 3 4)

;; 利用Java Swing显示一个消息对话框
(javax.swing.JOptionPane/showMessageDialog
  nil
  "Hello, World!")
;; => nil

软件事务内存

10个线程操纵一个共享数据结构，该结构由100个向量组成，而每个向量包含10个（最初是连续的）唯一数字。每个线程随后在两个随机向量中重复选择两个随机位置并交换它们。通过使用Clojure的软件事务内存系统，对向量的所有更改都发生在事务中： 

(defn run
  [nvecs nitems nthreads niters]
  (let [vec-refs
        (->> (* nvecs nitems)
             (range)
             (into [] (comp (partition-all nitems)
                            (map vec)
                            (map ref))))

        swap
        #(let [v1 (rand-int nvecs)
               v2 (rand-int nvecs)
               i1 (rand-int nitems)
               i2 (rand-int nitems)]
          (dosync
            (let [tmp (nth @(vec-refs v1) i1)]
              (alter (vec-refs v1) assoc i1 (nth @(vec-refs v2) i2))
              (alter (vec-refs v2) assoc i2 tmp))))

        report
        #(->> vec-refs
              (into [] (comp (map deref)
                             (map (fn [v] (prn v) v))
                             cat
                             (distinct)))
              (count)
              (println "Distinct:"))]

    (report)

    (->> #(dotimes [_ niters] (swap))
         (repeat nthreads)
         (apply pcalls)
         (dorun))

    (report)))

(run 100 10 10 100000)
;; =>
[0 1 2 3 4 5 6 7 8 9]
[10 11 12 13 14 15 16 17 18 19]
  ...
[990 991 992 993 994 995 996 997 998 999]
Distinct: 1000

[382 318 466 963 619 22 21 273 45 596]
[808 639 804 471 394 904 952 75 289 778]
  ...
[484 216 622 139 651 592 379 228 242 355]
Distinct: 1000
nil

参考文献

  1. ↑ 1.0 1.1 Agents and Asynchronous Actions. Clojure.org. [2019-07-07]. 
  2. ↑ Concurrent Programming. Clojure.org. [2019-07-07]. 
  3. ↑ Hickey, Rich; contributors. core.async. GitHub.com. [2019-07-07]. 
  4. ↑ Functional Programming. Clojure.org. [2019-07-07]. 
  5. ↑ Nolen, David; Hickey, Rich; contributors. core.logic. GitHub.com. [2019-07-07]. 
  6. ↑ 6.0 6.1 Macros. Clojure.org. [2019-07-07]. 
  7. ↑ Esterhazy, Paulus. Threading Macros Guide. Clojure.org. [2019-07-07]. 
  8. ↑ 8.0 8.1 Miller, Alex. Clojure 1.10.1 release. Clojure.org. 2019-06-06 [2019-06-08]. 
  9. ↑ Fogus, Michael. Rich Hickey Q&A. CodeQuarterly.com. 2011 [2019-07-08]. 
  10. ↑ Hickey, Rich. Clojure Bookshelf. Amazon.com. [2019-07-07]. 
  11. ↑ Bonnaire-Sergeant, Ambrose. A Practical Optional Type System for Clojure (学位论文). The University of Western Australia. 2012. 
  12. ↑ Clojure Programming (PDF). OReilly.com. [2013-04-30]. 
  13. ↑ Baldridge, Timothy. Pixie. PixieLang.org. [2019-07-07]. 
  14. ↑ Ramachandra, Ramkumar. Rhine. GitHub.org. [2019-07-07]. 
  15. ↑ 15.0 15.1 15.2 15.3 15.4 Edwards, Kathryn. The A-Z of Programming Languages: Clojure. Computerworld.com.au. 2009-08-10 [2019-09-11]. 
  16. ↑ Hickey, Rich. meaning and pronunciation of Clojure. Google.com. 2009-01-05. 
  17. ↑ 17.0 17.1 Krill, Paul. Clojure inventor Hickey now aims for Android. InfoWorld.com. 2012-03-22 [2019-07-08]. 
  18. ↑ 18.0 18.1 Clojure. Clojure.org. [2019-07-07]. 
  19. ↑ 19.0 19.1 Differences with other Lisps. Clojure.org. [2019-07-07]. 
  20. ↑ 20.0 20.1 Development. Clojure.org. [2019-07-07]. 
  21. ↑ Hickey, Rich. Open Source is Not About You. GitHub.com. 2018-11-26 [2019-07-08]. 
  22. ↑ 22.0 22.1 22.2 Values and Change: Clojure’s approach to Identity and State. Clojure.org. [2019-07-07]. 
  23. ↑ 23.0 23.1 Hickey, Rich. Rationale. Clojure.org. [2019-07-07]. 
  24. ↑ 24.0 24.1 Torre, Charles. Expert to Expert: Rich Hickey and Brian Beckman – Inside Clojure. MSDN.com. 2009-10-06 [2018-11-01]. 
  25. ↑ core.typed. GitHub.com. [2019-07-07]. 
  26. ↑ Investing in A Better Way. Cognitect.com. [2019-07-07]. 
  27. ↑ Clojure/conj. Clojure-Conj.org. [2019-07-07]. 
  28. ↑ Hickey, Rich. [ANN] dotLisp – a Lisp dialect for .Net. Google.com. 2002-10-16. 
  29. ↑ Hickey, Rich. jfli. SourceForge.net. 2013-04-15 [2018-11-03]. 
  30. ↑ Hickey, Rich. foil - Foreign Object Interface for Lisp. SourceForge.net. 2013-04-03 [2018-11-03]. 
  31. ↑ Hickey, Rich. Lisplets. SourceForge.net. 2013-03-07 [2018-11-03]. 
  32. ↑ Clojure. Atlassian.net. [2019-07-07]. 
  33. ↑ Clojure. Google.com. 
  34. ↑ Contributor Agreement. Clojure.org. [2019-07-07]. 
  35. ↑ Workflow. Clojure.org. [2019-07-07]. 
  36. ↑ Elmendorf, Dirk. Economy Size Geek – Interview with Rich Hickey, Creator of Clojure. LinuxJournal.com. 2010-04-01 [2018-11-03]. 
  37. ↑ Hickey, Rich. Clojure 1.2 Release. Google.com. 2010-08-19. 
  38. ↑ Redinger, Christopher. [ANN] Clojure 1.3 Released. Google.com. 2011-09-23. 
  39. ↑ Dipert, Alan. [ANN] Clojure 1.4 Released. Google.com. 2012-04-17. 
  40. ↑ Halloway, Stuart. ANN: Clojure 1.5. Google.com. 2013-03-01. 
  41. ↑ Halloway, Stuart. Clojure 1.5.1. Google.com. 2013-03-10. 
  42. ↑ Miller, Alex. [ANN] Clojure 1.6. Google.com. 2014-03-25. 
  43. ↑ 43.0 43.1 Miller, Alex. Clojure 1.7 is now available. Clojure.org. 2015-06-30 [2019-07-08]. 
  44. ↑ Miller, Alex. Clojure 1.8 is now available. Clojure.org. 2016-01-19 [2019-07-08]. 
  45. ↑ Miller, Alex. Clojure 1.9 is now available. Clojure.org. 2017-12-08 [2019-07-08]. 
  46. ↑ Miller, Alex. Clojure 1.10 release. Clojure.org. 2018-12-17 [2018-12-17]. 
  47. ↑ 47.0 47.1 Hosted on the JVM. Clojure.org. [2019-07-07]. 
  48. ↑ Java Interop. Clojure.org. [2019-07-07]. 
  49. ↑ Hagelberg, Phil; contributors. Leiningen. Leiningen.org. [2019-07-07]. 
  50. ↑ 50.0 50.1 50.2 The Reader. Clojure.org. [2019-07-07]. 
  51. ↑ Hickey, Rich. edn. GitHub.com. [2019-07-07]. 
  52. ↑ Multimethods and Hierarchies. Clojure.org. [2019-07-07]. 
  53. ↑ Protocols. Clojure.org. [2019-07-07]. 
  54. ↑ Datatypes: deftype, defrecord and reify. Clojure.org. [2019-07-07]. 
  55. ↑ Rose, John. tail calls in the VM. Oracle.com. 2007-07-12 [2018-11-04]. 
  56. ↑ Rose, John. Some languages need to be able to perform tail calls. Java.net. 2009-02-11 [2018-11-04]. 
  57. ↑ Special Forms. Clojure.org. [2019-07-07]. 
  58. ↑ Refs and Transactions. Clojure.org. [2019-07-07]. 
  59. ↑ Hickey, Rich. Clojure core.async Channels. Clojure.org. 2013-06-28 [2019-07-08]. 
  60. ↑ Hickey, Rich. Transducers are Coming. Cognitect.com. 2014-08-06 [2019-07-08]. 
  61. ↑ ClojureScript. ClojureScript.org. [2019-07-06]. 
  62. ↑ ClojureScript – FAQ (for JavaScript developers). ClojureScript.org. [2018-02-04]. 
  63. ↑ ClojureCLR. GitHub.com. [2012-06-28]. 
  64. ↑ Emerick, Chas. Results of the 2013 State of Clojure & ClojureScript survey. CEmerick.com. 2013-11-18 [2018-11-04]. 
  65. ↑ State of Clojure 2014 Survey Results. WuFoo.com. [2015-09-17]. 
  66. ↑ Gehtland, Justin. State of Clojure 2015 Survey Results. Cognitect.com. 2016-01-28 [2018-11-04]. 
  67. ↑ Reagent. GitHub.io. [2019-07-06]. 
  68. ↑ re-frame. GitHub.com. [2019-07-06]. 
  69. ↑ Prokopov, Nikita. Rum. GitHub.com. [2019-07-06]. 
  70. ↑ Nolen, David. Om. GitHub.com. [2019-07-06]. 
  71. ↑ Coupland, Tom. Om: Enhancing Facebook's React with Immutability. InfoQ.com. 2014-01-17 [2019-07-08]. 
  72. ↑ Goetz, Brian. Brian Goetz' favorite non-Java JVM language (Part 1 of 3). Twitch.tv. 2020-05-24 [2020-08-07]. 
  73. ↑ Goetz, Brian. Brian Goetz' favorite non-Java JVM language (Part 2 of 3). Twitch.tv. 2020-05-24 [2020-08-07]. 
  74. ↑ Goetz, Brian. Brian Goetz' favorite non-Java JVM language (Part 3 of 3). Twitch.tv. 2020-05-24 [2020-08-07]. 
  75. ↑ Martin, Robert. Why Clojure?. CleanCoder.com. 2019-08-22 [2019-08-23]. 
  76. ↑ Martin, Robert. Introduction To Functional Programming. CleanCoders.com. 2018-08 [2019-07-08]. 
  77. ↑ Martin, Robert. Pragmatic Functional Programming. CleanCoder.com. 2017-07-11 [2019-07-08]. 
  78. ↑ Maple, Simon; Binstock, Andrew. JVM Ecosystem Report 2018. Snyk.io. 2018-10-17 [2019-06-08]. 
  79. ↑ Jobs at Apple. Apple.com. [2019-07-06]. 
  80. ↑ Pither, Jon. Clojure in London: Funding Circle – Lending some Clojure. JUXT.pro. 2016-10-04 [2018-11-02]. 
  81. ↑ Williams, Alex. The New Stack Makers: Adrian Cockcroft on Sun, Netflix, Clojure, Go, Docker and More. TheNewStack.io. 2014-08-03 [2019-06-08]. 
  82. ↑ Price, Chris. A New Era of Application Services at Puppet Labs. Puppet.com. 2014-04-11 [2020-08-06]. 
  83. ↑ Phillips, Marc. Walmart Runs Clojure at Scale. Cognitect.com. 2015-07-14 [2018-11-03]. 
  84. ↑ Success Stories. Clojure.org. [2018-10-27]. 
  85. ↑ Common-Metadata-Repository. GitHub.com. [2019-07-06]. 
  86. ↑ Meier, Carin. Creative computing with Clojure. OReilly.com. 2015-05-06 [2018-11-04]. 
  87. ↑ Frequently Asked Questions - Technology Radar - ThoughtWorks. ThoughtWorks.com. [2019-02-10]. 
  88. ↑ Clojure - Technology Radar - ThoughtWorks. ThoughtWorks.com. [2019-02-10]. 
  89. ↑ Hu, Wei. A Lisp on Perl. MetaCPAN.org. [2019-07-06]. 
  90. ↑ Facorro, Juan. Clojerl. GitHub.com. [2019-07-06]. 
  91. ↑ Baldridge, Timothy. clojure-py. GitHub.com. [2019-07-06]. 
  92. ↑ Akkaya, Nurullah. Ferret. Ferret-Lang.org. [2019-07-06]. 
  93. ↑ Bataev, Roman. Joker. Joker-Lang.org. [2019-07-06]. 
  94. ↑ Cannon, Aemon. Laz3r. GitHub.com. [2019-07-06]. 
  95. ↑ Baldridge, Timothy. Pixie. PixieLang.org. [2019-07-06]. 
  96. ↑ Connor, Ashe. Rouge. GitHub.com. [2019-07-06]. 
  97. ↑ Miller, Alex. "State of Clojure 2019" Results. Clojure.org. 2019-02-04 [2019-07-05]. 
  98. ↑ Szabo, Maurício. Chlorine: Socket REPL Client for Clojure and ClojureScript. Atom.io. [2019-07-05]. 
  99. ↑ Batsov, Bozhidar; contributors. CIDER: The Clojure Interactive Development Environment that Rocks. CIDER.mx. [2019-07-05]. 
  100. ↑ Shrago, Greg. Clojure-Kit: Clojure and ClojureScript plugin for IntelliJ-based tools. JetBrains.com. [2019-07-05]. 
  101. ↑ Fleming, Colin. Cursive: Provides full Clojure and ClojureScript language support. JetBrains.com. [2019-07-05]. 
  102. ↑ Light Table: The Next Generation Code Editor. LightTable.com. [2019-07-05]. 
  103. ↑ Pope, Tim. fireplace.vim: Clojure REPL Support. VIM.org. [2019-07-05]. 
  104. ↑ Monroe, Dominic. Clojure and Vim: An overview – It's very possible. JUXT.pro. 2016-12-13 [2019-07-15]. 
  105. ↑ Masashi, Iizuka. vim-iced: Clojure Interactive Development Environment for Vim8/Neovim. GitHub.com. [2020-03-13]. 
  106. ↑ Caldwell, Oliver. Neovim Clojure(Script) tooling over prepl. GitHub.com. [2019-11-09]. 
  107. ↑ Caldwell, Oliver. Getting started with Clojure, Neovim and Conjure in minutes. oli.me.uk. 2019-11-06 [2019-11-10]. 
  108. ↑ Strömberg, Peter. Calva: Clojure & ClojureScript Interactive Programming. VisualStudio.com. [2019-07-05]. 
  109. ↑ 109.0 109.1 Miller, Alex. Deps and CLI Guide. Clojure.org. [2019-07-08]. 
  110. ↑ Miller, Alex. Clojure 1.9. Cognitect.com. 2017-12-08 [2019-07-05]. 
  111. ↑ Online Clojure REPL. REPL.it. [2019-07-08]. 
  112. ↑ Programming at the REPL: Introduction. Clojure.org. [2018-12-04]. 

延伸阅读

外部链接

编程语言
按范型
过程式
面向对象
多范型
函数式
逻辑式
脚本语言
动态语言
Shell语言
ECMA-262
特定平台
.NET
JVM
Xcode
特定领域
科学计算
GPU计算
数据查询
可视化
音视设计
其它
取自“https://www.qiuwenbaike.cn/index.php?title=Clojure&oldid=6452408”