{"version":"https:\/\/jsonfeed.org\/version\/1","title":"mathspp.com feed","home_page_url":"https:\/\/mathspp.com\/blog\/tags\/rust","feed_url":"https:\/\/mathspp.com\/blog\/tags\/rust.json","description":"Stay up-to-date with the articles on mathematics and programming that get published to mathspp.com.","author":{"name":"Rodrigo Gir\u00e3o Serr\u00e3o"},"items":[{"title":"TIL #070 \u2013 writing and running tests in Rust","date_published":"2023-07-18T12:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/til\/writing-and-running-tests-in-rust","url":"https:\/\/mathspp.com\/blog\/til\/writing-and-running-tests-in-rust","content_html":"

Today I learned how to write and run tests in the Rust programming language.<\/p>\n\n

Writing a test in Rust<\/a><\/h2>\n

I'm attending a Rust tutorial at EuroPython 2023<\/a> and I just learned how to write and run tests in Rust.\nTurns out it is quite straightforward!<\/p>\n

\n

I'm a Rust beginner!\nI don't know if there are other ways of writing tests, possibly more advanced and\/or more flexible.\nWhat I'm showing is just a simple way of creating tests.<\/p>\n<\/div>\n

Suppose you have a function that determines whether or not a given age corresponds to an adult age in Europe (or, at least, most European countries):<\/p>\n

fn is_adult(age: u8) -> bool {\n    age >= 18\n}<\/code><\/pre>\n
In order to test this function, you create test functions (like you do in pytest<\/code>, for example).\nIn pytest<\/code>, a function is a test function whenever its name starts with test_<\/code>.\nIn Rust, if you add a #[test]<\/code> at the top of the function definition, that function is now a test function.<\/p>\n
Then, similarly to how the keyword assert<\/code> works in Python, you can use the macro assert!<\/code> to check for the test result in Rust.<\/p>\n
Here are a couple of tests for the function is_adult<\/code>, above:<\/p>\n
#[test]\nfn is_adult_is_true_for_adults() {\n    assert!(is_adult(18));\n    assert!(is_adult(19));\n    assert!(is_adult(123));\n}\n\n#[test]\nfn is_adult_is_false_for_kids() {\n    assert!( !is_adult(1) );\n    assert!( !is_adult(17) );\n}<\/code><\/pre>\n
The macro assert!<\/code> expects a Boolean value and it will fail if the Boolean is false<\/code>.<\/p>\n
I know that there is, at least<\/em>, one other assertion macro in Rust.\nassert_eq!<\/code> takes two values, compares them, and if they differ, the test fails.<\/p>\n
Your whole file could look like this:<\/p>\n
fn is_adult(age: u8) -> bool {\n    age >= 18\n}\n\nfn main() {\n    println!(\"What's up?\");\n}\n\n#[test]\nfn is_adult_is_true_for_adults() {\n    assert!(is_adult(18));\n    assert!(is_adult(19));\n    assert!(is_adult(123));\n}\n\n#[test]\nfn is_adult_is_false_for_kids() {\n    assert!( !is_adult(1) );\n    assert!( !is_adult(17) );\n}<\/code><\/pre>\n
How to run your Rust tests<\/a><\/h2>\n
To run your Rust tests, you just use the command cargo test<\/code>.\nThat's it!\nIf you do, you should get output like this:<\/p>\n
\"Command
Output of running Rust tests.<\/figcaption><\/figure>\n
That's it for now! Stay tuned<\/a> and I'll see you around!<\/p>","summary":"Today I learned how to write and run tests in the Rust programming language.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","rust"],"image":"\/user\/pages\/02.blog\/04.til\/070.writing-and-running-tests-in-rust\/thumbnail.webp"},{"title":"TIL #062 \u2013 dbg! macro for debugging in Rust","date_published":"2023-05-05T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/til\/dbg%21-macro-for-debugging-in-rust","url":"https:\/\/mathspp.com\/blog\/til\/dbg%21-macro-for-debugging-in-rust","content_html":"
Today I learned why I should use the dbg!<\/code> macro instead of the println!<\/code> macro for debugging in Rust.<\/p>\n\n
What is the dbg!<\/code> macro in Rust?<\/a><\/h2>\n
The dgb!<\/code> macro is a macro that is similar to println!<\/code> but that is designed specifically for debugging.\nNot only does it print the values you pass it, but it also adds a tag with the name of the file and the line from where the macro was called.<\/p>\n
Here is an example of using the dbg!<\/code> macro:<\/p>\n
fn main() {\n    dbg!(\"hello, world!\");\n}<\/code><\/pre>\n
If you run your program with cargo run<\/code> now, this is what you get:<\/p>\n
\u276f cargo run\n   Compiling borrowing v0.1.0 (\/Users\/rodrigogs\/Documents\/rust\/borrowing)\n    Finished dev [unoptimized + debuginfo] target(s) in 0.10s\n     Running `target\/debug\/borrowing`\n[src\/main.rs:2] \"hello, world\" = \"hello, world\"<\/code><\/pre>\n
Notice the last line of the output, that shows the argument to the macro, along with the line of code from where the macro was called.\nIt may look redundant to have \"hello, world\" = \"hello, world\"<\/code> displayed there, but that is because the macro will show the expression that was used as its argument and<\/em> it will show the value of that expression.<\/p>\n
Here is another example program:<\/p>\n
fn main() {\n    dbg!(3 + 3);\n}<\/code><\/pre>\n
This shows:<\/p>\n
\u276f cargo run\n## ...\n[src\/main.rs:2] 3 + 3 = 6<\/code><\/pre>\n
Or this program:<\/p>\n
fn main() {\n    let x = 3;\n    dbg!(x);\n}<\/code><\/pre>\n
Shows:<\/p>\n
\u276f cargo run\n## ...\n[src\/main.rs:3] x = 3<\/code><\/pre>\n
So, this is how you use the dbg!<\/code> macro in Rust!<\/p>\n
That's it for now! Stay tuned<\/a> and I'll see you around!<\/p>","summary":"Today I learned why I should use the `dbg!` macro instead of the `println!` macro for debugging in Rust.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","rust"],"image":"\/user\/pages\/02.blog\/04.til\/062.dbg!-macro-for-debugging-in-rust\/thumbnail.webp"},{"title":"Write a Python module in Rust","date_published":"2023-05-03T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/write-a-python-module-in-rust","url":"https:\/\/mathspp.com\/blog\/write-a-python-module-in-rust","content_html":"
Learn how to write your first Python module in Rust.<\/p>\n\n
\"\"<\/p>\n
Introduction<\/a><\/h2>\n
I'm not going to open with a long-winded introduction explaining why Rust is so awesome and great.\nI don't know if it is or not.\nI just hear a lot about Rust and I wanted to try and write a Python module in Rust.\nSo, I did!<\/p>\n
Set up<\/a><\/h2>\n
To follow this tutorial, you need to start by installing Rust.\nYou can head over to rust-lang.org<\/a> and follow the installation instructions there.<\/p>\n
Then, we'll use PyO3 to bind Python and Rust together.\nTo make our lives easier, we set everything up through maturin, which I understand simplifies the process a bit.<\/p>\n
Start by creating a virtual environment in a folder for this project:<\/p>\n
$ mkdir rust-factorial\n$ cd rust-factorial\n$ python -m venv .env\n$ source .env\/bin\/activate  # Activate the virtual env.\n$ pip install maturin<\/code><\/pre>\n
After installing maturin, we use the command maturin init<\/code> to create a project.\nWhen asked for it, select the pyo3<\/code> bindings!<\/p>\n
Maturin will go ahead and create a couple of files for you.\nThey'll contain a simple, working example of a Python module written in Rust.<\/p>\n
You can actually see it already works by running the command maturin develop<\/code> and then using the module from Python:<\/p>\n
$ maturin develop\n## lots of progress output as maturin runs the compilation...\n$ python\n>>> import rust_factorial\n>>> rust_factorial.sum_as_string(5, 20)\n'25'<\/code><\/pre>\n
Now, let us write our own Rust code.<\/p>\n
A factorial function in Rust<\/a><\/h2>\n
As my first attempt at writing some Rust code, I decided to write the factorial function.\nBetween some educated guesses and compiler errors, I managed to put this together:<\/p>\n
fn factorial(n: u128) -> u128 {\n    if n <= 1 {\n        return n\n    } else {\n        return n * factorial(n - 1)\n    }\n}<\/code><\/pre>\n
This is the base Rust code I used.<\/p>\n
Then, I need to fit this into the file lib.rs<\/code> that maturin created for me:<\/p>\n
use pyo3::prelude::*;\n\n\/\/\/ Formats the sum of two numbers as string.\n#[pyfunction]\nfn sum_as_string(a: usize, b: usize) -> PyResult<String> {\n    Ok((a + b).to_string())\n}\n\n\/\/\/ A Python module implemented in Rust.\n#[pymodule]\nfn rust_factorial(_py: Python, m: &PyModule) -> PyResult<()> {\n    m.add_function(wrap_pyfunction!(sum_as_string, m)?)?;\n    Ok(())\n}<\/code><\/pre>\n
The function factorial<\/code> is going to replace the function sum_as_string<\/code>, so it looks like it takes some arguments and then it needs to return a data type that is compatible with Python.\nThat's what I gather from the PyResult<String><\/code> result.<\/p>\n
The PyO3 documentation<\/a> tells me I can use Rust integer types inside the PyResult<\/code>, so I tried this:<\/p>\n
use pyo3::prelude::*;\n\nfn factorial(n: u128) -> PyResult<u128> {\n    if n <= 1 {\n        Ok(n)\n    } else {\n        Ok(n * factorial(n - 1))\n    }\n}\n\n#[pymodule]\nfn rust_factorial(_py: Python, m: &PyModule) -> PyResult<()> {\n    m.add_function(wrap_pyfunction!(factorial, m)?)?;\n    Ok(())\n}<\/code><\/pre>\n
Now, this gives me errors, because the recursive function is trying to multiply a regular Rust integer with the PyResult<\/code> thing, so I actually added my original, 100% Rust function as _factorial<\/code>, and then...<\/p>","summary":"Learn how to write your first Python module in Rust.","date_modified":"2025-07-23T16:49:02+02:00","tags":["programming","python","rust"],"image":"\/user\/pages\/02.blog\/write-a-python-module-in-rust\/thumbnail.webp"}]}