- 浏览: 84568 次
- 性别:
- 来自: 成都
最新评论
-
荆人七十:
谢谢分享~
在eclipse上面搭建Clojure开发运行环境 -
lanily:
楼主,跟你学clojure了,我想请教一个问题:本人事先是用j ...
Clojure细节之form和special form的区别 -
Dead_knight:
http://code.google.com/p/clojur ...
practical_clojure chapter3 控制程序流(未完) -
石建武:
谢谢。提供的离线包。但如果通过‘install new’方式, ...
在eclipse上面搭建Clojure开发运行环境 -
songry:
linkerlin 写道标题里面的 未完 ,啥时候能去掉?可以 ...
practical_clojure chapter3 控制程序流(未完)
附注:本文基于jdk1.6,clojure1.2
数学运算
让我们通过学习clojure的API来一步步了解它,首先是最简单的数学运算。
加法+
API中对加法函数的描述是:
clojure.core/+
([] [x] [x y] [x y & more])
Returns the sum of nums. (+) returns 0.
首先,它位于clojure.core命名空间下,能够接受0到任意数量的参数,如果没有参数,则返回0。下面我们来
实验一下:
user> (+) 0 user> (+ 1) 1 user> (+ 255 1) 256
很明显,我们都得到了预期的结果。那么,如果是混合的数据类型会如何呢?
user> (+ 1 2r01111111) 128 user> (+ 0x7f 0177) 254
在上面的例子中,我们采用了十进制数和二进制数相加,16进制数和8进制数相加,最后都得到了预期的结果,
但是要注意,这个结果是十进制数。
众所周知,在java中,char和int是能够相互转换的,让我们来试试:
user> (+ 1 \a)
结果抛出异常了:
java.lang.Character cannot be cast to java.lang.Number [Thrown class java.lang.ClassCastException]
原因很明显,clojure中采用的都是java的包装类型而非基础类型,所以在进行加法运算时,就不能像java一样:
int first = 1; char second = 'a'; System.out.println(first+second);
这个没有异常,输出值为98。
由此可见,只要参数不是java.lang.number的子类,那么肯定会抛出类型转换异常,这次我们换用一个字符串
参数来试试,预期会抛出String无法转换成Number的异常:
user> (+ 1 "a")
果然抛出异常了:
java.lang.String cannot be cast to java.lang.Number [Thrown class java.lang.ClassCastException]
那么,我们换用一个浮点数试试,不管是Double还是Float都是Number的子类,应该不会有异常了:
user> (+ 3.5 2) 5.5
成功运行,这儿我们注意到,如果采用浮点数,则返回的类型也自动转换为浮点数了。这让我们想到另外的一种
类型--分数,clojure是支持分数的,那么我们采用分数来做加法,能否取得预期的结果呢?
user> (+ 2 2/3) 8/3
可以相加!那让我们探寻一下更深入的境界,浮点数和分数相加:
user> (+ 2.5 2/3) 3.166666666666667
这样也可以,注意返回的结果被转换成了浮点数。
然后我们看看+函数的源代码:
(defn + "Returns the sum of nums. (+) returns 0." {:inline (fn [x y] `(. clojure.lang.Numbers (add ~x ~y))) :inline-arities #{2} :added "1.0"} ([] 0) ([x] (cast Number x)) ([x y] (. clojure.lang.Numbers (add x y))) ([x y & more] (reduce + (+ x y) more)))
在定义的语法(defn +)后首先我们看到的是一段针对函数的说明性文字("Returns the sum of nums.
(+) returns 0."),然后是元数据结构(花括号包含的那三行),它包含了内联的匿名函数、内联的参数数量
以及从哪个版本以上开始支持这个函数。最后是函数体的实现。
很明显,从函数体上来看,这是一个基于参数数量重载的函数,它可以接收从0到任意数量的参数,直到
堆栈溢出。
([] 0)代表没有参数时返回0。
([x] (cast Number x))说明只有一个参数时,执行表达式(cast Number x),cast是个函数,这个表达式
的含义是如果x不是Number类型,则抛出类型转换异常,否则返回x。
([x y] (. clojure.lang.Numbers (add x y)))是传入两个参数时,执行表达式
(. clojure.lang.Numbers (add x y)),这个表达式的含义是调用java类clojure.lang.Numbers的add方法,
并将x、y作为参数传入add方法,并返回方法的执行结果。(clojure.lang.Numbers一共4528行,如果add
的两个参数类型相同,则直接调用静态方法返回结果;如果两个参数类型不同,则通过内部接口的多个内部实现类
通过combine来定义返回结果的类型,比如:如果是一个Integer和Long相加,则返回的是Long;如果是一个
BigInteger和Long相加,则返回的是一个BigInteger)。
([x y & more]
(reduce + (+ x y) more)))这是在传入参数大于2时,执行(reduce + (+ x y) more))这个表达式。我们可以
看出,这儿出现了一个递归调用。+函数作为reduce函数的参数被调用了,那么reduce函数的作用是什么呢?它
接收两个或者三个参数,第一个参数是一个拥有两个参数的函数,在当前表达式中,就是+函数本身;第二个参数
是可选的,是一个元素,在当前表达式中,就是(+ x y)表达式的返回值,这儿也是个递归调用;第三个参数则是一
个集合,在当前表达式中,就是+函数接收的第三个到最后一个参数的集合。reduce的作用就是将第二个参数和
第三个参数集合中的第一个元素作为参数传给第一个参数函数,在当前的表达式中,就是将(+ x y)求值的结果和
more里头的第一个元素即+函数的第三个参数相加;这个执行结果又将作为参数和集合中的下一个元素一起作为
参数传递给第一个参数函数,以此类推,有点像累加器,最后的结果作为返回值。
至此,我们可以看出,+函数的主体实现其实就是通过java类clojure.lang.Numbers的add方法进行两个数的
相加,更多数字的相加都是通过对两个数字相加操作的递归调用来实现的。
减法-
在探寻加法操作时,我们已经发现了,能进行数学操作的都是java.lang.number的子类,那么我们能进行的
减法就很明显了:
user> (- 1 2) -1 user> (- 3 4.53) -1.5300000000000002 user> (- 1/2 1/3) 1/6 user> (- 5.5 1/2) 5.0 user> (- 0x54 2r11111111) -171
在这当中,我们注意到一个很有趣的现象, (- 3 4.53)这一句的执行结果莫名多了0.0000000000000002出来,
这是怎么回事呢?让我们到java中来看看:
System.out.println(3-4.53);
结果果然是:
-1.5300000000000002
这是因为二进制无法精确表达一些十进制浮点数造成的,《java解惑》中对此有精确的描述。clojure在此忠实地
继承了这一特性。如果需要进行浮点数的精确运算,我们需要将参数声明为BigDecimal就能够解决这个问题了:
user> (- 3 (. java.math.BigDecimal valueOf 453e-2)) -1.53M
我们看到,这样就得到了预期的结果,不过后面这个M是啥玩意?其实,这就是标注这个数字的对象类型是BigDecimal,让我们用class来查看一下就明白了:
user> (class 1.53M) java.math.BigDecimal user> (class 1.53) java.lang.Double
一目了然,如果没有M后缀,这个数字是Double类型,有了M后缀,这个数字就属于BigDecimal类型了,所以,
之前的例子我们也可以写作:
user> (- 3 4.53M) -1.53M
得到了相同的结果。不过,据测试BigDecimal执行运算的性能大约是Double的60-100倍,这个大家自己斟酌吧。
接下来我们看看-函数的源码:
(defn - "If no ys are supplied, returns the negation of x, else subtracts the ys from x and returns the result." {:inline (fn [& args] `(. clojure.lang.Numbers (minus ~@args))) :inline-arities #{1 2} :added "1.0"} ([x] (. clojure.lang.Numbers (minus x))) ([x y] (. clojure.lang.Numbers (minus x y))) ([x y & more] (reduce - (- x y) more)))
结构很眼熟,不是吗?最大的差别在于,单参数情况下,-函数返回的是这个参数的负值;而且并不支持无参调用。
乘法*
有了前面加减法的经验,乘法就没什么惊喜了:
user> (* 3 8) 24 user> (* 5 4/5) 4 user> (* 3.5 9) 31.5 user> (* 5 3 6.5) 97.5
看看源码:
(defn * "Returns the product of nums. (*) returns 1." {:inline (fn [x y] `(. clojure.lang.Numbers (multiply ~x ~y))) :inline-arities #{2} :added "1.0"} ([] 1) ([x] (cast Number x)) ([x y] (. clojure.lang.Numbers (multiply x y))) ([x y & more] (reduce * (* x y) more)))
跟加法几乎一模一样的结构,不需要任何解说了。
除法/
除法不一样的地方在于,它能产生分数:
user> (/ 3 2) 3/2 user> (/ 4 2) 2 user> (/ 3.0 2) 1.5 user> (/ 0 3) 0
如果我们查询分数的类型,会发现这实际上是一个clojure自定的类型:
user> (class 3/3) java.lang.Integer user> (class 3/2) clojure.lang.Ratio
除法的源码:
(defn / "If no denominators are supplied, returns 1/numerator, else returns numerator divided by all of the denominators." {:inline (fn [x y] `(. clojure.lang.Numbers (divide ~x ~y))) :inline-arities #{2} :added "1.0"} ([x] (/ 1 x)) ([x y] (. clojure.lang.Numbers (divide x y))) ([x y & more] (reduce / (/ x y) more)))
这个结构我们已经看过三次了,已经都很熟悉了。
整除quot
整除和一般除法不同的地方在于,它不会产生分数和小数,它直接抛弃余数,得到整型的结果:
user> (quot 3 2) 1 user> (quot 3 2.0) 1 user> (class (quot 3 2.0)) java.lang.Integer
从上面例子我们可以看出,即使我们采用了Double类型的分母2.0,最后得出的结果仍然是整型。
整除的源码:
(defn quot "quot[ient] of dividing numerator by denominator." {:added "1.0"} [num div] (. clojure.lang.Numbers (quotient num div)))
更加简单,除了调用clojure.lang.Numbers中的quotient方法外,没有其他任何操作。
取余rem
如同字面意义一样,取余操作就是对两个数相除取余数:
user> (rem 3 2) 1 user> (rem 3 2.0) 1.0 user> (rem 5 1/4) 0 user> (rem 3 2/5) 1/5 user> (rem 4.5 3.5) 1.0
如上所见,余数有可能是整型、浮点型或者分数。看看源码:
(defn rem "remainder of dividing numerator by denominator." {:added "1.0"} [num div] (. clojure.lang.Numbers (remainder num div)))
很好,没什么内容。
求模mod
在参数都为正数或者都为负数时,求模和取余得到的结果是一致的,但是如果一个参数为正,一个参数为负时,
mod和rem的结果就不一样了:
user> (mod -7 -2) -1 user> (rem -7 -2) -1 user> (mod 7 2) 1 user> (rem 7 2) 1 user> (mod 7 -2) -1 user> (rem 7 -2) 1 user> (mod -10 3) 2 user> (rem -10 3) -1
关于求模和取余的详细操作,大家可以自行百度。源码是:
(defn mod "Modulus of num and div. Truncates toward negative infinity." {:added "1.0"} [num div] (let [m (rem num div)] (if (or (zero? m) (pos? (* num div))) m (+ m div))))
这个代码很清晰,如果num对div取余的结果为零或者num和div都为正数或者都为负数,就直接返回结果;
否则返回取余结果加上div的值。
加一inc
inc函数的作用是返回某个数字加一的结果,有点类似于java中的++操作符,但是区别在于,clojure中的数据结构
是不可变的,在执行了inc函数后,原本的值是没有改变的:
user> (def var-a 1) #'user/var-a user> (inc var-a) 2 user> var-a 1 user> (inc 2.15) 3.15 user> (inc 2/3) 5/3
如上所见,在执行了inc函数后,var-a的值依然是1。同时我们也注意到,针对浮点数和分数,inc函数仍然能够
产生作用。源码如下:
(defn inc "Returns a number one greater than num." {:inline (fn [x] `(. clojure.lang.Numbers (inc ~x))) :added "1.0"} [x] (. clojure.lang.Numbers (inc x)))
嗯,又直接交给clojure.lang.Numbers处理了。
减一dec
dec函数类似于inc函数,只不过它执行的是减一的操作:
user> (dec 2.51) 1.5099999999999998 user> (dec 2/3) -1/3 user> (dec 50) 49
在执行浮点数减法时,又出现了我们之前遇到过的精度问题。源码如下:
(defn dec "Returns a number one less than num." {:inline (fn [x] `(. clojure.lang.Numbers (dec ~x))) :added "1.0"} [x] (. clojure.lang.Numbers (dec x)))
毫不意外的,clojure.lang.Numbers类再次大展身手。
取最大值max
max函数可以接收任意数目的参数,然后返回其中最大值:
user> (max 0x235 2r111111 513 34e5) 3400000.0 user> (max 1 2 3 4 5) 5 user> (max 151/8 20 13) 20 user> (max 151/8 10 13)
很明显,max的返回类型是跟最大值的类型一致的。源码如下:
(defn max "Returns the greatest of the nums." {:added "1.0"} ([x] x) ([x y] (if (> x y) x y)) ([x y & more] (reduce max (max x y) more)))
嗯,似曾相识的结构,仍然是将多元操作通过递归解析为二元操作。
取最小值min
min函数类似于max函数,所以我们看看源码就直接跳过吧:
(defn min "Returns the least of the nums." {:added "1.0"} ([x] x) ([x y] (if (< x y) x y)) ([x y & more] (reduce min (min x y) more)))
设置精度with-precision
with-precision宏是为之前我们提到的BigDecimal运算操作时指定精度的:
user> (with-precision 10 (/ 1M 3)) 0.3333333333M user> (with-precision 6 (/ 2 3M)) 0.666667M
仔细数数小数点后面的位数,就能看到它和with-precision宏的第一个参数是吻合的。
如果with-precision的第二个参数不是BigDecimal,那么它将不起作用:
user> (with-precision 6 (/ 2 3.0)) 0.6666666666666666
我们看看源码:
(defmacro with-precision "Sets the precision and rounding mode to be used for BigDecimal operations. Usage: (with-precision 10 (/ 1M 3)) or: (with-precision 10 :rounding HALF_DOWN (/ 1M 3)) The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP." {:added "1.0"} [precision & exprs] (let [[body rm] (if (= (first exprs) :rounding) [(next (next exprs)) `((. java.math.RoundingMode ~(second exprs)))] [exprs nil])] `(binding [*math-context* (java.math.MathContext. ~precision ~@rm)] ~@body)))
这是一个宏的定义,所以要比我们之前看到的函数定义复杂得多,但大体结构仍然相同,首先是定义语法,然后
是说明性文字,然后是元数据,最后是宏的主体。显而易见,宏的主体是最为复杂的部分。
首先看看参数vector,它包含了两部分,precision和& exprs,precision是精度数字,而& exprs代表任意数量
的表达式参数,实际上,with-precision宏只会返回最后一个表达式的带精度结果,示例如下:
user> (with-precision 6 (/ 1M 3) (/ 2M 3) (/ 4M 3)) 1.33333M
然后我们看到了一个let包裹了下面所有的内容,let是一个特殊form,它的作用就是建立绑定,可以理解为临时变量
,但是跟其他语言的临时变量不同的是,let建立的绑定一旦初始化,就不能再更改绑定的值。在这个地方,let建立的
绑定是个vector--[body rm],这里面包含了两个符号body和rm,而这两个符号对应的值是表达式:
(if (= (first exprs) :rounding) [(next (next exprs)) `((. java.math.RoundingMode ~(second exprs)))] [exprs nil])
的返回值。我们可以看得出,这个表达式的结构是一个判断语句,如果传入的表达式集合参数exprs的第一个元素是
:rounding关键字,则返回如下vector:
[(next (next exprs)) `((. java.math.RoundingMode ~(second exprs)))]
这个结果vector的第一个元素是exprs中排除第一、二个元素后剩下的所有元素,这个exprs剩余元素集合将被赋给
body绑定,而结果vector的第二个元素实际上是调用java.math.RoundingMode枚举中的某个常量,这个常量将被
赋给rm绑定,实际上,我们在之前的说明性文字中也可以看到:
(with-precision 10 :rounding HALF_DOWN (/ 1M 3)) The rounding mode is one of CEILING, FLOOR, HALF_UP, HALF_DOWN, HALF_EVEN, UP, DOWN and UNNECESSARY; it defaults to HALF_UP.
在这儿,exprs就是 :rounding HALF_DOWN (/ 1M 3) 这个集合。(first exprs)的结果就是:rounding关键字,
(second exprs)的结果就是HALF_DOWN,前面的~意思是取这个表达式的执行结果而非表达式本身。而
(. java.math.RoundingMode ~(second exprs))等同于java中的java.math.RoundingMode.HALF_DOWN。
这个枚举常量的作用是决定丢弃精度数值操作的舍入模式,详情请见相关API 。而(next (next exprs)对应的就是
exprs剩余的部分(/ 1M 3)。
而如果exprs的第一个元素不是:rounding关键字,则会直接返回 [exprs nil]这个vector,那么,body绑定的
值就是exprs的所有元素,而rm绑定的值则是空--nil。
在临时绑定赋值完成之后,开始执行业务代码:
`(binding [*math-context* (java.math.MathContext. ~precision ~@rm)] ~@body)))
`代表在运行时直接按照字面值展开其后的表达式,而不会进行求值;除非是有~前缀的符号。binding宏和let类似,
同样是先在vector中建立绑定,然后返回下面的表达式。我们先看这个vector:
[*math-context* (java.math.MathContext. ~precision ~@rm)],它要对*math-context*全局变量进行赋值
,(java.math.MathContext. ~precision ~@rm)这个表达式代表将precision和rm的值作为参数传入
java.math.MathContext的构造函数中返回一个java.math.MathContext对象实例。这个对象实例将被赋给
*math-context*全局变量。绑定赋值结束后,body绑定的值就会作为结果被返回。注意,body绑定的值本身就是一个
表达式集合。
现在,我们再回头看看这个例子:
(with-precision 10 :rounding HALF_DOWN (/ 1M 3))
在运行中,首先会根据:rounding和HALF_DOWN生成java.math.RoundingMode.HALF_DOWN枚举常量,然后
将10和java.math.RoundingMode.HALF_DOWN传入java.math.MathContext的构造函数中生成
java.math.MathContext对象实例,然后将这个对象实例赋值给全局变量*math-context*,最后执行(/ 1M 3)
表达式并返回结果。
然后我们采用macroexpand将with-precision的执行过程展开看看:
user> (macroexpand '(with-precision 10 :rounding HALF_DOWN (/ 1M 3))) (let* [] (clojure.core/push-thread-bindings (clojure.core/hash-map (var clojure.core/*math-context*) (java.math.MathContext. 10 (. java.math.RoundingMode HALF_DOWN)))) (try (/ 1M 3) (finally (clojure.core/pop-thread-bindings))))
可以看到,整个执行过程跟上面描述的是一致的。
发表评论
-
Clojure细节之Reader
2012-05-10 15:19 0前言 Clojure中提供了多种reader语法糖来 ... -
Clojure细节之form和special form的区别
2012-05-07 14:26 2267前言 在lisp程序员看来,form和special ... -
Clojure入门-前言
2012-04-10 09:04 0前言 0.1 关于Clojure 在正式接触Clo ... -
使用c通过jni调用java
2012-04-02 12:01 9385编译环境: fedora16 gcc (GCC) ... -
clojure调用java方法时参数问题
2012-02-24 10:05 1980众所周知,clojure基于jvm,可以在不做引入的情 ... -
换零钱的clojure实现
2012-01-06 19:27 1854题目:有半美元、四分 ... -
clojure API学习(4) 程序流控制
2011-12-20 16:38 0本文基于jdk1.6和clojure1.2 if ... -
clojure API学习(3) 字符和字符串操作
2011-12-16 00:08 4667注:本文基于jdk1.6,clojur ... -
clojure的冒泡排序实现
2011-12-08 17:11 2187冒泡排序的基本概念是:依次比较相邻的两个数,将小数放在 ... -
Clojure-JVM上的函数式编程语言(17)数据库 作者: R. Mark Volkmann
2011-11-26 09:20 1843原帖地址:http://java.ociweb.com/mar ... -
clojure API学习(2) 比较操作
2011-11-26 08:59 2692注:本文基于jdk1.6,clojur ... -
Clojure-JVM上的函数式编程语言(16)Web应用 作者: R. Mark Volkmann
2011-11-19 11:37 2011原帖地址:http://java.ociweb.com/mar ... -
Clojure-JVM上的函数式编程语言(15) 桌面应用 作者: R. Mark Volkmann
2011-11-19 11:04 1560原帖地址:http://java.ociweb.com/mar ... -
Clojure-JVM上的函数式编程语言(14) 编辑器和开发环境 作者: R. Mark Volkmann
2011-11-19 10:31 1713原帖地址:http://java.ociweb.com/mar ... -
Clojure-JVM上的函数式编程语言(13)自动化测试 作者: R. Mark Volkmann
2011-11-17 21:25 1424原帖地址:http://java.ociweb.com/ma ... -
如何将Clojure作为java工程中的脚本
2011-11-17 09:57 0注:本文基于jdk1.6和Clojure1.2 -
Clojure-JVM上的函数式编程语言(12)编译 作者: R. Mark Volkmann
2011-11-17 11:52 2686原帖地址:http://java.ociweb.com/ma ... -
Clojure与java设计模式(3) 策略模式
2011-11-16 15:45 1844注:本文基于jdk1.6和Clojure1.2 策略模 ... -
在eclipse上面搭建Clojure开发运行环境
2011-11-15 13:30 12518首先,需要下 ... -
Clojure和JAVA设计模式(2) 工厂模式之工厂方法
2011-11-15 15:05 1293注:本文基于jdk1.6和Clojure1.2 工厂方 ...
相关推荐
关于这是 Clojure 官方 API 文档的中文翻译版本。在线阅读地址: 。翻译进度模块进度译者clojure.core进行中 , ,clojure.data无 clojure.inspector无 clojure.java.browse已完成clojure.java.io已完成clojure.java...
Clojure Spark API SparkPlug是的Clojure API。 安装 库版本在Clojars上发布。 要将最新版本与Leiningen一起使用,请在您的项目中添加以下依赖项: 这将引入omnibus程序包,而该程序包又取决于相同版本的每个子...
clojure1.6.0的API文档,英文版
此外,Clojure提供了基本的数学操作符,如加法(+)、减法(-)、乘法(*)和除法(/)。例如,`(+ 1 1)` 将返回 `2`,`(* 1 2)` 将返回 `2`。 列表和向量: 列表(list)是Clojure中的基本数据结构,用于表示有序...
clj-osf clj-osf是一种简单的 Clojure 域特定语言 (DSL),用于查询...文档用法如何使用 API 使用这个 API 真的很简单。 开发人员必须: 在他们的项目中使用 clj-osf 包声明他们想要使用的命名空间通过调用 defosf 和
【1】[Clojure编程乐趣](The Joy of Clojure).pdf 【2】Clojure – Functional Programming for the JVM中文版.pdf 【3】Clojure Cookbook.pdf 【4】Clojure Data Analysis Cookbook.pdf 【5】clojure Hand book...
[2009] Programming Clojure.(Stuart Halloway).[1934356336].pdf [2010] Functional Programming with Clojure - Simple Concurrency on the JVM.(Tim Berglund, Matthew McCullough).[193650202X].pdf [2010] ...
《Clojure电子书》集合包含了三本关于Clojure编程的重要书籍和一个Leiningen的Windows安装程序,这对于学习和深入理解Clojure语言至关重要。Clojure是一种基于Lisp的函数式编程语言,它运行在Java虚拟机(JVM)上,...
标题 "Clojure学习——使用clojure jdbc操作mysql" 指出的是一个关于使用Clojure编程语言通过Java Database Connectivity (JDBC) API来操作MySQL数据库的主题。Clojure是一种基于Lisp的函数式编程语言,它运行在Java...
Clojure Handbook是一份关于Clojure编程语言的学习笔记,旨在为读者提供一个方便的备查材料,以加深对Clojure语言特性的理解和记忆。 首先,Clojure作为Lisp语言家族的一员,具有一些独特的特性。Lisp语言以其极简...
clojure-twitter, 面向 Twitter API的Clojure客户端 面向Clojure的 Twitter 客户端 API从Clojure访问 Twitter API 。建筑lein depslein jar示例(require 'twitter ['oauth.
1. **基础篇**:这一部分将引导读者入门 Clojure 编程语言的基本概念和语法,为后续深入学习打下坚实的基础。 - **Clojure 入门**:介绍 Clojure 的安装过程、REPL(Read-Eval-Print Loop)环境的使用方法以及简单...
在Clojure中,Java interoperability(Java互操作性)是一个重要特性,书里会讲解如何无缝地与Java库和API交互,利用JVM的强大生态。同时,Clojure的REPL(Read-Eval-Print Loop)环境也是其一大特色,它促进了快速...
作者在开始学习Clojure时,体会到了编程的乐趣,这种感觉只有在初次接触计算机并执行命令时才曾经有过。Clojure语言让程序员能够直接与程序沟通,无需经过模糊的间接层次,使得程序员感觉自己真正控制了程序。 ...
在“Clojure编程乐趣”这本书中,你将学习到如何使用Clojure进行函数式编程,如何利用Clojure的强大工具处理数据,以及如何构建并发和分布式系统。此外,书中可能还会介绍Clojure社区的一些最佳实践和常用库,例如...
1. **《Programming Clojure》**:这本书由Stuart Halloway和Aaron Bedra编写,是Clojure编程的经典教材之一。它全面介绍了Clojure的基础知识,包括数据结构、控制流、函数式编程概念、元编程以及与Java的交互。...