synchro

package module
v0.0.9 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 13, 2023 License: MIT Imports: 11 Imported by: 35

README

🕰️ Synchro: Timezone-typesafe date and time library for Go

test codecov Go Reference

This library is inspired by Rust chrono

Features

  • Timezone-typesafe date and time handling
  • Easy conversion between time zones
  • Support for common date and time operations
  • Compatible with the standard time package
  • Compatible with ISO8601

Installation

To install Synchro, use go get:

go get github.com/Code-Hex/synchro

Synopsis

To use Synchro, import it in your Go code:

package main

import (
    "fmt"

    "github.com/Code-Hex/synchro"
    "github.com/Code-Hex/synchro/tz"
)

func main() {
    // The current UTC time is fixed to `2023-09-02 14:00:00`.
    utcNow := synchro.Now[tz.UTC]()
    fmt.Println(utcNow)

    jstNow := synchro.Now[tz.AsiaTokyo]()
    fmt.Println(jstNow)
    // Output:
    // 2009-11-10 23:00:00 +0000 UTC
    // 2009-11-11 08:00:00 +0900 JST
}

https://go.dev/play/p/Ql3CM7NLfj0

Please refer to the numerous usage examples on GoDoc for reference.

Utilities

We also have a wide range of very useful utilities!!

If you have a feature request, please open an issue. It would be great if you could provide relevant examples or links that could be helpful.

TODO

  • Support database/sql
  • Support i18n
  • Optimization

Contributing

Contributions to Synchro are welcome!

To contribute, please fork the repository and submit a pull request.

License

Synchro is licensed under the MIT License. See LICENSE for more information.

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func After 

func After[T TimeZone](d time.Duration) <-chan Time[T]

After waits for the duration to elapse and then sends the current time on the returned channel. It is equivalent to NewTimer(d).C. The underlying Timer is not recovered by the garbage collector until the timer fires. If efficiency is a concern, use NewTimer instead and call Timer.Stop if the timer is no longer needed.

This is a simple wrapper function for time.After.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

var c chan int

func handle(int) {}

func main() {
	select {
	case m := <-c:
		handle(m)
	case <-synchro.After[tz.UTC](time.Millisecond):
		fmt.Println("timed out")
	}
}

Output:

timed out

func NowWithContext 

func NowWithContext[T TimeZone](ctx context.Context, t Time[T]) context.Context

NowWithContext returns a new context with the provided time with timezone stored in it. This allows you to create a context with a specific time value attached to it.

Types

type Day added in v0.0.9 

type Day int

Day sets the day component of the time being built.

type Hour added in v0.0.9 

type Hour int

Hour sets the hour component of the time being built.

type Minute added in v0.0.9 

type Minute int

Minute sets the minute component of the time being built.

type Month added in v0.0.9 

type Month int

Month sets the month component of the time being built.

type Nanosecond added in v0.0.9 

type Nanosecond int

Nanosecond sets the nanosecond component of the time being built.

type NullTime added in v0.0.4 

type NullTime[T TimeZone] struct {
	Time  Time[T]
	Valid bool // Valid is true if Time is not NULL
}

NullTime represents a Time[T] that may be null. NullTime implements the sql.Scanner interface so it can be used as a scan destination, similar to sql.NullString.

func (*NullTime[T]) Scan added in v0.0.4 

func (n *NullTime[T]) Scan(src any) error

Scan implements the sql.Scanner interface.

func (NullTime[T]) Value added in v0.0.4 

func (n NullTime[T]) Value() (driver.Value, error)

Value implements the driver.Valuer interface.

type Quarter 

type Quarter[T TimeZone] struct {
	// contains filtered or unexported fields
}

func (Quarter[T]) After 

func (q Quarter[T]) After(u Quarter[T]) bool

After reports whether the Quarter instant q is after u.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 4, 1, 0, 0, 0, 0)
	d3 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	q1 := d1.Quarter()
	q2 := d2.Quarter()
	q3 := d3.Quarter()

	fmt.Printf("q2.After(q1) = %v\n", q2.After(q1))
	fmt.Printf("q3.After(q1) = %v\n", q3.After(q1))
	fmt.Printf("q1.After(q2) = %v\n", q1.After(q2))
}

Output:

q2.After(q1) = true
q3.After(q1) = true
q1.After(q2) = false

func (Quarter[T]) Before 

func (q Quarter[T]) Before(u Quarter[T]) bool

Before reports whether the Quarter instant q is before u.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 4, 1, 0, 0, 0, 0)
	d3 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	q1 := d1.Quarter()
	q2 := d2.Quarter()
	q3 := d3.Quarter()

	fmt.Printf("q1.Before(q2) = %v\n", q1.Before(q2))
	fmt.Printf("q1.Before(q3) = %v\n", q1.Before(q3))
	fmt.Printf("q2.Before(q1) = %v\n", q2.Before(q1))
}

Output:

q1.Before(q2) = true
q1.Before(q3) = true
q2.Before(q1) = false

func (Quarter[T]) Compare 

func (q Quarter[T]) Compare(u Quarter[T]) int

Compare compares the Quarter instant q with u. If q is before u, it returns -1; if q is after u, it returns +1; if they're the same, it returns 0.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 3, 31, 23, 59, 59, 999999999)
	d3 := synchro.New[tz.UTC](2023, 7, 1, 0, 0, 0, 0)
	d4 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	q1 := d1.Quarter()
	q2 := d2.Quarter()
	q3 := d3.Quarter()
	q4 := d4.Quarter()

	fmt.Printf("q1.Compare(q2) = %d\n", q1.Compare(q2))
	fmt.Printf("q1.Compare(q3) = %d\n", q1.Compare(q3))
	fmt.Printf("q4.Compare(q1) = %d\n", q4.Compare(q1))

}

