RUST Archives - 12 중 3 번째 페이지

[RUST/TOKIO] spawn 함수 : 비동기 병렬 처리하기

■ spawn 함수를 사용해 비동기 병렬 처리하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

tokio = { version = "1", features = ["full"] }

▶ src/main.rs


use tokio::time;

async fn print_message_async(second_count : u64, message : &str)
{
    time::sleep(time::Duration::from_secs(second_count)).await;

    println!("{} : {}", second_count, message);
}

#[tokio::main]
async fn main()
{
    tokio::spawn(print_message_async(3, "메시지 #1"));
    tokio::spawn(print_message_async(2, "메시지 #2"));
    tokio::spawn(print_message_async(1, "메시지 #3"));

    time::sleep(time::Duration::from_secs(4)).await;
}

use tokio::time;

async fn print_message_async(second_count : u64, message : &str)

{

time::sleep(time::Duration::from_secs(second_count)).await;

println!("{} : {}", second_count, message);

}

#[tokio::main]

async fn main()

{

tokio::spawn(print_message_async(3, "메시지 #1"));

tokio::spawn(print_message_async(2, "메시지 #2"));

tokio::spawn(print_message_async(1, "메시지 #3"));

time::sleep(time::Duration::from_secs(4)).await;

}

test_project.zip

[RUST/TOKIO] 블럭문을 사용해 비동기 처리하기

■ 블럭문을 사용해 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

tokio = { version = "1", features = ["full"] }

▶ src/main.rs


use tokio::time;

#[tokio::main]
async fn main()
{
    for i in 1..=3
    {
        println!("#{} START TO GET MESSAGE", i);

        let message = async
        {
            time::sleep(time::Duration::from_secs(1)).await;

            return String::from(format!("MESSAGE {}", i));
        }.await;

        println!("{}", message);
    }
}

use tokio::time;

#[tokio::main]

async fn main()

