DEV Community: Rajkumar

Wrapping Goroutines to Handle Return Values in Go

Rajkumar — Sun, 20 Apr 2025 16:53:16 +0000

Introduction

Concurrency is one of Go's superpowers, enabling developers to run tasks in parallel using go routines. A go routine is launched with the go keyword followed by a function call, as shown below:

package main

import (
    "fmt"
    "time"
)

func say(s string) {
    for i := 0; i < 5; i++ {
        time.Sleep(100 * time.Millisecond)
        fmt.Println(s)
    }
}

func main() {
    go say("world")
    say("hello")
}

Go playground link to the example

This simple example prints "hello" and "world" concurrently. However, the Go language specification notes that if a function called in a goroutine returns values, those values are discarded. This raises a question: how can we capture and use return values from a goroutine?

In this article, we'll explore how to wrap goroutines in anonymous functions to handle return values effectively, address synchronization challenges, and manage errors in concurrent Go programs.

Understanding Goroutine Return Values

The Go specification defines a GoStmt as

GoStmt = "go" Expression .

where the expression must be a function call. Attempting to use a non-function-call expression results in the error: expression in go must be function call.

To capture return values, we can wrap the function call in an anonymous function. Here's a basic example:

package main

import (
    "fmt"
    "time"
)

func main() {

    a := 10
    fmt.Println("Value of a before goroutine", a)
    go func() {
        a += 10
    }()

    time.Sleep(1 * time.Second)
    fmt.Println("Value of a after goroutine call", a)
}

Go playground link to the example

In this example, an anonymous function modifies the variable a. However, using time.Sleep for synchronization is unreliable, as it doesn't guarantee the goroutine has completed. Additionally, concurrent access to a could lead to race conditions. We'll address these issues later.

A Practical Example with Synchronization

package main

import (
    "fmt"
    "sync"
)

func main() {
    fName := "John"
    lName := "Doe"
    var fullName string
    var errs []error
    var mu sync.Mutex // Protects shared variables
    var wg sync.WaitGroup

    // Process full name with valid input
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName(fName, lName)
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    // Process full name with empty first name
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName("", lName)
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    // Process full name with empty last name
    wg.Add(1)
    go func() {
        defer wg.Done()
        result, err := generateFullName(fName, "")
        if err != nil {
            mu.Lock()
            errs = append(errs, err)
            mu.Unlock()
            return
        }
        mu.Lock()
        fullName = result
        mu.Unlock()
    }()

    wg.Wait() // Wait for all goroutines to complete

    if len(errs) > 0 {
        fmt.Println("Errors encountered:")
        for _, err := range errs {
            fmt.Println(" -", err)
        }
    }
    fmt.Println("User's fullName:", fullName)
}

func generateFullName(firstName, lastName string) (string, error) {
    if firstName == "" {
        return "", fmt.Errorf("firstName is empty")
    }
    if lastName == "" {
        return "", fmt.Errorf("lastName is empty")
    }
    return fmt.Sprintf("%s %s", firstName, lastName), nil
}

Go playground link to the example

Key Improvements in This Example

Synchronization with sync.WaitGroup: We use wg.Add(1) to increment the WaitGroup counter before each goroutine and wg.Done() to signal completion. wg.Wait() ensures the main function waits for all goroutines to finish.
Thread-Safe Updates with sync.Mutex: The mu mutex protects fullName and errs from concurrent access, preventing race conditions.
Error Collection: Errors are collected in a slice, allowing the program to report all issues rather than stopping at the first error.
Clear Output: The program prints all errors and the final fullName, making it easier to debug and understand the results.

Benefits of Wrapping Goroutines

By wrapping function calls in anonymous goroutines, you gain flexibility to:

Log Errors and Metrics: Send errors to a logging system or increment counters in a monitoring tool.
Process Results: Set default values, update flags, or transform data based on the return values.
Collect Errors: Aggregate errors from multiple goroutines for comprehensive validation (e.g., checking user inputs).
Retry Logic: Implement retry mechanisms for transient errors, such as network failures.

