std::ops::Range - Rust
Struct std::ops::Range1.0.0 [−] [src] pub struct Range<Idx> { pub start: Idx, pub end: Idx, } A (half-open) range which is bounded at both ends: { x | start <= x < end }. Use start..end (two dots) for its shorthand. See the contains() method for its characterization. Examples fn main() { assert_eq!((3..5), std::ops::Range{ start: 3, end: 5 }); assert_eq!(3+4+5, (3..6).sum()); let arr = [0, 1, 2, 3
Procedural Macros (and custom derive) - The Rust Programming Language
Procedural Macros (and custom Derive) The first edition of the book is no longer distributed with Rust's documentation. If you came here via a link or web search, you may want to check out the current version of the book instead. If you have an internet connection, you can find a copy distributed with Rust 1.30.
println in std - Rust
macro_rules! println { () => { ... }; ($($arg:tt)*) => { ... }; }Expand description Prints to the standard output, with a newline. On all platforms, the newline is the LINE FEED character (\n/U+000A) alone (no additional CARRIAGE RETURN (\r/U+000D)). This macro uses the same syntax as format!, but writes to the standard output instead. See std::fmt for more information. The println! macro will loc
format in std - Rust
macro_rules! format { ($($arg:tt)*) => { ... }; }Expand description Creates a String using interpolation of runtime expressions. The first argument format! receives is a format string. This must be a string literal. The power of the formatting string is in the {}s contained. Additional parameters passed to format! replace the {}s within the formatting string in the order given unless named or posi
write in std - Rust
macro_rules! write { ($dst:expr, $($arg:tt)*) => { ... }; }Expand description Writes formatted data into a buffer. This macro accepts a ‘writer’, a format string, and a list of arguments. Arguments will be formatted according to the specified format string and the result will be passed to the writer. The writer may be any value with a write_fmt method; generally this comes from an implementation o
Introduction - Introduction - The Rust Programming Language
Welcome to “The Rust Programming Language,” an introductory book about Rust. Rust is a programming language that’s focused on safety, speed, and concurrency. Its design lets you create programs that have the performance and control of a low-level language, but with the powerful abstractions of a high-level language. These properties make Rust suitable for programmers who have experience in languag
Ownership
Ownership This guide is one of three presenting Rust’s ownership system. This is one of Rust’s most unique and compelling features, with which Rust developers should become quite acquainted. Ownership is how Rust achieves its largest goal, memory safety. There are a few distinct concepts, each with its own chapter: ownership, which you’re reading now borrowing, and their associated feature ‘refere
FFI - The Rust Programming Language
Foreign Function Interface The first edition of the book is no longer distributed with Rust's documentation. If you came here via a link or web search, you may want to check out the current version of the book instead. If you have an internet connection, you can find a copy distributed with Rust 1.30.
std::prelude - Rust
The Rust Prelude Rust comes with a variety of things in its standard library. However, if you had to manually import every single thing that you used, it would be very verbose. But importing a lot of things that a program never uses isn’t good either. A balance needs to be struck. The prelude is the list of things that Rust automatically imports into every Rust program. It’s kept as small as possi
Naming conventions
Avoid redundant prefixes [RFC 356] The guidelines below were approved by RFC #356. Names of items within a module should not be prefixed with that module's name: Prefer fn main() { mod foo { pub struct Error { ... } } }mod foo { pub struct Error { ... } } over fn main() { mod foo { pub struct FooError { ... } } }mod foo { pub struct FooError { ... } } This convention avoids stuttering (like io::Io
std::process::Command - Rust
The Command type acts as a process builder, providing fine-grained control over how a new process should be spawned. A default configuration can be generated using Command::new(program), where program gives a path to the program to be executed. Additional builder methods allow the configuration to be changed (for example, by adding arguments) prior to spawning: fn main() { use std::process::Comman
Races - The Rustonomicon
Data Races and Race Conditions Safe Rust guarantees an absence of data races, which are defined as: two or more threads concurrently accessing a location of memory one or more of them is a write one or more of them is unsynchronized A data race has Undefined Behavior, and is therefore impossible to perform in Safe Rust. Data races are mostly prevented through Rust's ownership system: it's impossib
Command in std::process - Rust
pub struct Command { /* private fields */ }Expand description A process builder, providing fine-grained control over how a new process should be spawned. A default configuration can be generated using Command::new(program), where program gives a path to the program to be executed. Additional builder methods allow the configuration to be changed (for example, by adding arguments) prior to spawning:
std::fmt - Rust
Utilities for formatting and printing Strings. This module contains the runtime support for the format! syntax extension. This macro is implemented in the compiler to emit calls to this module in order to format arguments at runtime into strings. Usage The format! macro is intended to be familiar to those coming from C’s printf/fprintf functions or Python’s str.format function. Some examples of th
Slice patterns
Slice patterns If you want to match against a slice or array, you can use & with the slice_patterns feature: #![feature(slice_patterns)] fn main() { let v = vec!["match_this", "1"]; match &v[..] { ["match_this", second] => println!("The second element is {}", second), _ => {}, } } #![feature(slice_patterns)] fn main() { let v = vec!["match_this", "1"]; match &v[..] { ["match_this", second] => prin
Rust Inside Other Languages
Rust Inside Other Languages For our third project, we’re going to choose something that shows off one of Rust’s greatest strengths: a lack of a substantial runtime. As organizations grow, they increasingly rely on a multitude of programming languages. Different programming languages have different strengths and weaknesses, and a polyglot stack lets you use a particular language where its strengths
リリース、障害情報などのサービスのお知らせ
最新の人気エントリーの配信
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く
Installation - The Rust Programming Language
Hello, World! - Hello, World! - The Rust Programming Language
Foreword - The Rust Programming Language
What is Ownership? - The Rust Programming Language