How to return a error from a goroutine (through channels)

When i write a function in Go, it should return a value and an error like

func createHashedPassword(password string) (string, error) {
  //code
}

I want to execute this createHashedPassword in a goroutine and I think to pass data via channel.
But my question is, how can I handle error here or in the goroutine?

It's common to bundle multiple outputs into a struct, and return them together over a single channel.

type Result struct {
    Message string
    Error error
}

ch := make(chan Result)

You can pass in an error channel as well as a result channel.

errors := make(chan error, 0)
results := make(chan string, 0)

password := "test"

go func() {
    result, err := createHashedPassword(string password)
    if err != nil {
        errors <- err
        return
    }

    results <- result
}()

// do something else

// When you are ready to read from goroutine do this:
select {
    case err := <- errors:
        println(err)
    case res := <- results:
        println(res)
}

Here are my two preferred ways:

Two channels, wrapped

This is the "two channels" way, but wrapped into a function to make it look similar to the common pattern:

func createHashedPasswordAsynchronously(password string) (chan string, chan error) {
	resultCh := make(chan string)
	errorCh := make(chan error)

	go func(password string) {
		//code
		if err != nil {
			errorCh <- errors.New("Does not compute")
		} else {
			resultCh <- "8badf00d"
		}
	}(password)

	return resultCh, errorCh
}

And called like this:

resultCh, errorCh := createHashedPasswordAsynchronously("mysecret")
select {
case result := <-resultCh:
	storeHashedPassword(result)
case err := <-errorCh:
	log.Println(err.Error())
}

Anonymous struct

This is the "anonymous struct" way, similar to @saward's answer, but without naming the struct members explicitly:

go func(password string, ch chan struct {
	string
	error
}) {
	//code
	if err != nil {
		ch <- struct {
			string
			error
		}{"", errors.New("Does not compute")}
	} else {
		ch <- struct {
			string
			error
		}{"8badf00d", nil}
	}
}("mysecret", ch)

r := <-ch
if r.error != nil {
	log.Println(r.error.Error())
} else {
	storeHashedPassword(r.string)
}

(since I cannot comment yet...)

I echo what JimB said with:

type Result struct {
    Message string
    Error error
}

ch := make(chan Result)

The trouble with two separate channels, one for the result, and another for the error, is that (as I understand) it won't support concurrent threads out of the box.

You could, for example, have two threads sending data at the same time, where the replies get out of order. That is, you receive the result from thread 1 first, but the error from thread 2 first.

It's easy to create new types like JimB suggested, and should work well with goroutines.

One of the common patterns is to pass a error channel and a result channel to the function:

package main

import (
  "fmt"
)

func main() {
  password := "blah blah"
  resultChan := make(chan string)
  errChan := make(chan error)

  go createHashedPassword(password, resultChan, errChan)

  // Do some other stuff

  select {
  case err := <-errChan:
	fmt.Println(err)
  case res := <-resultChan:
	fmt.Println(res)
  }
}

func createHashedPassword(password string, resultChan chan string, errChan chan error) {
  // your code for hashing and stuff
  if err != nil {
	errChan <- err
	return
  }
  resultChan <- result
}

You can also make channels inside the createHashedPassword as AndreKR said,

or call the createHashedPassword inside an anonymous goroutine as Ian Davis said.

There is also some other possible patterns, and you can combine any of them with combined struct:

type Result struct {
  err error
  msg string
}

or

type Result struct {
  err error
  msg *string // in cases that empty string can be a true result, you can evaluate msg with nil
}

I should also mention that in some special cases, we don't return the error and just log it there.

package main

import (
	"fmt"
	"log"
)

func main() {
	password := "blah blah"
	resultChan := make(chan string)

	go createHashedPassword(password, resultChan)

	// Do some other stuff

	fmt.Println(<-resultChan) // Be careful that it's a blocking code.
}

func createHashedPassword(password string, resultChan chan string) {
	// your code for hashing and stuff
	if err != nil {
		log.Println(err) // *** Here we just log the error, or handle it.
	}
	resultChan <- result
}