Output:

q1.Compare(q2) = 0
q1.Compare(q3) = -1
q4.Compare(q1) = 1

func (Quarter[T]) End 

func (q Quarter[T]) End() Time[T]

End returns end time in the quarter.

func (Quarter[T]) Number 

func (q Quarter[T]) Number() int

Number returns the number of quarter.

func (Quarter[T]) Start 

func (q Quarter[T]) Start() Time[T]

Start returns start time in the quarter.

func (Quarter[T]) Year 

func (q Quarter[T]) Year() int

Year returns the year in which q occurs.

type Second added in v0.0.9 

type Second int

Second sets the second component of the time being built.

type Semester 

type Semester[T TimeZone] struct {
	// contains filtered or unexported fields
}

func (Semester[T]) After 

func (s Semester[T]) After(u Semester[T]) bool

After reports whether the Semester instant s is after u.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 7, 1, 0, 0, 0, 0)
	d3 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	s1 := d1.Semester()
	s2 := d2.Semester()
	s3 := d3.Semester()

	fmt.Printf("s2.After(s1) = %v\n", s2.After(s1))
	fmt.Printf("s3.After(s1) = %v\n", s3.After(s1))
	fmt.Printf("s1.After(s2) = %v\n", s1.After(s2))
}

Output:

s2.After(s1) = true
s3.After(s1) = true
s1.After(s2) = false

func (Semester[T]) Before 

func (s Semester[T]) Before(u Semester[T]) bool

Before reports whether the Semester instant s is before u.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 7, 1, 0, 0, 0, 0)
	d3 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	s1 := d1.Semester()
	s2 := d2.Semester()
	s3 := d3.Semester()

	fmt.Printf("s1.Before(s2) = %v\n", s1.Before(s2))
	fmt.Printf("s1.Before(s3) = %v\n", s1.Before(s3))
	fmt.Printf("s2.Before(s1) = %v\n", s2.Before(s1))
}

Output:

s1.Before(s2) = true
s1.Before(s3) = true
s2.Before(s1) = false

func (Semester[T]) Compare 

func (s Semester[T]) Compare(u Semester[T]) int

Compare compares the Semester instant s with u. If s is before u, it returns -1; if s is after u, it returns +1; if they're the same, it returns 0.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2023, 1, 1, 0, 0, 0, 0)
	d2 := synchro.New[tz.UTC](2023, 6, 30, 23, 59, 59, 999999999)
	d3 := synchro.New[tz.UTC](2023, 7, 1, 0, 0, 0, 0)
	d4 := synchro.New[tz.UTC](2024, 1, 1, 0, 0, 0, 0)

	s1 := d1.Semester()
	s2 := d2.Semester()
	s3 := d3.Semester()
	s4 := d4.Semester()

	fmt.Printf("s1.Compare(s2) = %d\n", s1.Compare(s2))
	fmt.Printf("s1.Compare(s3) = %d\n", s1.Compare(s3))
	fmt.Printf("s4.Compare(s1) = %d\n", s4.Compare(s1))

}

Output:

s1.Compare(s2) = 0
s1.Compare(s3) = -1
s4.Compare(s1) = 1

func (Semester[T]) End 

func (s Semester[T]) End() Time[T]

End returns end time in the semester.

func (Semester[T]) Number 

func (s Semester[T]) Number() int

Number returns the number of semester.

func (Semester[T]) Start 

func (s Semester[T]) Start() Time[T]

Start returns start time in the semester.

func (Semester[T]) Year 

func (s Semester[T]) Year() int

Year returns the year in which s occurs.

type Time 

type Time[T TimeZone] struct {
	// contains filtered or unexported fields
}

func ConvertTz 

func ConvertTz[T TimeZone, U TimeZone](from Time[T]) Time[U]

ConvertTz can be used to convert a time from one time zone to another.

For example to convert from UTC to Asia/Tokyo. If `2009-11-10 23:00:00 +0000 UTC` as input, the output will be `2009-11-11 08:00:00 +0900 Asia/Tokyo`.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	utc := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	fmt.Printf("Go launched at %s\n", utc)

	jst := synchro.ConvertTz[tz.UTC, tz.AsiaTokyo](utc)
	fmt.Printf("Go launched at %s\n", jst)
}

Output:

Go launched at 2009-11-10 23:00:00 +0000 UTC
Go launched at 2009-11-11 08:00:00 +0900 JST

func In 

func In[T TimeZone](tm time.Time) Time[T]

In returns timezone-aware time.

If the given time.Time is the zero value, a zero value Time[T] is returned. A zero value Time[T] is not timezone-aware. Always set UTC.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d := time.Date(2023, 9, 2, 14, 0, 0, 0, time.UTC)
	utc := synchro.In[tz.UTC](d)
	fmt.Println(utc)

	jst := synchro.In[tz.AsiaTokyo](d)
	fmt.Println(jst)
}

Output:

2023-09-02 14:00:00 +0000 UTC
2023-09-02 23:00:00 +0900 JST

func New 

func New[T TimeZone](year int, month time.Month, day int, hour int, min int, sec int, nsec int) Time[T]

New returns the Time corresponding to 

yyyy-mm-dd hh:mm:ss + nsec nanoseconds

in the appropriate zone for that time in the given timezone.

The month, day, hour, min, sec, and nsec values may be outside their usual ranges and will be normalized during the conversion. For example, October 32 converts to November 1.

