Is there a way to ask time.After() for an infinite amount of time?

Is there a way to ask time.After() for an infinite amount of time?

Motivation: I have a service that a caller can request a message from, with an optional timeout. The obvious way to do this would be:

func service(timeout *time.Duration) SomeType {
    var timeout_value time.Duration
    if timeout != nil {
        timeout_value = *timeout
    } else {
        timeout_value = time.Forever /* or something */
    }

    select {
    case value <- some_channel:
        return value
    case <- time.After(timeout_value):
        return nil
    }
}

Except I don't know if there's a way to say time.Forever.

There is no "forever" duration, but there is max duration:

const maxDuration time.Duration = 1<<63 - 1

maxDuration is about 292 years. It should be enough for the lifetime of a single app. But instead I propose the below solution which doesn't use it:

Note that if "forever" is the intended max wait time, it's simpler and more efficient to omit time.After() and use a simple receive:

func service(timeout *time.Duration) SomeType {
	if timeout == nil {
		return <-some_channel
	}

	select {
	case value := <-some_channel:
		return value
	case <-time.After(*timeout):
		return nil
	}
}

You indicated that your actual code is much more complex and contains more cases.

In that case, I'd move the timeout channel creation outside of the select statement, and initialize accordingly. When timeout is nil, just leave the channel nil (its zero value), which will never deliver any value, so receiving from a nil channel literally takes "forever":

func service(timeout *time.Duration) SomeType {
	var timeoutCh <-chan time.Time
	if timeout != nil {
		timeoutCh = time.After(*timeout)
	}

	select {
	case value := <-some_channel:
		return value
	case <-timeoutCh:
		return nil
	}
}

Instead of the duration you could accept a context.Context in your function, which I think is quite idiomatic in Go code.

Then the caller can call the function with a Context.Background or with a Context.WithTimeout as needed. The service function selects on the context's Done(), which in case of the background context never ends (the chan is effectively nil).

> Done may return nil if this context can never be canceled. [...] Done is provided for use in select statements

func callerNoTimeout() {
    foo := service(context.Background())
}

func callerTimeout() {
    foo := service(context.WithTimeout(context.Background(), timeOut))
}

func service(ctx context.Context) SomeType {
    select {
        case value <-some_channel:
            return value
        case <-ctx.Done():
            return nil
    }
}

Firstly, it's common practice to use a time.Duration of 0 (or negative) to indicate no timeout - so it's not necessary to pass a pointer.

Secondly, just check for this zero-value when enforcing a timeout or not:

func service(timeout time.Duration) SomeType {
    
    if timeout <= 0 {
        return <- some_channel

    }

    select {
        case value <- some_channel:
            return value
        case <- time.After(timeout):
            return nil
    }
}