From 74fe16940580a3e9333996d673ca0ac094e925a8 Mon Sep 17 00:00:00 2001 From: Tanish-Eagle Date: Mon, 16 May 2022 21:05:05 +0530 Subject: [PATCH] Fixed punctuation and some grammar mistakes --- en/src/method.md | 50 ++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/en/src/method.md b/en/src/method.md index d103e26..31047df 100644 --- a/en/src/method.md +++ b/en/src/method.md @@ -1,4 +1,4 @@ -# Associated function & Method +# Associated functions & Methods ## Examples ```rust,editable @@ -7,7 +7,7 @@ struct Point { y: f64, } -// Implementation block, all `Point` associated functions & methods go in here +// Implementation block, all `Point` associated functions & methods go in here. impl Point { // This is an "associated function" because this function is associated with // a particular type, that is, Point. @@ -30,11 +30,11 @@ struct Rectangle { } impl Rectangle { - // This is a method + // This is a method. // `&self` is sugar for `self: &Self`, where `Self` is the type of the // caller object. In this case `Self` = `Rectangle` fn area(&self) -> f64 { - // `self` gives access to the struct fields via the dot operator + // `self` gives access to the struct fields via the dot operator. let Point { x: x1, y: y1 } = self.p1; let Point { x: x2, y: y2 } = self.p2; @@ -61,7 +61,7 @@ impl Rectangle { } } -// `Pair` owns resources: two heap allocated integers +// `Pair` owns resources: two heap allocated integers. struct Pair(Box, Box); impl Pair { @@ -73,7 +73,7 @@ impl Pair { println!("Destroying Pair({}, {})", first, second); - // `first` and `second` go out of scope and get freed + // `first` and `second` go out of scope and get freed. } } @@ -84,7 +84,7 @@ fn main() { p2: Point::new(3.0, 4.0), }; - // Methods are called using the dot operator + // Methods are called using the dot operator. // Note that the first argument `&self` is implicitly passed, i.e. // `rectangle.perimeter()` === `Rectangle::perimeter(&rectangle)` println!("Rectangle perimeter: {}", rectangle.perimeter()); @@ -96,7 +96,7 @@ fn main() { }; // Error! `rectangle` is immutable, but this method requires a mutable - // object + // object. //rectangle.translate(1.0, 0.0); // TODO ^ Try uncommenting this line @@ -116,7 +116,7 @@ fn main() { ## Exercises ### Method -1. 🌟🌟 Methods are similar to functions: declare with `fn`, have parameters and a return value. Unlike functions, methods are defined within the context of a struct (or an enum or a trait object), and their first parameter is always `self`, which represents the instance of the struct the method is being called on. +1. 🌟🌟 Methods are similar to functions: Declare with `fn`, have parameters and a return value. Unlike functions, methods are defined within the context of a struct (or an enum or a trait object), and their first parameter is always `self`, which represents the instance of the struct the method is being called on. ```rust,editable struct Rectangle { width: u32, @@ -124,7 +124,7 @@ struct Rectangle { } impl Rectangle { - // complete the area method which return the area of a Rectangle + // Complete the area method which return the area of a Rectangle. fn area } @@ -133,11 +133,11 @@ fn main() { assert_eq!(rect1.area(), 1500); - println!("Success!") + println!("Success!"); } ``` -2. 🌟🌟 `self` will take the ownership of current struct instance, however, `&self` will only borrow a reference from the instance +2. 🌟🌟 `self` will take the ownership of current struct instance, however, `&self` will only borrow a reference from the instance. ```rust,editable // Only fill in the blanks, DON'T remove any line! @@ -155,9 +155,9 @@ fn main() { let light = TrafficLight{ color: "red".to_owned(), }; - // Don't take the ownership of `light` here + // Don't take the ownership of `light` here. light.show_state(); - // ..otherwise, there will be an error below + // ... Otherwise, there will be an error below println!("{:?}", light); } ``` @@ -168,23 +168,23 @@ struct TrafficLight { } impl TrafficLight { - // using `Self` to fill in the blank + // Using `Self` to fill in the blank. pub fn show_state(__) { println!("the current state is {}", self.color); } - // fill in the blank, DON'T use any variants of `Self` + // Fill in the blank, DON'T use any variants of `Self`. pub fn change_state(__) { self.color = "green".to_string() } } fn main() { - println!("Success!") + println!("Success!"); } ``` -### Associated function +### Associated functions 4. 🌟🌟 All functions defined within an `impl` block are called associated functions because they’re associated with the type named after the `impl`. We can define associated functions that don’t have `self` as their first parameter (and thus are not methods) because they don’t need an instance of the type to work with. @@ -195,9 +195,9 @@ struct TrafficLight { } impl TrafficLight { - // 1. implement a assotiated function `new`, - // 2. it will return a TrafficLight contains color "red" - // 3. must use `Self`, DONT use `TrafficLight` in fn signatures or body + // 1. Implement an assotiated function `new`, + // 2. It will return a TrafficLight contains color "red" + // 3. Must use `Self`, DONT use `TrafficLight` in fn signatures or body pub fn new() pub fn get_state(&self) -> &str { @@ -209,7 +209,7 @@ fn main() { let light = TrafficLight::new(); assert_eq!(light.get_state(), "red"); - println!("Success!") + println!("Success!"); } ``` @@ -222,7 +222,7 @@ struct Rectangle { height: u32, } -// using multiple `impl` blocks to rewrite the code below +// Using multiple `impl` blocks to rewrite the code below. impl Rectangle { fn area(&self) -> u32 { self.width * self.height @@ -235,7 +235,7 @@ impl Rectangle { fn main() { - println!("Success!") + println!("Success!"); } ``` @@ -251,7 +251,7 @@ enum TrafficLightColor { Green, } -// implement TrafficLightColor with a method +// Implement TrafficLightColor with a method. impl TrafficLightColor { }