Chaining functions in Go?

I tried doing this:

package main

import (
    "fmt"
    "strings"
)

type String string


func (s *String) tolower() String {
    *s = String(strings.ToLower(string(*s)))
    return *s
}

func (s *String) toupper() String {
    *s = String(strings.ToUpper(string(*s)))
    return *s
}

func main() {
    var s String = "ASDF"
    (s.tolower()).toupper() // this fails
    // s.toupper();s.tolower(); // this works
    // s.tolower().toupper() // this fails too
    fmt.Println(s)
}

But I got these errors:

prog.go:30: cannot call pointer method on s.tolower()
prog.go:30: cannot take the address of s.tolower()

Program exited.

Why can't I make this chain work?

This works:

package main

import (
    "fmt"
    "strings"
)

type String string


func (s *String) tolower() *String {
    *s = String(strings.ToLower(string(*s)))
    return s
}

func (s *String) toupper() *String {
    *s = String(strings.ToUpper(string(*s)))
    return s
}

func main() {
    var s String = "ASDF"
    (s.tolower()).toupper()
    s.toupper();
    s.tolower();
    s.tolower().toupper()
    fmt.Println(s)
}

Your return type is of String, for functions defined on pointers to String. It wouldn't make sense to be able to chain them.

tolower() and toupper() have pointer-to-String as the receivers, but they are returning String (not pointer-to-String).

You can fix this by changing one or the other.

e.g. change the signature of the function to either:

func (s *String) toupper() *String

or

func (s String) toupper() String

(see: http://play.golang.org/p/FaCD8AQtIX)

When you call a method with a pointer receiver on a variable (s in your example), then an address of that value will be taken automatically. So, you are basically calling (&s).toupper(). This mechanism works for all values that are addressable.

Return values of functions are not addressable unless you store them in a variable (so that they have a permanent place in the current stack frame or the heap).

I would recommend the following API, because it looks like the user of your string type is supposed to work with String and not *String. Therefore it makes sense to design a consistent API that also uses String to avoid confusion. Passing a string by value is extremely fast anyway, because they are implemented as pointers to immutable arrays internally:

func (s String) tolower() String {
    return String(strings.ToLower(string(s)))
}

This method does not need a pointer receiver, because it doesn't modify the current string. It returns a new string instead. You can also easily chain those methods.

Alternatively, you can implement the methods this way:

func (s *String) tolower() *String {
    *s = String(strings.ToLower(string(*s)))
    return s
}

In this case, you keep returning the same pointer. So, in order to call (s.tolower()).toupper() you need to be able to take the address of s which is possible since you have assigned it to a variable. Then all further method calls in the chain are also possible, because you call them with a pointer to your initial variable. This differs from your attempt of chaining methods were each method call must have taken the address of a temporary variable in order to modify it (which isn't very useful).

maybe you can try this project: https://github.com/Laisky/go-chaining

import "github.com/Laisky/go-chaining"

func toLower(c *chaining.Chain) (interface{}, error) {
    v := c.GetString()
    return strings.ToLower(v), nil
}

func toUpper(c *chaining.Chain) (interface{}, error) {
    v := c.GetString()
    return strings.ToUpper(v), nil
}

func TestChainWithString(t *testing.T) {
    f := func() (string, error) { return "aBcD", nil }
    r := chaining.New(f()).
        Next(toLower).
        Next(toUpper)

    expectVal := "ABCD"
    if r.GetString() != expectVal {
        t.Errorf("expect %v, got %v", expectVal, r.GetString())
    }
}