精华内容
下载资源
问答
  • clojure

    千次阅读 2013-10-18 22:25:19
    clojure:lisp leiningen:ant http://clojure.org/ https://github.com/technomancy/leiningen
    展开全文
  • Clojure

    千次阅读 2014-10-09 00:52:58
    #ClojureClojure中,任何函数调用都需要用括号将其包起来。括号里 的第一个元素是函数名,剩下的是参数。 user=> ( println "Give Me Some Clojure!") Give Me Some Clojure! nil user=> (-1) ...

    #Clojure

    在Clojure中,任何函数调用都需要用括号将其包起来。括号里 的第一个元素是函数名,剩下的是参数。

    user=> ( println  "Give Me Some Clojure!")
    Give Me Some Clojure!
    nil
    user=> (-1)
    ClassCastException java.lang.Long cannot be cast to clojure.lang.IFn  user/eval1170 (form-init1159783663733578044.clj:1)
    user=> ( - 1 )
    -1
    user=> ( - 0 1 )
    -1
    user=> ( + 0 1 )
    1
    user=> ( * 0 1 )
    0
    user=> ( / 0 1 )
    0
    user=> ( / 0.0 1 )
    0.0
    user=> ( class ( / 1 3 ) )
    clojure.lang.Ratio
    user=> ( < 0.0 1 )
    true
    user=> ( > 0.0 1 )
    false
    
    • 字符串和字符

    字符并不是长度为1的字符串

    user=> ( = "a" \a )
    false
    user=> ( = (str  \a) "a" )
    true
    user=>
    
    • 布尔值和表达式
    user=> (first())
    nil
    user=> (if 0 ( println "true"))
    true
    nil
    user=> (if nil ( println "true"))
    nil
    user=> (if "" ( println "true"))
    true
    nil
    user=>
    

    0和""都是true,但nil不是.

    Lisp允许把数据当作代码。 这样我们可以把代码分成多行,让它看起来更漂亮些:

    user=> (if ( < 1 2)
      #_=> ( println "False it is not."))
    False it is not.
    nil
    user=>
    
    • 列表、映射表、集合以及向量
    1. 列表
    user=> ( list 1 2 4)
    (1 2 4)
    user=> `( 1 2 4)
    (1 2 4)
    user=> (first `(:r2d2 :c3pro))
    :r2d2
    user=> (last `(:r2d2 :c3pro))
    :c3pro
    user=> (rest `(:r2d2 :c3pro :e4))
    (:c3pro :e4)
    user=> (cons :battle-droid `(:r2d2 :c3pro :e4))
    (:battle-droid :r2d2 :c3pro :e4)
    user=>
    

    2.向量

    向量是为随机访问优化的,用方括号括起来。

    列表作代码,向量作数据。可以像下面这样获取各种元素:

    user=> [ :hutt :wookie :ework]
    [:hutt :wookie :ework]
    user=> (first [ :hutt :wookie :ework])
    :hutt
    user=> (nth [ :hutt :wookie :ework] 2 )
    :ework
    user=> (nth [ :hutt :wookie :ework] 0 )
    :hutt
    user=> (last [ :hutt :wookie :ework]  )
    :ework
    user=> ( [ :hutt :wookie :ework] 2)
    :ework
    user=>
    

    向量也是函数,取下标为参数。可以合并两个向量:

    user=> (concat [:hello, :word] [ :hutt :wookie :ework] )
    (:hello :word :hutt :wookie :ework)
    user=>
    

    向量必须使用:来定义元素。

    repl打印出来的不是向量而是列表。许多返回集合的函数都使用了称为序列的 Clojure抽象,在repl 中以列表的形式展现。

    列表和向量都是有序集合。

    • Set
    user=> #{:x-wing :y-wing :tie-fighter}
    #{:y-wing :tie-fighter :x-wing}
    user=> (def spacecraft #{:x-wing :y-wing :tie-fighter})
    #'user/spacecraft
    user=> (count spacecraft)
    3
    user=> (sort spacecraft)
    (:tie-fighter :x-wing :y-wing)
    user=> (sorted-set spacecraft)
    sorted-set      sorted-set-by
    user=> (sorted-set 231)
    #{231}
    user=> (sorted-set 2 3 1)
    #{1 2 3}
    user=> (clojure.set/union spacecraft #{2 3 1})
    #{1 :y-wing :tie-fighter 3 :x-wing 2}
    user=> (clojure.set/difference #{1 2 3} #{2})
    #{1 3}
    user=> (#{:jar-jar :chewbacca} :luke)
    nil
    user=> (#{:jar-jar :chewbacca} :jar-jar)
    :jar-jar
    user=>
    

    set也是函数

    • 映射表
    user=> (def mentors {:darth-vader "obi wan", :luke "yoda"})
    #'user/mentors
    user=> (mentors :luke)
    "yoda"
    

    映射表本身也是函数。关键词同样也是函数。

    user=> (:luke mentors)
    "yoda"
    user=>
    

    对于一个散列值同时出现在两个映射表中的情况,还可以声明一个操作符

    user=> ( merge {:y-wing 2, :x-wing 4} {:tie-fighter 2})
    {:tie-fighter 2, :y-wing 2, :x-wing 4}
    user=> ( merge-with + {:y-wing 2, :x-wing 4} {:tie-fighter 2, :x-wing 3})
    {:tie-fighter 2, :y-wing 2, :x-wing 7}
    user=>
    

    排序表

    user=> (sorted-map 1 :one, 3 :three, 2 :two)
    {1 :one, 2 :two, 3 :three}
    user=>
    
    • 函数

    定义函数的最简形式是 (defn [params] body) 。我们定义了一个没有参数的函数 force-it 。
    这个函数只是把两个字符串拼接起来。调用方式和其他任何函数一样:

    user=> (defn force-it [] (str "Use the force, " "Luke."))
    #'user/force-it
    user=> (force-it)
    "Use the force, Luke."
    user=> 
    

    如果愿意的话,还可以加上描述函数的字符串:

    user=> (defn force-it 
    "The first function a young Jedi needs"
    []
    (str "Use the force, " "Luke"))
    #'user/force-it
    user=> 
    user=> (defn force-it 
    "The first function a young Jedi needs"
    []
    (str "Use the force, " "Luke"))
    #'user/force-it
    user=> (doc force-it)
    -------------------------
    user/force-it
    ([])
      The first function a young Jedi needs
    nil
    user=> (defn force-it 
    "This first function a young Jedi needs"
    [jedi]
    (str "Use the force," jedi))
    #'user/force-it
    user=> (force-it "Luke")
    "Use the force,Luke"
    user=> (doc str)
    -------------------------
    clojure.core/str
    ([] [x] [x & ys])
      With no args, returns the empty string. With one arg x, returns
      x.toString().  (str nil) returns the empty string. With more than
      one arg, returns the concatenation of the str values of the args.
    nil
    user=> 
    

    绑定

    user=> (def line [[0 0] [10 20]])
    #'user/line
    user=> line
    [[0 0] [10 20]]
    user=> (defn line-end [ln] ( last ln))
    #'user/line-end
    user=> (line-end line)
    [10 20]
    user=> (defn line-end [[_ second]] second)
    #'user/line-end
    user=> (line-end line)
    [10 20]
    user=> 
    

    这里用到一个概念叫解构(destructuring)。即将一个数据结构拆解开来并从中提取出需要的
    部分。下面我们来详细探讨绑定。对于 [[_ second]] ,外层方括号用来定义形参向量,内层方
    括号指明将要绑定的是列表的元素还是向量的元素。 _ 和 second 分别表示单独的元素,通常
    用 _ (下划线)表示被忽略的参数。也就是说,这个函数的形参分别是: _ 对应第一个实参中的第
    一个元素, second 对应第一个实参中的第二个元素。
    绑定可以嵌套。比方说有个井字棋(又叫一字棋, tic-tac-toe)棋盘。现在我们想返回棋盘
    正中间那个方框里的值。假设棋盘表示为每行三子共三行,像下面这样:

    user=> (def borad [ [:x :o :x] [:o :x :o] [:o :x :o] ] )
    #'user/borad
    user=> (defn center [ [ _ [ _ c _] _ ] ] c )
    #'user/center
    user=> (center borad )
    :x
    user=> 
    

    可以利用 let 函数对 center 函数的调用方隐藏解构,let语句都能将一个变量绑定到一个值上:

    user=> (def person {:name "Jabba" :profession "Gangster"})
    #'user/person
    user=> (let [{name :name} person] (str "The person's name is " name ))
    "The person's name is Jabba"
    

    解构映射表:

    user=> borad 
    [[:x :o :x] [:o :x :o] [:o :x :o]]
    user=> (defn center [borad ]
    ( let [[ _ [ _ _ c ]] borad ] c ))
    #'user/center
    user=> (center borad )
    :o
    user=> 
    

    同时处理映射表和向量:

    user=> (def villains [{ :name "Godzilla" :size "big"} {:name "Ebola" :size "small"}])
    #'user/villains
    user=> (let [[ _ {name :name}] villains ] ( str "Name of the second villian:" name))
    "Name of the second villian:Ebola"
    user=> 
    

    匿名函数

    user=> (map (fn [w] ( * 2 (count w))) people)
    (6 16)
    user=> (map #( * 2 (count % ) ) people )
    (6 16)
    user=> 
    

    在这个简写形式中,#定义了一个匿名函数,而%则被绑定到序列中的每个元素上。#叫做宏读取器(reader macro)。

    • Yoda 与原力

    用loop 和 recure 递归

    user=> (defn size [v] 
    (if ( empty? v)
    0
    (inc ( size ( rest v )))))
    #'user/size
    user=> (size [1 2 3 4])
    4
    user=> ( loop [ x  1 ] x )
    1
    user=> ( defn size [ v ] 
    ( loop [ l v , c 0 ]
    (if ( empty? l )
    c
    (recur (rest l ) ( inc c )))))
    #'user/size
    user=> (size [ 1 2 4])
    3
    user=> 
    

    序列

    序列是与具体实现无关的抽象层,囊括了Clojure系统里各式的容器。序列封装了所有Clojure集合(set、映射表、向量,等等)、字符串,甚至包括文件系统结构(流、目录)。它们也为Java容器提供了公共抽象,包括Java集合、数组以及字符串。一般来说,只要支持函数 first 、 rest和 cons ,就可以用序列封装起来。

    使用向量时,Clojure有时会在命令行中返回列表:

    user=> [ 1 2 3  ] 
    [1 2 3]
    user=> (rest [ 1 2 ])
    (2)
    user=> 
    

    注意,开始用的是向量,但结果并不是列表。repl实际上是返回序列作为响应。这意味着所有集合都能以一种通用方式对待。让我们来看看公共序列函数库,它的丰富与强大,用一节的内容难以描述,但我会试着让你了解都有哪些可用的函数,下面简单介绍一下用于修改、测试和创建序列的函数。

    测试

    user=> ( every? number? [ 1 2 4 0 :four])
    false
    user=> ( some nil? [ 1 2 nil] )
    true
    user=> ( not-every? odd? [ 1 3 5 ])
    false
    user=> (not-any? number? [:one :two :three])
    true
    user=> 
    

    修改序列

    user=> ( every? number? [ 1 2 4 0 :four])
    false
    user=> ( some nil? [ 1 2 nil] )
    true
    user=> ( not-every? odd? [ 1 3 5 ])
    false
    user=> (not-any? number? [:one :two :three])
    true
    user=> (def words [ "luke" "chewie" "han" "lando"])
    #'user/words
    user=> (filter (fn [word] ( > (count word) 4 )) words )
    ("chewie" "lando")
    user=> (map ( fn [x] ( * x x)) [ 1 2 3 34 4])
    (1 4 9 1156 16)
    user=> (def colors [ "red" "blue"])
    #'user/colors
    user=> (def toys ["block" "car"])
    #'user/toys
    user=> (for [x colors ] (str "I like "  x ))
    ("I like red" "I like blue")
    user=> (for [x colors, y toys ] (str "I like "  x  " " y "s"))
    ("I like red blocks" "I like red cars" "I like blue blocks" "I like blue cars")
    user=> (defn small-word? [w] ( < (count w) 4 ))
    #'user/small-word?
    user=> (for [ x colors , y toys , :when (small-word? y)] 
    ( str "I like" x " " y "s"))
    ("I likered cars" "I likeblue cars")
    user=> (reduce + [ 1 2 3 4] )
    10
    user=> (reduce * [ 1 2 3 4 5])
    120
    user=> (sort [ 3 1 2 34])
    (1 2 3 34) 
    user=> (defn abs [x] (if ( < x 0) ( - x ) x )) 
    #'user/abs
    user=> (sort-by abs [ -1 -4 3 2 ])
    (-1 2 3 -4)
    

    延迟计算

    1.用range 创建有穷序列

    user=> (range 1 10 )
    (1 2 3 4 5 6 7 8 9)
    user=> ( range 1 10 3)
    (1 4 7)
    user=> (range  10 )
    (0 1 2 3 4 5 6 7 8 9)
    user=> 
    

    2.无穷序列和 take

    user=> (take 3 (repeat "Use the Force, Luke"))
    ("Use the Force, Luke" "Use the Force, Luke" "Use the Force, Luke")
    user=> (take 5 (cycle [:lather :rinse :repeat]))
    (:lather :rinse :repeat :lather :rinse)
    user=> (take 5 (drop 2 ( cycle [:lather :rinse :repeat ])))
    (:repeat :lather :rinse :repeat :lather)
    user=> ( ->> [:lather :rinse :repeat ] ( cycle ) ( drop 2 ) ( take 5 ))
    (:repeat :lather :rinse :repeat :lather)
    user=> (take 5 (interpose :and (cycle [:lather :rinse :repeat ])))
    (:lather :and :rinse :and :repeat)
    user=> (take 20 (interleave (cycle (range 2)) (cycle (range 3))))
    (0 0 1 1 0 2 1 0 0 1 1 2 0 0 1 1 0 2 1 0)
    user=> (take 5 ( iterate inc 1))
    (1 2 3 4 5)
    user=> (take 5 (iterate dec 0))
    (0 -1 -2 -3 -4)
    
    user=> (defn fib-pair [[a b]] [b (+ a b)])
    #'user/fib-pair
    user=> (fib-pair [3 5])
    [5 8]
    user=> (iterate fib-pair [1 1]))
    ([1 1] [1 2] [2 3] [3 5] [5 8] [8 13] [13 21] [21 34] [34 55] [55 89] [89 144] [144 233] [233 377] [377 610] [610 987] [987 1597] [1597 2584] [2584 4181] [4181 6765] [6765 10946] [10946 17711] [17711 28657] [28657 46368] [46368 75025] [75025 121393] [121393 196418] [196418 317811] [317811 514229] [514229 832040] [832040 1346269] [1346269 2178309] [2178309 3524578] [3524578 5702887] [5702887 9227465] [9227465 14930352] [14930352 24157817] [24157817 39088169] [39088169 63245986] [63245986 102334155] [102334155 165580141] [165580141 267914296] [267914296 433494437] [433494437 701408733] [701408733 1134903170] [1134903170 1836311903] [1836311903 2971215073] [2971215073 4807526976] [4807526976 7778742049] [7778742049 12586269025] [12586269025 20365011074] [20365011074 32951280099] [32951280099 53316291173] [53316291173 86267571272] [86267571272 139583862445] [139583862445 225851433717] [225851433717 365435296162] [365435296162 591286729879] [591286729879 956722026041] [956722026041 1548008755920] [1548008755920 2504730781961] [2504730781961 4052739537881] [4052739537881 6557470319842] [6557470319842 10610209857723] [10610209857723 17167680177565] [17167680177565 27777890035288] [27777890035288 44945570212853] [44945570212853 72723460248141] [72723460248141 117669030460994] [117669030460994 190392490709135] [190392490709135 308061521170129] [308061521170129 498454011879264] [498454011879264 806515533049393] [806515533049393 1304969544928657] [1304969544928657 2111485077978050] [2111485077978050 3416454622906707] [3416454622906707 5527939700884757] [5527939700884757 8944394323791464] [8944394323791464 14472334024676221] [14472334024676221 23416728348467685] [23416728348467685 37889062373143906] [37889062373143906 61305790721611591] [61305790721611591 99194853094755497] [99194853094755497 160500643816367088] [160500643816367088 259695496911122585] [259695496911122585 420196140727489673] [420196140727489673 679891637638612258] [679891637638612258 1100087778366101931] [1100087778366101931 1779979416004714189] [1779979416004714189 2880067194370816120] [2880067194370816120 4660046610375530309] ArithmeticException integer overflow  clojure.lang.Numbers.throwIntOverflow (Numbers.java:1374)
    RuntimeException Unmatched delimiter: )  clojure.lang.Util.runtimeException (Util.java:156)
    user=> (map
    first 
    (iterate fib-pair [1 1]))
    (1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155 165580141 267914296 433494437 701408733 1134903170 1836311903 2971215073 4807526976 7778742049 12586269025 20365011074 32951280099 53316291173 86267571272 139583862445 225851433717 365435296162 591286729879 956722026041 1548008755920 2504730781961 4052739537881 6557470319842 10610209857723 17167680177565 27777890035288 44945570212853 72723460248141 117669030460994 190392490709135 308061521170129 498454011879264 806515533049393 1304969544928657 2111485077978050 3416454622906707 5527939700884757 8944394323791464 14472334024676221 23416728348467685 37889062373143906 61305790721611591 99194853094755497 160500643816367088 259695496911122585 420196140727489673 679891637638612258 1100087778366101931 1779979416004714189 2880067194370816120 ArithmeticException integer overflow  clojure.lang.Numbers.throwIntOverflow (Numbers.java:1374)
    user=> 
    

    defrecord 和protocol*

    Clojure程序的执行分为两个阶段。宏展开(macro expansion)阶段将语言里的所有宏翻译成
    其展开形式。你可以用命令 macroexpand 观察宏展开。我们已经用过几个宏了,它们都叫做宏读
    取器。分号( ; )表示注释,单引号( ' )表示引用,而数学符号( # )则表示匿名函数。为了避
    免早于预期执行,在想展开的表达式前面加上一个引号:

    user=> (macroexpand '' something-we-do-not-want-interpreted)
    (quote something-we-do-not-want-interpreted)
    user=> (macroexpand '#(count %))
    (fn* [p1__71#] (count p1__71#))
    user=> 
    展开全文
  • clojure-源码

    2021-03-18 04:08:27
    Clojure
  • clojureClojure编程语言
  • clojure网站:clojure.org网站
  • clojure_Clojure访谈

    2020-06-24 08:57:31
    clojure 在2010年JAX伦敦秋季版上 ,尼尔·福特(Neal Ford)将提供关于结对编程和敏捷开发的实践会议。 我们赶上了他,以了解有关本次会议的更多信息,并谈论Clojure…。 JAXenter: JVM出现了许多新语言。 ...

    clojure

    2010年JAX伦敦秋季版上 ,尼尔·福特(Neal Ford)将提供关于结对编程和敏捷开发的实践会议。 我们赶上了他,以了解有关本次会议的更多信息,并谈论Clojure…。

    JAXenter: JVM出现了许多新语言。 Clojure提供什么好处?

    尼尔·福特(Neal Ford):克洛瑞(Clojure)是新与旧的迷人结合。 它是一种Lisp(可以说是有史以来功能最强大的语言),但在JVM上也具有功能和高性能。 对于使用传统基于C语言的开发人员来说,Clojure语法看起来有些奇怪,但是它很容易学习,因为实际上那里的语言很少-Lisp的语法很少。 它还具有强大的库,可以消除您用其他语言编写的许多样板代码的需求,这也有帮助。 最终结果是简洁,功能强大的高性能代码。

    JAXenter: Clojure与Lisp有什么共同之处

    尼尔·福特Neal Ford): Clojure是Lisp的实现(具有所有带来的好处),但是该语言的创建者Rich Hickey对Lisp的传统制作方式进行了一些更改,以使其更适合JVM,并且最终结果是Lisp支持Lisp的所有功能,但针对JVM的使用和速度进行了优化。

    JAXenter: Clojure如何处理并发?

    尼尔·福特(Neal Ford): Clojure对并发的支持使它成为许多开发人员关注的焦点。 Rich对Clojure中的可变状态做出了一些非常明智的选择,使默认值不可变(即使对于Rich Collections API也是如此)。可变状态具有特定的数据结构来管理对其状态的更改。 固有的线程安全性与真正需要更改的状态的真正智能数据结构相结合,使Clojure成为JVM上用于高度并发处理的最佳语言之一。 这是开始使用Clojure的早期适配器模式之一。

    JAXenter:除了在JAX伦敦举行的“ Clojure简介”会议之外,您还将运行一个敏捷开发会议,该会议有望“动手”。 与会者对本届会议有何期待?

    尼尔·福特(Neal Ford):在本次会议中,我将允许开发人员(全部或其中至少一半配备了笔记本电脑)体验真正的配对编程。 我要给小组一个简单的问题,然后让他们配对程序以得出结果。 这是一个亲自了解配对编程工作原理的机会(不仅仅是两个人为同一个键盘而战!)


    翻译自: https://jaxenter.com/interview-on-clojure-101856.html

    clojure

    展开全文
  • #lang clojure 该项目是Racket中Clojure兼容语言的存根。 它的主要目的是让我练习编写宏和使用Racket的语言扩展工具。 如果您有兴趣将其用于实际用途,请随时向我发送请求请求。 要在Racket 5.3.4及更高版本上...
  • MixRadio的clojure骨架项目。 这将生成我们在MixRadio上使用的基本REST服务项目。 在中,我们找到了各种有用的库,这些库可以看作是我们许多clojure Web服务之间各种共性的浓缩。 我们每天在MixRadio使用此功能来为...
  • Dropwizard Clojure 目录 莱宁根 [dropwizard-clojure/dropwizard-clojure " 0.2.0 " ] 创建一个配置类 package com.example.todo ; import com.fasterxml.jackson.annotation.JsonProperty ; import io....
  • clojure-init:发情的slo clojure
  • clojure-mxnet:MXNET的Clojure软件包
  • 它从clojure开始:Clojure实用指南
  • Clojure算法 我发现有趣的Clojure算法集合。
  • 钟表音符 Clojure学习笔记
  • 学习Clojure 动机 这是一个专用的回购协议,旨在帮助激励成员以及其他任何人学习编程语言Clojure。 此仓库的约定是让贡献者在其github句柄下的文件夹下命名其研究和贡献的名称空间。 应存在于回购协议根源的所有内容...
  • clojure笔记

    2014-05-10 20:33:10
    clojure
    clojure
    
    展开全文
  • 写于2014年1月,与Clojure 1.5.1和Leiningen 2.3.4一起在Java 1.7.0_45上编写。 受到Aphyr出色的Clojure从头开始的教程的启发,并因“ Clojure的喜悦”这本书而成为可能。 我还大量使用了Clojure的父亲Rich Hickey所...
  • clojure-新闻 一个使用#clojure日志的小新闻引擎,提取一些有趣的统计数据,并每天使用它来编译“昨天最好的”新闻通讯。 用法 修复:写 执照 版权所有 (C) 2012 FIXME 在 Eclipse 公共许可证下分发,与 Clojure ...
  • Clojure-开源

    2021-05-15 00:57:00
    Clojure是JVM的一种动态编程语言。 注意-当前Clojure开发已移至Google代码:http://code.google.com/p/clojure/项目网站:http://clojure.org
  • Clojure-Misc Clojure练习-不实用
  • Clojure native

    2020-12-02 02:18:55
    <div><p>rewrite of the clojure backend in clojure - includes a lein plugin - snippet support is not included - dealing with abstract classes with private and protected methods and fields in clojure ...
  • clojure电子书

    2016-06-26 11:31:45
    包含 clojure programming 和 programming clojure ,还有一个 windows 下的 leiningen 安装文件
  • Clojure-control仅依赖于OpenSSH和本地控制计算机上的clojure.Remote计算机仅需要一个标准的sshd守护程序。 这个想法来自。 ##消息 控件0.4.1已释放。 安装 Clojure-Control使用control外壳程序脚本进行引导。 ...
  • clojure eclipse

    2011-10-19 19:31:49
    clojure clojure clojureclojure clojure

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,976
精华内容 3,190
关键字:

clojure