Effective Interfaces In Golang

Will — Sun, 13 Dec 2020 02:37:34 +0000

In go interfaces are useful to use in functions that you want to support multiple types

To start we need to create a function

func hello() {

}

I want this function to be able to take strings, ints, and floats. How would I do this?

With an interface{} parameter

func hello(s interface{}) {

}

Now how to add handling for the types that you may find in an interface with a switch statement.

func hello(s interface{}) {
    switch s.(type) {
        case int:
            fmt.Printf("%d", s.(int))
        case float64:
            fmt.Printf("%d", s.(float64))
        case string:
            fmt.Printf("%s", s.(string))
        default:
            fmt.Printf("No handling for this type")
    }
}

This is an easy way to add handling for interface types using a switch statement.

Know that s.(type) can only be used within a switch statement.

You may notice the use of s.(int) and s.(string) This is simply telling the compiler that you would like to use the interface as a string or the interface as an int so that you can use functions that are associated with said type.

I hope that clears up some confusion about go interfaces

How to operator overload in Rust.

Will — Thu, 03 Dec 2020 05:55:41 +0000

In Rust, types that have certain traits implemented for them are able to be added, subtracted, multiplied, divided, and much more from each other.

In order to operator overload custom types one must implement these traits for their types.

The traits in question come from the standard library at std::ops::*; and can be implemented by doing the following...

First let's create two structs that we can use.

struct Foo(i32);
struct Bar(i32);

Don't forget to use the traits from the standard library.
(You do not have to use them but for convenience I will import them)

use std::ops::{Add};

struct Foo(i32);
struct Bar(i32);

For the purposes of this I will only show adding. After you learn adding the rest should be easy to implement.

Next let's implement these traits that we just imported for our structs.

impl Add<Bar> for Foo {
   /// Todo
}

Above you can see how we implemented Add for the struct Foo + Bar. Now we just have to add the functionality.

impl Add<Bar> for Foo {
    type Output = i32;
    fn add(self, b: Bar) -> i32 {
        self.0 + b.0
    }
}

That is all for adding now to see how it works.

The first thing that might look odd is the type Output, this is simply because if you have a trait and you want the implementor to be able to add any return type to a function within the trait you have to set the return type to a type you create that the implementor can then go and change.

The other thing that might seem odd is that we are creating a function called add, add is already defined within the Add trait, we are simply adding new code to the inside of it so that it works for out type, to do that we have to create the function within our scope.

Let's see if it works now!

fn main() {
    let f = Foo(10);
    let b = Bar(20);
    println!("{}", f + b);
}

Now when you cargo r your program you should get an output of 30!

That is how you operator overload in Rust.

DEV Community: Will

Effective Interfaces In Golang

In go interfaces are useful to use in functions that you want to support multiple types

I hope that clears up some confusion about go interfaces

How to operator overload in Rust.