Conclusion

Wrapping goroutines in anonymous functions is a powerful technique for capturing return values and managing errors in concurrent Go programs. By combining this approach with proper synchronization tools like sync.WaitGroup and sync.Mutex, you can build robust and efficient concurrent applications. Experiment with these patterns in your projects, and share your experiences.

Using Constants in PostgreSQL queries

Rajkumar — Wed, 01 Dec 2021 10:13:59 +0000

Introduction

Imagine we have a long query which has a lots of conditions, and many of the conditions has some kind of comparisions with literals instead of some other record value.

Example:

SELECT * FROM users u where (u.name='some name' or u.age=12 or u.email='qwe@qwe.qwe');

For example sake we are taking the name, age and email as constants.

Imagine these literal values used multiple times in the query. We will have very untidy query.

To make the query more readable and tidy we can use constants, like we do in normal programming languages where if some literal value is/will be used repeatedly then we define it as a constant.

Solution

To achieve this we will be using the WITH Common Table Expression (CTE)

Common Table Expression are very powerful as they allow us to create temporary named result set which can be used within a SELECT, INSERT, UPDATE, DELETE query.

The result set is temporary and only limited to the scope of the query, it is not stored any where and exists only for the duration of the query.

Thus we are not creating any garbage after our query has been executed.

Let's see how our new query will look like

WITH consts AS (
    SELECT 'some name' as temp_name, 12 as temp_age, 'qwe@qwe.qwe' as temp_email
)
SELECT * FROM users u, consts c where (u.name= c.temp_name or u.age=c.temp_age or u.email=c.temp_email);

Notice that we are using the result set consts as we use a table.

Conclusion

Thus we have seen how we can use named constants and how helpful are the CTEs to write compact, readable and efficient queries.

I usually write on my git pages which you can reach from https://rajkumargosavi.github.io, from which this post was re-shared.

Practical guide to parsing your Date and Time in Go

Rajkumar — Fri, 27 Aug 2021 17:00:08 +0000

Often we find ourselves with a Date Time that is not in some standard format. This is where we identify the pattern of the date time and then try to write a custom layout.

Let us see how we can achieve this in go using the standard time package. The time package provides us with several functionalities which includes functions like Parse and Format that serves our purpose.

Parse

Parse parses a formatted string and returns the time value it represents.

func Parse(layout, value string) (Time, error)

package main

import (
    "fmt"
    "time"
)

func main() {
    const longForm = "Jan 2, 2006 at 3:04pm (MST)"
    t, _ := time.Parse(longForm, "Feb 3, 2013 at 7:54pm (PST)")
    fmt.Println(t)

    const shortForm = "2006-Jan-02"
    t, _ = time.Parse(shortForm, "2013-Feb-03")
    fmt.Println(t)
}

Output:
2013-02-03 19:54:00 +0000 PST
2013-02-03 00:00:00 +0000 UTC

Go Playground Link: Parse Example

Format

Format returns a textual representation of the time value formatted according to the layout defined by the argument.

func (t Time) Format(layout string) string

func main() {
    t, err := time.Parse(time.UnixDate, "Wed Feb 25 11:06:39 PST 2015")
    if err != nil { // Always check errors even if they should not happen.
        panic(err)
    }

    fmt.Println("default format:", t)

    fmt.Println("Unix format:", t.Format(time.UnixDate))
}

Output:
default format: 2015-02-25 11:06:39 +0000 PST
Unix format: Wed Feb 25 11:06:39 PST 2015

Go Playground Link: Format Example

Predefined Layouts available in time package

