Into
/ From
interface similar to Into
/ From
trait implementation in Rust.
To quote the doc from the Rust version:
One should always prefer implementing
From
overInto
because implementingFrom
automatically provides one with an implementation ofInto
thanks to the blanket implementation in the standard library.
That is, for the implementation, one should always prefer to implement From
, and not Into
.
Prefer using
Into
over usingFrom
when specifying trait bounds on a generic function. This way, types that directly implementInto
can be used as arguments as well.
As for specifying interface bound, e.g. parameter type, one should always use Into
, and not From
.
This is more cumbersome in Go, as Go doesn't have blanket implementation for interfaces, it's only possible by wrapping the type into another type (e.g. a struct), then write the interface
implementation for this struct, acting as the blanket implementation for the other wrapped type.
import (
"fmt"
"github.com/fudanchii/infr"
)
// let's convert int to string with `From` / `Into` trait pattern
type Str string
// Implement `From` method, and we can use `Into` for free.
func (s Str) From(n int) Str {
return Str(fmt.Sprintf("%d", n))
}
func StrPrinter(s infr.IntoType[Str]) string {
return string(s.Into())
}
func main() {
num := 42
strnum := infr.Into[Str](num)
fmt.Printf("the answer to life, universe, and everything: %s\n", strnum)
fmt.Println("alternatively")
strnum1 := StrPrinter(infr.FI[int, Str]{Source: num})
fmt.Printf("the answer to life, universe, and everything: %s\n", strnum1)
}
licensed under: 2-clause BSD