Skip to content
master
Go to file
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

README.md

go-typeconv - Bring implicit type conversion into Go in a explicit way

Build Status Go Report Card Coverage LICENSE

Go doesn't have implicit type conversion.

Unlike in C, in Go assignment between items of different type requires an explicit conversion. -- Type conversions https://tour.golang.org/basics/13

FAQ: Why does Go not provide implicit numeric conversions? https://golang.org/doc/faq#conversions

I like this design. Explicit is better than implicit. In Go, almost all things are expressed explicitly.

However, sometimes... it's too tedious to fix type coversion errors by hand. If a required type is int64 and got int type, why not converting it automatically? I'm tired of wrapping expressions with int64() or something here and there.

Here comes gotypeconv! gotypeconv takes source code, detects the type conversion errors and fixes them automatically by rewriting AST.

gotypeconv is like gofmt (it actually formats code as well), but it also fixes type conversions errors.

Installation

go get -u github.com/haya14busa/go-typeconv/cmd/gotypeconv

Usage example

./testdata/tour.input.go

// https://tour.golang.org/basics/13
package main

import (
	"fmt"
	"math"
)

func main() {
	var x, y int = 3, 4
	var f float64 = math.Sqrt(x*x + y*y)
	var z uint = f
	fmt.Println(x, y, z)
}

Above code has type conversion errors as follow.

$ go build testdata/tour.input.go
testdata/tour.input.go:11: cannot use x * x + y * y (type int) as type float64 in argument to math.Sqrt
testdata/tour.input.go:12: cannot use f (type float64) as type uint in assignment

gotypeconv can fix them automatically!

$ gotypeconv ./testdata/tour.input.go
// https://tour.golang.org/basics/13
package main

import (
        "fmt"
        "math"
)

func main() {
        var x, y int = 3, 4
        var f float64 = math.Sqrt(float64(x*x + y*y))
        var z uint = uint(f)
        fmt.Println(x, y, z)
}

gotypeconv also supports displaying diff (-d flag) and rewriting files in-place (-w flag) same as gofmt.

More example

Go doesn't have overloading. https://golang.org/doc/faq#overloading I like this design too.

However, sometimes... it's inconvenient. For example, when you want max utility function, you may write something like this func max(x int64, ys ...int64) int64. It works, but when you want to calculate max of given ints, you cannot ues this function unless wrapping them with int64().

You also may start to write func max(x int, ys ...int) int, and change type to int64 later. Then, you need to wrap expressions with int64() here and there in this case as well.

Here comes gotypeconv, again!

package main

import "fmt"

func main() {
	var (
		x int     = 1
		y int64   = 14
		z float64 = -1.4
	)

	var ans int = max(x, x+y, z)
	fmt.Println(ans)
}

func max(x int64, ys ...int64) int64 {
	for _, y := range ys {
		if y > x {
			x = y
		}
	}
	return x
}

Above code can be fixed gotypeconv. ($ gotypeconv -d testdata/max.input.go)

@@ -9,7 +9,7 @@
                z float64 = -1.4
        )

-       var ans int = max(x, x+y, z)
+       var ans int = int(max(int64(x), int64(x)+y, int64(z)))
        fmt.Println(ans)
 }

(I miss generics in this case... but gotypeconv can also solve the problem!)

Hou to Use in Vim

Use https://github.com/haya14busa/vim-gofmt with following sample config.

let g:gofmt_formatters = [
\   { 'cmd': 'gofmt', 'args': ['-s', '-w'] },
\   { 'cmd': 'goimports', 'args': ['-w'] },
\   { 'cmd': 'gotypeconv', 'args': ['-w'] },
\ ]

🐦 Author

haya14busa (https://github.com/haya14busa)

About

Bring implicit type conversion into Go in a explicit way

Topics

Resources

License

Releases

No releases published

Sponsor this project

 
Learn more about GitHub Sponsors

Languages

You can’t perform that action at this time.