Forem: Joaquín Caro

Discovering Rust

Joaquín Caro — Mon, 02 Nov 2020 14:44:01 +0000

Being a developer it is easy to jump on the hype train and try to learn or even use in pet projects the latest libraries, frameworks and why not programming languages.
In a sector where everything evolves at a very high speed, sometimes it is difficult to keep the focus and not go crazy with the constant changes.
In my case, I like to read and practice different programming languages and the more the better, because they bring different visions of how to solve problems and even give you more tools for your day to day. And today’s article is about Discovering Rust.

Why Rust??

In one of the lunch & learn that we do in Apiumhub, a colleague gave me an idea to migrate an internal client that we have in pure bash to some other language and as candidates were Go and Rust, as between us we did not agree, we decided that each would choose a language and make its port.

The result was that that client never migrated, but along the way, both of us were able to discover the advantages and disadvantages of languages like GO and Rust.

From that moment on, I was hooked on Rust and desperate since then, any personal project or proof of concept or idea that I can think of, I try to go first with Rust.

What is Rust?

Rust is based on three pillars:

Performance, fast and efficient with memory, no runtime or Garbaje collector.
Reliability, ownership model guarantee memory-safety and thread-safety.
Productivity, great documentation, a compiler that in most cases tells you how to do it and gives you references to the documentation so you understand the problem and a tool that serves as a package manager, code formatter, improvement and suggestions.

Rust began by defining itself as a systems language, but over time that definition has been disappearing, there are more and more libraries for web, GUI , games and of course for systems!

The first thing that you think when you read “system language” is… I will have to deal with pointers, I will have to work releasing and assigning memory, I will have to work at a very low level without abstractions and of course… if it is not your day to day because it is scary to return to the origins of C C++, but the great majority of these fears are very well resolved and by the compiler! with which it facilitates the way a lot to us.

In this article we will see some basic concepts of rust and some of its features that under my point of view make it a very attractive language.

Rust Concepts

Rust has a wide range of primitive types
Rust bets on immutability, therefore, all declared variables are immutable unless they are specified with the keyword mut at the time of declaration.
The same happens with visibility, everything is private and in the case that you want to make it public you will do it with the keyword pub.
In the case of functions we can specify the keyword return to indicate that it is the value to be returned from the function or if the last sentence does not include the ; it will become the return of the function.
Rust has a very complete type inference and we rarely need to specify the type of variable we are creating.
Other features that give Rust a plus are the Generic types, Pattern matching, Macro system and many concepts of functional programming such as first-class functions, closures, Iterators

let name = "Jon".to_string(); // String type
let year = 2020; // i32 type
let age: u8 = 35;

let mut index = 0; //mutable variable
index = index +=1; 

let add_one = |x: i32| x + 1; //closure
let two = add_one(1);

let numbers = vec![1, 2, 3, 4, 5, 6];
let pairs: Vec<i32> = numbers.into_iter()
        .filter(|n| n % 2 == 0)
        .collect(); // [2, 4, 6]

fn greet(name: String) {
    println!("hello {}", name);
}
pub fn plus_one(x: i32) -> i32 {
    return x + 1; 
}
pub fn plus_two(x: i32) -> i32 {
    x + 2 
}

Ownership, borrowing & lifetimes

These three concepts are the greatest complexity that we will find in Rust, since they are concepts that in languages with QA it is the QA itself that treats them making it transparent for the developer.

As it does not have an associated runtime or a Garbage Collector that frees the memory of the objects it does not use, all this is handled by the compiler with the help of the ownership,
Although the concept is suitable for more than one article, let’s see the basics of the concept with some examples.

Each value has an assigned variable (owner) and there can only be one owner at a time, when that owner is out of scope the value will be released.

So we have the following example:

fn main() {
    let name = "Jon".to_string();
    greet(name);
    println!("goodbye {}", name); //^^^^ value borrowed here after move
}

fn greet(name:String) {
    println!("hello {}", name);
}

The compiler is telling us that the owner of the variable name has been passed to the greet function, so after running greet it is no longer in that scope. To solve it is as simple as indicating that what we want is to lend the owner, so that when the function ends, get the owner again, and that is indicated with &

fn main() {
    let name = "Jon".to_string();
    greet(&name);
    println!("goodbye {}", name);
}

fn greet(name:&String) {
    println!("hello {}", name);
}