A daylight savings time transition skips or repeats times. For example, in the United States, March 13, 2011 2:15am never occurred, while November 6, 2011 1:15am occurred twice. In such cases, the choice of time zone, and therefore the time, is not well-defined. Date returns a time that is correct in one of the two zones involved in the transition, but it does not guarantee which.

This is a simple wrapper function for time.Date.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	utc := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	fmt.Printf("Go launched at %s\n", utc)
}

Output:

Go launched at 2009-11-10 23:00:00 +0000 UTC

func Now 

func Now[T TimeZone]() Time[T]

Now returns the current time with timezone.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	// The current UTC time is fixed to `2023-09-02 14:00:00`.
	utcNow := synchro.Now[tz.UTC]()
	fmt.Println(utcNow)

	jstNow := synchro.Now[tz.AsiaTokyo]()
	fmt.Println(jstNow)
}

Output:

2023-09-02 14:00:00 +0000 UTC
2023-09-02 23:00:00 +0900 JST

func NowContext 

func NowContext[T TimeZone](ctx context.Context) Time[T]

NowContext returns the current time stored in the provided context. If the time is not found in the context, it returns zero value.

NowContext and NowWithContext are useful when you want to store the current time within the context of the executing logic. For example, in scenarios where you consider the entire lifecycle of an HTTP request, from its initiation to the response.

By capturing the timestamp when the request occurs and fixing it as the current time, you can achieve consistent handling of the current time throughout that request. This ensures uniformity in dealing with the current time within the scope of that specific request.

Example 
package main

import (
	"context"
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	// This is the timestamp when the request occurred.
	// The current UTC time is fixed to `2023-09-02 14:00:00`.
	timestamp := synchro.Now[tz.UTC]()

	// The context of the request.
	ctx := context.Background()

	// Set the current time within the request context.Context.
	ctx = synchro.NowWithContext[tz.UTC](ctx, timestamp)
	utcNow := synchro.NowContext[tz.UTC](ctx)
	fmt.Println(utcNow)

	// A zero value is returned because the time is not stored in the same timezone.
	jstNow := synchro.NowContext[tz.AsiaTokyo](ctx)
	fmt.Println(jstNow)
}

Output:

2023-09-02 14:00:00 +0000 UTC
0001-01-01 00:00:00 +0000 UTC

func Parse 

func Parse[T TimeZone](layout, value string) (Time[T], error)

Parse parses a formatted string and returns the time value it represents. See the documentation for the constant called Layout to see how to represent the format. The second argument must be parseable using the format string (layout) provided as the first argument.

This is a simple wrapper function for time.ParseInLocation.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func init() {
	synchro.SetNow(func() time.Time {
		return time.Date(2023, 9, 2, 14, 0, 0, 0, time.UTC)
	})
}

type EuropeBerlin struct{}

func (EuropeBerlin) Location() *time.Location {
	loc, _ := time.LoadLocation("Europe/Berlin")
	return loc
}

func main() {
	const longForm = "Jan 2, 2006 at 3:04pm (MST)"
	t, _ := synchro.Parse[EuropeBerlin](longForm, "Jul 9, 2012 at 5:02am (CEST)")
	fmt.Println(t)

	// Note: without explicit zone, returns time in given location.
	const shortForm = "2006-Jan-02"
	t, _ = synchro.Parse[EuropeBerlin](shortForm, "2012-Jul-09")
	fmt.Println(t)

	_, err := synchro.Parse[tz.UTC](time.RFC3339, time.RFC3339)
	fmt.Println("error", err) // Returns an error as the layout is not a valid time value

}

Output:

2012-07-09 05:02:00 +0200 CEST
2012-07-09 00:00:00 +0200 CEST
error parsing time "2006-01-02T15:04:05Z07:00": extra text: "07:00"

func ParseISO added in v0.0.5 

func ParseISO[T TimeZone](value string) (Time[T], error)

ParseISO parses an ISO8601-compliant date or datetime string and returns its representation as a Time. If the input string does not conform to the ISO8601 standard or if any other parsing error occurs, an error is returned. Supported formats include: 

Basic                        Extended
20070301                     2007-03-01
2012W521                     2012-W52-1
2012Q485                     2012-Q4-85
20070301T1300Z               2007-03-01T13:00Z
20070301T1300Z               2007-03-01T13:00Z
20070301T1300+0100           2007-03-01T13:00+01:00
20070301T1300-0600           2007-03-01T13:00-06:00
20070301T130045Z             2007-03-01T13:00:45Z
20070301T130045+0100         2007-03-01T13:00:45+01:00
... and other combinations

func Unix 

func Unix[T TimeZone](sec int64, nsec int64) Time[T]

Unix returns the local Time corresponding to the given Unix time, sec seconds and nsec nanoseconds since January 1, 1970 UTC. It is valid to pass nsec outside the range [0, 999999999]. Not all sec values have a corresponding time value. One such value is 1<<63-1 (the largest int64 value).

This is a simple wrapper function for time.Unix.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	unixTime := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	fmt.Println(unixTime.Unix())
	t := synchro.Unix[tz.UTC](unixTime.Unix(), 0)
	fmt.Println(t)

}

Output:

1257894000
2009-11-10 23:00:00 +0000 UTC

func UnixMicro 

func UnixMicro[T TimeZone](usec int64) Time[T]

UnixMicro returns the local Time corresponding to the given Unix time, usec microseconds since January 1, 1970 UTC.

This is a simple wrapper function for time.UnixMicro.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	umt := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	fmt.Println(umt.UnixMicro())
	t := synchro.UnixMicro[tz.UTC](umt.UnixMicro())
	fmt.Println(t)

}

Output:

1257894000000000
2009-11-10 23:00:00 +0000 UTC

func UnixMilli 

