How do you deal with wall-clock times without date in Go?

In order to have just time and omit the other information about the day, month and year you can make use of Format() method. I have created a sample program for the same as follows:

package main

import (
    "fmt"
    "time"
)

func main() {

    const (
        layoutTime = "15:04:05"
    )

    fmt.Println("Date", time.Now())
    fmt.Println("Time", time.Now().Format(layoutTime))

}

Output:

Date 2009-11-10 23:00:00 +0000 UTC m=+0.000000001
Time 23:00:00

Trust me, You still need the Date, not just the Clock.

For example : what if the StartTime = 23:00:00 and FinishTime = 06:00:00, if you didn't capture the date, the information inside of the Shift struct is FinishTime < StartTime, and that goes against the words of start and finish itself.

That's where the date works, so if the FinishTime is more than the StartTime, the StartTime needs to be reduced by 1 day OR FinishTime plus 1 day.

Here's the example solution code that I make to check if the currentTime is between 2 time(clock)

First of all since I just need the clock information (HH:mm:ss), I prefer to use a string type for the StartTime and FinishTime.

type Shift struct {
    StartTime  string
    FinishTime string
}

and here's what it goes.

type Shift struct {
    StartTime  string
    FinishTime string
}

func main() {
    myShift := Shift{
        StartTime:  "23:00",
        FinishTime: "06:00",
    }
    actualStartTime, actualEndTIme := convertShiftClockToShiftTime(myShift.StartTime, myShift.FinishTime)
    fmt.Println(actualStartTime, actualEndTIme)
}

func convertShiftClockToShiftTime(StartTime string, FinishTime string) (startTime time.Time, endTime time.Time) {

    // I need to convert the time to a string so I can easily add the clock
    timeLayout := "2006-01-02T15:04"
    dateOnlyLayout := "2006-01-02"

    currentTime := time.Now()
    currentDate := currentTime.Format(dateOnlyLayout)
    // currentDate = Y-m-d

    startDateStr := currentDate + "T" + StartTime
    startTime, _ = time.Parse(timeLayout, startDateStr)

    endDateStr := currentDate + "T" + FinishTime
    endTime, _ = time.Parse(timeLayout, endDateStr)

    if startTime.After(endTime) {
        // plus 1 day to the endTime if the endTime < startTime
        endTime = endTime.AddDate(0, 0, 1)
    }

    return startTime, endTime
}

I created a function called convertShiftClockToShiftTime to change the clock into actual time as I mentioned before, what if the StartTime = 23:00 and EndTime = 06:00.

Basically the program should know if the StartTime is more than FinishTime, FinishTime should be tomorrow.

Hope this helps, I hope my explanation can explain to you what time itself means.

It's kind of hard to answer this question, as you haven't really described what the type would need to do, other than this:

Yeah, but the point is, that time.Time will be prone to bugs in a less-than / more-than comparison if you allow the user to give a date. The goal should be to have a comparable struct and for the user not to give a date in order not to mess it up.

So going off that, you could use something like this:

package wall
import "errors"

type Clock struct { hour, minute, second int }

func NewClock(h, m, s int) (*Clock, error) {
   if h > 23 || m > 59 || s > 59 {
      return nil, errors.New("invalid input")
   }
   return &Clock{h, m, s}, nil
}

func (c Clock) Seconds() int {
   return c.hour * 60 * 60 + c.minute * 60 + c.second
}

func (c Clock) LessThan(d *Clock) bool {
   return c.Seconds() < d.Seconds()
}

Example:

package main
import "wall"

func main() {
   c, err := wall.NewClock(9, 59, 59)
   if err != nil {
      panic(err)
   }
   d, err := wall.NewClock(10, 59, 59)
   if err != nil {
      panic(err)
   }
   println(c.LessThan(d))
}

time.Duration can be used for wall-clock time without date. Some examples:

type Shift struct {
    StartTime  time.Duration
    FinishTime time.Duration
}

func main() {
    d1, _ := time.ParseDuration("11h")  // 11:00
    d2, _ := time.ParseDuration("20h")  // 20:00
    shift := Shift{
        StartTime:  d1,
        FinishTime: d2,
    }

    // If you want to put them into specific day
    today0 := time.Now().UTC().Truncate(24 * time.Hour)

    start := today0.Add(shift.StartTime)
    finish := today0.Add(shift.FinishTime)

    fmt.Printf("Start at: %v\nFinish at: %v\n", start, finish)
}

For times that span two days:

d1, _ := time.ParseDuration("-30m")   // 23:30 of previous day
d2, _ := time.ParseDuration("6h30m")  // 6:30 of next day