The lifetime is a check of the management of ownership and borrowing of the values, most of the times the compiler knows how to interpret it, but sometimes it is necessary to detail it. Without going into too much detail since the same as the ownership and borrowing, gives for a series of articles.

Structs

Structs exist to define our own types, they are created with the keyword struct and have no associated behavior.

To give behavior to a struct it will be done with the keyword impl.

struct Point {
    x: f32,
    y: f32,
}
impl Point {
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}
let point1 = Point {
  x: 10.0,
  y: 20.0,
};

let point2 = Point {
  x: 5.0,
  y: 1.0,
};

let point3 = point1.add(point2); //Point { x: 15.0, y: 21.0 }

In the Point implementation the add method receives as parameter self, this is because that method is of instance, if we don’t want to do it of instance it is as simple as removing the self

Traits

The Rust Traits are a collection of methods defined to be implemented by Structs, they are similar to the interfaces of other languages.

pub trait Summary {
    fn summarize(&self) -> String;
}

pub struct NewsArticle {
    pub headline: String,
    pub location: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize(&self) -> String {
        format!("{}, by {} ({})", self.headline, self.author, self.location)
    }
}

pub struct Tweet {
    pub username: String,
    pub content: String,
    pub reply: bool,
    pub retweet: bool,
}

impl Summary for Tweet {
    fn summarize(&self) -> String {
        format!("{}: {}", self.username, self.content)
    }
}

Enums

We can create enums, without value, with value or even have each enum have values of different types.

enum IpAddrKind {
    V4,
    V6,
}

enum IpAddr {
    V4(String),
    V6(String),
}

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

This is where pattern matching and destructuring play a very important role in managing enums

Alias

In Rust we can create our aliases for existing types

type Second = u64;
let seconds: Second = 10;

Adding functionality to Types once they are defined

In some programming languages it is possible to add methods (extension methods) to classes once they have been defined, in Rust this would not be less! First we will create the path with the method that we want to use, then we will implement the path previously created to the type that we want to extend.

pub trait Reversible {
    fn reverse(&self) -> Self;
}

impl Reversible for String {
    fn reverse(&self) -> Self {
        self.chars()
            .rev()
            .collect::<String>()
    }
}

let hello = String::from("hello");
println!("{}",hello.reverse()); // olleh

Operator Overload

Imagine being able to apply arithmetic operations to your own types, following the example before the struct point, being able to add Points with the simple + operator. In Rust this is possible by overloading the operators, which is the same again, implement traits for the types.
Here are all the possible operators to overload

struct Point {
    x: f32,
    y: f32,
}

impl std::ops::Add for Point { // implement Add trait for Point
    type Output = Self;

