You are a pragmatic Rust programmer. Given the following question, and rust function, write three unit tests for the function. The tests should be a simple line delimited list of assert! or assert_eq! statements.

For example, if the function is:

```rust
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

The unit tests should be

```rust
assert_eq!(add_nums(1, 2), 3);
assert_eq!(add_nums(10, 2), 12);
assert_eq!(add_nums(-10, 2), 8);
```

Make the tests simple and easy to understand. The code should pass `cargo build` and `cargo clippy` and `cargo test`. Do not add a main function or any other code. Respond with only the assert statements and nothing else.

============

Question:
{rust_prompt}

Code:
{rust_code}

Unit Tests:

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else.

Question:
{rust_prompt}

Code:

The following prompt may have Python syntax, variable types, and pythonic behavior mentioned. Translate the question to the appropriate Rust syntax and replace anything mentioning Python with Rust. 

Do NOT use or mention:
* &'static str
* <&dyn Any>
* lifetimes
* Advanced rust objects
* External libraries

Make sure to use:
* Simple types, i32, f32, String, etc

Only return the translated question and do not answer the question.

Python Prompt:
{text}

You are a pragmatic Rust programmer. Given the following question, and rust function, write three unit tests for the function. The tests should be a simple line delimited list of assert! or assert_eq! statements.

For example, if the function is:

```rust
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

The unit tests should be

```rust
assert_eq!(add_nums(1, 2), 3);
assert_eq!(add_nums(10, 2), 12);
assert_eq!(add_nums(-10, 2), 8);
```

Make the tests simple and easy to understand. The code should pass `cargo build` and `cargo clippy` and `cargo test`. Do not add a main function or any other code. Respond with only the assert statements and nothing else.

============

Question:
{rust_prompt}

Code:
{rust_code}

Unit Tests:

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else.

Question:
{rust_prompt}

Code:

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else.

Question:
{rust_prompt}

Code:

The following prompt may have Python syntax, variable types, and pythonic behavior mentioned. Translate the question to the appropriate Rust syntax and replace anything mentioning Python with Rust. 

Do NOT use or mention:
* &'static str
* <&dyn Any>
* lifetimes
* Advanced rust objects
* External libraries

Make sure to use:
* Simple types, i32, f32, String, etc

Only return the translated question and do not answer the question.

Python Prompt:
{text}

You are a pragmatic Rust programmer who enjoys test driven development. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else. Be careful with your types, and try to limit yourself to the basic built in types and standard library functions. When writing the function you can think through how to solve the problem and perform reasoning in the comments above the function.

Then write unit tests for the function you defined. Write three unit tests for the function. The tests should be a simple line delimited list of assert! or assert_eq! statements. When writing the unit tests you can have comments specifying what you are testing in plain english.


An example output should look like the following:

```rust
/// Reasoning goes here
/// and can be multi-line
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

```tests
// Test adding small positive numbers
assert_eq!(add_nums(1, 2), 3);
// Test adding two negative numbers
assert_eq!(add_nums(-10, -2), -14);
// Test adding a positive and a negative number
assert_eq!(add_nums(-10, 2), 8);
```

Make sure to only respond with two blocks, a ```rust``` block and a ```tests``` block.

Here is the question:
{rust_prompt}

You are a pragmatic Rust programmer who enjoys test driven development. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else. Be careful with your types, and try to limit yourself to the basic built in types and standard library functions. When writing the function you can think through how to solve the problem and perform reasoning in the comments above the function.

Then write unit tests for the function you defined. Write three unit tests for the function. The tests should be a simple line delimited list of assert! or assert_eq! statements. When writing the unit tests you can have comments specifying what you are testing in plain english.


An example output should look like the following:

```rust
/// Reasoning goes here
/// and can be multi-line
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

```tests
// Test adding small positive numbers
assert_eq!(add_nums(1, 2), 3);
// Test adding two negative numbers
assert_eq!(add_nums(-10, -2), -14);
// Test adding a positive and a negative number
assert_eq!(add_nums(-10, 2), 8);
```

Make sure to only respond with two blocks, a ```rust``` block and a ```tests``` block.

Here is the question:
{rust_prompt}

You are a pragmatic Rust programmer. Given the following question, and rust function, write three unit tests for the function. The tests should be a simple line delimited list of assert! or assert_eq! statements.

For example, if the function is:

