matrix_display 1.0.0

A library to display a matrix in command line with pretty unicode separators
Documentation
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
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Source to the Rust file `/home/pierrec/.cargo/registry/src/github.com-1ecc6299db9ec823/ansi_term-0.11.0/src/lib.rs`."><meta name="keywords" content="rust, rustlang, rust-lang"><title>lib.rs.html -- source</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><noscript><link rel="stylesheet" href="../../noscript.css"></noscript><link rel="shortcut icon" href="../../favicon.ico"><style type="text/css">#crate-search{background-image:url("../../down-arrow.svg");}</style></head><body class="rustdoc source"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">&#9776;</div><a href='../../ansi_term/index.html'><img src='../../rust-logo.png' alt='logo' width='100'></a></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><pre class="line-numbers"><span id="1">  1</span>
<span id="2">  2</span>
<span id="3">  3</span>
<span id="4">  4</span>
<span id="5">  5</span>
<span id="6">  6</span>
<span id="7">  7</span>
<span id="8">  8</span>
<span id="9">  9</span>
<span id="10"> 10</span>
<span id="11"> 11</span>
<span id="12"> 12</span>
<span id="13"> 13</span>
<span id="14"> 14</span>
<span id="15"> 15</span>
<span id="16"> 16</span>
<span id="17"> 17</span>
<span id="18"> 18</span>
<span id="19"> 19</span>
<span id="20"> 20</span>
<span id="21"> 21</span>
<span id="22"> 22</span>
<span id="23"> 23</span>
<span id="24"> 24</span>
<span id="25"> 25</span>
<span id="26"> 26</span>
<span id="27"> 27</span>
<span id="28"> 28</span>
<span id="29"> 29</span>
<span id="30"> 30</span>
<span id="31"> 31</span>
<span id="32"> 32</span>
<span id="33"> 33</span>
<span id="34"> 34</span>
<span id="35"> 35</span>
<span id="36"> 36</span>
<span id="37"> 37</span>
<span id="38"> 38</span>
<span id="39"> 39</span>
<span id="40"> 40</span>
<span id="41"> 41</span>
<span id="42"> 42</span>
<span id="43"> 43</span>
<span id="44"> 44</span>
<span id="45"> 45</span>
<span id="46"> 46</span>
<span id="47"> 47</span>
<span id="48"> 48</span>
<span id="49"> 49</span>
<span id="50"> 50</span>
<span id="51"> 51</span>
<span id="52"> 52</span>
<span id="53"> 53</span>
<span id="54"> 54</span>
<span id="55"> 55</span>
<span id="56"> 56</span>
<span id="57"> 57</span>
<span id="58"> 58</span>
<span id="59"> 59</span>
<span id="60"> 60</span>
<span id="61"> 61</span>
<span id="62"> 62</span>
<span id="63"> 63</span>
<span id="64"> 64</span>
<span id="65"> 65</span>
<span id="66"> 66</span>
<span id="67"> 67</span>
<span id="68"> 68</span>
<span id="69"> 69</span>
<span id="70"> 70</span>
<span id="71"> 71</span>
<span id="72"> 72</span>
<span id="73"> 73</span>
<span id="74"> 74</span>
<span id="75"> 75</span>
<span id="76"> 76</span>
<span id="77"> 77</span>
<span id="78"> 78</span>
<span id="79"> 79</span>
<span id="80"> 80</span>
<span id="81"> 81</span>
<span id="82"> 82</span>
<span id="83"> 83</span>
<span id="84"> 84</span>
<span id="85"> 85</span>
<span id="86"> 86</span>
<span id="87"> 87</span>
<span id="88"> 88</span>
<span id="89"> 89</span>
<span id="90"> 90</span>
<span id="91"> 91</span>
<span id="92"> 92</span>
<span id="93"> 93</span>
<span id="94"> 94</span>
<span id="95"> 95</span>
<span id="96"> 96</span>
<span id="97"> 97</span>
<span id="98"> 98</span>
<span id="99"> 99</span>
<span id="100">100</span>
<span id="101">101</span>
<span id="102">102</span>
<span id="103">103</span>
<span id="104">104</span>
<span id="105">105</span>
<span id="106">106</span>
<span id="107">107</span>
<span id="108">108</span>
<span id="109">109</span>
<span id="110">110</span>
<span id="111">111</span>
<span id="112">112</span>
<span id="113">113</span>
<span id="114">114</span>
<span id="115">115</span>
<span id="116">116</span>
<span id="117">117</span>
<span id="118">118</span>
<span id="119">119</span>
<span id="120">120</span>
<span id="121">121</span>
<span id="122">122</span>
<span id="123">123</span>
<span id="124">124</span>
<span id="125">125</span>
<span id="126">126</span>
<span id="127">127</span>
<span id="128">128</span>
<span id="129">129</span>
<span id="130">130</span>
<span id="131">131</span>
<span id="132">132</span>
<span id="133">133</span>
<span id="134">134</span>
<span id="135">135</span>
<span id="136">136</span>
<span id="137">137</span>
<span id="138">138</span>
<span id="139">139</span>
<span id="140">140</span>
<span id="141">141</span>
<span id="142">142</span>
<span id="143">143</span>
<span id="144">144</span>
<span id="145">145</span>
<span id="146">146</span>
<span id="147">147</span>
<span id="148">148</span>
<span id="149">149</span>
<span id="150">150</span>
<span id="151">151</span>
<span id="152">152</span>
<span id="153">153</span>
<span id="154">154</span>
<span id="155">155</span>
<span id="156">156</span>
<span id="157">157</span>
<span id="158">158</span>
<span id="159">159</span>
<span id="160">160</span>
<span id="161">161</span>
<span id="162">162</span>
<span id="163">163</span>
<span id="164">164</span>
<span id="165">165</span>
<span id="166">166</span>
<span id="167">167</span>
<span id="168">168</span>
<span id="169">169</span>
<span id="170">170</span>
<span id="171">171</span>
<span id="172">172</span>
<span id="173">173</span>
<span id="174">174</span>
<span id="175">175</span>
<span id="176">176</span>
<span id="177">177</span>
<span id="178">178</span>
<span id="179">179</span>
<span id="180">180</span>
<span id="181">181</span>
<span id="182">182</span>
<span id="183">183</span>
<span id="184">184</span>
<span id="185">185</span>
<span id="186">186</span>
<span id="187">187</span>
<span id="188">188</span>
<span id="189">189</span>
<span id="190">190</span>
<span id="191">191</span>
<span id="192">192</span>
<span id="193">193</span>
<span id="194">194</span>
<span id="195">195</span>
<span id="196">196</span>
<span id="197">197</span>
<span id="198">198</span>
<span id="199">199</span>
<span id="200">200</span>
<span id="201">201</span>
<span id="202">202</span>
<span id="203">203</span>
<span id="204">204</span>
<span id="205">205</span>
</pre><div class="example-wrap"><pre class="rust ">
<span class="doccomment">//! This is a library for controlling colours and formatting, such as</span>
<span class="doccomment">//! red bold text or blue underlined text, on ANSI terminals.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ## Basic usage</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! There are two main data structures in this crate that you need to be</span>
<span class="doccomment">//! concerned with: `ANSIString` and `Style`. A `Style` holds stylistic</span>
<span class="doccomment">//! information: colours, whether the text should be bold, or blinking, or</span>
<span class="doccomment">//! whatever. There are also `Colour` variants that represent simple foreground</span>
<span class="doccomment">//! colour styles. An `ANSIString` is a string paired with a `Style`.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! (Yes, it’s British English, but you won’t have to write “colour” very often.</span>
<span class="doccomment">//! `Style` is used the majority of the time.)</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! To format a string, call the `paint` method on a `Style` or a `Colour`,</span>
<span class="doccomment">//! passing in the string you want to format as the argument. For example,</span>
<span class="doccomment">//! here’s how to get some red text:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Red;</span>
<span class="doccomment">//!     println!(&quot;This is in red: {}&quot;, Red.paint(&quot;a red string&quot;));</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! It’s important to note that the `paint` method does *not* actually return a</span>
<span class="doccomment">//! string with the ANSI control characters surrounding it. Instead, it returns</span>
<span class="doccomment">//! an `ANSIString` value that has a `Display` implementation that, when</span>
<span class="doccomment">//! formatted, returns the characters. This allows strings to be printed with a</span>
<span class="doccomment">//! minimum of `String` allocations being performed behind the scenes.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! If you *do* want to get at the escape codes, then you can convert the</span>
<span class="doccomment">//! `ANSIString` to a string as you would any other `Display` value:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Red;</span>
<span class="doccomment">//!     use std::string::ToString;</span>
<span class="doccomment">//!     let red_string = Red.paint(&quot;a red string&quot;).to_string();</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ## Bold, underline, background, and other styles</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! For anything more complex than plain foreground colour changes, you need to</span>
<span class="doccomment">//! construct `Style` objects themselves, rather than beginning with a `Colour`.</span>
<span class="doccomment">//! You can do this by chaining methods based on a new `Style`, created with</span>
<span class="doccomment">//! `Style::new()`. Each method creates a new style that has that specific</span>
<span class="doccomment">//! property set. For example:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Style;</span>
<span class="doccomment">//!     println!(&quot;How about some {} and {}?&quot;,</span>
<span class="doccomment">//!              Style::new().bold().paint(&quot;bold&quot;),</span>
<span class="doccomment">//!              Style::new().underline().paint(&quot;underline&quot;));</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! For brevity, these methods have also been implemented for `Colour` values,</span>
<span class="doccomment">//! so you can give your styles a foreground colour without having to begin with</span>
<span class="doccomment">//! an empty `Style` value:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::{Blue, Yellow};</span>
<span class="doccomment">//!     println!(&quot;Demonstrating {} and {}!&quot;,</span>
<span class="doccomment">//!              Blue.bold().paint(&quot;blue bold&quot;),</span>
<span class="doccomment">//!              Yellow.underline().paint(&quot;yellow underline&quot;));</span>
<span class="doccomment">//!     println!(&quot;Yellow on blue: {}&quot;, Yellow.on(Blue).paint(&quot;wow!&quot;));</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The complete list of styles you can use are: `bold`, `dimmed`, `italic`,</span>
<span class="doccomment">//! `underline`, `blink`, `reverse`, `hidden`, `strikethrough`, and `on` for</span>
<span class="doccomment">//! background colours.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! In some cases, you may find it easier to change the foreground on an</span>
<span class="doccomment">//! existing `Style` rather than starting from the appropriate `Colour`.</span>
<span class="doccomment">//! You can do this using the `fg` method:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Style;</span>
<span class="doccomment">//!     use ansi_term::Colour::{Blue, Cyan, Yellow};</span>
<span class="doccomment">//!     println!(&quot;Yellow on blue: {}&quot;, Style::new().on(Blue).fg(Yellow).paint(&quot;yow!&quot;));</span>
<span class="doccomment">//!     println!(&quot;Also yellow on blue: {}&quot;, Cyan.on(Blue).fg(Yellow).paint(&quot;zow!&quot;));</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Finally, you can turn a `Colour` into a `Style` with the `normal` method.</span>
<span class="doccomment">//! This will produce the exact same `ANSIString` as if you just used the</span>
<span class="doccomment">//! `paint` method on the `Colour` directly, but it’s useful in certain cases:</span>
<span class="doccomment">//! for example, you may have a method that returns `Styles`, and need to</span>
<span class="doccomment">//! represent both the “red bold” and “red, but not bold” styles with values of</span>
<span class="doccomment">//! the same type. The `Style` struct also has a `Default` implementation if you</span>
<span class="doccomment">//! want to have a style with *nothing* set.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Style;</span>
<span class="doccomment">//!     use ansi_term::Colour::Red;</span>
<span class="doccomment">//!     Red.normal().paint(&quot;yet another red string&quot;);</span>
<span class="doccomment">//!     Style::default().paint(&quot;a completely regular string&quot;);</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ## Extended colours</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! You can access the extended range of 256 colours by using the `Fixed` colour</span>
<span class="doccomment">//! variant, which takes an argument of the colour number to use. This can be</span>
<span class="doccomment">//! included wherever you would use a `Colour`:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Fixed;</span>
<span class="doccomment">//!     Fixed(134).paint(&quot;A sort of light purple&quot;);</span>
<span class="doccomment">//!     Fixed(221).on(Fixed(124)).paint(&quot;Mustard in the ketchup&quot;);</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The first sixteen of these values are the same as the normal and bold</span>
<span class="doccomment">//! standard colour variants. There’s nothing stopping you from using these as</span>
<span class="doccomment">//! `Fixed` colours instead, but there’s nothing to be gained by doing so</span>
<span class="doccomment">//! either.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! You can also access full 24-bit color by using the `RGB` colour variant,</span>
<span class="doccomment">//! which takes separate `u8` arguments for red, green, and blue:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::RGB;</span>
<span class="doccomment">//!     RGB(70, 130, 180).paint(&quot;Steel blue&quot;);</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ## Combining successive coloured strings</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The benefit of writing ANSI escape codes to the terminal is that they</span>
<span class="doccomment">//! *stack*: you do not need to end every coloured string with a reset code if</span>
<span class="doccomment">//! the text that follows it is of a similar style. For example, if you want to</span>
<span class="doccomment">//! have some blue text followed by some blue bold text, it’s possible to send</span>
<span class="doccomment">//! the ANSI code for blue, followed by the ANSI code for bold, and finishing</span>
<span class="doccomment">//! with a reset code without having to have an extra one between the two</span>
<span class="doccomment">//! strings.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! This crate can optimise the ANSI codes that get printed in situations like</span>
<span class="doccomment">//! this, making life easier for your terminal renderer. The `ANSIStrings`</span>
<span class="doccomment">//! struct takes a slice of several `ANSIString` values, and will iterate over</span>
<span class="doccomment">//! each of them, printing only the codes for the styles that need to be updated</span>
<span class="doccomment">//! as part of its formatting routine.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! The following code snippet uses this to enclose a binary number displayed in</span>
<span class="doccomment">//! red bold text inside some red, but not bold, brackets:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Red;</span>
<span class="doccomment">//!     use ansi_term::{ANSIString, ANSIStrings};</span>
<span class="doccomment">//!     let some_value = format!(&quot;{:b}&quot;, 42);</span>
<span class="doccomment">//!     let strings: &amp;[ANSIString&lt;&#39;static&gt;] = &amp;[</span>
<span class="doccomment">//!         Red.paint(&quot;[&quot;),</span>
<span class="doccomment">//!         Red.bold().paint(some_value),</span>
<span class="doccomment">//!         Red.paint(&quot;]&quot;),</span>
<span class="doccomment">//!     ];</span>
<span class="doccomment">//!     println!(&quot;Value: {}&quot;, ANSIStrings(strings));</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! There are several things to note here. Firstly, the `paint` method can take</span>
<span class="doccomment">//! *either* an owned `String` or a borrowed `&amp;str`. Internally, an `ANSIString`</span>
<span class="doccomment">//! holds a copy-on-write (`Cow`) string value to deal with both owned and</span>
<span class="doccomment">//! borrowed strings at the same time. This is used here to display a `String`,</span>
<span class="doccomment">//! the result of the `format!` call, using the same mechanism as some</span>
<span class="doccomment">//! statically-available `&amp;str` slices. Secondly, that the `ANSIStrings` value</span>
<span class="doccomment">//! works in the same way as its singular counterpart, with a `Display`</span>
<span class="doccomment">//! implementation that only performs the formatting when required.</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! ## Byte strings</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! This library also supports formatting `[u8]` byte strings; this supports</span>
<span class="doccomment">//! applications working with text in an unknown encoding.  `Style` and</span>
<span class="doccomment">//! `Color` support painting `[u8]` values, resulting in an `ANSIByteString`.</span>
<span class="doccomment">//! This type does not implement `Display`, as it may not contain UTF-8, but</span>
<span class="doccomment">//! it does provide a method `write_to` to write the result to any</span>
<span class="doccomment">//! `io::Write`:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Green;</span>
<span class="doccomment">//!     Green.paint(&quot;user data&quot;.as_bytes()).write_to(&amp;mut std::io::stdout()).unwrap();</span>
<span class="doccomment">//!</span>
<span class="doccomment">//! Similarly, the type `ANSIByteStrings` supports writing a list of</span>
<span class="doccomment">//! `ANSIByteString` values with minimal escape sequences:</span>
<span class="doccomment">//!</span>
<span class="doccomment">//!     use ansi_term::Colour::Green;</span>
<span class="doccomment">//!     use ansi_term::ANSIByteStrings;</span>
<span class="doccomment">//!     ANSIByteStrings(&amp;[</span>
<span class="doccomment">//!         Green.paint(&quot;user data 1\n&quot;.as_bytes()),</span>
<span class="doccomment">//!         Green.bold().paint(&quot;user data 2\n&quot;.as_bytes()),</span>
<span class="doccomment">//!     ]).write_to(&amp;mut std::io::stdout()).unwrap();</span>


