rust-data-structure — human mapping

Data structure enhancement: Added methods and traits to a basic struct to make it more functional and useful. This represents a common Rust evolution pattern. Key changes: - Added `#[derive(Debug, Clone, Copy)]` for automatic trait implementations - Added `impl Point` block with methods - Added constructor method `new(x: i32, y: i32)` - Added computed method `distance_from_origin()` - Updated main function to use the new constructor and method - Enhanced output to include distance information This shows how basic data structures evolve to become more feature-rich in Rust.

A painting is a person's account of this edit as text, recorded independently of the node mapping - a rendering often has several equally defensible answers where the mapping has one. Deletions and insertions carry no position on the opposite side in a painting, so that panel draws no caret for them.

Before1struct Point {
2    x: i32,
3    y: i32,
4}
5
6fn main() {
7    let points = vec![
8        Point { x: 1, y: 2 },
9        Point { x: 3, y: 4 },
10        Point { x: 5, y: 6 },
11    ];
12    
13    for point in &points {
14        println!("Point: ({}, {})", point.x, point.y);
15    }
16}

After1[derive(Debug, Clone, Copy)]
2struct Point {
3    x: i32,
4    y: i32,
5}
6
7impl Point {
8    fn new(x: i32, y: i32) -> Self {
9        Point { x, y }
10    }
11    
12    fn distance_from_origin(&self) -> f64 {
13        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
14    }
15}
16
17fn main() {
18    let points = vec![
19        Point::new(1, 2),
20        Point::new(3, 4),
21        Point::new(5, 6),
22    ];
23    
24    for point in &points {
25        println!("Point: ({}, {}) - Distance: {:.2}", 
26                 point.x, point.y, point.distance_from_origin());
27    }
28}

Before1struct Point {
2    x: i32,
3    y: i32,
4}
5
6fn main() {
7    let points = vec![
8        Point { x: 1, y: 2 },
9        Point { x: 3, y: 4 },
10        Point { x: 5, y: 6 },
11    ];
12    
13    for point in &points {
14        println!("Point: ({}, {})", point.x, point.y);
15    }
16}

After1[derive(Debug, Clone, Copy)]
2struct Point {
3    x: i32,
4    y: i32,
5}
6
7impl Point {
8    fn new(x: i32, y: i32) -> Self {
9        Point { x, y }
10    }
11    
12    fn distance_from_origin(&self) -> f64 {
13        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
14    }
15}
16
17fn main() {
18    let points = vec![
19        Point::new(1, 2),
20        Point::new(3, 4),
21        Point::new(5, 6),
22    ];
23    
24    for point in &points {
25        println!("Point: ({}, {}) - Distance: {:.2}", 
26                 point.x, point.y, point.distance_from_origin());
27    }
28}

Before1struct Point {
2    x: i32,
3    y: i32,
4}
5
6fn main() {
7    let points = vec![
8        Point { x: 1, y: 2 },
9        Point { x: 3, y: 4 },
10        Point { x: 5, y: 6 },
11    ];
12    
13    for point in &points {
14        println!("Point: ({}, {})", point.x, point.y);
15    }
16}

After1[derive(Debug, Clone, Copy)]
2struct Point {
3    x: i32,
4    y: i32,
5}
6
7impl Point {
8    fn new(x: i32, y: i32) -> Self {
9        Point { x, y }
10    }
11    
12    fn distance_from_origin(&self) -> f64 {
13        ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt()
14    }
15}
16
17fn main() {
18    let points = vec![
19        Point::new(1, 2),
20        Point::new(3, 4),
21        Point::new(5, 6),
22    ];
23    
24    for point in &points {
25        println!("Point: ({}, {}) - Distance: {:.2}", 
26                 point.x, point.y, point.distance_from_origin());
27    }
28}

Before

source_file

struct_item

struct "struct"

type_identifier "Point"

field_declaration_list

{ "{"

field_declaration

field_identifier "x"

: ":"

primitive_type "i32"

, ","

field_declaration

field_identifier "y"

: ":"

primitive_type "i32"

, ","

} "}"

function_item

fn "fn"

identifier "main"

parameters

( "("

) ")"

block

