Understanding Rust Closures

Niranjana — Fri, 07 Aug 2020 11:40:49 +0000

Closures are very interesting programming concepts. It helps save a lot of expensive calculations while writing programs.
Closure syntax of Rust is very similar to that of Ruby and SmallTalk.

Rust’s closures are anonymous functions you can save in a variable or pass as arguments to other functions. You can create the closure in one place and then call the closure to evaluate it in a different context. Unlike functions, closures can capture values from the scope in which they’re defined.

Closures are usually short and relevant only within a narrow context rather than in any arbitrary scenario. Within these limited contexts, the compiler is reliably able to infer the types of the parameters and the return type, similar to how it’s able to infer the types of most variables.

Closures don’t require you to annotate the types of the parameters or the return value like fn functions do. Type annotations are required on functions because they’re part of an explicit interface exposed to your users. Defining this interface rigidly is important for ensuring that everyone agrees on what types of values a function uses and returns. But closures aren’t used in an exposed interface like this: they’re stored in variables and used without naming them and exposing them to users of our library.

Let us dive into when to use closures. As mentioned in the definition, they are used at places when you need to call functions several times or repeat a value from a function call.

Consider the following snippet. This piece helps to explain how closures work and most importantly how and where to apply closures.



``` rust
 fn main() {
    let fact = |x| -> usize { (2..=x).product() };
    
    let five_fact = fact(5);
    
    println!("{}", five_fact);
    
    println!("{}", fact(8));

}

```

One of the first functions we write in any programming language is that of a factorial calculator. The code above is pretty much self-explanatory. Instead of defining the function, we have used anonymous functions, i.e, closures.

Minigrep : grep using Rust

Niranjana — Thu, 23 Jul 2020 05:12:02 +0000

grep (Global Regular Expression Print)is a command-line utility for searching plain-text data sets for lines that match a regular expression.
Minigrep is a simple rust program that recreates the basic functions of grep alongside providing few more addition features:
1.Case-insensitive search can be done by passing an option.
2.Ability to do exact-match search.
3.The query is highlighted in the output.

The aim of the program is to be able to search for word in a given a text file. It goes by the following format:



```shell
CASE_INSENSITIVE=1 cargo run “word to be searched” “filename” > “output file”
```

Miniproject follows Test-driven development (TDD) process. This is a software development technique that uses the method of writing a test that fails for a reason expected and later modifying the code to make new test pass. This is followed by refactoring the code and continuing to ensure that the tests pass. Writing the test before you write the code that makes the test pass helps to maintain high test coverage throughout the process.
The logic behind Minigrep can be explained with its main struct and run function.



```rust
//struct
pub struct Config {
pub query: String,
pub filename: String,
pub case_sensitive: bool,
}
//run function
pub fn run(config: Config) -> Result> {
let contents = fs::read_to_string(config.filename)?;
let results = if config.case_sensitive {
search(&config.query, &contents)
} else {
search_case_insensitive(&config.query, &contents)
};
for line in results {
println!(“{}”, line);
}
Ok(())
}
```

The program can be broken down into 5 parts:
1.Accepting command line arguments
2.Reading a file
3.Writing tests an developing library
4.Setting up environment variable
5.Writing error messages to standard error
6.Throughout these steps, we use refactoring to make the
program more efficient.
For instance, the program began with the basic lines of code



```rust
use std::env;
fn main() {
 let args: Vec = env::args().collect();
let query = &args[1];
let filename = &args[2];
println!(“Searching for {}”, query);
 println!(“In file {}”, filename);
}
```

This was further developed into a struct seeing repetitions. The query and filename along with case sensitive boolean were added to the structure Config.
To see more of how the logic panned into run() function, the tests and library along with directions of use, please find the source code on GitHub.

Forem: Niranjana

Understanding Rust Closures

Minigrep : grep using Rust