Label	Definition
Layout	01/02 03:04:05PM '06 -0700
ANSIC	Mon Jan _2 15:04:05 2006
UnixDate	Mon Jan _2 15:04:05 MST 2006
RubyDate	Mon Jan 02 15:04:05 -0700 2006
RFC822	02 Jan 06 15:04 MST
RFC822Z	02 Jan 06 15:04 -0700
RFC850	Monday, 02-Jan-06 15:04:05 MST
RFC1123	Mon, 02 Jan 2006 15:04:05 MST
RFC1123Z	Mon, 02 Jan 2006 15:04:05 -0700
RFC3339	2006-01-02T15:04:05Z07:00
RFC3339Nano	2006-01-02T15:04:05.999999999Z07:00
Kitchen	3:04PM
Stamp	Jan _2 15:04:05
StampMilli	Jan _2 15:04:05.000
StampMicro	Jan _2 15:04:05.000000
StampNano	Jan _2 15:04:05.000000000

Building Blocks for creating your own layout

Type	Options
Year	"2006", "06"
Month	"Jan", "January", "1", "01"
Textual day of the week	"Mon", "Monday"
Numeric day of the month	"2", "_2", "02"
Numeric day of the year	"__2", "002"
Hour	"15", "3", "03" (PM or AM)
Minute	"4", "04"
Second	"5", "05"
AM/PM mark	"PM"

For layouts specifying the two-digit year 06, a value NN >= 69 will be treated as 19NN and a value NN < 69 will be treated as 20NN.

Numeric time zone offsets format as follows:

Value	Format
"-0700"	±hhmm
"-07:00"	±hh:mm
"-07"	±hh

Replacing the sign in the format with a Z triggers the ISO 8601 behavior of printing Z instead of an offset for the UTC zone. Thus:

Value	Format
"Z0700"	Z or ±hhmm
"Z07:00"	Z or ±hh:mm
"Z07"	Z or ±hh

Final Example

func main() {
    ipTimes := []string{
        "24 Aug 2021 7:20:50 PM",
        "Aug 24 2021 07:20:50PM",
        "24-08-2021 17:20:50",
        "08-24-2021 13:12:32",
        "24/8/21 9:00:12",
        "8/24/2021 10:10:10",
        "1993-11-23 7**12**44PM",
        "24 October 97 7:12:45PM+05:30", // 24 th January 1997
    }

    layouts := []string{
        "2 Jan 2006 3:04:05 PM",
        "Jan 2 2006 03:04:05PM",
        "2-01-2006 15:04:05",
        "01-02-2006 15:4:5",
        "2/1/06 3:4:5",
        "1/2/2006 3:4:5",
        "2006-01-02 3**4**5PM",
        "2 January 06 3:4:5PMZ07:00",
    }

    for i := 0; i < len(ipTimes); i++ {
        t, err := time.Parse(layouts[i], ipTimes[i]) // parsing to get time value
        if err != nil {                              // check for errors
            fmt.Println(err)
            return
        }

        fmt.Println("    Input DateTime String: ", ipTimes[i])
        fmt.Println("                   Layout: ", layouts[i])
        fmt.Println("Time value Default Format: ", t)
        fmt.Println("   Time in RFC3339 Format: ", t.Format(time.RFC3339))
    }
}

Let us take one such example to iterate through it

Input: "24 October 97 7:12:45PM+05:30"
Layout: "2 January 06 3:4:5PMZ07:00"

From the building blocks listed above we can map things

Layout Key	Actual Value	Description
2	24	Numeric day of the month
January	October	month
06	97	Year (1997)
3	7	Hour
4	12	Minute
5	45	Second
Z07:00	+05:30	Offset

Since PM is specified 7:12:45 is in 12 hour format.

Using the Layout blocks specified we can easily see the pattern and can create our own layout.

Fun Tip

Ever wondered why time.Now() on golang playground prints the same time (2009-11-10 23:00:00 +0000 UTC m=+0.000000001) ?

Drum roll!!!!!!

It is the time and date of Go Lang's birthday.

Hope you learnt something new or had your concepts revised.

Let me know if I missed something.

Complete Working Date Time Example

References

Time Format
Time Parse
Constants