-
Notifications
You must be signed in to change notification settings - Fork 1
/
Copy pathgetstarted.html
340 lines (310 loc) · 27.3 KB
/
getstarted.html
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
<!DOCTYPE html>
<html lang="en" data-content_root="./">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1.0" /><meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Getting Started — Neat documentation</title>
<link rel="stylesheet" type="text/css" href="_static/pygments.css?v=4f649999" />
<link rel="stylesheet" type="text/css" href="_static/alabaster.css?v=039e1c02" />
<script src="_static/jquery.js?v=5d32c60e"></script>
<script src="_static/_sphinx_javascript_frameworks_compat.js?v=2cd50e6c"></script>
<script src="_static/documentation_options.js?v=5929fcd5"></script>
<script src="_static/doctools.js?v=888ff710"></script>
<script src="_static/sphinx_highlight.js?v=dc90522c"></script>
<link rel="index" title="Index" href="genindex.html" />
<link rel="search" title="Search" href="search.html" />
<link rel="next" title="Introduction" href="intro.html" />
<link rel="prev" title="The Neat Language" href="index.html" />
<link rel="stylesheet" href="_static/custom.css" type="text/css" />
<meta name="viewport" content="width=device-width, initial-scale=0.9, maximum-scale=0.9" />
</head><body>
<div class="document">
<div class="documentwrapper">
<div class="bodywrapper">
<div class="body" role="main">
<section id="getting-started">
<h1>Getting Started<a class="headerlink" href="#getting-started" title="Link to this heading">¶</a></h1>
<p>The Neat compiler is at the moment only tested on 64-bit x86 Linux. However, it <em>should</em> work on other 64-bit platforms,
and be able to be ported to 32-bit platforms with little effort.</p>
<p>There are two available versions, depending on backend: LLVM 15 or GCC based. Note that both versions will require gcc
to be installed for certain macros to work. Also, while the LLVM backend release may use the gcc backend, the gcc backend
release cannot use LLVM, because it will not be built against it.</p>
<p>The primary question, thus, is which backend you expect to use “by default.” However, to my knowledge, aside the inherent
differences of LLVM’s and gcc’s backend, both Neat backends are equally capable. The choice is thus largely down to personal preference.</p>
<p>The installation instructions assume, and are tested with, Ubuntu 22.04. Take required steps as equivalent for your system.</p>
<section id="install-on-windows">
<h2>Install on Windows<a class="headerlink" href="#install-on-windows" title="Link to this heading">¶</a></h2>
<p>Warning: as I don’t have any Windows computer around, very little testing effort has gone into this deployment.
The testsuite passes on Wine, that’s about all I can say.</p>
<ol class="arabic">
<li><p>Install <a class="reference external" href="https://github.com/mstorsjo/llvm-mingw/releases/tag/20220906">llvm-mingw with LLVM 15</a>.</p></li>
<li><p>Ensure that the ‘bin’ folder of llvm-mingw distro is in the <code class="code docutils literal notranslate"><span class="pre">PATH</span></code>.</p></li>
<li><p>Download the latest win64-gcc release from <a class="reference external" href="https://github.com/neat-lang/neat/releases">https://github.com/neat-lang/neat/releases</a></p></li>
<li><p>Execute <code class="code docutils literal notranslate"><span class="pre">build.bat</span></code>. This should (eventually) create a file <code class="code docutils literal notranslate"><span class="pre">neat.exe</span></code>.</p></li>
<li><p>Test the compiler: save a file ‘hello.nt’:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="k">module</span><span class="w"> </span><span class="n">hello</span><span class="p">;</span>
<span class="k">import</span><span class="w"> </span><span class="n">std</span><span class="p">.</span><span class="n">stdio</span><span class="p">;</span>
<span class="kt">void</span><span class="w"> </span><span class="n">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"Hello World"</span><span class="p">);</span><span class="w"> </span><span class="p">}</span>
</pre></div>
</div>
</li>
</ol>
<p>Then compile it with:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">neat</span><span class="w"> </span><span class="n">hello</span><span class="p">.</span><span class="n">nt</span>
<span class="n">hello</span><span class="p">.</span><span class="n">exe</span>
</pre></div>
</div>
<p>If that printed “Hello World”, your Neat compiler is now ready for use!</p>
</section>
<section id="install-with-llvm">
<h2>Install with LLVM<a class="headerlink" href="#install-with-llvm" title="Link to this heading">¶</a></h2>
<ol class="arabic simple">
<li><p>Install required packages:</p></li>
</ol>
<div class="highlight-bash notranslate"><div class="highlight"><pre><span></span>apt-get<span class="w"> </span>install<span class="w"> </span>-y<span class="w"> </span>--no-install-recommends<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>ca-certificates<span class="w"> </span>clang-15<span class="w"> </span>curl<span class="w"> </span>file<span class="w"> </span>gcc<span class="w"> </span>git<span class="w"> </span><span class="se">\</span>
<span class="w"> </span>llvm-15<span class="w"> </span>llvm-15-dev<span class="w"> </span>xz-utils<span class="w"> </span>unzip
</pre></div>
</div>
<ol class="arabic" start="2">
<li><p>Download the latest release from <a class="reference external" href="https://github.com/neat-lang/neat/releases">https://github.com/neat-lang/neat/releases</a></p></li>
<li><p>Unpack the archive:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">tar</span><span class="w"> </span><span class="n">xf</span><span class="w"> </span><span class="n">neat</span><span class="p">-</span><span class="n">v</span><span class="p">*-</span><span class="n">llvm</span><span class="p">.</span><span class="n">tar</span><span class="p">.</span><span class="n">xz</span>
<span class="n">cd</span><span class="w"> </span><span class="n">neat</span><span class="p">-</span><span class="n">v</span><span class="p">*-</span><span class="n">llvm</span>
</pre></div>
</div>
</li>
<li><p>Build the compiler:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="p">./</span><span class="n">build</span><span class="p">.</span><span class="n">sh</span>
</pre></div>
</div>
</li>
<li><p>Symlink the compiler somewhere that’s in your path:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">mkdir</span><span class="w"> </span><span class="p">-</span><span class="n">p</span><span class="w"> </span><span class="s">"$HOME"</span><span class="p">/.</span><span class="n">local</span><span class="p">/</span><span class="n">bin</span>
<span class="n">ln</span><span class="w"> </span><span class="p">-</span><span class="n">s</span><span class="w"> </span><span class="s">"$PWD"</span><span class="p">/</span><span class="n">neat</span><span class="w"> </span><span class="s">"$HOME"</span><span class="p">/.</span><span class="n">local</span><span class="p">/</span><span class="n">bin</span><span class="p">/</span><span class="n">neat</span>
</pre></div>
</div>
</li>
</ol>
<ol class="arabic" start="5">
<li><p>Test the compiler:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">cat</span><span class="w"> </span><span class="p">></span><span class="w"> </span><span class="n">hello</span><span class="p">.</span><span class="n">nt</span><span class="w"> </span><span class="p"><<</span><span class="n">EOF</span>
<span class="k">module</span><span class="w"> </span><span class="n">hello</span><span class="p">;</span>
<span class="k">import</span><span class="w"> </span><span class="n">std</span><span class="p">.</span><span class="n">stdio</span><span class="p">;</span>
<span class="kt">void</span><span class="w"> </span><span class="n">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"Hello World"</span><span class="p">);</span><span class="w"> </span><span class="p">}</span>
<span class="n">EOF</span>
<span class="n">neat</span><span class="w"> </span><span class="n">hello</span><span class="p">.</span><span class="n">nt</span><span class="w"> </span><span class="p">&&</span><span class="w"> </span><span class="p">./</span><span class="n">hello</span>
</pre></div>
</div>
</li>
</ol>
<p>If that printed “Hello World”, your Neat compiler is now ready for use!</p>
</section>
<section id="install-with-gcc">
<h2>Install with GCC<a class="headerlink" href="#install-with-gcc" title="Link to this heading">¶</a></h2>
<ol class="arabic">
<li><p>Install required packages:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">apt</span><span class="p">-</span><span class="n">get</span><span class="w"> </span><span class="n">install</span><span class="w"> </span><span class="n">xz</span><span class="p">-</span><span class="n">utils</span><span class="w"> </span><span class="n">wget</span><span class="w"> </span><span class="n">gcc</span>
</pre></div>
</div>
</li>
<li><p>Download the latest release from <a class="reference external" href="https://github.com/neat-lang/neat/releases">https://github.com/neat-lang/neat/releases</a></p></li>
<li><p>Unpack the archive:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">tar</span><span class="w"> </span><span class="n">xf</span><span class="w"> </span><span class="n">neat</span><span class="p">-</span><span class="n">v</span><span class="p">*-</span><span class="n">gcc</span><span class="p">.</span><span class="n">tar</span><span class="p">.</span><span class="n">xz</span>
<span class="n">cd</span><span class="w"> </span><span class="n">neat</span><span class="p">-</span><span class="n">v</span><span class="p">*-</span><span class="n">gcc</span>
</pre></div>
</div>
</li>
<li><p>Build the compiler:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="p">./</span><span class="n">build</span><span class="p">.</span><span class="n">sh</span>
</pre></div>
</div>
</li>
<li><p>Symlink the compiler somewhere that’s in your path:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">mkdir</span><span class="w"> </span><span class="p">-</span><span class="n">p</span><span class="w"> </span><span class="s">"$HOME"</span><span class="p">/.</span><span class="n">local</span><span class="p">/</span><span class="n">bin</span>
<span class="n">ln</span><span class="w"> </span><span class="p">-</span><span class="n">s</span><span class="w"> </span><span class="s">"$PWD"</span><span class="p">/</span><span class="n">neat</span><span class="w"> </span><span class="s">"$HOME"</span><span class="p">/.</span><span class="n">local</span><span class="p">/</span><span class="n">bin</span><span class="p">/</span><span class="n">neat</span>
</pre></div>
</div>
</li>
</ol>
<ol class="arabic" start="5">
<li><p>Test the compiler:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="n">cat</span><span class="w"> </span><span class="p">></span><span class="w"> </span><span class="n">hello</span><span class="p">.</span><span class="n">nt</span><span class="w"> </span><span class="p"><<</span><span class="n">EOF</span>
<span class="k">module</span><span class="w"> </span><span class="n">hello</span><span class="p">;</span>
<span class="k">import</span><span class="w"> </span><span class="n">std</span><span class="p">.</span><span class="n">stdio</span><span class="p">;</span>
<span class="kt">void</span><span class="w"> </span><span class="n">main</span><span class="p">()</span><span class="w"> </span><span class="p">{</span><span class="w"> </span><span class="n">print</span><span class="p">(</span><span class="s">"Hello World"</span><span class="p">);</span><span class="w"> </span><span class="p">}</span>
<span class="n">EOF</span>
<span class="n">neat</span><span class="w"> </span><span class="n">hello</span><span class="p">.</span><span class="n">nt</span><span class="w"> </span><span class="p">&&</span><span class="w"> </span><span class="p">./</span><span class="n">hello</span>
</pre></div>
</div>
</li>
</ol>
<p>If that printed “Hello World”, your Neat compiler is now ready for use!</p>
</section>
<section id="start-a-project">
<h2>Start a Project<a class="headerlink" href="#start-a-project" title="Link to this heading">¶</a></h2>
<section id="binary">
<h3>Binary<a class="headerlink" href="#binary" title="Link to this heading">¶</a></h3>
<p>Neat comes with a built-in package manager. To configure it, create a file <code class="code docutils literal notranslate"><span class="pre">package.json</span></code> in the project’s base folder:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="p">{</span>
<span class="w"> </span><span class="s">"source"</span><span class="p">:</span><span class="w"> </span><span class="s">"src"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"type"</span><span class="p">:</span><span class="w"> </span><span class="s">"binary"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"binary"</span><span class="p">:</span><span class="w"> </span><span class="s">"progname"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"main"</span><span class="p">:</span><span class="w"> </span><span class="s">"src/main.nt"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"dependencies"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s">"package"</span><span class="p">:</span><span class="w"> </span><span class="s">"*"</span>
<span class="w"> </span><span class="p">},</span>
<span class="w"> </span><span class="s">"sources"</span><span class="p">:</span><span class="w"> </span><span class="p">{</span>
<span class="w"> </span><span class="s">"package"</span><span class="p">:</span><span class="w"> </span><span class="s">"https://github.com/example/package"</span>
<span class="w"> </span><span class="p">}</span>
<span class="p">}</span>
</pre></div>
</div>
<p>Run <code class="code docutils literal notranslate"><span class="pre">neat</span> <span class="pre">build</span></code> in a folder that contains a <code class="code docutils literal notranslate"><span class="pre">package.json</span></code> with type <code class="code docutils literal notranslate"><span class="pre">binary</span></code>, and Neat will attempt to build a binary.</p>
</section>
<section id="library">
<h3>Library<a class="headerlink" href="#library" title="Link to this heading">¶</a></h3>
<p>The format for library repos is significantly simpler:</p>
<div class="highlight-d notranslate"><div class="highlight"><pre><span></span><span class="p">{</span>
<span class="w"> </span><span class="s">"source"</span><span class="p">:</span><span class="w"> </span><span class="s">"src"</span><span class="p">,</span>
<span class="w"> </span><span class="s">"type"</span><span class="p">:</span><span class="w"> </span><span class="s">"library"</span>
<span class="p">}</span>
</pre></div>
</div>
</section>
<section id="keys">
<h3>Keys<a class="headerlink" href="#keys" title="Link to this heading">¶</a></h3>
<ul class="simple">
<li><p><code class="code docutils literal notranslate"><span class="pre">source</span></code>: The default source folder.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">type</span></code>: <code class="code docutils literal notranslate"><span class="pre">binary</span></code> or <code class="code docutils literal notranslate"><span class="pre">library</span></code>. Note that all Neat packages are effectively source libraries.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">binary</span></code>: The executable that will be generated.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">main</span></code>: The name of the file that contains the main function. This does nothing at the moment, but will be important when <code class="code docutils literal notranslate"><span class="pre">neat</span> <span class="pre">unittest</span></code> is added.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">compilerVersion</span></code>: The version of the compiler to build with. When the installed compiler does not match this version, the required compiler version (gcc backend) will be built and executed.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">dependencies</span></code>: A map of dependencies and their versions.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">sources</span></code>: A map of dependencies to Git Remote URLs.</p></li>
</ul>
</section>
<section id="version-specification">
<h3>Version Specification<a class="headerlink" href="#version-specification" title="Link to this heading">¶</a></h3>
<p>Neat implements <a class="reference external" href="https://semver.org/">semantic versioning</a>. The required version of a package can be specified in the following ways:</p>
<ul class="simple">
<li><p><code class="code docutils literal notranslate"><span class="pre">*</span></code>: Any version will do.</p></li>
<li><dl class="simple">
<dt><code class="code docutils literal notranslate"><span class="pre">^x.y.z</span></code>: Any version <em>semver-compatible</em> with <code class="code docutils literal notranslate"><span class="pre">x.y.z</span></code> will do.</dt><dd><p>That is, it must be equal on <code class="code docutils literal notranslate"><span class="pre">x</span></code> and greater or equal on <code class="code docutils literal notranslate"><span class="pre">y.z</span></code>.</p>
</dd>
</dl>
</li>
<li><p><code class="code docutils literal notranslate"><span class="pre">>=x.y.z</span></code>: Any version newer or equal to <code class="code docutils literal notranslate"><span class="pre">x.y.z</span></code> will do.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre"><=x.y.z</span></code>: etc.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">>x.y.z</span></code>: etc.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre"><x.y.z</span></code>: etc.</p></li>
<li><p><code class="code docutils literal notranslate"><span class="pre">=x.y.z</span></code>: etc.</p></li>
</ul>
<p>Version resolution proceeds recursively with backtracking. A version is a tag on the Git source of the format <code class="code docutils literal notranslate"><span class="pre">vx.y.z</span></code>, for instance <code class="code docutils literal notranslate"><span class="pre">v1.0.3</span></code>.</p>
<p>On first run, <code class="code docutils literal notranslate"><span class="pre">neat</span> <span class="pre">build</span></code> writes the recursive selected package versions in a file <code class="code docutils literal notranslate"><span class="pre">package-lock.json</span></code>. This file should be committed to ensure reproducible builds; however, when recursing into packages, the recursive package-lock files are ignored.</p>
</section>
</section>
<section id="good-and-bad-neat">
<h2>Good and Bad Neat<a class="headerlink" href="#good-and-bad-neat" title="Link to this heading">¶</a></h2>
<p>With D, you can write code in many styles, and while programs off the “happy path” will have problems, they will generally
still work. As Neat is heavily alpha, code that diverges too far from my own style will probably explode.</p>
<p>Keep in mind that if you’re unsure, you can always just ask me. And if it seems like there isn’t a way to do something, it’s very plausible
that there isn’t, just because it’s something I haven’t needed yet. And keep in mind: if something randomly doesn’t work, it’s
very plausibly a compiler bug.</p>
<section id="pure-functions-are-just-better">
<h3>Pure functions are Just Better<a class="headerlink" href="#pure-functions-are-just-better" title="Link to this heading">¶</a></h3>
<p>If runtime is not absolutely critical, try to arrange your code so that it never mutates parameters. When you need to
mutate something, encapsulate it in a class. (<code class="code docutils literal notranslate"><span class="pre">final</span> <span class="pre">class</span></code> method calls are as good as direct function calls.) Alternately,
take old state as parameters and return new state as return values. (This isn’t just good Neat, it’s good code in general.)
Neat has several features to support this, such as sumtypes and tuples, to allow defining complex returned data structures.</p>
</section>
<section id="structs-are-values-classes-are-owners">
<h3>Structs are values, classes are owners<a class="headerlink" href="#structs-are-values-classes-are-owners" title="Link to this heading">¶</a></h3>
<p>Generally speaking, you should use structs (and the other built-in data types) for the “domain” layer of your code,
ie. values that are passed to a function and returned from a function. Classes should be reserved for types that own
data, mutate state and react to events. If it involves a change in the state of your application, a class makes sense.</p>
<p>(But don’t take this as gospel too much: classes are also just reference types, and useful if you need a reference for
whatever reason.)</p>
</section>
<section id="don-t-microoptimize">
<h3>Don’t microoptimize<a class="headerlink" href="#don-t-microoptimize" title="Link to this heading">¶</a></h3>
<p>The advice usually goes to not microoptimize prematurely. As Neat is alpha, I would make the advice stronger:
don’t microoptimize at all. If you write some incredibly microoptimized code and it doesn’t work, and you submit
that as a bug report, I’m just as likely to make that entire idiom forbidden. Remember: many things compile in Neat today
that <em>shouldn’t</em>, simply because I haven’t thought to add checks for them yet. If you write code in a straightforward
fashion, I’ll be much more amenable to a bug report to make it fast. (So long as it doesn’t unduly complicate the compiler.)</p>
</section>
<section id="don-t-use-pointers">
<h3>Don’t use pointers<a class="headerlink" href="#don-t-use-pointers" title="Link to this heading">¶</a></h3>
<p>Pointers are in the language for one thing and one thing only: interacting with C APIs. They do <strong>not</strong> participate in
reference counting. If you absolutely have to use pointers, make sure that the reference you are passing a pointer to
outlives the pointer value.</p>
<p>How do you modify state from a called function? Pass a “natural” reference type, ie. an object. Or just
return the new value.</p>
</section>
<section id="closures-are-a-bit-fishy">
<h3>Closures are a bit fishy<a class="headerlink" href="#closures-are-a-bit-fishy" title="Link to this heading">¶</a></h3>
<p>I’ve tried to allow closures to mostly avoid refcounting. The result is its own special little corner of the language.
If a closure does a weird thing, try heap-allocating it or raise a bug.</p>
</section>
<section id="neat-base-is-the-key-to-macros">
<h3><code class="code docutils literal notranslate"><span class="pre">neat.base</span></code> is the key to macros<a class="headerlink" href="#neat-base-is-the-key-to-macros" title="Link to this heading">¶</a></h3>
<p>The compiler is not as fast as I’d wish. As such, while you can in principle access every module from a macro,
limiting yourself to <code class="code docutils literal notranslate"><span class="pre">neat.base</span></code> or <code class="code docutils literal notranslate"><span class="pre">neat.util</span></code> will keep your macros reasonably fast to load. Similarly, if you
read <code class="code docutils literal notranslate"><span class="pre">neat.base</span></code>, it will give you a good introduction to the data structures used by the rest of the compiler.</p>
</section>
<section id="neat-is-not-great-neat-is-not-final">
<h3>Neat is not great, Neat is not final<a class="headerlink" href="#neat-is-not-great-neat-is-not-final" title="Link to this heading">¶</a></h3>
<p>There were several decisions made during design that have come back to hamper me. While the language <em>is</em> broadly
where I wanted it starting out, every aspect of it is amenable to modification. Don’t assume that because something
is in the compiler, that it is deliberate and optimal. Feel free to experiment with a local copy, and as usual:</p>
<p>Patches welcome!</p>
</section>
</section>
</section>
</div>
</div>
</div>
<div class="sphinxsidebar" role="navigation" aria-label="main navigation">
<div class="sphinxsidebarwrapper">
<h1 class="logo"><a href="index.html">Neat</a></h1>
<h3>Navigation</h3>
<ul class="current">
<li class="toctree-l1 current"><a class="current reference internal" href="#">Getting Started</a><ul>
<li class="toctree-l2"><a class="reference internal" href="#install-on-windows">Install on Windows</a></li>
<li class="toctree-l2"><a class="reference internal" href="#install-with-llvm">Install with LLVM</a></li>
<li class="toctree-l2"><a class="reference internal" href="#install-with-gcc">Install with GCC</a></li>
<li class="toctree-l2"><a class="reference internal" href="#start-a-project">Start a Project</a></li>
<li class="toctree-l2"><a class="reference internal" href="#good-and-bad-neat">Good and Bad Neat</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="intro.html">Introduction</a></li>
<li class="toctree-l1"><a class="reference internal" href="manual.html">Manual</a></li>
<li class="toctree-l1"><a class="reference internal" href="std.html">Standard Library</a></li>
<li class="toctree-l1"><a class="reference external" href="https://github.com/neat-lang/neat/">Neat on Github 🔗</a></li>
</ul>
<div id="searchbox" style="display: none" role="search">
<h3 id="searchlabel">Quick search</h3>
<div class="searchformwrapper">
<form class="search" action="search.html" method="get">
<input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
<input type="submit" value="Go" />
</form>
</div>
</div>
<script>document.getElementById('searchbox').style.display = "block"</script>
</div>
</div>
<div class="clearer"></div>
</div>
<div class="footer">
©@FeepingCreature.
|
Powered by <a href="http://sphinx-doc.org/">Sphinx 7.2.6</a>
& <a href="https://github.com/bitprophet/alabaster">Alabaster 0.7.13</a>
|
<a href="_sources/getstarted.rst.txt"
rel="nofollow">Page source</a>
</div>
</body>
</html>