Rust - Revision history

Savoundg: /* References */

2018-12-24T14:14:44Z

References

← Older revision		Revision as of 14:14, 24 December 2018
Line 138:		Line 138:
	\|Fearless Concurrency with Rust		\|Fearless Concurrency with Rust
	\|https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html		\|https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
			\|-
			\|Rust Means Never Having to Close a Socket
			\|https://blog.skylight.io/rust-means-never-having-to-close-a-socket/
	\|}		\|}

2018-12-24T13:56:32Z

← Older revision		Revision as of 13:56, 24 December 2018
Line 135:		Line 135:
	\|into_rust()		\|into_rust()
	\|http://intorust.com/		\|http://intorust.com/
			\|-
			\|Fearless Concurrency with Rust
			\|https://blog.rust-lang.org/2015/04/10/Fearless-Concurrency.html
	\|}		\|}

2018-12-24T09:36:48Z

← Older revision		Revision as of 09:36, 24 December 2018
Line 132:		Line 132:
	\|C++Now 2017: Niko Matsakis "Rust: Hack Without Fear!"		\|C++Now 2017: Niko Matsakis "Rust: Hack Without Fear!"
	\|https://www.youtube.com/watch?v=lO1z-7cuRYI		\|https://www.youtube.com/watch?v=lO1z-7cuRYI
			\|-
			\|into_rust()
			\|http://intorust.com/
	\|}		\|}

2018-12-24T08:16:10Z

Marker traits

@@ Line 83: / Line 83: @@
 ==== Marker traits ====
-* trait Send { }: Safe to send between thread: String, u32, Arc<String>
+* trait Send { }: Safe to send between thread: String, u32, Arc<String> (Atomic reference count)
-* trait Copy { }: Safe to memcpy: u32, f32,
+* trait Copy { }: Safe to memcpy: u32, f32
 == References ==

2018-12-23T08:50:42Z

Traits

@@ Line 68: / Line 68: @@
 === Traits ===
-Traits is the cornerstone of generic programming in rust.
+Traits is used for generic programming in rust. It is a sort of interface that is implemented for a given type.
 ==== Marker traits ====

2018-12-23T08:00:04Z

← Older revision		Revision as of 08:00, 23 December 2018
Line 61:		Line 61:

	=== Lifetime reference ===		=== Lifetime reference ===
	The lifetime is part of the type of de reference.		The lifetime is part of the type of de reference.<syntaxhighlight lang="rust">
			fn first<'a>(obj: &'a Vec<String>) -> &'a String {
			return &obj[0];
			}
			</syntaxhighlight>

	=== Traits ===		=== Traits ===
			Traits is the cornerstone of generic programming in rust.

	==== Marker traits ====		==== Marker traits ====

2018-12-23T07:51:13Z

Lifetime reference

← Older revision		Revision as of 07:51, 23 December 2018
Line 61:		Line 61:

	=== Lifetime reference ===		=== Lifetime reference ===
			The lifetime is part of the type of de reference.

	=== Traits ===		=== Traits ===

2018-12-23T07:37:06Z

← Older revision		Revision as of 07:37, 23 December 2018
Line 36:		Line 36:
	==== Shared borrow ====		==== Shared borrow ====
	Cannot mutate while shared.		Cannot mutate while shared.

			Transfer reference instead of ownership:<syntaxhighlight lang="rust">
			fn print(obj: &Vec<String>) { ... }
			fn main() {
			let vec: Vec<String> = Vec::new();
			print(&vec);
			print(&vec); // OK
			}
			</syntaxhighlight>

	==== Mutable borrow ====		==== Mutable borrow ====
	Cannot access while borrowed.		Cannot access while borrowed.

	Can access the mutable borrowed variable.		Can access the mutable borrowed variable.<syntaxhighlight lang="rust">
			fn print(obj: &Vec<String>) { ... }
			fn modif(obj: &mut Vec<String>) { ... }
			fn main() {
			let vec: Vec<String> = Vec::new();
			print(&vec);
			modif(&mut vec);
			print(&vec); // OK
			}
			</syntaxhighlight>

	=== Lifetime reference ===		=== Lifetime reference ===

2018-12-23T07:33:49Z

← Older revision		Revision as of 07:33, 23 December 2018
Line 22:		Line 22:

	=== Ownership ===		=== Ownership ===
	In Rust, unlike C++, by default, on a function call, the ownership of parameters is transferred; the copy should be explicit (.clone()). Therefore, parameters cannot be reused after the function call.		In Rust, unlike C++, by default, on a function call, the ownership of parameters is transferred; the copy should be explicit (.clone()). Therefore, parameters cannot be reused after the function call.<syntaxhighlight lang="rust">
			fn print(obj: Vec<String>) { ... }
			fn main() {
			let vec: Vec<String> = Vec::new();
			print(vec);
			// vec does not exist anymore because the ownership has been transferred to the print function
			print(vec); // FAIL: value
			}
			</syntaxhighlight>

	=== Borrowing ===		=== Borrowing ===

2018-12-23T07:16:10Z

@@ Line 1: / Line 1: @@
 == Cargo ==
 {| class="wikitable"
@@ Line 15: / Line 17: @@
 == Advanced concepts ==
 === Ownership ===
-In Rust, unlike C++, by default, on a function call, the ownership of parameters is transferred; the copy should be explicit (.clone()).
+In Rust, unlike C++, by default, on a function call, the ownership of parameters is transferred; the copy should be explicit (.clone()). Therefore, parameters cannot be reused after the function call.
 === Borrowing ===
@@ Line 36: / Line 41: @@
 * trait Send { }: Safe to send between thread: String, u32, Arc<String>
 * trait Copy { }: Safe to memcpy: u32, f32,