{

for i in 1..=3

{

println!("#{} START TO GET MESSAGE", i);

let message = async

{

time::sleep(time::Duration::from_secs(1)).await;

return String::from(format!("MESSAGE {}", i));

}.await;

println!("{}", message);

}

test_project.zip

[RUST/TOKIO] tokio 크레이트를 사용해 반환값을 갖는 비동기 처리하기

■ tokio 크레이트를 사용해 반환값을 갖는 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

tokio = { version = "1", features = ["full"] }

▶ src/main.rs


use tokio::time;

#[tokio::main]
async fn main()
{
    for i in 1..=3
    {
        println!("#{} START TO GET MESSAGE", i);

        let message : String = get_message_async(i).await;

        println!("{}", message);
    }
}

async fn get_message_async(value : i32) -> String
{
    time::sleep(time::Duration::from_secs(1)).await;

    return String::from(format!("MESSAGE {}", value));
}

use tokio::time;

#[tokio::main]

async fn main()

{

for i in 1..=3

{

println!("#{} START TO GET MESSAGE", i);

let message : String = get_message_async(i).await;

println!("{}", message);

}

async fn get_message_async(value : i32) -> String

{

time::sleep(time::Duration::from_secs(1)).await;

return String::from(format!("MESSAGE {}", value));

}

test_project.zip

[RUST/TOKIO] sleep 함수 : 실행을 일정 시간 대기하기

■ sleep 함수를 사용해 실행을 일정 시간 동안 대기하는 방법을 보여준다. ▶ 예제 코드 (RS)


use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

time::sleep(duration).await;

use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

time::sleep(duration).await;

[RUST/TOKIO] Duration 구조체 : from_secs 연관 함수를 사용해 초단위 Duration 객체 구하기

■ Duration 구조체의 from_secs 연관 함수를 사용해 초단위 Duration 객체를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

use tokio::time;

let duration : time::Duration = time::Duration::from_secs(1);

[RUST/TOKIO] tokio 크레이트를 사용해 비동기 처리하기

■ tokio 크레이트를 사용해 비동기 처리를 하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
tokio = { version = "1", features = ["full"] }

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

tokio = { version = "1", features = ["full"] }

▶ src/main.rs


#[tokio::main]
async fn main()
{
    let future  = print_message_async("메시지 #1");

    println!("메시지 #2");

    future.await;
}

async fn print_message_async(message : &'static str)
{
    println!("{}", message);
}

#[tokio::main]

async fn main()

{

let future = print_message_async("메시지 #1");

println!("메시지 #2");

future.await;

}

async fn print_message_async(message : &'static str)

{

println!("{}", message);

}

test_project.zip

[RUST/COMMON] 크레이트 설치 : tokio

■ tokio 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
tokio = { version = "1", features = ["full"] }

...

[dependencies]

tokio = { version = "1", features = ["full"] }

[RUST/WASM-BINDGEN] 미니 언어를 실행하는 웹 어셈블리 만들기

■ 미니 언어를 실행하는 웹 어셈블리를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_library"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
peg = "0.7"
wasm-bindgen = "0.2"

[package]

name = "test_library"

version = "0.1.0"

edition = "2021"

[lib]

crate-type = ["cdylib", "rlib"]

[dependencies]

peg = "0.7"

wasm-bindgen = "0.2"

▶ src/node.rs


#[derive(Debug, Clone)]
pub enum Node
{
    Nop,
    Number(i64),                                   // 숫자 값
    Expression(char, Box<Node>, Box<Node>),        // 계산식
    If(Box<Node>, Box<Vec<Node>>, Box<Vec<Node>>), // if문
    For(String, i64, i64, Box<Vec<Node>>),         // for문
    Print(Box<Node>),                              // print문(계산 출력)
    PrintString(String),                           // print문(문자열 출력)
    SetVariable(String, Box<Node>),                // 변수 대입
    GetVariable(String)                            // 변수 참조
}

impl Node
{
    pub fn expression(operator : char, left_value : Node, right_value : Node) -> Node
    {
        return Node::Expression(operator, Box::new(left_value), Box::new(right_value));
    }

    pub fn if_(condition_node : Node, true_node_vector : Vec<Node>, false_node_vector : Vec<Node>) -> Node
    {
        return Node::If(Box::new(condition_node), Box::new(true_node_vector), Box::new(false_node_vector));
    }
}

#[derive(Debug, Clone)]

pub enum Node

{

Nop,

Number(i64), // 숫자 값

Expression(char, Box<Node>, Box<Node>), // 계산식

If(Box<Node>, Box<Vec<Node>>, Box<Vec<Node>>), // if문

For(String, i64, i64, Box<Vec<Node>>), // for문

Print(Box<Node>), // print문(계산 출력)

PrintString(String), // print문(문자열 출력)

SetVariable(String, Box<Node>), // 변수 대입

GetVariable(String) // 변수 참조

}

impl Node

{

pub fn expression(operator : char, left_value : Node, right_value : Node) -> Node

{

return Node::Expression(operator, Box::new(left_value), Box::new(right_value));

}

pub fn if_(condition_node : Node, true_node_vector : Vec<Node>, false_node_vector : Vec<Node>) -> Node

{

return Node::If(Box::new(condition_node), Box::new(true_node_vector), Box::new(false_node_vector));

}

▶ src/parser.rs


use peg;

use crate::node;

peg::parser!
(
    pub grammar custom_language() for str
    {
        pub rule parse() -> Vec<node::Node>
            = value : sentences()

        rule sentences() -> Vec<node::Node>
            = sentence() ** end_of_line()

        rule sentence() -> node::Node
            = print() / if() / for() / let() / _ { node::Node::Nop }

        rule print() -> node::Node
            = "print" _ "\"" value : $([^ '"']*) "\""
            { node::Node::PrintString(value.to_string()) }
            / "print" _ value : calc()
            { node::Node::Print(Box::new(value)) }

        rule if() -> node::Node = "if" _ value : if_cond() { value }

        rule if_cond() -> node::Node
            = if_elif() / if_else() / if_true_only()

        rule if_elif() -> node::Node
            = condition_node : calc() true_node_vector : block() lf() "elif" _ false_node_vector : if_cond()
            { node::Node::if_(condition_node, true_node_vector, vec![false_node_vector]) }

        rule if_else() -> node::Node
            = condition_node : calc() true_node_vector : block() lf() "else" _ false_node_vector : block()
            { node::Node::if_(condition_node, true_node_vector, false_node_vector) }

        rule if_true_only() -> node::Node
            = condition_node : calc() true_node_vector : block()
            { node::Node::if_(condition_node, true_node_vector, vec![]) }

        rule block() -> Vec<node::Node>
            = "{" _ value : sentences() _ "}" _ { value }

        rule for() -> node::Node
            = "for" _ variable_name : word() _ "=" _ start : number() _ "to" _ end : number() _ body : block()
            { node::Node::For(variable_name, start, end, Box::new(body)) }

        rule let() -> node::Node
            = variable_name : word() _ "=" _ value : calc()
            { node::Node::SetVariable(variable_name, Box::new(value))}

        rule calc() -> node::Node = comp()

        rule comp() -> node::Node
            = left : expr() "==" _ right : comp() { node::Node::expression('=', left, right) }
            / left : expr() "!=" _ right : comp() { node::Node::expression('!', left, right) }
            / left : expr() ">"  _ right : comp() { node::Node::expression('>', left, right) }
            / left : expr() ">=" _ right : comp() { node::Node::expression('g', left, right) }
            / left : expr() "<"  _ right : comp() { node::Node::expression('<', left, right) }
            / left : expr() "<=" _ right : comp() { node::Node::expression('l', left, right) }
            / expr()

        rule expr() -> node::Node
            = left : term() "+" _ right : calc() { node::Node::expression('+', left, right) }
            / left : term() "-" _ right : calc() { node::Node::expression('-', left, right) }
            / term()

        rule term() -> node::Node
            = left : val() "*" _ right : term() { node::Node::expression('*', left, right) }
            / left : val() "/" _ right : term() { node::Node::expression('/', left, right) }
            / left : val() "%" _ right : term() { node::Node::expression('%', left, right) }
            / val()

        rule val() -> node::Node
            = "(" _ value : calc() _ ")" _ { value }
            / value : number() _ { node::Node::Number(value) }
            / value : word() _ { node::Node::GetVariable(value) }

        rule number() -> i64
            = value : $(['0'..='9']+) { value.parse().unwrap() }

        rule word() -> String
            = value : $(['a'..='z'|'A'..='Z'|'_']+ ['0'..='9']*)
            { String::from(value) }

        rule end_of_line() = [';' | '\n']+ _ // 문장 나누기

        rule lf() = _ ['\n']* _              // 줄바꿈

        rule _ = [' ' | '\t']*               // 공백문자
    }
);

use peg;

use crate::node;

peg::parser!

(

pub grammar custom_language() for str

{

pub rule parse() -> Vec<node::Node>

= value : sentences()

rule sentences() -> Vec<node::Node>

= sentence() ** end_of_line()

rule sentence() -> node::Node

= print() / if() / for() / let() / _ { node::Node::Nop }

rule print() -> node::Node

= "print" _ "\"" value : $([^ '"']*) "\""

{ node::Node::PrintString(value.to_string()) }

/ "print" _ value : calc()

{ node::Node::Print(Box::new(value)) }

rule if() -> node::Node = "if" _ value : if_cond() { value }

rule if_cond() -> node::Node

= if_elif() / if_else() / if_true_only()

rule if_elif() -> node::Node

= condition_node : calc() true_node_vector : block() lf() "elif" _ false_node_vector : if_cond()

{ node::Node::if_(condition_node, true_node_vector, vec![false_node_vector]) }

rule if_else() -> node::Node

= condition_node : calc() true_node_vector : block() lf() "else" _ false_node_vector : block()

{ node::Node::if_(condition_node, true_node_vector, false_node_vector) }

rule if_true_only() -> node::Node

= condition_node : calc() true_node_vector : block()

{ node::Node::if_(condition_node, true_node_vector, vec![]) }

rule block() -> Vec<node::Node>

= "{" _ value : sentences() _ "}" _ { value }

rule for() -> node::Node

= "for" _ variable_name : word() _ "=" _ start : number() _ "to" _ end : number() _ body : block()

{ node::Node::For(variable_name, start, end, Box::new(body)) }

rule let() -> node::Node

= variable_name : word() _ "=" _ value : calc()

{ node::Node::SetVariable(variable_name, Box::new(value))}

rule calc() -> node::Node = comp()

rule comp() -> node::Node

= left : expr() "==" _ right : comp() { node::Node::expression('=', left, right) }

/ left : expr() "!=" _ right : comp() { node::Node::expression('!', left, right) }

/ left : expr() ">" _ right : comp() { node::Node::expression('>', left, right) }

/ left : expr() ">=" _ right : comp() { node::Node::expression('g', left, right) }

/ left : expr() "<" _ right : comp() { node::Node::expression('<', left, right) }

/ left : expr() "<=" _ right : comp() { node::Node::expression('l', left, right) }

/ expr()

rule expr() -> node::Node

= left : term() "+" _ right : calc() { node::Node::expression('+', left, right) }

/ left : term() "-" _ right : calc() { node::Node::expression('-', left, right) }

/ term()

rule term() -> node::Node

= left : val() "*" _ right : term() { node::Node::expression('*', left, right) }

/ left : val() "/" _ right : term() { node::Node::expression('/', left, right) }

/ left : val() "%" _ right : term() { node::Node::expression('%', left, right) }

/ val()

rule val() -> node::Node

= "(" _ value : calc() _ ")" _ { value }

/ value : number() _ { node::Node::Number(value) }

/ value : word() _ { node::Node::GetVariable(value) }

rule number() -> i64

= value : $(['0'..='9']+) { value.parse().unwrap() }

rule word() -> String

= value : $(['a'..='z'|'A'..='Z'|'_']+ ['0'..='9']*)

{ String::from(value) }

rule end_of_line() = [';' | '\n']+ _ // 문장 나누기

rule lf() = _ ['\n']* _ // 줄바꿈

rule _ = [' ' | '\t']* // 공백문자

}

);

▶ src/runner.rs


use std::collections;

use crate::node;
use crate::parser;

struct Context
{
    variable_hashmap : collections::HashMap<String, i64>,
    output           : String
}

fn run_node(context : &mut Context, node : node::Node) -> i64
{
    match node
    {
        node::Node::Number(value) => value,

        node::Node::Expression(operator, left_value, right_value) =>
        {
            return calculate(operator, run_node(context, *left_value), run_node(context, *right_value));
        },

        node::Node::GetVariable(variable_name) =>
        {
            return match context.variable_hashmap.get(&variable_name)
            {
                Some(value) => *value,
                None => 0
            };
        },

        node::Node::SetVariable(variable_name, node) =>
        {
            let value : i64 = run_node(context, *node);

            context.variable_hashmap.insert(variable_name, value);

            return value;
        },

        node::Node::If(condition_node_box, true_node_vector_box, false_node_vector_box) =>
        {
            let result : i64 = run_node(context, *condition_node_box);

            if result > 0
            {
                return run_nodes(context, &*true_node_vector_box);
            }
            else
            {
                return run_nodes(context, &*false_node_vector_box);
            }
        },

        node::Node::For(control_variable_name, start_value, end_value, body_node_vector_box) =>
        {
            let mut result : i64 = 0;

            let node_vector : Vec<node::Node> = *body_node_vector_box;

            for i in start_value..=end_value
            {
                context.variable_hashmap.insert(control_variable_name.clone(), i);

                result = run_nodes(context, &node_vector);
            }

            return result;
        },

        node::Node::PrintString(value) =>
        {
            context.output += &format!("{}\n", value);

            return 0;
        },

        node::Node::Print(node_box) =>
        {
            let value : i64 = run_node(context, *node_box);

            context.output += &format!("{}\n", value);

            return value;
        },

        _ => 0
    }
}

fn calculate(operator : char, left_value : i64, right_value : i64) -> i64
{
    return match operator
    {
        '+' => left_value + right_value,
        '-' => left_value - right_value,
        '*' => left_value * right_value,
        '/' => left_value / right_value,
        '%' => left_value % right_value,
        '=' => if left_value == right_value {1} else {0},
        '!' => if left_value != right_value {1} else {0},
        '>' => if left_value >  right_value {1} else {0},
        'g' => if left_value >= right_value {1} else {0},
        '<' => if left_value <  right_value {1} else {0},
        'l' => if left_value <= right_value {1} else {0},
        _   => 0
    };
}

fn run_nodes(context : &mut Context, node_vector : &Vec<node::Node>) -> i64
{
    let mut result : i64 = 0;

    node_vector.iter().for_each(|node : &node::Node| { result = run_node(context, node.clone()); });

    return result;
}

pub fn run(source : &str) -> String
{
    let node_vector : Vec<node::Node> = match parser::custom_language::parse(source)
    {
        Ok(res) => res,
        Err(e) => return e.to_string()
    };

    let mut context : Context = Context
    {
        variable_hashmap : collections::HashMap::new(),
        output           : String::new()
    };

    let result = run_nodes(&mut context, &node_vector);

    if context.output == ""
    {
        return format!("{}", result);
    }
    else
    {
        return context.output.clone();
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

use std::collections;

use crate::node;

use crate::parser;

struct Context

{

variable_hashmap : collections::HashMap<String, i64>,

output : String

}

fn run_node(context : &mut Context, node : node::Node) -> i64

{

match node

{

node::Node::Number(value) => value,

node::Node::Expression(operator, left_value, right_value) =>

{

return calculate(operator, run_node(context, *left_value), run_node(context, *right_value));

node::Node::GetVariable(variable_name) =>

{

return match context.variable_hashmap.get(&variable_name)

{

Some(value) => *value,

None => 0

};

node::Node::SetVariable(variable_name, node) =>

{

let value : i64 = run_node(context, *node);

context.variable_hashmap.insert(variable_name, value);

return value;

node::Node::If(condition_node_box, true_node_vector_box, false_node_vector_box) =>

{

let result : i64 = run_node(context, *condition_node_box);

if result > 0

{

return run_nodes(context, &*true_node_vector_box);

}

else

{

return run_nodes(context, &*false_node_vector_box);

}

node::Node::For(control_variable_name, start_value, end_value, body_node_vector_box) =>

{

let mut result : i64 = 0;

let node_vector : Vec<node::Node> = *body_node_vector_box;

for i in start_value..=end_value

{

context.variable_hashmap.insert(control_variable_name.clone(), i);

result = run_nodes(context, &node_vector);

}

return result;

node::Node::PrintString(value) =>

{

context.output += &format!("{}\n", value);

return 0;

node::Node::Print(node_box) =>

{

let value : i64 = run_node(context, *node_box);

context.output += &format!("{}\n", value);

return value;

_ => 0

}

fn calculate(operator : char, left_value : i64, right_value : i64) -> i64

{

return match operator

{

'+' => left_value + right_value,

'-' => left_value - right_value,

'*' => left_value * right_value,

'/' => left_value / right_value,

'%' => left_value % right_value,

'=' => if left_value == right_value {1} else {0},

'!' => if left_value != right_value {1} else {0},

'>' => if left_value > right_value {1} else {0},

'g' => if left_value >= right_value {1} else {0},

'<' => if left_value < right_value {1} else {0},

'l' => if left_value <= right_value {1} else {0},

_ => 0

};

}

fn run_nodes(context : &mut Context, node_vector : &Vec<node::Node>) -> i64

{

let mut result : i64 = 0;

node_vector.iter().for_each(|node : &node::Node| { result = run_node(context, node.clone()); });

return result;

}

pub fn run(source : &str) -> String

{

let node_vector : Vec<node::Node> = match parser::custom_language::parse(source)

{

Ok(res) => res,

Err(e) => return e.to_string()

};

let mut context : Context = Context

{

variable_hashmap : collections::HashMap::new(),

output : String::new()

};

let result = run_nodes(&mut context, &node_vector);

if context.output == ""

{

return format!("{}", result);

}

else

{

return context.output.clone();

}

▶

[RUST/WASM-BINDGEN] 웹 어셈블리 만들기

■ 웹 어셈블리를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_library"
version = "0.1.0"
edition = "2021"

[lib]
crate-type = ["cdylib", "rlib"]

[dependencies]
wasm-bindgen = "0.2"

[package]

name = "test_library"

version = "0.1.0"

edition = "2021"

[lib]

crate-type = ["cdylib", "rlib"]

[dependencies]

wasm-bindgen = "0.2"

▶ src/lib.rs


extern crate wasm_bindgen;

use wasm_bindgen::prelude::*;

#[wasm_bindgen]
extern
{
&nbsp; &nbsp; pub fn alert(message : &str);
}

#[wasm_bindgen]
pub fn print_message(message : &str)
{
&nbsp; &nbsp; let target_message : String = format!("Hello, {}!", message);

&nbsp; &nbsp; alert(&target_message);
}

#[wasm_bindgen]
pub fn multiply(value1 : i32, value2 : i32) -> i32
{
&nbsp; &nbsp; return value1 * value2;
}

extern crate wasm_bindgen;

use wasm_bindgen::prelude::*;

#[wasm_bindgen]

extern

{

    pub fn alert(message : &str);

}

#[wasm_bindgen]

pub fn print_message(message : &str)

{

    let target_message : String = format!("Hello, {}!", message);

    alert(&target_message);

}

#[wasm_bindgen]

pub fn multiply(value1 : i32, value2 : i32) -> i32

{

    return value1 * value2;

}

▶ index.html


<!DOCTYPE html>
<html>
&nbsp; &nbsp; <meta charset="utf-8">
&nbsp; &nbsp; <body>
&nbsp; &nbsp; &nbsp; &nbsp; <script type="module">
import init, {print_message, multiply} from './pkg/test_library.js';

init().then
(
&nbsp; &nbsp; () =>
&nbsp; &nbsp; {
&nbsp; &nbsp; &nbsp; &nbsp; setTimeout
&nbsp; &nbsp; &nbsp; &nbsp; (
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; () =>
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; {
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; print_message('Rust');
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; },
&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 300
&nbsp; &nbsp; &nbsp; &nbsp; );

&nbsp; &nbsp; &nbsp; &nbsp; const value = multiply(2000, 3);

&nbsp; &nbsp; &nbsp; &nbsp; document.getElementById('info').innerHTML = value;
&nbsp; &nbsp; }
);
&nbsp; &nbsp; &nbsp; &nbsp; </script>
&nbsp; &nbsp; &nbsp; &nbsp; <h1>index.html</h1>
&nbsp; &nbsp; &nbsp; &nbsp; <h2 id="info"></h2>
&nbsp; &nbsp; </body>
</html>

<!DOCTYPE html>

<html>

    <body>

import init, {print_message, multiply} from './pkg/test_library.js';

init().then

(

    () =>

    {

        setTimeout

        (

            () =>

            {

                print_message('Rust');

            300

        );

        const value = multiply(2000, 3);

        document.getElementById('info').innerHTML = value;

    }

);

        </script>

        <h1>index.html</h1>

    </body>

</html>

※ 참고 사항 1. wasm-pack이 설치되어 있어야

[RUST/COMMON] wasm-pack build 명령 : 웹 어셈블리 프로젝트 컴파일하기

■ wasm-pack build 명령을 사용해 웹 어셈블리 프로젝트를 컴파일하는 방법을 보여준다. 1. [명령 프롬프트]를 실행한다. 2. [명령 프롬프트]에서 아래 명령을 실행한다. ▶

[RUST/COMMON] 크레이트 설치 : wasm-bindgen

■ wasm-bindgen 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
wasm-bindgen = "0.2"

...

[dependencies]

wasm-bindgen = "0.2"

[RUST/COMMON] cargo install 명령 : wasm-pack 설치하기

■ cargo install 명령을 사용해 wasm-pack를 설치하는 방법을 보여준다. 1. [명령 프롬프트]를 실행한다. 2. [명령 프롬프트]에서 아래 명령을 실행한다. ▶ 실행 명령

[RUST/COMMON] C 언어로 작성한 라이브러리 사용하기

■ C 언어로 작성한 라이브러리를 사용하는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
libc = "0.2"

[build-dependencies]
cc = "1.0"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

libc = "0.2"

[build-dependencies]

cc = "1.0"

▶ build.rs


extern crate cc;

fn main()
{
    cc::Build::new()
        .file("src/calculator.c") // C 언어 소스 코드 파일
        .include("src")
        .compile("calculator");   // 출력 라이브러리명
}

extern crate cc;

fn main()

{

cc::Build::new()

.file("src/calculator.c") // C 언어 소스 코드 파일

.include("src")

.compile("calculator"); // 출력 라이브러리명

}

▶ src/calculator.c


#include<stdio.h>

int multiply(int a, int b)
{
    return a * b;
}

#include<stdio.h>

int multiply(int a, int b)

{

return a * b;

}

▶ src/main.rs


#[link(name="calculator", kind="static")]
extern "C"
{
    fn multiply(a : isize, b : isize) -> isize;
}

fn main()
{
    unsafe
    {
        let result1 : isize = multiply(10, 20);

        println!("{}", result1);

        let result2 : isize = multiply(30, 40);

        println!("{}", result2);
    }
}

#[link(name="calculator", kind="static")]

extern "C"

{

fn multiply(a : isize, b : isize) -> isize;

}

fn main()

{

unsafe

{

let result1 : isize = multiply(10, 20);

println!("{}", result1);

let result2 : isize = multiply(30, 40);

println!("{}", result2);

}

test_project.zip

[RUST/COMMON] 크레이트 설치 : libc

■ libc 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
libc = "0.2"

...

[dependencies]

libc = "0.2"

[RUST/COMMON] 크레이트 설치 : cc

■ cc 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[build-dependencies]
cc = "1.0"

...

[build-dependencies]

cc = "1.0"

[RUST/PEG] parser! 매크로 : 미니 언어 만들기

■ parser! 매크로를 사용해 미니 언어를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
peg = "0.8"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

peg = "0.8"

▶ src/node.rs


#[derive(Debug, Clone)]
pub enum Node
{
    Nop,
    Number(i64),                                   // 숫자 값
    Expression(char, Box<Node>, Box<Node>),        // 계산식
    If(Box<Node>, Box<Vec<Node>>, Box<Vec<Node>>), // if문
    For(String, i64, i64, Box<Vec<Node>>),         // for문
    Print(Box<Node>),                              // print문(계산 출력)
    PrintString(String),                           // print문(문자열 출력)
    SetVariable(String, Box<Node>),                // 변수 대입
    GetVariable(String)                            // 변수 참조
}

impl Node
{
    pub fn expression(operator : char, left_value : Node, right_value : Node) -> Node
    {
        return Node::Expression(operator, Box::new(left_value), Box::new(right_value));
    }

    pub fn if_(condition_node : Node, true_node_vector : Vec<Node>, false_node_vector : Vec<Node>) -> Node
    {
        return Node::If(Box::new(condition_node), Box::new(true_node_vector), Box::new(false_node_vector));
    }
}

#[derive(Debug, Clone)]

pub enum Node

{

Nop,

Number(i64), // 숫자 값

Expression(char, Box<Node>, Box<Node>), // 계산식

If(Box<Node>, Box<Vec<Node>>, Box<Vec<Node>>), // if문

For(String, i64, i64, Box<Vec<Node>>), // for문

Print(Box<Node>), // print문(계산 출력)

PrintString(String), // print문(문자열 출력)

SetVariable(String, Box<Node>), // 변수 대입

GetVariable(String) // 변수 참조

}

impl Node

{

pub fn expression(operator : char, left_value : Node, right_value : Node) -> Node

{

return Node::Expression(operator, Box::new(left_value), Box::new(right_value));

}

pub fn if_(condition_node : Node, true_node_vector : Vec<Node>, false_node_vector : Vec<Node>) -> Node

{

return Node::If(Box::new(condition_node), Box::new(true_node_vector), Box::new(false_node_vector));

}

▶ src/parser.rs


use peg;

use crate::node;

peg::parser!
(
    pub grammar custom_language() for str
    {
        pub rule parse() -> Vec<node::Node>
            = value : sentences()

        rule sentences() -> Vec<node::Node>
            = sentence() ** end_of_line()

        rule sentence() -> node::Node
            = print() / if() / for() / let() / _ { node::Node::Nop }

        rule print() -> node::Node
            = "print" _ "\"" value : $([^ '"']*) "\""
            { node::Node::PrintString(value.to_string()) }
            / "print" _ value : calc()
            { node::Node::Print(Box::new(value)) }

        rule if() -> node::Node = "if" _ value : if_cond() { value }

        rule if_cond() -> node::Node
            = if_elif() / if_else() / if_true_only()

        rule if_elif() -> node::Node
            = condition_node : calc() true_node_vector : block() lf() "elif" _ false_node_vector : if_cond()
            { node::Node::if_(condition_node, true_node_vector, vec![false_node_vector]) }

        rule if_else() -> node::Node
            = condition_node : calc() true_node_vector : block() lf() "else" _ false_node_vector : block()
            { node::Node::if_(condition_node, true_node_vector, false_node_vector) }

        rule if_true_only() -> node::Node
            = condition_node : calc() true_node_vector : block()
            { node::Node::if_(condition_node, true_node_vector, vec![]) }

        rule block() -> Vec<node::Node>
            = "{" _ value : sentences() _ "}" _ { value }

        rule for() -> node::Node
            = "for" _ variable_name : word() _ "=" _ start : number() _ "to" _ end : number() _ body : block()
            { node::Node::For(variable_name, start, end, Box::new(body)) }

        rule let() -> node::Node
            = variable_name : word() _ "=" _ value : calc()
            { node::Node::SetVariable(variable_name, Box::new(value))}

        rule calc() -> node::Node = comp()

        rule comp() -> node::Node
            = left : expr() "==" _ right : comp() { node::Node::expression('=', left, right) }
            / left : expr() "!=" _ right : comp() { node::Node::expression('!', left, right) }
            / left : expr() ">"  _ right : comp() { node::Node::expression('>', left, right) }
            / left : expr() ">=" _ right : comp() { node::Node::expression('g', left, right) }
            / left : expr() "<"  _ right : comp() { node::Node::expression('<', left, right) }
            / left : expr() "<=" _ right : comp() { node::Node::expression('l', left, right) }
            / expr()

        rule expr() -> node::Node
            = left : term() "+" _ right : calc() { node::Node::expression('+', left, right) }
            / left : term() "-" _ right : calc() { node::Node::expression('-', left, right) }
            / term()

        rule term() -> node::Node
            = left : val() "*" _ right : term() { node::Node::expression('*', left, right) }
            / left : val() "/" _ right : term() { node::Node::expression('/', left, right) }
            / left : val() "%" _ right : term() { node::Node::expression('%', left, right) }
            / val()

        rule val() -> node::Node
            = "(" _ value : calc() _ ")" _ { value }
            / value : number() _ { node::Node::Number(value) }
            / value : word() _ { node::Node::GetVariable(value) }

        rule number() -> i64
            = value : $(['0'..='9']+) { value.parse().unwrap() }

        rule word() -> String
            = value : $(['a'..='z'|'A'..='Z'|'_']+ ['0'..='9']*)
            { String::from(value) }

        rule end_of_line() = [';' | '\n']+ _ // 문장 나누기

        rule lf() = _ ['\n']* _              // 줄바꿈

        rule _ = [' ' | '\t']*               // 공백문자
    }
);

use peg;

use crate::node;

peg::parser!

(

pub grammar custom_language() for str

{

pub rule parse() -> Vec<node::Node>

= value : sentences()

rule sentences() -> Vec<node::Node>

= sentence() ** end_of_line()

rule sentence() -> node::Node

= print() / if() / for() / let() / _ { node::Node::Nop }

rule print() -> node::Node

= "print" _ "\"" value : $([^ '"']*) "\""

{ node::Node::PrintString(value.to_string()) }

/ "print" _ value : calc()

{ node::Node::Print(Box::new(value)) }

rule if() -> node::Node = "if" _ value : if_cond() { value }

rule if_cond() -> node::Node

= if_elif() / if_else() / if_true_only()

rule if_elif() -> node::Node

= condition_node : calc() true_node_vector : block() lf() "elif" _ false_node_vector : if_cond()

{ node::Node::if_(condition_node, true_node_vector, vec![false_node_vector]) }

rule if_else() -> node::Node

= condition_node : calc() true_node_vector : block() lf() "else" _ false_node_vector : block()

{ node::Node::if_(condition_node, true_node_vector, false_node_vector) }

rule if_true_only() -> node::Node

= condition_node : calc() true_node_vector : block()

{ node::Node::if_(condition_node, true_node_vector, vec![]) }

rule block() -> Vec<node::Node>

= "{" _ value : sentences() _ "}" _ { value }

rule for() -> node::Node

= "for" _ variable_name : word() _ "=" _ start : number() _ "to" _ end : number() _ body : block()

{ node::Node::For(variable_name, start, end, Box::new(body)) }

rule let() -> node::Node

= variable_name : word() _ "=" _ value : calc()

{ node::Node::SetVariable(variable_name, Box::new(value))}

rule calc() -> node::Node = comp()

rule comp() -> node::Node

= left : expr() "==" _ right : comp() { node::Node::expression('=', left, right) }

/ left : expr() "!=" _ right : comp() { node::Node::expression('!', left, right) }

/ left : expr() ">" _ right : comp() { node::Node::expression('>', left, right) }

/ left : expr() ">=" _ right : comp() { node::Node::expression('g', left, right) }

/ left : expr() "<" _ right : comp() { node::Node::expression('<', left, right) }

/ left : expr() "<=" _ right : comp() { node::Node::expression('l', left, right) }

/ expr()

rule expr() -> node::Node

= left : term() "+" _ right : calc() { node::Node::expression('+', left, right) }

/ left : term() "-" _ right : calc() { node::Node::expression('-', left, right) }

/ term()

rule term() -> node::Node

= left : val() "*" _ right : term() { node::Node::expression('*', left, right) }

/ left : val() "/" _ right : term() { node::Node::expression('/', left, right) }

/ left : val() "%" _ right : term() { node::Node::expression('%', left, right) }

/ val()

rule val() -> node::Node

= "(" _ value : calc() _ ")" _ { value }

/ value : number() _ { node::Node::Number(value) }

/ value : word() _ { node::Node::GetVariable(value) }

rule number() -> i64

= value : $(['0'..='9']+) { value.parse().unwrap() }

rule word() -> String

= value : $(['a'..='z'|'A'..='Z'|'_']+ ['0'..='9']*)

{ String::from(value) }

rule end_of_line() = [';' | '\n']+ _ // 문장 나누기

rule lf() = _ ['\n']* _ // 줄바꿈

rule _ = [' ' | '\t']* // 공백문자

}

);

▶ src/runner.rs


use std::collections;

use crate::node;
use crate::parser;

struct Context
{
    variable_hashmap : collections::HashMap<String, i64>
}

fn run_node(context : &mut Context, node : node::Node) -> i64
{
    match node
    {
        node::Node::Number(value) => value,

        node::Node::Expression(operator, left_value, right_value) =>
        {
            return calculate(operator, run_node(context, *left_value), run_node(context, *right_value));
        },

        node::Node::GetVariable(variable_name) =>
        {
            return match context.variable_hashmap.get(&variable_name)
            {
                Some(value) => *value,
                None => 0
            };
        },

        node::Node::SetVariable(variable_name, node) =>
        {
            let value : i64 = run_node(context, *node);

            context.variable_hashmap.insert(variable_name, value);

            return value;
        },

        node::Node::If(condition_node_box, true_node_vector_box, false_node_vector_box) =>
        {
            let result : i64 = run_node(context, *condition_node_box);

            if result > 0
            {
                return run_nodes(context, &*true_node_vector_box);
            }
            else
            {
                return run_nodes(context, &*false_node_vector_box);
            }
        },

        node::Node::For(control_variable_name, start_value, end_value, body_node_vector_box) =>
        {
            let mut result : i64 = 0;

            let node_vector : Vec<node::Node> = *body_node_vector_box;

            for i in start_value..=end_value
            {
                context.variable_hashmap.insert(control_variable_name.clone(), i);

                result = run_nodes(context, &node_vector);
            }

            return result;
        },

        node::Node::PrintString(value) =>
        {
            println!("{}", value);

            return 0;
        },

        node::Node::Print(node_box) =>
        {
            let value : i64 = run_node(context, *node_box);

            println!("{}", value);

            return value;
        },

        _ => 0
    }
}

fn calculate(operator : char, left_value : i64, right_value : i64) -> i64
{
    return match operator
    {
        '+' => left_value + right_value,
        '-' => left_value - right_value,
        '*' => left_value * right_value,
        '/' => left_value / right_value,
        '%' => left_value % right_value,
        '=' => if left_value == right_value {1} else {0},
        '!' => if left_value != right_value {1} else {0},
        '>' => if left_value >  right_value {1} else {0},
        'g' => if left_value >= right_value {1} else {0},
        '<' => if left_value <  right_value {1} else {0},
        'l' => if left_value <= right_value {1} else {0},
        _   => 0
    };
}

fn run_nodes(context : &mut Context, node_vector : &Vec<node::Node>) -> i64
{
    let mut result : i64 = 0;

    node_vector.iter().for_each(|node : &node::Node| { result = run_node(context, node.clone()); });

    return result;
}

pub fn run(source : &str) -> i64
{
    let node_vector : Vec<node::Node> = parser::custom_language::parse(source).unwrap();

    let mut context : Context = Context { variable_hashmap : collections::HashMap::new() };

    return run_nodes(&mut context, &node_vector);
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

use std::collections;

use crate::node;

use crate::parser;

struct Context

{

variable_hashmap : collections::HashMap<String, i64>

}

fn run_node(context : &mut Context, node : node::Node) -> i64

{

match node

{

node::Node::Number(value) => value,

node::Node::Expression(operator, left_value, right_value) =>

{

return calculate(operator, run_node(context, *left_value), run_node(context, *right_value));

node::Node::GetVariable(variable_name) =>

{

return match context.variable_hashmap.get(&variable_name)

{

Some(value) => *value,

None => 0

};

node::Node::SetVariable(variable_name, node) =>

{

let value : i64 = run_node(context, *node);

context.variable_hashmap.insert(variable_name, value);

return value;

node::Node::If(condition_node_box, true_node_vector_box, false_node_vector_box) =>

{

let result : i64 = run_node(context, *condition_node_box);

if result > 0

{

return run_nodes(context, &*true_node_vector_box);

}

else

{

return run_nodes(context, &*false_node_vector_box);

}

node::Node::For(control_variable_name, start_value, end_value, body_node_vector_box) =>

{

let mut result : i64 = 0;

let node_vector : Vec<node::Node> = *body_node_vector_box;

for i in start_value..=end_value

{

context.variable_hashmap.insert(control_variable_name.clone(), i);

result = run_nodes(context, &node_vector);

}

return result;

node::Node::PrintString(value) =>

{

println!("{}", value);

return 0;

node::Node::Print(node_box) =>

{

let value : i64 = run_node(context, *node_box);

println!("{}", value);

return value;

_ => 0

}

fn calculate(operator : char, left_value : i64, right_value : i64) -> i64

{

return match operator

{

'+' => left_value + right_value,

'-' => left_value - right_value,

'*' => left_value * right_value,

'/' => left_value / right_value,

'%' => left_value % right_value,

'=' => if left_value == right_value {1} else {0},

'!' => if left_value != right_value {1} else {0},

'>' => if left_value > right_value {1} else {0},

'g' => if left_value >= right_value {1} else {0},

'<' => if left_value < right_value {1} else {0},

'l' => if left_value <= right_value {1} else {0},

_ => 0

};

}

fn run_nodes(context : &mut Context, node_vector : &Vec<node::Node>) -> i64

{

let mut result : i64 = 0;

node_vector.iter().for_each(|node : &node::Node| { result = run_node(context, node.clone()); });

return result;

}

pub fn run(source : &str) -> i64

{

let node_vector : Vec<node::Node> = parser::custom_language::parse(source).unwrap();

let mut context : Context = Context { variable_hashmap : collections::HashMap::new() };

return run_nodes(&mut context, &node_vector);

}

▶

[RUST/PEG] parser! 매크로 : 사칙 연산 계산기 만들기

■ parser! 매크로를 사용해 사칙 연산 계산기를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
peg = "0.8"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

peg = "0.8"

▶ src/main.rs


peg::parser!
(
    grammar calc() for str
    {
        pub rule eval() -> i64
            = expr()

        rule expr() -> i64
            = left_value : term() "+" right_value : expr() { left_value + right_value }
            / left_value : term() "-" right_value : expr() { left_value - right_value }
            / term()

        rule term() -> i64
            = left_value : value() "*" right_value : term() { left_value * right_value }
            / left_value : value() "/" right_value : term() { left_value / right_value }
            / value : value()

        rule value() -> i64
            = number()
            / "(" value : expr() ")" { value }

        rule number() -> i64
            = value : $(['0'..='9']+)
            { value.parse().unwrap() }
    }
);

fn main()
{
    println!("{}", calc::eval("10+20*30").unwrap());
    println!("{}", calc::eval("(10+20)*30").unwrap());
    println!("{}", calc::eval("10/20-30").unwrap());
}

peg::parser!

(

grammar calc() for str

{

pub rule eval() -> i64

= expr()

rule expr() -> i64

= left_value : term() "+" right_value : expr() { left_value + right_value }

/ left_value : term() "-" right_value : expr() { left_value - right_value }

/ term()

rule term() -> i64

= left_value : value() "*" right_value : term() { left_value * right_value }

/ left_value : value() "/" right_value : term() { left_value / right_value }

/ value : value()

rule value() -> i64

= number()

/ "(" value : expr() ")" { value }

rule number() -> i64

= value : $(['0'..='9']+)

{ value.parse().unwrap() }

}

);

fn main()

{

println!("{}", calc::eval("10+20*30").unwrap());

println!("{}", calc::eval("(10+20)*30").unwrap());

println!("{}", calc::eval("10/20-30").unwrap());

}

test_project.zip

[RUST/PEG] parser! 매크로 : 간단 덧셈 계산기 만들기

■ parser! 매크로를 사용해 간단 덧셈 계산기를 만드는 방법을 보여준다. ▶ Cargo.toml


[package]
name = "test_project"
version = "0.1.0"
edition = "2021"

[dependencies]
peg = "0.8"

[package]

name = "test_project"

version = "0.1.0"

edition = "2021"

[dependencies]

peg = "0.8"

▶ src/main.rs


peg::parser!
(
    grammar calc() for str
    {
        pub rule eval() -> i64
            = term()

        rule term() -> i64
            = v1 : num() "+" v2 : num()
            { v1 + v2 }

        rule num() -> i64
            = value : $(['0'..='9']+)
            { value.parse().unwrap() }
    }
);

fn main()
{
    println!("2+5={}", calc::eval("2+5").unwrap());

    println!("8+2={}", calc::eval("8+2").unwrap());

    println!("200+50={}", calc::eval("200+50").unwrap());
}

/*
2+5=7
8+2=10
200+50=250
*/

peg::parser!

(

grammar calc() for str

{

pub rule eval() -> i64

= term()

rule term() -> i64

= v1 : num() "+" v2 : num()

{ v1 + v2 }

rule num() -> i64

= value : $(['0'..='9']+)

{ value.parse().unwrap() }

}

);

fn main()

{

println!("2+5={}", calc::eval("2+5").unwrap());

println!("8+2={}", calc::eval("8+2").unwrap());

println!("200+50={}", calc::eval("200+50").unwrap());

}

2+5=7

8+2=10

200+50=250

test_project.zip

[RUST/COMMON] 크레이트 설치 : peg

■ peg 크레이트를 설치하는 방법을 보여준다. ▶ Cargo.toml


...

[dependencies]
peg = "0.8"

...

[dependencies]

peg = "0.8"

[RUST/COMMON] Rc/Weak 구조체를 사용해 양방향 연결 리스트 만들기

■ Rc<T>/Weak<T> 구조체를 사용해 양방향 연결 리스트를 만드는 방법을 보여준다. ▶ double_linked_list.rs


use std::cell;
use std::rc;

pub struct Node
{
    data     : isize,
    next     : Option<rc::Rc<cell::RefCell<Node>>>,
    previous : Option<rc::Weak<cell::RefCell<Node>>>
}

pub struct DoubleLinkedList
{
    head : Option<rc::Rc<cell::RefCell<Node>>>,
    foot : Option<rc::Rc<cell::RefCell<Node>>>
}

impl DoubleLinkedList
{
    pub fn new() -> Self
    {
        return Self { head : None, foot : None};
    }

    fn new_node(value : isize) -> rc::Rc<cell::RefCell<Node>>
    {
        let node_refcell : cell::RefCell<Node> = cell::RefCell::new(Node{ data : value, next : None, previous : None });

        return rc::Rc::new(node_refcell);
    }

    pub fn push(&mut self, v : isize)
    {
        let node_refcell_rc : rc::Rc<cell::RefCell<Node>> = DoubleLinkedList::new_node(v);

        match self.foot.take()
        {
            None =>
            {
                self.foot = Some(rc::Rc::clone(&node_refcell_rc));
                self.head = Some(node_refcell_rc);
            },
            Some(previous_foot_node_refcell_rc) =>
            {
                self.foot = Some(rc::Rc::clone(&node_refcell_rc));

                node_refcell_rc.borrow_mut().previous = Some(rc::Rc::downgrade(&previous_foot_node_refcell_rc));

                previous_foot_node_refcell_rc.borrow_mut().next = Some(node_refcell_rc);
            }
        }
    }

    pub fn insert_head(&mut self, value : isize)
    {
        let new_node_refcell_rc : rc::Rc<cell::RefCell<Node>> = DoubleLinkedList::new_node(value);

        match self.head.take()
        {
            None =>
            {
                self.foot = Some(rc::Rc::clone(&new_node_refcell_rc));
                self.head = Some(new_node_refcell_rc);
            },
            Some(previous_head_refcell_rc) =>
            {
                previous_head_refcell_rc.borrow_mut().previous = Some(rc::Rc::downgrade(&new_node_refcell_rc));

                new_node_refcell_rc.borrow_mut().next = Some(previous_head_refcell_rc);

                self.head = Some(new_node_refcell_rc);
            }
        }
    }

    pub fn iter(&mut self) -> ListIter
    {
        return match &self.head
        {
            None => ListIter { cur : None },
            Some(head_refcell_rc) =>
            {
                let head : rc::Rc<cell::RefCell<Node>> = rc::Rc::clone(&head_refcell_rc);

                ListIter { cur : Some(head) }
            },
        };
    }
}

pub struct ListIter
{
    pub cur : Option<rc::Rc<cell::RefCell<Node>>>
}

impl Iterator for ListIter
{
    type Item = isize;

    fn next(&mut self) -> Option<Self::Item>
    {
        match self.cur.take()
        {
            None => None,
            Some(current_node_refcell_rc) =>
            {
                let node_ref : cell::Ref<'_, Node> = current_node_refcell_rc.borrow();

                let data : isize = node_ref.data;

                match &node_ref.next
                {
                    None => self.cur = None,
                    Some(next) => self.cur = Some(rc::Rc::clone(&next))
                };

                return Some(data);
            }
        }
    }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

use std::cell;

use std::rc;

pub struct Node

{

data : isize,

next : Option<rc::Rc<cell::RefCell<Node>>>,

previous : Option<rc::Weak<cell::RefCell<Node>>>

}

pub struct DoubleLinkedList

{

head : Option<rc::Rc<cell::RefCell<Node>>>,

foot : Option<rc::Rc<cell::RefCell<Node>>>

}

impl DoubleLinkedList

{

pub fn new() -> Self

{

return Self { head : None, foot : None};

}

fn new_node(value : isize) -> rc::Rc<cell::RefCell<Node>>

{

let node_refcell : cell::RefCell<Node> = cell::RefCell::new(Node{ data : value, next : None, previous : None });

return rc::Rc::new(node_refcell);

}

pub fn push(&mut self, v : isize)

{

let node_refcell_rc : rc::Rc<cell::RefCell<Node>> = DoubleLinkedList::new_node(v);

match self.foot.take()

{

None =>

{

self.foot = Some(rc::Rc::clone(&node_refcell_rc));

self.head = Some(node_refcell_rc);

Some(previous_foot_node_refcell_rc) =>

{

self.foot = Some(rc::Rc::clone(&node_refcell_rc));

node_refcell_rc.borrow_mut().previous = Some(rc::Rc::downgrade(&previous_foot_node_refcell_rc));

previous_foot_node_refcell_rc.borrow_mut().next = Some(node_refcell_rc);

}

pub fn insert_head(&mut self, value : isize)

{

let new_node_refcell_rc : rc::Rc<cell::RefCell<Node>> = DoubleLinkedList::new_node(value);

match self.head.take()

{

None =>

{

self.foot = Some(rc::Rc::clone(&new_node_refcell_rc));

self.head = Some(new_node_refcell_rc);

Some(previous_head_refcell_rc) =>

{

previous_head_refcell_rc.borrow_mut().previous = Some(rc::Rc::downgrade(&new_node_refcell_rc));

new_node_refcell_rc.borrow_mut().next = Some(previous_head_refcell_rc);

self.head = Some(new_node_refcell_rc);

}

pub fn iter(&mut self) -> ListIter

{

return match &self.head

{

None => ListIter { cur : None },

Some(head_refcell_rc) =>

{

let head : rc::Rc<cell::RefCell<Node>> = rc::Rc::clone(&head_refcell_rc);

ListIter { cur : Some(head) }

};

}

pub struct ListIter

{

pub cur : Option<rc::Rc<cell::RefCell<Node>>>

}

impl Iterator for ListIter

{

type Item = isize;

fn next(&mut self) -> Option<Self::Item>

{

match self.cur.take()

{

None => None,

Some(current_node_refcell_rc) =>

{

let node_ref : cell::Ref<'_, Node> = current_node_refcell_rc.borrow();

let data : isize = node_ref.data;

match &node_ref.next

{

None => self.cur = None,

Some(next) => self.cur = Some(rc::Rc::clone(&next))

};

return Some(data);

}

▶ main.rs


mod double_linked_list;

fn main()
{
    let mut list : double_linked_list::DoubleLinkedList = double_linked_list::DoubleLinkedList::new();

    list.push(300);
    list.push(400);

    list.insert_head(100);
    list.insert_head(200);

    for value in list.iter()
    {
        println!("{}", value);
    }
}

mod double_linked_list;

fn main()

{

let mut list : double_linked_list::DoubleLinkedList = double_linked_list::DoubleLinkedList::new();

list.push(300);

list.push(400);

list.insert_head(100);

list.insert_head(200);

for value in list.iter()

{

println!("{}", value);

}

test_project.zip

[RUST/COMMON] RefCell 구조체 : borrow/borrow_mut 메소드 사용하기

■ RefCell<T> 구조체의 borrow/borrow_mut 메소드를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::cell;
use std::rc;

fn main()
{
    let a_refcell : cell::RefCell<i32> = cell::RefCell::new(1000);

    let a_refcell_rc : rc::Rc<cell::RefCell<i32>> = rc::Rc::new(a_refcell);

    let b_refcell_rc : rc::Rc<cell::RefCell<i32>> = rc::Rc::clone(&a_refcell_rc);

    *b_refcell_rc.borrow_mut() += 100;

    println!("{}", a_refcell_rc.borrow());
}

use std::cell;

use std::rc;

fn main()

{

let a_refcell : cell::RefCell<i32> = cell::RefCell::new(1000);

let a_refcell_rc : rc::Rc<cell::RefCell<i32>> = rc::Rc::new(a_refcell);

let b_refcell_rc : rc::Rc<cell::RefCell<i32>> = rc::Rc::clone(&a_refcell_rc);

*b_refcell_rc.borrow_mut() += 100;

println!("{}", a_refcell_rc.borrow());

}

[RUST/COMMON] Rc 구조체 : new/clone/strong_count 연관 함수 사용하기

■ Rc<T> 구조체의 new/clone/strong_count 연관 함수를 사용하는 방법을 보여준다. ▶ 예제 코드 (RS)


use std::rc;

fn main()
{
    let a_rc : rc::Rc<i32> = rc::Rc::new(1000);

    {
        let b_rc : rc::Rc<i32> = rc::Rc::clone(&a_rc);

        println!("{}", b_rc);

        println!("참조 카운트 : {}", rc::Rc::strong_count(&a_rc));
    }

    println!("{}", a_rc);

    println!("참조 카운트 : {}", rc::Rc::strong_count(&a_rc));
}

use std::rc;

fn main()

{

let a_rc : rc::Rc<i32> = rc::Rc::new(1000);

{

let b_rc : rc::Rc<i32> = rc::Rc::clone(&a_rc);

println!("{}", b_rc);

println!("참조 카운트 : {}", rc::Rc::strong_count(&a_rc));

}

println!("{}", a_rc);

println!("참조 카운트 : {}", rc::Rc::strong_count(&a_rc));

}

[RUST/COMMON] Box 구조체 : 단방향 연결 리스트 만들기 (기능 추가)

■ Box<T> 구조체를 사용해 단방향 연결 리스트를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


pub struct Node
{
    data : isize,
    link : Option<Box<Node>>
}

pub struct LinkedList
{
    head : Option<Box<Node>>
}

impl LinkedList
{
    pub fn new() -> Self
    {
        return Self { head : None };
    }

    pub fn insert_first(&mut self, value : isize)
    {
        let node_box_option : Option<Box<Node>> = self.head.take();

        let new_node : Node = Node { data : value, link : node_box_option };

        let new_node_box : Box<Node> = Box::new(new_node);

        self.head = Some(new_node_box);
    }

    pub fn push(&mut self, value : isize)
    {
        let new_node : Node = Node { data : value, link : None };

        match self.head
        {
            None =>
            {
                let node_box : Box<Node> = Box::new(new_node);

                self.head = Some(node_box);
            },
            Some(ref mut head) =>
            {
                let mut current_node_box : &mut Box<Node> = head;

                loop
                {
                    match current_node_box.link
                    {
                        None =>
                        {
                            let new_node_box : Box<Node> = Box::new(new_node);

                            current_node_box.link = Some(new_node_box);

                            break;
                        },
                        Some(ref mut next) => current_node_box = next,
                    }
                }
            }
        }
    }

    pub fn get(&self, index : isize) -> Option<isize>
    {
        match self.head
        {
            None => return None,
            Some(ref top) =>
            {
                let mut current_node_box : &Box<Node> = top;

                let mut current_index : isize = 0;

                loop
                {
                    if current_index == index
                    {
                        return Some(current_node_box.data);
                    }

                    match current_node_box.link
                    {
                        None => return None,
                        Some(ref next) => current_node_box = next,
                    }

                    current_index += 1;
                }
            }
        }
    }
}

fn main()
{
    let mut linked_list : LinkedList = LinkedList::new();

    linked_list.push(300);
    linked_list.push(400);

    linked_list.insert_first(200);
    linked_list.insert_first(100);

    println!("{}", linked_list.get(0).unwrap());
    println!("{}", linked_list.get(1).unwrap());
    println!("{}", linked_list.get(2).unwrap());
    println!("{}", linked_list.get(3).unwrap());
}

/*
100
200
300
400
*/

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

pub struct Node

{

data : isize,

link : Option<Box<Node>>

}

pub struct LinkedList

{

head : Option<Box<Node>>

}

impl LinkedList

{

pub fn new() -> Self

{

return Self { head : None };

}

pub fn insert_first(&mut self, value : isize)

{

let node_box_option : Option<Box<Node>> = self.head.take();

let new_node : Node = Node { data : value, link : node_box_option };

let new_node_box : Box<Node> = Box::new(new_node);

self.head = Some(new_node_box);

}

pub fn push(&mut self, value : isize)

{

let new_node : Node = Node { data : value, link : None };

match self.head

{

None =>

{

let node_box : Box<Node> = Box::new(new_node);

self.head = Some(node_box);

Some(ref mut head) =>

{

let mut current_node_box : &mut Box<Node> = head;

loop

{

match current_node_box.link

{

None =>

{

let new_node_box : Box<Node> = Box::new(new_node);

current_node_box.link = Some(new_node_box);

break;

Some(ref mut next) => current_node_box = next,

}

pub fn get(&self, index : isize) -> Option<isize>

{

match self.head

{

None => return None,

Some(ref top) =>

{

let mut current_node_box : &Box<Node> = top;

let mut current_index : isize = 0;

loop

{

if current_index == index

{

return Some(current_node_box.data);

}

match current_node_box.link

{

None => return None,

Some(ref next) => current_node_box = next,

}

current_index += 1;

}

fn main()

{

let mut linked_list : LinkedList = LinkedList::new();

linked_list.push(300);

linked_list.push(400);

linked_list.insert_first(200);

linked_list.insert_first(100);

println!("{}", linked_list.get(0).unwrap());

println!("{}", linked_list.get(1).unwrap());

println!("{}", linked_list.get(2).unwrap());

println!("{}", linked_list.get(3).unwrap());

}

100

200

300

400

[RUST/COMMON] Box 구조체 : 단방향 연결 리스트 만들기

■ Box<T> 구조체를 사용해 단방향 연결 리스트를 만드는 방법을 보여준다. ▶ 예제 코드 (RS)


pub struct Node
{
    data : i64,
    link : Option<Box<Node>>
}

fn node(data : i64, link : Option<Box<Node>>) -> Option<Box<Node>>
{
    let node : Node = Node { data, link };

    let node_box : Box<Node> = Box::new(node);

    return Some(node_box);
}

fn main()
{
    let mut node_box1 : Box<Node> = node(10, None).unwrap();
    let mut node_box2 : Box<Node> = node(20, None).unwrap();
    let     node_box3 : Box<Node> = node(30, None).unwrap();

    node_box2.link = Some(node_box3);
    node_box1.link = Some(node_box2);

    let first_node_box : Box<Node> = node_box1;

    let mut current_pointer : &Box<Node> = &first_node_box;

    loop
    {
        println!("{}", current_pointer.data);

        match current_pointer.link
        {
            None           => break,
            Some(ref link) => current_pointer = &link,
        }
    }
}

/*
10
20
30
*/

pub struct Node

{

data : i64,

link : Option<Box<Node>>

}

fn node(data : i64, link : Option<Box<Node>>) -> Option<Box<Node>>

{

let node : Node = Node { data, link };

let node_box : Box<Node> = Box::new(node);

return Some(node_box);

}

fn main()

{

let mut node_box1 : Box<Node> = node(10, None).unwrap();

let mut node_box2 : Box<Node> = node(20, None).unwrap();

let node_box3 : Box<Node> = node(30, None).unwrap();

node_box2.link = Some(node_box3);

node_box1.link = Some(node_box2);

let first_node_box : Box<Node> = node_box1;

let mut current_pointer : &Box<Node> = &first_node_box;

loop

{

println!("{}", current_pointer.data);

match current_pointer.link

{

None => break,

Some(ref link) => current_pointer = &link,

}

[RUST/COMMON] Box 구조체 : 값 T 구하기

■ Box<T> 구조체에서 값 T를 구하는 방법을 보여준다. ▶ 예제 코드 (RS)


let value_box : Box<i32> = Box::new(100);

let value : i32 = *value_box;

println!("{}", value);

let value_box : Box<i32> = Box::new(100);

let value : i32 = *value_box;

println!("{}", value);