    fn add(self, other: Self) -> Self { //implement add function
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

let point1 = Point { x: 10.0, y: 20.0};

let point2 = Point {x: 5.0, y: 1.0};

let p = point1 + point2; // apply add trait

Question mark operator

It is very common to see the handling of errors in Rust through the type Result being T the value of OK and E the one of the error, and the handling of this type is done through pattern matching. Let’s
imagine that we want to read the content of a file, for it we will use the function read_to_string of the module fs, the result of this function is a Result.

let content = fs::read_to_string("filename");
match content {
    Ok(file_content) => { println!("{}", file_content) }
    Err(e) => { println!("Error reading file: {}", e) }
}

By means of pattern matching we have dealt with both possible cases of the result. For this example we only wanted to print it by console, but imagine that you want to treat that content, the code becomes a little more complex, for these cases in Rust there is the ? operator with which we directly obtain the value of the Result if it has gone well and if not directly the error will be returned as return of the function. But in order to use the ? operator the method signature has to return a type Result

fn get_content() ->  Result<String, Error>{
    let content = fs::read_to_string("filename")?;
    println!("{}", content);
    Ok(content)
}

If the reading of the file fails, it will automatically return the Error trace, otherwise the code will continue to be executed until it returns the Result ok of the content.

Type Conversion

Another very interesting feature is the type conversion that can be applied in Rust only by implementing the Trait std::convert::From

The clearest use case is a function where you handle different types of errors but the return of your function you want it to be in the case of error a mistake of yours, of your domain, through pattern matching we could go hunting all the results and creating the Results of our type, but it would make our code difficult to maintain and not very readable.

Using the ? operator and type conversion would look like this:

fn get_and_save() -> Result<String, DomainError> {
    let content:  Result<String,HttpError> = get_from_http()?; 
    let result: Result<String,DbError> = save_to_database(content)?; 
    // with ? operator in case of error, the return of the function will be Result of Error
    Ok(result)
}

pub struct DomainError {
    pub error: String,
}

impl std::convert::From<DbError> for DomainError {
    fn from(_: DbError) -> Self {
        DomainError {
            error: (format!("Error connecting with database")),
        }
    }
}

impl std::convert::From<HttpError> for DomainError {
    fn from(_: HttpError) -> Self {
        DomainError {
            error: (format!("Error connecting with http service")),
        }
    }
}

Cargo & utilities

And if we talk about Rust, we can’t leave out your package manager position, which comes with the Rust installation itself.

With cargo we can create a project from scratch, manage the dependencies, generate the release, launch the tests, generate the documentation, publish the package to the registry…

In addition there is a large list of third party commands available

Resources

Although Rust was created by Mozilla, rust is maintained by the community, it is the community itself that proposes the changes and adapts the language to the needs.

Some of the most interesting links to follow in order to keep up with the news:

rust-lang.slack](rust-lang.slack.com): Slack in which all language issues are discussed with a lot of help for those who are new to the language.

Weekly: Weekly newsletter with news about language changes, interesting articles and conferences/talks.

youtube: official Rust channel where conferences, meetings of the different working groups formed for language development are posted.

Discord: Discord server where most of the working groups are coordinated to maintain the language.

The Rust Book: Documentación oficial sobre Rust, todo lo que debes de saber sobre el lenguaje está en el libro.

And a couple of personal projects with which I’m putting into practice everything I’m reading about Rust

Adh : is a docker client, ported from the original ApiumHub with the commands I use most in my daily life, there are still many features to be added.

Covid-bot: is a telegram bot developed on rust to keep track of covid-19

Originally published at Apiumhub

Be more functional in java with Vavr

Joaquín Caro — Wed, 06 May 2020 10:30:14 +0000

With the release of java 8 a new paradigm was discovered in the development with java, but the question arises – is it enough? And what if we could have other functionalities of more purely functional languages in java? To meet these needs vavr was invented with the mission of reducing the code making it more readable and adding robustness with the immutability of the data. And in this article, we will see how to be more functional in java with vavr.

Vavr among other things includes immutability in lists and functions to work with them, it also includes some of the monads most used in other languages, more functional, currying and partial application in functions.

Functions

Composition

With the arrival of java 8 the concept of Function and BiFunction was included, with which we can define functions of one or two input parameters, for example:

Function<Integer, Integer> pow = (n) -> n * n;
assertThat(pow.apply(2)).isEqualTo(4);

BiFunction<Integer, Integer, Integer> multiply = (a, b) -> a * b;
assertThat(multiply.apply(10, 5)).isEqualTo(50);

With vavr we can have functions up to 8 parameters with the FunctionN types

Function1<Integer, Integer> pow = (n) -> n * n;
assertThat(pow.apply(2)).isEqualTo(4);

Function3<Integer, Integer, Integer, Integer> multiply = (n1, n2, n3) -> n1 * n2 * n3;
assertThat(multiply.apply(5, 4, 3)).isEqualTo(60);

Besides being able to create functions of up to 8 input parameters, it also offers us the composition of functions with operations .andThen .apply and .compose

Function1<String, String> toUpper = String::toUpperCase;
Function1<String, String> trim = String::trim;
Function1<String, String> cheers = (s) -> String.format("Hello %s", s);
assertThat(trim
            .andThen(toUpper)
            .andThen(cheers)
            .apply("   john")).isEqualTo("Hello JOHN");

Function1<String, String> composedCheer = cheers.compose(trim).compose(toUpper);
assertThat(composedCheer.apply(" steve ")).isEqualTo("Hello STEVE");

Lifting

With lifting what we get is to deal with the exceptions when composing the functions, with which the function will return an Option.none in case that an exception and Option.some, in case everything has gone correctly.

This is very useful when composing functions that use third-party libraries that can return exceptions.

Function1<String, String> toUpper = (s) -> {
    if (s.isEmpty()) throw new IllegalArgumentException("input can not be null");
    return s.toUpperCase();
};
Function1<String, String> trim = String::trim;
Function1<String, String> cheers = (s) -> String.format("Hello %s", s);
Function1<String, String> composedCheer = cheers.compose(trim).compose(toUpper);

Function1<String, Option<String>> lifted = Function1.lift(composedCheer); assertThat(lifted.apply("")).isEqualTo(Option.none());
assertThat(lifted.apply(" steve ")).isEqualTo(Option.some("Hello STEVE"));

Partial application

With the partial application we can create a new function by setting n parameters to an existing one, where n will always be less than the arity of the original function and the return will be an original arity function – parameters set

Function2<String, String, String> cheers = (s1, s2) -> String.format("%s %s", s1, s2);
Function1<String, String> sayHello = cheers.apply("Hello");
Function1<String, String> sayHola = cheers.apply("Hola");

assertThat(sayHola.apply("Juan")).isEqualTo("Hola Juan");
assertThat(sayHello.apply("John")).isEqualTo("Hello John");

We have defined a generic cheers function that accepts two input parameters, we have derived this to two new sayHello and sayHola applying it partially, and we already have two more specific ones to say hello and we could derive more cases if we needed them.

Currying

Currying is the technique of decomposing a function of multiple arguments into a succession of functions of an argument.