func UnixMilli[T TimeZone](msec int64) Time[T]

UnixMilli returns the local Time corresponding to the given Unix time, msec milliseconds since January 1, 1970 UTC.

This is a simple wrapper function for time.UnixMilli.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	umt := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	fmt.Println(umt.UnixMilli())
	t := synchro.UnixMilli[tz.UTC](umt.UnixMilli())
	fmt.Println(t)

}

Output:

1257894000000
2009-11-10 23:00:00 +0000 UTC

func (Time[T]) Add 

func (t Time[T]) Add(d time.Duration) Time[T]

Add returns the time t+d.

This is a simple wrapper method for (time.Time{}).Add.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	start := synchro.New[tz.UTC](2009, 1, 1, 12, 0, 0, 0)
	afterTenSeconds := start.Add(time.Second * 10)
	afterTenMinutes := start.Add(time.Minute * 10)
	afterTenHours := start.Add(time.Hour * 10)
	afterTenDays := start.Add(time.Hour * 24 * 10)

	fmt.Printf("start = %v\n", start)
	fmt.Printf("start.Add(time.Second * 10) = %v\n", afterTenSeconds)
	fmt.Printf("start.Add(time.Minute * 10) = %v\n", afterTenMinutes)
	fmt.Printf("start.Add(time.Hour * 10) = %v\n", afterTenHours)
	fmt.Printf("start.Add(time.Hour * 24 * 10) = %v\n", afterTenDays)

}

Output:

start = 2009-01-01 12:00:00 +0000 UTC
start.Add(time.Second * 10) = 2009-01-01 12:00:10 +0000 UTC
start.Add(time.Minute * 10) = 2009-01-01 12:10:00 +0000 UTC
start.Add(time.Hour * 10) = 2009-01-01 22:00:00 +0000 UTC
start.Add(time.Hour * 24 * 10) = 2009-01-11 12:00:00 +0000 UTC

func (Time[T]) AddDate 

func (t Time[T]) AddDate(years int, months int, days int) Time[T]

AddDate returns the time corresponding to adding the given number of years, months, and days to t.

This is a simple wrapper method for (time.Time{}).AddDate.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	start := synchro.New[tz.UTC](2009, 1, 1, 0, 0, 0, 0)
	oneDayLater := start.AddDate(0, 0, 1)
	oneMonthLater := start.AddDate(0, 1, 0)
	oneYearLater := start.AddDate(1, 0, 0)

	fmt.Printf("oneDayLater: start.AddDate(0, 0, 1) = %v\n", oneDayLater)
	fmt.Printf("oneMonthLater: start.AddDate(0, 1, 0) = %v\n", oneMonthLater)
	fmt.Printf("oneYearLater: start.AddDate(1, 0, 0) = %v\n", oneYearLater)

}

Output:

oneDayLater: start.AddDate(0, 0, 1) = 2009-01-02 00:00:00 +0000 UTC
oneMonthLater: start.AddDate(0, 1, 0) = 2009-02-01 00:00:00 +0000 UTC
oneYearLater: start.AddDate(1, 0, 0) = 2010-01-01 00:00:00 +0000 UTC

func (Time[T]) Advance added in v0.0.8 

func (t Time[T]) Advance(u1 unit, u2 ...unit) Time[T]

Advance adjusts the time based on the provided unit values, moving it forward in time. u1 is a required unit, while u2... can be provided as additional optional units. This method returns a new Time[T] and does not modify the original. The time is adjusted in the order the units are provided.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

// shorthand way
type Y = synchro.Year
type M = synchro.Month
type D = synchro.Day
type HH = synchro.Hour
type MM = synchro.Minute
type SS = synchro.Second
type NS = synchro.Nanosecond

func main() {
	utc := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	c1 := utc.Advance(synchro.Year(1))
	c11 := utc.Advance(Y(1), Y(1)) // +2 years

	c2 := utc.Advance(Y(1), M(1))
	c3 := utc.Advance(Y(1), M(1), D(1))
	c4 := c3.Advance(HH(1))
	c5 := c3.Advance(HH(1), MM(1))
	c6 := c3.Advance(HH(1), MM(1), SS(1))
	c7 := c3.Advance(HH(1), MM(1), SS(1), NS(123456789))

	fmt.Printf("Go launched at %s\n", utc)
	fmt.Println(c1)
	fmt.Println(c11)
	fmt.Println()
	fmt.Println(c2)
	fmt.Println(c3)
	fmt.Println(c4)
	fmt.Println(c5)
	fmt.Println(c6)
	fmt.Println(c7)
}

Output:

Go launched at 2009-11-10 23:00:00 +0000 UTC
2010-11-10 23:00:00 +0000 UTC
2011-11-10 23:00:00 +0000 UTC

2010-12-10 23:00:00 +0000 UTC
2010-12-11 23:00:00 +0000 UTC
2010-12-12 00:00:00 +0000 UTC
2010-12-12 00:01:00 +0000 UTC
2010-12-12 00:01:01 +0000 UTC
2010-12-12 00:01:01.123456789 +0000 UTC

func (Time[T]) After 

func (t Time[T]) After(u Time[T]) bool

After reports whether the time instant t is after u.

If you want to compare time.Time as a parameter, please use with the Time method.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	year2000 := synchro.New[tz.UTC](2000, 1, 1, 0, 0, 0, 0)
	year3000 := synchro.New[tz.UTC](3000, 1, 1, 0, 0, 0, 0)

	isYear3000AfterYear2000 := year3000.After(year2000) // True
	isYear2000AfterYear3000 := year2000.After(year3000) // False

	fmt.Printf("year3000.After(year2000) = %v\n", isYear3000AfterYear2000)
	fmt.Printf("year2000.After(year3000) = %v\n", isYear2000AfterYear3000)

}

