---

yaml
---
r: 228991
b: refs/heads/try
c: 59ff3a3
h: refs/heads/master
i:
  228989: b3ac14d
  228987: 43697dd
  228983: 16e0a69
  228975: 67425d9
  228959: 984c7bf
  228927: bae3316
  228863: 1fec5f7
v: v3

Author: Gankra

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: aca2057ed5fb7af3f8905b2bc01f72fa001c35c8
 refs/heads/snap-stage3: 1af31d4974e33027a68126fa5a5a3c2c6491824f
-refs/heads/try: 31adad6aad5b0fbff85a6effcfc5e11ba611493d
+refs/heads/try: 59ff3a39ae866b862678a769f469f0bae55606e5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try/constructors.md

@@ -1,26 +1,55 @@
 % Constructors
 
-Unlike C++, Rust does not come with a slew of builtin
-kinds of constructor. There are no Copy, Default, Assignment, Move, or whatever constructors.
-This largely has to do with Rust's philosophy of being explicit.
-
-Move constructors are meaningless in Rust because we don't enable types to "care" about their
-location in memory. Every type must be ready for it to be blindly memcopied to somewhere else
-in memory. This means pure on-the-stack-but-still-movable intrusive linked lists are simply
-not happening in Rust (safely).
-
-Assignment and copy constructors similarly don't exist because move semantics are the *default*
-in rust. At most `x = y` just moves the bits of y into the x variable. Rust does provide two
-facilities for going back to C++'s copy-oriented semantics: `Copy` and `Clone`. Clone is our
-moral equivalent of a copy constructor, but it's never implicitly invoked. You have to explicitly
-call `clone` on an element you want to be cloned. Copy is a special case of Clone where the
-implementation is just "copy the bits". Copy types *are* implicitly
-cloned whenever they're moved, but because of the definition of Copy this just means *not*
-treating the old copy as uninitialized -- a no-op.
-
-While Rust provides a `Default` trait for specifying the moral equivalent of a default
-constructor, it's incredibly rare for this trait to be used. This is because variables
-[aren't implicitly initialized][uninit]. Default is basically only useful for generic
-programming. In concrete contexts, a type will provide a static `new` method for any
-kind of "default" constructor. This has no relation to `new` in other
-languages and has no special meaning. It's just a naming convention.
+There is exactly one way to create an instance of a user-defined type: name it,
+and initialize all its fields at once:
+
+```rust
+struct Foo {
+	a: u8,
+	b: u32,
+	c: bool,
+}
+
+enum Bar {
+	X(u32),
+	Y(bool),
+}
+
+struct Empty;
+
+let foo = Foo { a: 0, b: 1, c: false };
+let bar = Bar::X(0);
+let empty = Empty;
+```
+
+That's it. Every other way you make an instance of a type is just calling a
+totally vanilla function that does some stuff and eventually bottoms out to The
+One True Constructor.
+
+Unlike C++, Rust does not come with a slew of built in kinds of constructor.
+There are no Copy, Default, Assignment, Move, or whatever constructors. The
+reasons for this are varied, but it largely boils down to Rust's philosophy
+of *being explicit*.
+
+Move constructors are meaningless in Rust because we don't enable types to
+"care" about their location in memory. Every type must be ready for it to be
+blindly memcopied to somewhere else in memory. This means pure on-the-stack-but-
+still-movable intrusive linked lists are simply not happening in Rust (safely).
+
+Assignment and copy constructors similarly don't exist because move semantics
+are the *only* semantics in Rust. At most `x = y` just moves the bits of y into the x
+variable. Rust *does* provide two facilities for providing C++'s copy-oriented
+semantics: `Copy` and `Clone`. Clone is our moral equivalent of a copy
+constructor, but it's never implicitly invoked. You have to explicitly call
+`clone` on an element you want to be cloned. Copy is a special case of Clone
+where the implementation is just "copy the bits". Copy types *are* implicitly
+cloned whenever they're moved, but because of the definition of Copy this just
+means *not* treating the old copy as uninitialized -- a no-op.
+
+While Rust provides a `Default` trait for specifying the moral equivalent of a
+default constructor, it's incredibly rare for this trait to be used. This is
+because variables [aren't implicitly initialized][uninit]. Default is basically
+only useful for generic programming. In concrete contexts, a type will provide a
+static `new` method for any kind of "default" constructor. This has no relation
+to `new` in other languages and has no special meaning. It's just a naming
+convention.