 Function3<Integer, Integer, Integer, Integer> sum = (a, b, c) -> a + b + c;

        Function1<Integer, Function1<Integer, Integer>> add2 = sum.curried().apply(2);

        Function1<Integer, Integer> add2And3 = add2.curried().apply(3);
        assertThat(add2And3.apply(4)).isEqualTo(9);

Memoization

One of the premises of the functional programming is to have pure functions, without side effects, this basically means that a function passing the same arguments always has to return the same result.

Therefore, if it always returns the same thing, why not cache it? because this is the mission of memoization, caching the inputs and outputs of the functions to only launch them once.

void memoization() {
        Function1<Integer, Integer> calculate = 
            Function1.of(this::aVeryExpensiveMethod).memoized();

        long startTime = System.currentTimeMillis();
        calculate.apply(40);
        long endTime = System.currentTimeMillis();
        assertThat(endTime - startTime).isGreaterThanOrEqualTo(5000l);

        startTime = System.currentTimeMillis();
        calculate.apply(40);
        endTime = System.currentTimeMillis();
        assertThat(endTime - startTime).isLessThan(5000l);


        startTime = System.currentTimeMillis();
        calculate.apply(50);
        endTime = System.currentTimeMillis();
        assertThat(endTime - startTime).isGreaterThanOrEqualTo(5000l);

    }

