blocks|key|499137|text|下面是你如何定义你的记录：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|499138|(defrecord+MyType+[a+b])|code-block|syntax|javascript|499139|请注意，在Clojure中，您通常不会在记录类型本身中定义“方法”(例外情况是您希望直接实现Java接口或协议)。|499140|免费自动生成一个基本构造函数(以->为前缀)：|offset|length|style|CODE|499141|(def+foo+(->MyType+[1+2+3]+[4+5+6]))

foo
=>+#user.MyType{:a+[1+2+3],+:b+[4+5+6]}|499142|然后，您可以编写更复杂的构造函数来使用它，例如|499143|(defn+mytype-with-length+[n]
++(let+[a+(vec+(range+n))
++++++++b+(vec+(range+n))]+
++++(->MyType+a+b)))

(mytype-with-length+3)
=>+#user.MyType{:a+[0+1+2],+:b+[0+1+2]}|499144|而且“变异和返回”也是免费的--你可以只使用assoc|499145|(assoc+foo+:b+[7+8+9])
=>+user.MyType{:a+[1+2+3],+:b+[7+8+9]}|499146|entityMap|0|LINK|mutability|MUTABLE|url|http://clojuredocs.org/clojure_core/clojure.core/assoc^0|0|0|0|G|2|0|0|0|0|M|5|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|18|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|19|8|@$K|1A|L|1B|M|N]]|9|@]|A|$]]|$1|O|3|P|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|1D|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1E|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1F|8|@]|9|@$K|1G|L|1H|1|1I]]|A|$]]|$1|W|3|X|5|D|7|1J|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1K|8|@]|9|@]|A|$]]]|Z|$10|$5|11|12|13|A|$14|15]]]]

Here's how you define your record:

<pre><code>(defrecord MyType [a b])
</code></pre>

Note that in Clojure you don't typically define "methods" within your record type itself (the exception is if you want to directly implement a Java interface or a protocol).

A basic constructor (prefixed with <code>-&gt;</code>) gets generated automatically for free:

<pre><code>(def foo (-&gt;MyType [1 2 3] [4 5 6]))

foo
=&gt; #user.MyType{:a [1 2 3], :b [4 5 6]}
</code></pre>

You can then write more sophisticated constructor functions that use this, e.g.

<pre><code>(defn mytype-with-length [n]
 (let [a (vec (range n))
 b (vec (range n))] 
 (-&gt;MyType a b)))

(mytype-with-length 3)
=&gt; #user.MyType{:a [0 1 2], :b [0 1 2]}
</code></pre>

And "mutate-and-return" also comes for free - you can just use <a href="http://clojuredocs.org/clojure_core/clojure.core/assoc">assoc</a>:

<pre><code>(assoc foo :b [7 8 9])
=&gt; user.MyType{:a [1 2 3], :b [7 8 9]}
</code></pre>

blocks|key|499202|text|Clojure+defrecord示例：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|499203|；；定义地址记录|499204|(defrecord+Address+[city+state])|code-block|syntax|javascript|499205|；；定义人员记录|499206|(defrecord+Person+[firstname+lastname+%5EAddress+address])|499207|；；构建构造函数|499208|(defn+make-person+([fname+lname+city+state]
+++++++++++++++(->Person+fname+lname+(->Address+city+state))))|499209|；；创建一个人|499210|(def+person1+(make-person+"John"+"Doe"+"LA"+"CA"))|499211|；；检索值|499212|(:firstname+person1)
(:city+(:address+person1))|499213|entityMap^0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|U|3|V|5|6|7|19|8|@]|9|@]|A|$]]|$1|W|3|X|5|F|7|1A|8|@]|9|@]|A|$G|H]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Clojure defrecord example:

;;define Address record

<pre><code>(defrecord Address [city state])
</code></pre>

;;define Person record

<pre><code>(defrecord Person [firstname lastname ^Address address])
</code></pre>

;;buid the constructor

<pre><code>(defn make-person ([fname lname city state]
 (-&gt;Person fname lname (-&gt;Address city state))))
