forked from clojure/clojure
/
changes.txt
227 lines (148 loc) · 5.95 KB
/
changes.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
Changes to Clojure in Version 1.1
= CONTENTS =
1 Deprecated Features
1.1 add-classpath
1.2 ^ reader macro
1.3 clojure.parallel
2 New Features in clojure.core
2.1 Primitive Array Generators
2.2 Casting to Primitive Arrays
2.3 Chunked Sequences
2.4 Futures
2.5 Promises
2.6 Futures vs. Promises
2.7 Transients
2.8 User-controlled Thread Bindings
2.9 Ref History
2.10 Function pre- and postconditions
2.11 Miscellaneous
3 New Namespaces
3.1 clojure.test
3.2 clojure.test.junit
3.3 clojure.stacktrace
3.4 clojure.walk
3.5 clojure.template
4 Closed Tickets
= 1 Deprecated Features =
== 1.1 add-classpath ==
This function can not be made to work in many environments.
Always use Java's built-in mechanisms to control the
classpath.
== 1.2 ^ reader macro ==
The ^ reader macro has been deprecated as a shortcut for meta
in the hopes that it can eventually replace the #^ reader macro.
== 1.3 clojure.parallel ==
The clojure.parallel namespace has been deprecated. Eventually it
will be replaced with a faster and more idiomatic alternative
based on the JDK7 ForkJoin library. A preview of this work is
already available in the 'par' branch of Clojure.
= 2 New Features in clojure.core =
== 2.1 Primitive Array Generators ==
(just like int-array, double-array)
* boolean-array : New
* byte-array : New
* char-array : New
* short-array : New
== 2.2 Casting To Primitive Arrays ==
(just like ints, doubles)
* booleans : New
* bytes : New
* chars : New
* shorts : New
== 2.3 Chunked Seqs ==
Some Clojure data structures now yield chunked seqs, which, in addition
to satisfying the normal item-at-a-time seq interface, also support processing
data sequentially by small blocks called 'chunks'. This can provide greater
efficiency by leveraging the structure of the data and amortizing the overhead
of sequential access. Some of the sequence processing functions (like map and filter)
are now chunk-aware and leverage this efficiency.
Consumption of chunked-seqs as normal seqs should be completely transparent. However,
note that some sequence processing will occur up to 32 elements at a time. This could
matter to you if you are relying on full laziness to preclude the generation of any
non-consumed results. An interface to force single-item consumption of chunked seqs is
still being designed. Please share any use cases where chunked processing has resulted
in behavioral differences that matter to you on the Clojure google group.
The following fns should be considered implementation details subject to change,
but can be used for experimentation with building your own chunked-seq
functions from scratch. See map and filter as examples.
* chunk : New
* chunk-buffer : New
* chunk-append : New
* chunk-first : New
* chunk-rest : New
* chunk-next : New
* chunk-cons : New
* chunked-seq? : New
== 2.4 Futures ==
Futures represent asynchronous computations. They are away to get
code to run in another thread, and obtain the result.
* future : New
* future? : New
* future-done? : New
* future-cancel : New
* future-cancelled? : New
== 2.5 Promises ==
A promise is a synchronization construct that can be used to deliver a value
from one thread to another. Until the value has been delivered, any attempt
to dereference the promise will block. It thus enables dataflow-style programming.
* promise : New
* deliver : New
== 2.6 Futures vs. Promises ==
A future is associated with a computation, whereas a promise is just a handoff reference.
== 2.7 Transients ==
See: http://clojure.org/transients
* transient : New
* persistent! : New
* conj! : New
* assoc! : New
* dissoc! : New
* pop! : New
* disj! : New
== 2.8 User-Controlled Thread Bindings ==
* push-thread-bindings : New
* pop-thread-bindings : New
* get-thread-bindings : New
* with-bindings* : New
* with-bindings : New
* bound-fn* : New
* bound-fn : New
== 2.9 Ref History ==
* ref : Updated
* ref-history-count : New
* ref-min-history : New
* ref-max-history : New
== 2.10 Function pre- and postconditions ==
Functions support specifying runtime pre- and postconditions.
See: http://clojure.org/special_forms
== 2.11 Miscellaneous ==
* juxt : New
* import : Now a macro form
* assert : Now with *assert* binding
* slurp : Now with encoding parameter
* with-loading-context : New
= 3 New Namespaces =
Complete documentation for all namespaces is in the source and API docs.
http://richhickey.github.com/clojure/
== 3.1 clojure.test ==
The test framework formerly known as clojure.contrib.test-is.
== 3.2 clojure.test.junit ==
An extension to clojure.test for JUnit-style XML output. This
enables you to use JUnit reporting tools with clojure.test.
== 3.3 clojure.stacktrace ==
A few utility functions for printing Java stacktraces in a
format that distinguishes between Clojure function calls
and Java method calls.
== 3.4 clojure.walk ==
A simple tree walker for transforming data structures. Similar in
intent to clojure.zip, but less flexible. Useful when you want to
call a function on every value in a complex, nested data structure.
Includes some examples such as stringify-keys, which replaces all
keywords in a map with strings, and macroexpand-all, a
quick-and-dirty macroexpansion tester. Note: macroexpand-all is
NOT 100% correct, it just recursively tries to macroexpand a form;
it does not correctly interpret special forms such as let.
== 3.5 clojure.template ==
Macros that apply a "template expression" to a list of forms.
Used to implement the "are" macro in clojure.test.
= 4 Closed Tickets =
http://www.assembla.com/spaces/clojure/tickets?milestone_id=93750&tickets_report_id=5