Go functions dot notation

I want to build this:

finalResult, err := Function1(whatever type)
    .Function2(whatever type)
    .Function3(whatever type)

Something similar to promises in javascript but not necessarily the same concepts. Or similar to nested methods in Java. I just pretend avoid more code for the same tasks.

I don't want to do this :

result, err := new(Function1(whatever type)) //or *Function1(whatever type)
if err != nil {...}
result1, err := result.Function2(whatever type)
if err != nil {...}
finalResult, err := result1.Function3(whatever type)
if err != nil {...}

I've been trying with several options with structs and interfaces but I can't get any result.

My apology if I have a mistake in my grammar. I'm not still so good with my skill English.

Thanks,

David

I think you mean the Fluent API design pattern. You return the same Object, or struct in Go, over and over.

This pattern does not allow you to return a tuple, or multiple return types though. You can only return one object.

https://play.golang.org/p/9PceZwi1a3

package main

import (
	"fmt"
)

type Object struct {
	Value string
	Error error
}

func (o *Object) Before(s string) *Object {
	o.Value = s + o.Value
	// add an error if you like
   	// o.Error = error.New(...)
	return o
}

func (o *Object) After(s string) *Object {
    // could check for errors too
    if o.Error != nil {
	    o.Value = o.Value + s
    }
	return o
}

func main() {
	x := Object{}

	x.
		Before("123").
		After("456").
		After("789").
		Before("0")

	if x.Error != nil {
		// handle error
	}
	fmt.Println(x.Value)
}

Edit: sberry's answer had a good idea. Add an Error state on the Object struct itself which could allow u to check for errors in each func call.

Since you are new, please remember to evaluate all answers and mark the best one you believe lead you the answer.

The only way to do this would be to have each FunctionX be a method on a receiver (most likely a pointer receiver if you are mutating state) and have them each return the receiver. Like so

type someNumber struct {
	n int32
}

func (s *someNumber) Add(i int32) *someNumber {
	s.n += i
	return s
}

func (s *someNumber) Multiply(i int32) *someNumber {
	s.n *= i
	return s
}

func (s *someNumber) Subtract(i int32) *someNumber {
	s.n -= i
	return s
}

func main() {
	num := &someNumber{n: 0}
	result := num.Add(5).Multiply(4).Subtract(10)
	fmt.Println(result.n)
}

You could set and error on the someNumber as well, and check it at the end.

If you are looking to actually carry through the error, then you would need to do something like this.

func Function1(a int, err error) (int, error) {
	if err != nil {
		return a, err
	}
	return a, nil
}

func Function2(a int, err error) (int, error) {
	if err != nil {
		return a, err
	}
	return a*2, nil
}


func Function3(a int, err error) (int, error) {
	if err != nil {
		return a, err
	}
	return a*3, nil
}

func main() {
	a, err := Function3(Function2(Function1(1, nil)))
	fmt.Println(a, err)	
}

But, it seems like you are looking for the type of behavior an Error Monad would bring and that does not exist in Go.