    private Integer aVeryExpensiveMethod(Integer number) {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return number * number;
    }

Monads

Try

The monad Try includes an execution capturing of a possible exception, its two possible return values are the case of failure by exception or the value if it has gone well.

Some useful methods of the Try are:

.isSuccess () -> as the name itself indicates, returns a boolean by checking if it is a success.

.isFailure () -> returns a boolean by checking if it is a failure.

get () -> get the value in case it has gone correctly, if a get is made and it is not checked if it done without checking if it is success, it will drop the exception.

map () -> map over the value in case it went well, if it is a failure it will not be executed.

getOrElse (T) -> which allows to return a default value in the case of error.

getOrElse (Supplier) -> which allows to pass another function in the case of error.

recover (throwable -> {}) -> Same as getOrElse but in this case we will have the exception that has been thrown to be able to achieve it or to be able to return different values depending on the type of exception.

Function2<Integer, Integer, Integer> divide = (n1, n2) -> n1 / n2;

assertThat(Try.of(() -> divide.apply(10, 0)).isFailure()).isTrue();

assertThat(Try.of(() -> divide.apply(10, 5)).isSuccess()).isTrue();

assertThat(Try.of(() -> divide.apply(10, 5)).get()).isEqualTo(2);

assertThat(Try.of(() -> divide.apply(10, 0)).getOrElse(0)).isEqualTo(0);

Lazy

Lazy is a monad about a Supplier to whom memoization is applied the first time it is evaluated.

Lazy<List<User>> lazyOperation = Lazy.of(this::getAllActiveUsers);
assertThat(lazyOperation.isEvaluated()).isFalse();
assertThat(lazyOperation.get()).isNotEmpty();
assertThat(lazyOperation.isEvaluated()).isTrue();

Either

Either represents a value of two types, Left and Right being by convention, putting the value in the Right when it is correct and in the Left when it is not.

Always the result will be a left or a right, it can never be the case that they are both.

Data structures

Immutable lists

If one of the principles of functional programming is immutability, what happens when we define a list and add items? Well, we are mutating it.

Vavr provides a specialization of List, which once created cannot be modified, any operation of adding, deleting, replacing, will give us a new instance with the changes applied.

import io.vavr.collection.List;
...

//Append
List<Integer> original = List.of(1,2,3);
List<Integer> newList = original.append(4);
assertThat(original.size()).isEqualTo(3);
assertThat(newList.size()).isEqualTo(4);

//Remove
List<Integer> original = List.of(1, 2, 3);
List<Integer> newList = original.remove(3);
assertThat(original.size()).isEqualTo(3);
assertThat(newList.size()).isEqualTo(2);

//Replace
List<Integer> original = List.of(1, 2, 4);
List<Integer> newList = original.replace(4,3);
assertThat(original).contains(1,2,4);
assertThat(newList).contains(1,2,3);

Besides the immutability, it also provides direct methods to operate with the list without going through the stream, get the minimum, maximum, average value .. for more information about what this list offers you, check javadoc.

And these are the main features that Vavr offers us, however, there are some more that help us to be more functional in a language like java with vavr.

Originally published at Apiumhub

Rust Overload Add operator

Joaquín Caro — Wed, 06 May 2020 07:30:52 +0000

Can you imagine being able to perform arithmetic operations with your own types in java? to have two Money instances and add between them?
Well in Rust it is possible! Let's see a simple example of how to implement it.

For our example, we want to be able to add amounts of the same currency, for that we will create the ValueObject Money

#[derive(Debug, PartialEq)]
enum Currency {DOLLAR, EURO}

#[derive(Debug, PartialEq)]
struct Money {
    currency: Currency,
    amount: u8,
}

Now what we would like is to be able to add Money without having to add the internal amount and creating a Money again.
In Rust it is as simple as implementing the std :: ops :: Add trait for our struct:

impl std::ops::Add for Money {
    type Output = Self;

    fn add(self, other: Self) -> Self {
        Money {
            currency: self.currency,
            amount: self.amount + other.amount,
        }
    }
}

in this way we could already add Money to each other:

#[test]
fn should_add_money_with_same_currency() {
    let ten_dollars = Money {
        currency: Currency::DOLLAR,
        amount: 10,
    };
    let five_dollars = Money {
        currency: Currency::DOLLAR,
        amount: 5,
    };
    let fifteen = Money {
        currency: Currency::DOLLAR,
        amount: 15,
    };
    assert_eq!(ten_dollars + five_dollars, 
               fifteen);
}

But of course ... what if we are adding dollars to euros? with this implementation the sum would be incorrect, so in our case what we want is that the result of the sum is a Result Type.
For that case, we are going to change our implementation of the Add so that the output becomes a Result instead of a Money

impl std::ops::Add for Money {
    type Output = Result<Self, &'static str>;

    fn add(self, money: Self) -> Self::Output {
        if  money.currency != self.currency {
            return Err("Can not operate with different currencies")
        }
        Ok(Money {
            currency: self.currency,
            amount: self.amount + money.amount,
        })
    }
}

#[test]
fn should_add_money_with_same_currency() {
    let ten_dollars = Money {
        currency: Currency::DOLLAR,
        amount: 10,
    };
    let five_dollars = Money {
        currency: Currency::DOLLAR,
        amount: 5,
    };
    let fifteen = ten_dollars + five_dollars;
    assert!(fifteen.is_ok(),true);
    assert_eq!(fifteen.ok().unwrap().amount,15);
}

#[test]
fn should_not_allow_add_money_with_different_currency() {
    let ten_dollars = Money {
        currency: Currency::DOLLAR,
        amount: 10,
    };
    let five_euros = Money {
        currency: Currency::EURO,
        amount: 5,
    };
    let fifteen = ten_dollars + five_euros;
    assert!(fifteen.is_err(),true);
}

Add operator It is not the only operator that we have available to overload it in rust, the complete list can be seen in the documentation

The complete code example can be downloaded at github or run it on Rust Playground

Originally published at blog.joaquin-caro.es