Output:

year3000.After(year2000) = true
year2000.After(year3000) = false

func (Time[T]) AppendFormat 

func (t Time[T]) AppendFormat(b []byte, layout string) []byte

AppendFormat is like Format but appends the textual representation to b and returns the extended buffer.

This is a simple wrapper method for (time.Time{}).AppendFormat.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	t := synchro.New[tz.UTC](2017, time.November, 4, 11, 0, 0, 0)
	text := []byte("Time: ")

	text = t.AppendFormat(text, time.Kitchen)
	fmt.Println(string(text))

}

Output:

Time: 11:00AM

func (Time[T]) Before 

func (t Time[T]) Before(u Time[T]) bool

Before reports whether the time instant t is before u.

If you want to compare time.Time as a parameter, please use with the Time method.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	year2000 := synchro.New[tz.UTC](2000, 1, 1, 0, 0, 0, 0)
	year3000 := synchro.New[tz.UTC](3000, 1, 1, 0, 0, 0, 0)

	isYear2000BeforeYear3000 := year2000.Before(year3000) // True
	isYear3000BeforeYear2000 := year3000.Before(year2000) // False

	fmt.Printf("year2000.Before(year3000) = %v\n", isYear2000BeforeYear3000)
	fmt.Printf("year3000.Before(year2000) = %v\n", isYear3000BeforeYear2000)

}

Output:

year2000.Before(year3000) = true
year3000.Before(year2000) = false

func (Time[T]) Change added in v0.0.8 

func (t Time[T]) Change(u1 unit, u2 ...unit) Time[T]

Change modifies the time based on the provided unit values. u1 is a required unit, while u2... can be provided as additional optional units. This method returns a new Time[T] and does not modify the original.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

// shorthand way
type Y = synchro.Year
type M = synchro.Month
type D = synchro.Day
type HH = synchro.Hour
type MM = synchro.Minute
type SS = synchro.Second
type NS = synchro.Nanosecond

func main() {
	utc := synchro.New[tz.UTC](2009, time.November, 10, 23, 0, 0, 0)
	c1 := utc.Change(synchro.Year(2010))
	c2 := utc.Change(synchro.Year(2010), synchro.Month(time.December))
	c3 := utc.Change(Y(2010), M(time.December), D(1))
	c4 := c3.Change(synchro.Hour(1))
	c5 := c3.Change(HH(1), MM(1))
	c6 := c3.Change(HH(1), MM(1), SS(1))
	c7 := c3.Change(HH(1), MM(1), SS(1), NS(123456789))
	fmt.Printf("Go launched at %s\n", utc)
	fmt.Println(c1)
	fmt.Println(c2)
	fmt.Println(c3)
	fmt.Println(c4)
	fmt.Println(c5)
	fmt.Println(c6)
	fmt.Println(c7)
}

Output:

Go launched at 2009-11-10 23:00:00 +0000 UTC
2010-11-10 23:00:00 +0000 UTC
2010-12-10 23:00:00 +0000 UTC
2010-12-01 23:00:00 +0000 UTC
2010-12-01 01:00:00 +0000 UTC
2010-12-01 01:01:00 +0000 UTC
2010-12-01 01:01:01 +0000 UTC
2010-12-01 01:01:01.123456789 +0000 UTC

func (Time[T]) Clock 

func (t Time[T]) Clock() (hour, min, sec int)

Clock returns the hour, minute, and second within the day specified by t.

This is a simple wrapper method for (time.Time{}).Clock.

func (Time[T]) Compare 

func (t Time[T]) Compare(u Time[T]) int

Compare compares the time instant t with u. If t is before u, it returns -1; if t is after u, it returns +1; if they're the same, it returns 0.

If you want to compare time.Time as a parameter, please use with the Time method.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	base := synchro.New[tz.UTC](2000, 1, 1, 1, 0, 0, 0)
	before := synchro.New[tz.UTC](2000, 1, 1, 0, 0, 0, 0)
	after := synchro.New[tz.UTC](3000, 1, 1, 2, 0, 0, 0)

	isSame := base.Compare(base)
	isAfter := base.Compare(after)
	isBefore := base.Compare(before)

	fmt.Printf("base.Compare(base) = %d\n", isSame)
	fmt.Printf("base.Compare(after) = %d\n", isAfter)
	fmt.Printf("base.Compare(before) = %d\n", isBefore)

}

Output:

base.Compare(base) = 0
base.Compare(after) = -1
base.Compare(before) = 1

func (Time[T]) Date 

func (t Time[T]) Date() (year int, month time.Month, day int)

Date returns the year, month, and day in which t occurs.

This is a simple wrapper method for (time.Time{}).Date.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d := synchro.New[tz.UTC](2000, 2, 1, 12, 30, 0, 0)
	year, month, day := d.Date()

	fmt.Printf("year = %v\n", year)
	fmt.Printf("month = %v\n", month)
	fmt.Printf("day = %v\n", day)

}

Output:

year = 2000
month = February
day = 1

func (Time[T]) Day 

func (t Time[T]) Day() int

Day returns the day of the month specified by t.

This is a simple wrapper method for (time.Time{}).Day.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d := synchro.New[tz.UTC](2000, 2, 1, 12, 30, 0, 0)
	day := d.Day()

	fmt.Printf("day = %v\n", day)

}

Output:

day = 1

func (Time[T]) DiffInCalendarDays added in v0.0.5 

func (t Time[T]) DiffInCalendarDays(u Time[T]) int

