Go Pipe

Go Pipe is a simple implementation of pipe operator in Go.

What is it all about?

One of the most interesting features of functional languages is the ability to easily compose functions. The function composition is the operation that takes two functions and produces another function in the way that the result of the second function is passed as the input argument of first one.

Function composition is so common in functional programming which most of the functional languages have defined a special operator, typically called a pipe operator, to make composition even simpler. For example, in Haskell we have the . (dot) operator, and Elixir defines the |> (pipe) operator:

append = fn list, item ->
  list
  |> Enum.reverse
  |> prepend.(item)
  |> Enum.reverse
end

Actually, in any programming language which supports functional style we can achieve the same result by applying functions consequently. For example in Go, we can write:

func h(x int) int {
    f := func(x int) int {
        if x < 0 {
            return -x
        } else {
            return x
        }
    }

    g := func(x int) int {
        return x * x
    }

    return f(g(x))
}

But the problem arises when one of the func's returns multiple values, as is common with returning errors. In that case we need to handle error specifically and write:

func h(x int) (int, error) {
    f := func(x int) (int, error) {
        if x < 0 {
            return 0, errors.New("x should not be nagtive")
        }
        return x, nil
    }

    g := func(x int) int {
        return x * x
    }

    y, err := f(x)
    if err != nil {
        return 0, err
    }

    return g(y), nil
}

This is not much complex for two func's, but it can easily become a burden if the number of func's grows.

To overcome this complexity I've written this library to make life simpler for those who love functional style like me. Go Pipe provides a Pipe func which composes one or more funcs into a pipeline func, which can be invoked anytime withing the code.

Using Pipe func is very simple:

import . "github.com/aslrousta/pipe"

func h(x int) int {
    var result int

    pipe := Pipe(
        func(x int) int {
            if x < 0 {
                return -x
            } else {
                return x
            }
        },
        func(x int) {
            result = x * x
        },
    )

    pipe(x)
    return result
}

And, it can handle errors automatically:

import . "github.com/aslrousta/pipe"

func h(x int) (int, error) {
    var result int

    pipe := Pipe(
        func(x int) (int, error) {
            if x < 0 {
                return 0, errors.New("x should not be nagtive")
            }
            return x, nil
        },
        func(x int) {
            result = x * x
        },
    )

    err := pipe(x)
    return result, err
}

License

Go Pipe source is released to the public under MIT license.