</code></pre>

;;create a person

<pre><code>(def person1 (make-person "John" "Doe" "LA" "CA"))
</code></pre>

;;retrieve values

<pre><code>(:firstname person1)
(:city (:address person1))
</code></pre>

blocks|key|282525|text|Clojure允许您创建记录，这些记录是自定义的maplike数据类型。它们类似于maplike，因为它们将键与值相关联，您可以像使用map一样查找它们的值，并且它们像map一样是不可变的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|282526|282527|(defrecord+Person+[last+first+address])
;=>+core.Person

(defrecord+Ad+[street+city+zip])
;=>+core.Ad

(def+p1+(Person.+"Jhon"+"Mick"
+++++++++++++++++(Ad.+"US187956"+"NY"+3369)))
;=>+#'core/p1

(update-in+p1+[:address+:zip]+inc)
;=>+#core.Person{:last+"Jhon",+:first+"Mick",+:address+#playsync.core.Ad{:street+"US187956",+:city+"NY",+:zip+3370}}

(assoc+p1+:last+"Adam")
;=>+#core.Person{:last+"Adam",+:first+"Mick",+:address+#playsync.core.Ad{:street+"US187956",+:city+"NY",+:zip+3370}}|code-block|syntax|javascript|282528|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|K|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|L|8|@]|9|@]|A|$F|G]]|$1|H|3|-4|5|6|7|M|8|@]|9|@]|A|$]]]|I|$]]

Clojure allows you to create records, which are custom, maplike data types.
They’re maplike in that they associate keys with values, you can look up their values the same way you can with maps, and they’re immutable like maps.
<hr />
<pre><code>(defrecord Person [last first address])
;=&gt; core.Person

(defrecord Ad [street city zip])
;=&gt; core.Ad

(def p1 (Person. &quot;Jhon&quot; &quot;Mick&quot;
 (Ad. &quot;US187956&quot; &quot;NY&quot; 3369)))
;=&gt; #'core/p1

(update-in p1 [:address :zip] inc)
;=&gt; #core.Person{:last &quot;Jhon&quot;, :first &quot;Mick&quot;, :address #playsync.core.Ad{:street &quot;US187956&quot;, :city &quot;NY&quot;, :zip 3370}}

(assoc p1 :last &quot;Adam&quot;)
;=&gt; #core.Person{:last &quot;Adam&quot;, :first &quot;Mick&quot;, :address #playsync.core.Ad{:street &quot;US187956&quot;, :city &quot;NY&quot;, :zip 3370}}
</code></pre>

I'm attempting to create my own immutable datatype/methods with <code>defrecord</code> in Clojure. The goal is to have a datatype that I can create instances of, and then call its methods to return a new copy of itself with mutated variables. Say a and b are vectors. I'd like to update a value in both and return a new copy of the entire structure with those vectors updated. This obviously doesn't compile, I'm just trying to get my ideas across.

<pre><code>(defrecord MyType [a b]
 (constructor [N]
 ; I'd like to build an initial instance, creating a and b as vectors of length N
 ) 

 (mutate-and-return [] 
 ; I'd like to mutate (assoc the vectors) and return the new structure, a and b modified
 )
)
</code></pre>

I'd like to call the constructor and then the mutator as many times as I'd like (there are other functions that don't mutate, but I don't want to make it more complex for the question).

Alternatively, if this is not idiomatic Clojure, how are you supposed to do something like this?

Clojure's defrecord - how to use it?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

我正在尝试用Clojure中的defrecord创建我自己的不可变数据类型/方法。我们的目标是有一个数据类型，我可以创建它的实例，然后调用它的方法来返回带有变异变量的自身的新副本。假设a和b是向量。我想在两者中更新一个值，并返回整个结构的一个新副本，其中包含更新后的向量。这显然不能编译，我只是想让大家理解我的想法。(d...

问Clojure的defrecord -如何使用它？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Clojure的defrecord -如何使用它？EN