DiffInCalendarDays calculates the difference in calendar days between t and u. (t-u) Calendar days are calculated by considering only the dates, excluding the times, and then determining the difference in days.

func (Time[T]) EndOfMonth 

func (t Time[T]) EndOfMonth() Time[T]

EndOfMonth returns Time for end of the month.

func (Time[T]) EndOfQuarter 

func (t Time[T]) EndOfQuarter() Time[T]

EndOfQuarter returns a Time for end of the quarter.

func (Time[T]) EndOfSemester 

func (t Time[T]) EndOfSemester() Time[T]

EndOfSemester returns a Time for end of the semester.

func (Time[T]) EndOfWeek 

func (t Time[T]) EndOfWeek() Time[T]

EndOfWeek returns Time for end of the week.

func (Time[T]) EndOfYear 

func (t Time[T]) EndOfYear() Time[T]

EndOfYear returns Time for end of the year.

func (Time[T]) Equal 

func (t Time[T]) Equal(u Time[T]) bool

Equal reports whether t and u represent the same time instant.

If you want to compare time.Time as a parameter, please use with the Time method.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	d1 := synchro.New[tz.UTC](2000, 2, 1, 12, 30, 0, 0)
	d2, _ := synchro.Parse[tz.UTC]("2006 Jan 02 15:04:05 (MST)", "2000 Feb 01 12:30:00 (JST)")

	datesEqualUsingEqualOperator := d1 == d2
	datesEqualUsingFunction := d1.Equal(d2)

	fmt.Printf("d1 = %q\n", d1)
	fmt.Printf("d2 = %q\n", d2)
	fmt.Printf("datesEqualUsingEqualOperator = %v\n", datesEqualUsingEqualOperator)
	fmt.Printf("datesEqualUsingFunction = %v\n", datesEqualUsingFunction)

}

Output:

d1 = "2000-02-01 12:30:00 +0000 UTC"
d2 = "2000-02-01 12:30:00 +0000 UTC"
datesEqualUsingEqualOperator = true
datesEqualUsingFunction = true

func (Time[T]) Format 

func (t Time[T]) Format(layout string) string

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

This is a simple wrapper method for (time.Time{}).Format.

func (Time[T]) GoString 

func (t Time[T]) GoString() string

GoString implements fmt.GoStringer and formats t to be printed in Go source code.

This is a simple wrapper method for (time.Time{}).GoString.

func (*Time[T]) GobDecode 

func (t *Time[T]) GobDecode(data []byte) error

GobDecode implements the gob.GobDecoder interface.

This is a simple wrapper method for (time.Time{}).GobDecode.

func (Time[T]) GobEncode 

func (t Time[T]) GobEncode() ([]byte, error)

GobEncode implements the gob.GobEncoder interface.

This is a simple wrapper method for (time.Time{}).GobEncode.

func (Time[T]) Hour 

func (t Time[T]) Hour() int

Hour returns the hour within the day specified by t, in the range [0, 23].

This is a simple wrapper method for (time.Time{}).Hour.

func (Time[T]) ISOWeek 

func (t Time[T]) ISOWeek() (year, week int)

ISOWeek returns the ISO 8601 year and week number in which t occurs.

This is a simple wrapper method for (time.Time{}).ISOWeek.

func (Time[T]) IsBetween 

func (t Time[T]) IsBetween(from Time[T], to Time[T]) bool

IsBetween returns true if from < t && t < to.

func (Time[T]) IsDST 

func (t Time[T]) IsDST() bool

IsDST reports whether the time in the configured location is in Daylight Savings Time.

This is a simple wrapper method for (time.Time{}).IsDST.

func (Time[T]) IsLeapYear 

func (t Time[T]) IsLeapYear() bool

IsLeapYear returns true if t is leap year.

func (Time[T]) IsZero 

func (t Time[T]) IsZero() bool

IsZero reports whether t represents the zero time instant, January 1, year 1, 00:00:00 UTC.

This is a simple wrapper method for (time.Time{}).IsZero.

func (Time[T]) Local 

func (t Time[T]) Local() Time[tz.Local]

Local returns t with the location set to local time.

func (Time[T]) Location 

func (t Time[T]) Location() *time.Location

Location returns the time zone information associated with t.

This is a simple wrapper method for (time.Time{}).Location.

func (Time[T]) MarshalBinary 

func (t Time[T]) MarshalBinary() ([]byte, error)

MarshalBinary implements the encoding.BinaryMarshaler interface.

This is a simple wrapper method for (time.Time{}).MarshalBinary.

func (Time[T]) MarshalJSON 

func (t Time[T]) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface. The time is a quoted string in the RFC 3339 format with sub-second precision. If the timestamp cannot be represented as valid RFC 3339 (e.g., the year is out of range), then an error is reported.

This is a simple wrapper method for (time.Time{}).MarshalJSON.

func (Time[T]) MarshalText 

func (t Time[T]) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface. The time is formatted in RFC 3339 format with sub-second precision. If the timestamp cannot be represented as valid RFC 3339 (e.g., the year is out of range), then an error is reported.

This is a simple wrapper method for (time.Time{}).MarshalText.

func (Time[T]) Minute 

func (t Time[T]) Minute() int

Minute returns the minute offset within the hour specified by t, in the range [0, 59].

This is a simple wrapper method for (time.Time{}).Minute.

func (Time[T]) Month 

func (t Time[T]) Month() time.Month

Month returns the month of the year specified by t.

This is a simple wrapper method for (time.Time{}).Month.

func (Time[T]) Nanosecond 

func (t Time[T]) Nanosecond() int

Nanosecond returns the nanosecond offset within the second specified by t, in the range [0, 999999999].

This is a simple wrapper method for (time.Time{}).Nanosecond.