<span class="attribute">#![<span class="ident">crate_name</span> <span class="op">=</span> <span class="string">&quot;ansi_term&quot;</span>]</span>
<span class="attribute">#![<span class="ident">crate_type</span> <span class="op">=</span> <span class="string">&quot;rlib&quot;</span>]</span>
<span class="attribute">#![<span class="ident">crate_type</span> <span class="op">=</span> <span class="string">&quot;dylib&quot;</span>]</span>

<span class="attribute">#![<span class="ident">warn</span>(<span class="ident">missing_copy_implementations</span>)]</span>
<span class="attribute">#![<span class="ident">warn</span>(<span class="ident">missing_docs</span>)]</span>
<span class="attribute">#![<span class="ident">warn</span>(<span class="ident">trivial_casts</span>, <span class="ident">trivial_numeric_casts</span>)]</span>
<span class="attribute">#![<span class="ident">warn</span>(<span class="ident">unused_extern_crates</span>, <span class="ident">unused_qualifications</span>)]</span>

<span class="attribute">#[<span class="ident">cfg</span>(<span class="ident">target_os</span><span class="op">=</span><span class="string">&quot;windows&quot;</span>)]</span>
<span class="kw">extern</span> <span class="kw">crate</span> <span class="ident">winapi</span>;

<span class="kw">mod</span> <span class="ident">ansi</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">ansi</span>::{<span class="ident">Prefix</span>, <span class="ident">Infix</span>, <span class="ident">Suffix</span>};

