Is it possible to have Optional methods inside the interface in golang?

I want to create optional perim mehtod for interface. Is it possible?Like I don't want to create perim method for triangle but its giving me error that one method is missing. Is it possible to have optional method in interface?

Please tell me its alternative or some solution.

type geometry interface {
area() float64
perim() float64
}
type rect struct {
width, height float64
}
type triangle struct {
base, height float64
}
type circle struct {
radius float64
}
type square struct {
side float64
}
func (r rect) area() float64 {
return r.width * r.height
}
func (r rect) perim() float64 {
return 2*r.width + 2*r.height
}
func (c circle) area() float64 {
return math.Pi * c.radius * c.radius
}
func (c circle) perim() float64 {
return 2 * math.Pi * c.radius
}
func (t triangle) area() float64 {
return 1 / 2 * t.base * t.height
}
func measure(g geometry) {
fmt.Println(g)
switch g.(type) {
case rect:
fmt.Println("Rectangles area :", g.area())
fmt.Println("Rectangle perimeter: ", g.perim())
case circle:
fmt.Printf("Circles Area: %.2f\n", g.area())
fmt.Printf("Circles Perimeter: %.2f\n", g.perim())
case square:
fmt.Printf("Area of square: %.2f\n", g.area())
fmt.Printf("Perimeters of area: %.2f\n", g.perim())
case triangle:
fmt.Printf("Area of  triangle: %.2f\n", g.area())
}
}
func main() {
r := rect{width: 3, height: 4}
c := circle{radius: 5}
s := square{side: 7}
t := triangle{base: 3, height: 4}
measure(r)
measure(c)
measure(s)
measure(t)
}

The spec does not allow "marking" methods optional in interface types.

Note that your implementations may provide other methods, not just the methods that are part of the interface you want to implement. Type assertion may be used to check if the concrete type of a value has "additional" methods, by checking if they implement an interface type having those additional methods.

In this example FooImpl has only method One(), but Foo2Impl has methods One() and Two():

type Foo interface {
One()
}
type FooImpl int
func (fi FooImpl) One() {}
type Foo2Impl int
func (fi Foo2Impl) One() {}
func (fi Foo2Impl) Two() {}
func check(f Foo) {
if ft, ok := f.(interface{ Two() }); ok {
fmt.Printf("%T(%v) has method Two()\n", f, f)
ft.Two() // You can call it
} else {
fmt.Printf("%T(%v) doesn't have method Two()\n", f, f)
}
}
func main() {
check(FooImpl(1))
check(Foo2Impl(2))
}

Its output (try it on the Go Playground):

main.FooImpl(1) doesn't have method Two()
main.Foo2Impl(2) has method Two()

You can of course create an interface type with those additional methods:

type Bar interface {
Two()
}

And then checking it:

if ft, ok := f.(Bar); ok {
fmt.Printf("%T(%v) has method Two()\n", f, f)
ft.Two() // You can call it
} else {
fmt.Printf("%T(%v) doesn't have method Two()\n", f, f)
}

Try this one on the Go Playground.

Since you're already using type-switch statements, your argument g can be an empty interface as well:

func measure(g interface{}) {
fmt.Println(g)
switch v := g.(type) {
case rect:
fmt.Println("Rectangles area :", v.area())
fmt.Println("Rectangle perimeter: ", v.perim())
case circle:
fmt.Printf("Circles Area: %.2f\n", v.area())
fmt.Printf("Circles Perimeter: %.2f\n", v.perim())
case square:
fmt.Printf("Area of square: %.2f\n", v.area())
fmt.Printf("Perimeters of area: %.2f\n", v.perim())
case triangle:
fmt.Printf("Area of  triangle: %.2f\n", v.area())
}
}

(Go Playground)

Whether it's appropriate design (OOP people would disagree), depends on the context.

Interfaces cannot have optional methods by definition; there's no way for an optional method to work. If you have a value of an interface type, you can call any method defined on that interface on that value. If a method were optional, you couldn't assume it was available, so you couldn't call it, so there would be no point having it in the interface.

You can, however, just use multiple interfaces. This is used in the net/http package, for example, where a ResponseWriter may or may not be a Pusher; in this case, Pusher describes the "optional" Push method, which can be accessed by type assertion like so:

if ok,pusher := resp.(Pusher); ok {
pusher.Push(...)
}