func (Time[T]) Quarter 

func (t Time[T]) Quarter() Quarter[T]

Quarter gets current quarter.

func (Time[T]) Round 

func (t Time[T]) Round(d time.Duration) Time[T]

Round returns the result of rounding t to the nearest multiple of d (since the zero time). The rounding behavior for halfway values is to round up. If d <= 0, Round returns t stripped of any monotonic clock reading but otherwise unchanged.

This is a simple wrapper method for (time.Time{}).Round.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	t := synchro.New[tz.UTC](0, 0, 0, 12, 15, 30, 918273645)
	round := []time.Duration{
		time.Nanosecond,
		time.Microsecond,
		time.Millisecond,
		time.Second,
		2 * time.Second,
		time.Minute,
		10 * time.Minute,
		time.Hour,
	}

	for _, d := range round {
		fmt.Printf("t.Round(%6s) = %s\n", d, t.Round(d).Format("15:04:05.999999999"))
	}
}

Output:

t.Round(   1ns) = 12:15:30.918273645
t.Round(   1µs) = 12:15:30.918274
t.Round(   1ms) = 12:15:30.918
t.Round(    1s) = 12:15:31
t.Round(    2s) = 12:15:30
t.Round(  1m0s) = 12:16:00
t.Round( 10m0s) = 12:20:00
t.Round(1h0m0s) = 12:00:00

func (*Time[T]) Scan added in v0.0.4 

func (t *Time[T]) Scan(src any) error

Scan implements the sql.Scanner interface.

func (Time[T]) Second 

func (t Time[T]) Second() int

Second returns the second offset within the minute specified by t, in the range [0, 59].

This is a simple wrapper method for (time.Time{}).Second.

func (Time[T]) Semester 

func (t Time[T]) Semester() Semester[T]

Semester gets current semester.

func (Time[T]) StartOfMonth 

func (t Time[T]) StartOfMonth() Time[T]

StartOfMonth returns Time for start of the month.

func (Time[T]) StartOfQuarter 

func (t Time[T]) StartOfQuarter() Time[T]

StartOfQuarter returns a Time for start of the quarter.

func (Time[T]) StartOfSemester 

func (t Time[T]) StartOfSemester() Time[T]

StartOfSemester returns a Time for start of the semester.

func (Time[T]) StartOfWeek 

func (t Time[T]) StartOfWeek() Time[T]

StartOfWeek returns Time for start of the week.

func (Time[T]) StartOfYear 

func (t Time[T]) StartOfYear() Time[T]

StartOfYear returns Time for start of the year.

func (Time[T]) StdTime 

func (t Time[T]) StdTime() time.Time

StdTime returns the time.Time.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	want := time.Date(2023, 9, 2, 14, 0, 0, 0, time.UTC)
	got1 := synchro.In[tz.UTC](want).StdTime()
	got2 := synchro.In[tz.AsiaTokyo](want).StdTime()
	fmt.Println(want.Equal(got1))
	fmt.Println(want.Equal(got2))
}

Output:

true
true

func (Time[T]) String 

func (t Time[T]) String() string

String returns the time formatted using the format string 

"2006-01-02 15:04:05.999999999 -0700 MST"

If the time has a monotonic clock reading, the returned string includes a final field "m=±<value>", where value is the monotonic clock reading formatted as a decimal number of seconds.

This is a simple wrapper method for (time.Time{}).String.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	timeWithNanoseconds := synchro.New[tz.UTC](2000, 2, 1, 12, 13, 14, 15)
	withNanoseconds := timeWithNanoseconds.String()

	timeWithoutNanoseconds := synchro.New[tz.UTC](2000, 2, 1, 12, 13, 14, 0)
	withoutNanoseconds := timeWithoutNanoseconds.String()

	fmt.Printf("withNanoseconds = %v\n", string(withNanoseconds))
	fmt.Printf("withoutNanoseconds = %v\n", string(withoutNanoseconds))

}

Output:

withNanoseconds = 2000-02-01 12:13:14.000000015 +0000 UTC
withoutNanoseconds = 2000-02-01 12:13:14 +0000 UTC

func (Time[T]) Sub 

func (t Time[T]) Sub(u Time[T]) time.Duration

Sub returns the duration t-u. If the result exceeds the maximum (or minimum) value that can be stored in a Duration, the maximum (or minimum) duration will be returned. To compute t-d for a duration d, use t.Add(-d).

This is a simple wrapper method for (time.Time{}).Sub.

Example 
package main

import (
	"fmt"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	start := synchro.New[tz.UTC](2000, 1, 1, 0, 0, 0, 0)
	end := synchro.New[tz.UTC](2000, 1, 1, 12, 0, 0, 0)

	difference := end.Sub(start)
	fmt.Printf("difference = %v\n", difference)

}

Output:

difference = 12h0m0s

func (Time[T]) Truncate 

func (t Time[T]) Truncate(d time.Duration) Time[T]

Truncate returns the result of rounding t down to a multiple of d (since the zero time). If d <= 0, Truncate returns t stripped of any monotonic clock reading but otherwise unchanged.

This is a simple wrapper method for (time.Time{}).Truncate.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func init() {
	synchro.SetNow(func() time.Time {
		return time.Date(2023, 9, 2, 14, 0, 0, 0, time.UTC)
	})
}