<span class="kw">mod</span> <span class="ident">style</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">style</span>::{<span class="ident">Colour</span>, <span class="ident">Style</span>};

<span class="doccomment">/// Color is a type alias for Colour for those who can&#39;t be bothered.</span>
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">Colour</span> <span class="kw">as</span> <span class="ident">Color</span>;

<span class="comment">// I&#39;m not beyond calling Colour Colour, rather than Color, but I did</span>
<span class="comment">// purposefully name this crate &#39;ansi-term&#39; so people wouldn&#39;t get</span>
<span class="comment">// confused when they tried to install it.</span>
<span class="comment">//</span>
<span class="comment">// Only *after* they&#39;d installed it.</span>

<span class="kw">mod</span> <span class="ident">difference</span>;
<span class="kw">mod</span> <span class="ident">display</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">display</span>::<span class="kw-2">*</span>;

<span class="kw">mod</span> <span class="ident">write</span>;

<span class="kw">mod</span> <span class="ident">windows</span>;
<span class="kw">pub</span> <span class="kw">use</span> <span class="ident">windows</span>::<span class="kw-2">*</span>;

<span class="kw">mod</span> <span class="ident">debug</span>;
</pre></div>
</section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>&#9166;</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g., <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g., <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g., <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../../";window.currentCrate = "ansi_term";</script><script src="../../aliases.js"></script><script src="../../main.js"></script><script src="../../source-script.js"></script><script src="../../source-files.js"></script><script defer src="../../search-index.js"></script></body></html>