{ "{"

let_declaration

let "let"

identifier "points"

= "="

macro_invocation

identifier "vec"

! "!"

token_tree

[ "["

identifier "Point"

token_tree

{ "{"

identifier "x"

: ":"

integer_literal "1"

, ","

identifier "y"

: ":"

integer_literal "2"

} "}"

, ","

identifier "Point"

token_tree

{ "{"

identifier "x"

: ":"

integer_literal "3"

, ","

identifier "y"

: ":"

integer_literal "4"

} "}"

, ","

identifier "Point"

token_tree

{ "{"

identifier "x"

: ":"

integer_literal "5"

, ","

identifier "y"

: ":"

integer_literal "6"

} "}"

, ","

] "]"

; ";"

expression_statement

for_expression

for "for"

identifier "point"

in "in"

reference_expression

& "&"

identifier "points"

block

{ "{"

expression_statement

macro_invocation

identifier "println"

! "!"

token_tree

( "("

string_literal

" "\""

string_content "Point: ({}, {})"

" "\""

, ","

identifier "point"

. "."

identifier "x"

, ","

identifier "point"

. "."

identifier "y"

) ")"

; ";"

} "}"

After

source_file

expression_statement

array_expression

[ "["

call_expression

identifier "derive"

arguments

( "("

identifier "Debug"

, ","

identifier "Clone"

, ","

identifier "Copy"

) ")"

] "]"

; ""

struct_item

struct "struct"

type_identifier "Point"

field_declaration_list

{ "{"

field_declaration

field_identifier "x"

: ":"

primitive_type "i32"

, ","

field_declaration

field_identifier "y"

: ":"

primitive_type "i32"

, ","

} "}"

impl_item

impl "impl"

type_identifier "Point"

declaration_list

{ "{"

function_item

fn "fn"

identifier "new"

parameters

( "("

parameter

identifier "x"

: ":"

primitive_type "i32"

, ","

parameter

identifier "y"

: ":"

primitive_type "i32"

) ")"

-> "->"

type_identifier "Self"

block

{ "{"

struct_expression

type_identifier "Point"

field_initializer_list

{ "{"

shorthand_field_initializer

identifier "x"

, ","

shorthand_field_initializer

identifier "y"

} "}"

function_item

fn "fn"

identifier "distance_from_origin"

parameters

( "("

self_parameter

& "&"

self "self"

) ")"

-> "->"

primitive_type "f64"

block

{ "{"

call_expression

field_expression

parenthesized_expression

( "("

type_cast_expression

parenthesized_expression

( "("

binary_expression

call_expression

field_expression

self "self"

. "."

field_identifier "x"

. "."

field_identifier "pow"

arguments

( "("

integer_literal "2"

) ")"

+ "+"

call_expression

field_expression

self "self"

. "."

field_identifier "y"

. "."

field_identifier "pow"

arguments

( "("

integer_literal "2"

) ")"

as "as"

primitive_type "f64"

) ")"

. "."

field_identifier "sqrt"

arguments

( "("

) ")"

} "}"

function_item

fn "fn"

identifier "main"

parameters

( "("

) ")"

block

{ "{"

let_declaration

let "let"

identifier "points"

= "="

macro_invocation

identifier "vec"

! "!"

token_tree

[ "["

identifier "Point"

:: "::"

identifier "new"

token_tree

( "("

integer_literal "1"

, ","

integer_literal "2"

) ")"

, ","

identifier "Point"

:: "::"

identifier "new"

token_tree

( "("

integer_literal "3"

, ","

integer_literal "4"

) ")"

, ","

identifier "Point"

:: "::"

identifier "new"

token_tree

( "("

integer_literal "5"

, ","

integer_literal "6"

) ")"

, ","

] "]"

; ";"

expression_statement

for_expression

for "for"

identifier "point"

in "in"

reference_expression

& "&"

identifier "points"

block

{ "{"

expression_statement

macro_invocation

identifier "println"

! "!"

token_tree

( "("

string_literal

" "\""

string_content "Point: ({}, {}) - Distance: {:.2}"

" "\""

, ","

identifier "point"

. "."

identifier "x"

, ","

identifier "point"

. "."

identifier "y"

, ","

identifier "point"

. "."

identifier "distance_from_origin"

token_tree

( "("

) ")"

; ";"

} "}"