func main() {
	t, _ := synchro.Parse[tz.UTC]("2006 Jan 02 15:04:05", "2012 Dec 07 12:15:30.918273645")
	trunc := []time.Duration{
		time.Nanosecond,
		time.Microsecond,
		time.Millisecond,
		time.Second,
		2 * time.Second,
		time.Minute,
		10 * time.Minute,
	}

	for _, d := range trunc {
		fmt.Printf("t.Truncate(%5s) = %s\n", d, t.Truncate(d).Format("15:04:05.999999999"))
	}
	// To round to the last midnight in the local timezone, create a new Date.
	midnight := synchro.New[tz.UTC](t.Year(), t.Month(), t.Day(), 0, 0, 0, 0)
	_ = midnight

}

Output:

t.Truncate(  1ns) = 12:15:30.918273645
t.Truncate(  1µs) = 12:15:30.918273
t.Truncate(  1ms) = 12:15:30.918
t.Truncate(   1s) = 12:15:30
t.Truncate(   2s) = 12:15:30
t.Truncate( 1m0s) = 12:15:00
t.Truncate(10m0s) = 12:10:00

func (Time[T]) Unix 

func (t Time[T]) Unix() int64

Unix returns t as a Unix time, the number of seconds elapsed since January 1, 1970 UTC. The result does not depend on the location associated with t. Unix-like operating systems often record time as a 32-bit count of seconds, but since the method here returns a 64-bit value it is valid for billions of years into the past or future.

This is a simple wrapper method for (time.Time{}).Unix.

Example 
package main

import (
	"fmt"
	"time"

	"github.com/Code-Hex/synchro"
	"github.com/Code-Hex/synchro/tz"
)

func main() {
	// 1 billion seconds of Unix, three ways.
	fmt.Println(synchro.Unix[tz.UTC](1e9, 0))     // 1e9 seconds
	fmt.Println(synchro.Unix[tz.UTC](0, 1e18))    // 1e18 nanoseconds
	fmt.Println(synchro.Unix[tz.UTC](2e9, -1e18)) // 2e9 seconds - 1e18 nanoseconds

	t := synchro.New[tz.UTC](2001, time.September, 9, 1, 46, 40, 0)
	fmt.Println(t.Unix())     // seconds since 1970
	fmt.Println(t.UnixNano()) // nanoseconds since 1970

}

Output:

2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
2001-09-09 01:46:40 +0000 UTC
1000000000
1000000000000000000

func (Time[T]) UnixMicro 

func (t Time[T]) UnixMicro() int64

UnixMicro returns t as a Unix time, the number of microseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in microseconds cannot be represented by an int64 (a date before year -290307 or after year 294246). The result does not depend on the location associated with t.

This is a simple wrapper method for (time.Time{}).UnixMicro.

func (Time[T]) UnixMilli 

func (t Time[T]) UnixMilli() int64

UnixMilli returns t as a Unix time, the number of milliseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in milliseconds cannot be represented by an int64 (a date more than 292 million years before or after 1970). The result does not depend on the location associated with t.

This is a simple wrapper method for (time.Time{}).UnixMilli.

func (Time[T]) UnixNano 

func (t Time[T]) UnixNano() int64

UnixNano returns t as a Unix time, the number of nanoseconds elapsed since January 1, 1970 UTC. The result is undefined if the Unix time in nanoseconds cannot be represented by an int64 (a date before the year 1678 or after 2262). Note that this means the result of calling UnixNano on the zero Time is undefined. The result does not depend on the location associated with t.

This is a simple wrapper method for (time.Time{}).UnixNano.

func (*Time[T]) UnmarshalBinary 

func (t *Time[T]) UnmarshalBinary(data []byte) error

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.

This is a simple wrapper method for (time.Time{}).UnmarshalBinary.

func (*Time[T]) UnmarshalJSON 

func (t *Time[T]) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface. The time must be a quoted string in the RFC 3339 format.

This is a simple wrapper method for (time.Time{}).UnmarshalJSON.

func (*Time[T]) UnmarshalText 

func (t *Time[T]) UnmarshalText(data []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface. The time must be in the RFC 3339 format.

This is a simple wrapper method for (time.Time{}).MarshalText.

func (Time[T]) Value added in v0.0.4 

func (t Time[T]) Value() (driver.Value, error)

Value implements the driver.Valuer interface.

func (Time[T]) Weekday 

func (t Time[T]) Weekday() time.Weekday

Weekday returns the day of the week specified by t.

This is a simple wrapper method for (time.Time{}).Weekday.

func (Time[T]) Year 

func (t Time[T]) Year() int

Year returns the year in which t occurs.

This is a simple wrapper method for (time.Time{}).Year.

func (Time[T]) YearDay 

func (t Time[T]) YearDay() int

YearDay returns the day of the year specified by t, in the range [1,365] for non-leap years, and [1,366] in leap years.

This is a simple wrapper method for (time.Time{}).YearDay.

func (Time[T]) Zone 

func (t Time[T]) Zone() (name string, offset int)

Zone computes the time zone in effect at time t, returning the abbreviated name of the zone (such as "CET") and its offset in seconds east of UTC.

This is a simple wrapper method for (time.Time{}).Zone.

func (Time[T]) ZoneBounds 

func (t Time[T]) ZoneBounds() (start, end Time[T])

ZoneBounds returns the bounds of the time zone in effect at time t. The zone begins at start and the next zone begins at end. If the zone begins at the beginning of time, start will be returned as a zero Time. If the zone goes on forever, end will be returned as a zero Time. The Location of the returned times will be the same as t.

This is a simple wrapper method for (time.Time{}).ZoneBounds.

type TimeZone 

type TimeZone interface {
	Location() *time.Location
}

TimeZone represents the timezone.

type Year added in v0.0.9 

type Year int

Year sets the year component of the time being built.

Source Files

View all Source files

Directories

Path Synopsis
scripts
tzgen
Package tz provides timezone related types.
 Package tz provides timezone related types.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.