CODEWITHSUNDEEP
go
denqbit
denqbit

Reputation: 43

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

Upvotes: 4

Views: 4587

Answers (2)

eduncan911
eduncan911

Reputation: 17614

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.

Upvotes: 5

sberry
sberry

Reputation: 132088

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.

Upvotes: 0

Related Questions