Usando funciones, así quedó condensado las operaciones de la calculadora :eyes:

El concepto de Funciones es común en cualquier lenguaje de programación. Trozos de código separados de nuestro código principal que puedes llamar y utilizar cuando necesites.
Declarando y llamando funciones en Rust
La declaración de funciones en Rust se realiza con la palabra reservada fn. Ya la has visto antes en fn main() {} que es la función principal de tu aplicación y que se ejecuta siempre al iniciar la misma.
Declara tu propia función de la siguiente manera:
fn main() { sumar_numeros(10, 10); // 20 } fn sumar_numeros(num1: i32, num2: i32) { let sum: i32 = num1 + num2; println!("{}", sum); }
Las funciones reciben argumentos, puedes especificar el tipo de los mismos a lo igual que con una variable, para luego realizar una determinada lógica como la suma de dos números.
Retorno de valores de una función en Rust
Las funciones pueden o no retornar un valor. Para hacerlo, indica el tipo de retorno de la siguiente manera:
fn main() { let sum = sumar_numeros(10, 10); println!("{}", sum); // 20 } fn sumar_numeros(num1: i32, num2: i32) -> i32 { let sum: i32 = num1 + num2; return sum; }
Indica el tipo de retorno luego del -> y retorna una variable con la palabra reservada return para volver al flujo principal de tu código y utilizar ese valor.
Las funciones son un concepto clave en cualquier lenguaje de programación. La reutilización de código es esencial y hace al buen desarrollador o desarrolladora de software saber cuándo separar código y que este sea más limpio y claro.
Contribución creada por: Kevin Fiorentino.
El concepto de Funciones es común en cualquier lenguaje de programación. Trozos de código separados de nuestro código principal que puedes llamar y utilizar cuando necesites.
La declaración de funciones en Rust se realiza con la palabra reservada fn. Ya la has visto antes en fn main() {} que es la función principal de tu aplicación y que se ejecuta siempre al iniciar la misma.
Declara tu propia función de la siguiente manera:
fn main() {
sumar_numeros(10, 10); // 20
}
fn sumar_numeros(num1: i32, num2: i32) {
let sum: i32 = num1 + num2;
println!("{}", sum);
}
Las funciones reciben argumentos, puedes especificar el tipo de los mismos a lo igual que con una variable, para luego realizar una determinada lógica como la suma de dos números.
Las funciones pueden o no retornar un valor. Para hacerlo, indica el tipo de retorno de la siguiente manera:
fn main() {
let sum = sumar_numeros(10, 10);
println!("{}", sum); // 20
}
fn sumar_numeros(num1: i32, num2: i32) -> i32 {
let sum: i32 = num1 + num2;
return sum;
}
Indica el tipo de retorno luego del -> y retorna una variable con la palabra reservada return para volver al flujo principal de tu código y utilizar ese valor.
Las funciones son un concepto clave en cualquier lenguaje de programación. La reutilización de código es esencial y hace al buen desarrollador o desarrolladora de software saber cuándo separar código y que este sea más limpio y claro.
Contribución creada por: Kevin Fiorentino.
Usando funciones, así quedó condensado las operaciones de la calculadora :eyes:

Claro que se puede encapsular cada operación desde pedir los numeros al usuarios hasta ejecutar la operación, hasta imprimir por pantalla.....
Yo encapsulé la parte donde se realizan las operaciones en la expresión.
Aquí dejo un gist con mi solución completa: https://gist.github.com/d4vsanchez/e9721af978eccf36848f075bc4d3041b
El código que extraje a la función en específico es:
fn perform_operation(mut expression: String, operation: &str) -> String {
let operation_regex = Regex::from_str(operation).unwrap();
loop {
let caps = operation_regex.captures(expression.as_str());
if caps.is_none() {
break;
}
let caps = caps.unwrap();
let cap_expression = caps.get(0).unwrap().as_str();
let left_value: i32 = caps.get(1).unwrap().as_str().parse().unwrap();
let operation: &str = caps.get(2).unwrap().as_str();
let right_value: i32 = caps.get(3).unwrap().as_str().parse().unwrap();
let result = match operation {
"+" => left_value + right_value,
"-" => left_value - right_value,
"*" => left_value * right_value,
"/" => left_value / right_value,
_ => 0,
};
expression = expression.replace(cap_expression, &result.to_string());
}
expression
}
Sera que rust puede sacar mas numeros de fibonnacci en menos tiempo ?
Buenisimo, para cualquiera que lo necesite!
Ah, pues en la otra ya de una vez puse en funcion el bucle que se repetia xd.
use regex::Regex;
fn reduce_arithmetic_expression(regular_expressions: Vec<Regex>, mut expression: String) -> String {
for regular_expression in regular_expressions {
// let regular_expression = regular_expressions.get(i).unwrap();
loop {
// Aplicar Operaciones
let caps = regular_expression.captures(expression.as_str());
if caps.is_none() {
break;
}
let caps = caps.unwrap();
let cap_expression= caps.get(0).unwrap().as_str();
let left_value : i32 = caps.get(1).unwrap().as_str().parse().unwrap();
let right_value : i32 = caps.get(2).unwrap().as_str().parse().unwrap();
let mut resultado: i32 = 0;
if cap_expression.contains("*") {
resultado = left_value * right_value;
}
if cap_expression.contains("/") {
resultado = left_value / right_value;
}
if cap_expression.contains("+") {
resultado = left_value + right_value;
}
if cap_expression.contains("-") {
resultado = left_value - right_value;
}
// let multiplication = left_value * right_value;
// println!("{:?} izq: {}, der: {}", caps, left_value, right_value);
expression = expression.replace(cap_expression, &resultado.to_string());
// println!("{:?}", caps);
}
println!("Expression: {}", expression);
}
return expression;
}
fn main() {
println!("Hello, Platzi!");
// Regex
// (\d+) \s? \+ \s?(\d+)
let re_add = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap();
let re_multi = Regex::new(r"(\d+)\s?\*\s?(\d+)").unwrap();
let re_div = Regex::new(r"(\d+)\s?\/\s?(\d+)").unwrap();
let re_rest = Regex::new(r"(\d+)\s?\-\s?(\d+)").unwrap();
let reg_exps = vec![re_multi, re_div, re_add, re_rest];
// Traer datos del usuario
println!("Por favor introduce tu expresión: ");
let mut expression = String::new();
std::io::stdin().read_line(&mut expression).unwrap();
expression = reduce_arithmetic_expression(reg_exps, expression);
// Mostrar resultados
println!("Resultados: {}", expression);
}
En la solución de la calculadora no use match, como vi en muchos comentarios, si no que me limite a usar los if:
Dejo el gist por acá:
fn add_one(x: i32) -> i32 {
x + 1
}
fn main() {
println!("{:?}", { add_one(5) });
}
Dejo mi código por aquí:
use::regex::Regex;
fn division(mut expression: String) -> String {
loop {
let re_div = Regex::new(r"(\d+)\s?/\s?(\d+)").unwrap();
let caps = re_div.captures(&expression);
if caps.is_none() {
break expression;
}
let caps = caps.unwrap();
let cap_expression = caps.get(0).unwrap().as_str();
let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap();
let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap();
let result = left_value / right_value;
expression = expression.replace(cap_expression, &result.to_string());
}
}
fn mul(mut expression: String) -> String {
loop {
let re_mul = Regex::new(r"(\d+)\s?\*\s?(\d+)").unwrap();
let caps = re_mul.captures(&expression);
if caps.is_none() {
break expression;
}
let caps = caps.unwrap();
let cap_expression = caps.get(0).unwrap().as_str();
let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap();
let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap();
let result = left_value * right_value;
expression = expression.replace(cap_expression, &result.to_string());
}
}
fn addition(mut expression: String) -> String {
loop {
let re_add = Regex::new(r"(\d+)\s?\+\s?(\d+)").unwrap();
let caps = re_add.captures(&expression);
if caps.is_none() {
break expression;
}
let caps = caps.unwrap();
let cap_expression = caps.get(0).unwrap().as_str();
let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap();
let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap();
let result = left_value + right_value;
expression = expression.replace(cap_expression, &result.to_string());
}
}
fn substraction(mut expression: String) -> String {
loop {
let re_sub = Regex::new(r"(\d+)\s?\-\s?(\d+)").unwrap();
let caps = re_sub.captures(&expression);
if caps.is_none() {
break expression;
}
let caps = caps.unwrap();
let cap_expression = caps.get(0).unwrap().as_str();
let left_value = caps.get(1).unwrap().as_str().parse::<i32>().unwrap();
let right_value = caps.get(2).unwrap().as_str().parse::<i32>().unwrap();
let result = left_value - right_value;
expression = expression.replace(cap_expression, &result.to_string());
}
}
fn do_expression(mut expression: String) -> String {
expression = division(expression);
expression = mul(expression);
expression = addition(expression);
expression = substraction(expression);
return expression;
}
fn main() {
println!("Enter an operation to perform: ");
let mut expression = String::new();
std::io::stdin().read_line(&mut expression).unwrap();
expression = do_expression(expression);
println!("Result: {}", expression);
}