```rust
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

The unit tests should be

```rust
assert_eq!(add_nums(1, 2), 3);
assert_eq!(add_nums(10, 2), 12);
assert_eq!(add_nums(-10, 2), 8);
```

Make the tests simple and easy to understand. The code should pass `cargo build` and `cargo clippy` and `cargo test`. Do not add a main function or any other code. Respond with only the assert statements and nothing else.

============

Question:
{rust_prompt}

Code:
{rust_code}

Unit Tests:

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Try to limit library usage to the standard library std. Respond with only the Rust function and nothing else.

Question:
{rust_prompt}

Code:

The following prompt may have Python syntax, variable types, and pythonic behavior mentioned. Translate the question to the appropriate Rust syntax and replace anything mentioning Python with Rust. 

Do NOT use or mention:
* &'static str
* <&dyn Any>
* lifetimes
* Advanced rust objects
* External libraries

Make sure to use:
* Simple types, i32, f32, String, etc

Only return the translated question and do not answer the question.

Python Prompt:
{prompt}

Rust Prompt:

You are a pragmatic Rust programmer. Given the following question, and rust function, write three unit tests for the function. The tests should be a simple line delimited list of assert statements.

For example, if the function is:

```rust
fn add_nums(x: i32, y: i32) -> i32 {
  x + y
}
```

The unit tests should be

```rust
assert_eq!(add_nums(1, 2), 3);
assert_eq!(add_nums(10, 2), 12);
assert_eq!(add_nums(-10, 2), 8);
```

Make the tests simple and easy to understand. The code should pass `cargo build` and `cargo clippy` and `cargo test`. Do not add a main function or any other code. Respond with only the assert! statements and nothing else.

============

Question:
{rust_prompt}

Code:
{rust_code}

Unit Tests:

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand. The code should pass `cargo build` and `cargo clippy`. Do not add a main function. Respond with only the rust function and nothing else.

Question:
{rust_prompt}

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand.Do not add a main function. Respond with only the rust function and nothing else.

Question:
{rust_prompt}

You are a pragmatic Rust programmer. Given the following question, write a Rust function to complete the task. Make the code simple and easy to understand.Do not add a main function. Respond with only the rust function and nothing else.

Question:
{rust_prompt}

The following prompt may have python syntax, variable types, and pythonic behavior mentioned. Translate the question to the appropriate rust syntax and replace anything mentioning python with rust. 

Only return the translated question and do not answer the question.

Prompt:
{prompt}

Rust Version:

You are a programmer refactoring Python to Rust. You are given a problem statement, rust code, and example tests in python. Translate the following assert statements from unit tests from Python to Rust syntax. Be careful and translate the functionality of the code clearly. If the rust type system does not match the python functionality, implement the problem with the most simple rust data structures.

Only respond with the assert statements and nothing else.

Problem Statement:
{text}

Rust Code:
{rust_code}

Python Tests:
{test_list}

Rust Tests:

You are a programmer refactoring Python to Rust. Translate the following assert statements from unit tests from Python to Rust syntax. Be careful and translate the functionality of the code clearly. If the rust type system does not match the python functionality, implement the problem with the most simple rust data structures.

Only respond with the assert statements and nothing else.

Python Tests:
{test_list}

Rust Tests:

You are a programmer refactoring python to rust. Given the following description for what the code does, translate the code from python to rust. Be careful and translate the functionality of the code clearly. If the rust type system does not match the python functionality, implement the problem with the most simple rust data structures. Do not add a main function. Respond with only the code and nothing else.

Description:
{text}

Python Code:
{code}

Rust Code:

You are a programmer refactoring python to rust. Given the following description for what the code does, translate the code from python to rust. Be careful and translate the functionality of the code clearly. If the rust type system does not match the python functionality, implement the problem with the most simple rust data structures. Do not add a main function. Respond with only the code and nothing else.

Description:
{text}

Python Code:
{code}

Rust Code:

You are a programmer refactoring python to rust. Given the following description for what the code does, translate the code from python to rust. Be careful and translate the functionality of the code clearly. If the rust type system does not match the python functionality, implement the problem with the most simple rust data structures. Do not add a main function. Respond with only the code and nothing else.

Description:
{text}

Python Code:
{code}

Rust Code:

Translate the following unit tests from Python to Rust syntax. Only respond with the proper Rust syntax with the assert statements.

Python Tests:
{test_list}

Rust Tests:

Translate the following code from python to rust. Respond with only the code and nothing else.

Python Code:
{code}

Rust Code:

In the following text, replace the word "python" with "rust" if it exists, and if the text does not mention rust, modify it to specify we want a rust function. Return the modified text and nothing else.

Text:
{text}