Goda

https://pkg.go.dev/github.com/iseki0/goda
Admin
Goda is a Go library providing Java-like date and time types including LocalDate, LocalTime,...
Tokens:132,992
Snippets:1,036
Trust Score:10
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install goda Go Package

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

This snippet shows the command to install the goda package using the Go build tool. Ensure you have Go installed and configured in your environment.

```bash
go get github.com/iseki0/goda

```

--------------------------------

### Field Constants and Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Constants representing various date and time fields, and functions to get all fields or field names.

```APIDOC
## Field Constants and Functions

### Description
Defines constants for different date and time fields and provides functions to access and query them.

### Field Constants

- `FieldAlignedDayOfWeekInMonth`
- `FieldAlignedDayOfWeekInYear`
- `FieldAlignedWeekOfMonth`
- `FieldAlignedWeekOfYear`
- `FieldAmPmOfDay`
- `FieldClockHourOfAmPm`
- `FieldClockHourOfDay`
- `FieldDayOfMonth`
- `FieldDayOfWeek`
- `FieldDayOfYear`
- `FieldEpochDay`
- `FieldEra`
- `FieldHourOfAmPm`
- `FieldHourOfDay`
- `FieldInstantSeconds`
- `FieldMicroOfDay`
- `FieldMicroOfSecond`
- `FieldMilliOfDay`
- `FieldMilliOfSecond`
- `FieldMinuteOfDay`
- `FieldMinuteOfHour`
- `FieldMonthOfYear`
- `FieldNanoOfDay`
- `FieldNanoOfSecond`
- `FieldOffsetSeconds`
- `FieldProlepticMonth`
- `FieldSecondOfDay`
- `FieldSecondOfMinute`
- `FieldYear`
- `FieldYearOfEra`

### GetAllFields

```go
func GetAllFields() []Field
```

**Description:** Returns a slice containing all available `Field` constants.

### JavaName

```go
func (f Field) JavaName() string
```

**Description:** Returns the Java-style name of the `Field`.
```

--------------------------------

### ZoneOffset Utility Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Functions to get the maximum and minimum supported ZoneOffsets, and the UTC offset.

```APIDOC
## ZoneOffset Utility Functions

### ZoneOffsetMax

#### Description
Returns the maximum supported offset (+18:00).

#### Method
`func ZoneOffsetMax() ZoneOffset`

### ZoneOffsetMin

#### Description
Returns the minimum supported offset (-18:00).

#### Method
`func ZoneOffsetMin() ZoneOffset`

### ZoneOffsetUTC

#### Description
Returns UTC offset (+00:00).

#### Method
`func ZoneOffsetUTC() ZoneOffset`
```

--------------------------------

### Year Leap Year Check Example

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Demonstrates how to use the IsLeapYear() method to determine if a given Year is a leap year. It shows examples for common leap and non-leap years.

```go
// ExampleYear_IsLeapYear demonstrates checking for leap years.
// Output:
// 2024 is leap: true
// 2023 is leap: false
// 2000 is leap: true
// 1900 is leap: false
```

--------------------------------

### Create and Parse Dates, Times, and Datetimes in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

This snippet demonstrates how to create specific or current date, time, and datetime instances using the goda package. It also shows parsing these values from ISO 8601 formatted strings. Error handling is managed via `Must` functions, which panic on invalid input.

```go
// Specific date and time
date := goda.MustNewLocalDate(2024, goda.March, 15)
time := goda.MustNewLocalTime(14, 30, 45, 0)
datetime := goda.NewLocalDateTime(date, time)

// Current date and time
today := goda.LocalDateNow()
now := goda.LocalTimeNow()
currentDateTime := goda.LocalDateTimeNow()

// Parse from string
date = goda.MustParseLocalDate("2024-03-15")
time = goda.MustParseLocalTime("14:30:45.123456789")
datetime = goda.MustParseLocalDateTime("2024-03-15T14:30:45.123456789")

```

--------------------------------

### Month Methods

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Defines methods for the `Month` type, including calculating the first day of the year, and determining month length.

```APIDOC
## Month Methods

### Description
Methods for the `Month` type, providing calendar-related calculations.

### Methods

- `FirstDayOfYear(isLeap bool) int`: Returns the day of the year for the first day of the month.
- `IsZero() bool`: Checks if the month is zero.
- `Length(isLeap bool) int`: Returns the number of days in the month, considering leap year.
- `MaxDays() int`: Returns the maximum number of days in the month.
- `String() string`: Returns the month name as a string.
```

--------------------------------

### Get Current OffsetDateTime in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Functions to obtain the current OffsetDateTime in different contexts. This includes getting the current time in UTC, the system's local time, or a specified location.

```Go
func OffsetDateTimeNow() OffsetDateTime
func OffsetDateTimeNowIn(loc *time.Location) OffsetDateTime
func OffsetDateTimeNowUTC() OffsetDateTime
```

--------------------------------

### LocalTime Methods and Constructors

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Details the constructors and methods for the `LocalTime` struct, enabling creation, comparison, and querying of time values.

```APIDOC
## LocalTime Methods and Constructors

### Description
Constructors and methods for the `LocalTime` struct, enabling time manipulation and comparison.

### Constructors

- `MustNewLocalTime(hour, minute, second, nanosecond int) LocalTime`: Creates a `LocalTime` instance, panicking on error.
- `NewLocalTime(hour, minute, second, nanosecond int) (LocalTime, error)`: Creates a `LocalTime` instance, returning an error if invalid.
- `NewLocalTimeByGoTime(t time.Time) LocalTime`: Creates a `LocalTime` from a `time.Time` object.

### Methods

- `Scan(src any) error`: Scans a value into the `LocalTime`.
- `UnmarshalJSON(bytes []byte) error`: Unmarshals a JSON byte slice into `LocalTime`.
- `UnmarshalText(text []byte) error`: Unmarshals a text byte slice into `LocalTime`.
- `Value() (driver.Value, error)`: Returns the `LocalTime` as a driver.Value.
- `AppendText(b []byte) ([]byte, error)`: Appends the text representation of `LocalTime` to a byte slice.
- `Compare(other LocalTime) int`: Compares two `LocalTime` instances.
- `GoTime() time.Time`: Converts `LocalTime` to `time.Time`.
- `Hour() int`: Returns the hour.
- `IsAfter(other LocalTime) bool`: Checks if the time is after another.
- `IsBefore(other LocalTime) bool`: Checks if the time is before another.
- `IsZero() bool`: Checks if the time is zero.
- `MarshalJSON() ([]byte, error)`: Marshals `LocalTime` to JSON.
- `MarshalText() (text []byte, err error)`: Marshals `LocalTime` to text.
- `Millisecond() int`: Returns the millisecond.
- `Minute() int`: Returns the minute.
- `Nanosecond() int`: Returns the nanosecond.
- `Second() int`: Returns the second.
- `String() string`: Returns the time as a string.
```

--------------------------------

### Get Current OffsetDateTime (UTC)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

OffsetDateTimeNowUTC returns the current date-time with the offset set to UTC. This is the standard way to get the current time in a universally comparable format, independent of local system settings.

```go
func OffsetDateTimeNowUTC() OffsetDateTime
```

--------------------------------

### Get Current Local Time

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

The LocalTimeNow function returns the current time in the system's local time zone. It is equivalent to NewLocalTimeByGoTime(time.Now()) and provides a convenient way to get the current local time.

```go
func LocalTimeNow() LocalTime
```

--------------------------------

### Create LocalTime Instances

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Functions for creating LocalTime instances, including from current time and Go's time.Time. Also includes a constructor for parsing from string representations.

```Go
func LocalTimeNow() LocalTime
func LocalTimeNowIn(loc *time.Location) LocalTime
func LocalTimeNowUTC() LocalTime
func MustParseLocalTime(s string) LocalTime
func ParseLocalTime(s string) (LocalTime, error)
```

--------------------------------

### ZoneOffset Creation Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Functions for creating ZoneOffset values with specific hour, minute, and second components.

```APIDOC
## ZoneOffset Creation Functions

### Description
Functions to create `ZoneOffset` instances with precise hour, minute, and second values.

### MustZoneOffsetOf

```go
func MustZoneOffsetOf(hours, minutes, seconds int) ZoneOffset
```

**Description:** Creates a `ZoneOffset` from hours, minutes, and seconds, panicking on error.

### MustZoneOffsetOfHours

```go
func MustZoneOffsetOfHours(hours int) ZoneOffset
```

**Description:** Creates a `ZoneOffset` from hours only, panicking on error.

### MustZoneOffsetOfHoursMinutes

```go
func MustZoneOffsetOfHoursMinutes(hours, minutes int) ZoneOffset
```

**Description:** Creates a `ZoneOffset` from hours and minutes, panicking on error.

### MustZoneOffsetOfSeconds

```go
func MustZoneOffsetOfSeconds(seconds int) ZoneOffset
```

**Description:** Creates a `ZoneOffset` from seconds only, panicking on error.

### ZoneOffsetMax

```go
func ZoneOffsetMax() ZoneOffset
```

**Description:** Returns the maximum possible `ZoneOffset`.

### ZoneOffsetMin

```go
func ZoneOffsetMin() ZoneOffset
```

**Description:** Returns the minimum possible `ZoneOffset`.

### ZoneOffsetOf

```go
func ZoneOffsetOf(hours, minutes, seconds int) (ZoneOffset, error)
```

**Description:** Creates a `ZoneOffset` from hours, minutes, and seconds, returning an error on failure.

### ZoneOffsetOfHours

```go
func ZoneOffsetOfHours(hours int) (ZoneOffset, error)
```

**Description:** Creates a `ZoneOffset` from hours only, returning an error on failure.

### ZoneOffsetOfHoursMinutes

```go
func ZoneOffsetOfHoursMinutes(hours, minutes int) (ZoneOffset, error)
```

**Description:** Creates a `ZoneOffset` from hours and minutes, returning an error on failure.

### ZoneOffsetOfSeconds

```go
func ZoneOffsetOfSeconds(seconds int) (ZoneOffset, error)
```

**Description:** Creates a `ZoneOffset` from seconds only, returning an error on failure.
```

--------------------------------

### LocalTime - String Representation

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Method for getting the string representation of LocalTime.

```APIDOC
## LocalTime - String Representation

### Description
Provides a string representation of the LocalTime.

### String
#### Method
`func (t LocalTime) String() string`

#### Description
Returns the string format of LocalTime, including fractional seconds.

#### Response Example
```
14:30:45
14:30:45.123
14:30:45.123456
14:30:45.123456789
14:30:45.100
```
```

--------------------------------

### Basic Usage of goda Date and Time Types in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

Demonstrates fundamental operations with goda's date and time types, including creation, parsing from strings, obtaining current date/time, performing date arithmetic, and making comparisons. It requires importing the 'fmt' and 'github.com/iseki0/goda' packages.

```go
package main

import (
    "fmt"
    "github.com/iseki0/goda"
)

func main() {
    // Create dates and times
    date := goda.MustNewLocalDate(2024, goda.March, 15)
    time := goda.MustNewLocalTime(14, 30, 45, 123456789)
    datetime := goda.NewLocalDateTime(date, time)
    
    fmt.Println(date)     // 2024-03-15
    fmt.Println(time)     // 14:30:45.123456789
    fmt.Println(datetime) // 2024-03-15T14:30:45.123456789
    
    // Parse from strings
    date, _ = goda.ParseLocalDate("2024-03-15")
    time = goda.MustParseLocalTime("14:30:45.123456789")
    datetime = goda.MustParseLocalDateTime("2024-03-15T14:30:45")
    
    // Get current date/time
    today := goda.LocalDateNow()
    now := goda.LocalTimeNow()
    currentDateTime := goda.LocalDateTimeNow()
    
    // Date arithmetic
    tomorrow := today.PlusDays(1)
    nextMonth := today.PlusMonths(1)
    nextYear := today.PlusYears(1)
    
    // Comparisons
    if tomorrow.IsAfter(today) {
        fmt.Println("Tomorrow is after today!")
    }
}

```

--------------------------------

### Get UTC ZoneOffset

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Returns the UTC ZoneOffset, represented as +00:00.

```go
func ZoneOffsetUTC() ZoneOffset
```

--------------------------------

### Create LocalDate Instances

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Functions for creating LocalDate instances, including from current time, Go's time.Time, and Unix epoch days. Also includes a constructor for parsing from string representations.

```Go
func LocalDateNow() LocalDate
func LocalDateNowIn(loc *time.Location) LocalDate
func LocalDateNowUTC() LocalDate
func MustNewLocalDate(year Year, month Month, dayOfMonth int) LocalDate
func NewLocalDate(year Year, month Month, dayOfMonth int) (d LocalDate, e error)
func NewLocalDateByGoTime(t time.Time) LocalDate
func NewLocalDateByUnixEpochDays(days int64) LocalDate
func MustParseLocalDate(s string) LocalDate
func ParseLocalDate(s string) (LocalDate, error)
```

--------------------------------

### Get Minimum ZoneOffset

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Returns the minimum supported ZoneOffset, which is -18:00.

```go
func ZoneOffsetMin() ZoneOffset
```

--------------------------------

### Get Maximum ZoneOffset

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Returns the maximum supported ZoneOffset, which is +18:00.

```go
func ZoneOffsetMax() ZoneOffset
```

--------------------------------

### Create ZoneOffset (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Constructs ZoneOffset objects from hours, minutes, seconds, or total seconds. These represent time zone offsets from UTC. It includes functions to create valid offsets and handle potential errors.

```go
func NewZoneOffset(hours, minutes, seconds int) (ZoneOffset, error)
```

```go
func NewZoneOffsetHours(hours int) (ZoneOffset, error)
```

```go
func NewZoneOffsetSeconds(seconds int) (ZoneOffset, error)
```

```go
func MustNewZoneOffset(hours, minutes, seconds int) ZoneOffset
```

```go
func MustNewZoneOffsetHours(hours int) ZoneOffset
```

```go
func MustNewZoneOffsetSeconds(seconds int) ZoneOffset
```

--------------------------------

### LocalDateTime String Representation

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Method for getting the string representation of a LocalDateTime object.

```APIDOC
## LocalDateTime String Representation

### Description
Provides the method to obtain a string representation of a `LocalDateTime` object.

### Method

- **String()**
  - Description: Returns the ISO 8601 string representation (`yyyy-MM-ddTHH:mm:ss[.nnnnnnnnn]`).
  - Signature: `func (dt LocalDateTime) String() string`
```

--------------------------------

### LocalTime Creation and Manipulation in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Offers methods for creating LocalTime objects from Go time and specific time values (nanoseconds/seconds of day). Supports arithmetic operations like adding or subtracting hours, minutes, seconds, and nanoseconds.

```go
type LocalTime
func LocalTimeOfGoTime(t time.Time) LocalTime
func LocalTimeOfNanoOfDay(nanoOfDay int64) (LocalTime, error)
func LocalTimeOfSecondOfDay(secondOfDay int) (LocalTime, error)
func MustLocalTimeOfNanoOfDay(nanoOfDay int64) LocalTime
func MustLocalTimeOfSecondOfDay(secondOfDay int) LocalTime
func (t LocalTime) MinusHours(hours int) LocalTime
func (t LocalTime) MinusMinutes(minutes int) LocalTime
func (t LocalTime) MinusNanos(nanos int64) LocalTime
func (t LocalTime) MinusSeconds(seconds int) LocalTime
func (t LocalTime) PlusHours(hours int) LocalTime
func (t LocalTime) PlusMinutes(minutes int) LocalTime
func (t LocalTime) PlusNanos(nanos int64) LocalTime
func (t LocalTime) PlusSeconds(seconds int) LocalTime
func (t LocalTime) GetField(field Field) TemporalValue
```

--------------------------------

### Create and Parse ZoneOffset in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Functions for creating and parsing ZoneOffset objects. This includes creating from hours, minutes, seconds, or parsing from string representations. `Must` versions are available for convenience when errors are not expected.

```Go
func MustNewZoneOffset(hours, minutes, seconds int) ZoneOffset
func MustNewZoneOffsetHours(hours int) ZoneOffset
func MustNewZoneOffsetSeconds(seconds int) ZoneOffset
func MustParseZoneOffset(s string) ZoneOffset
func NewZoneOffset(hours, minutes, seconds int) (ZoneOffset, error)
func NewZoneOffsetHours(hours int) (ZoneOffset, error)
func NewZoneOffsetSeconds(seconds int) (ZoneOffset, error)
func ParseZoneOffset(s string) (ZoneOffset, error)
```

--------------------------------

### Get Month Component from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Retrieves the month component from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Month() Month
```

--------------------------------

### YearMonth Creation and Manipulation in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Functions for creating and working with YearMonth objects, representing a specific year and month. Includes safe and unsafe creation methods, along with methods for comparison, checking leap years, and getting month length.

```go
type YearMonth struct
func MustYearMonthOf(year Year, month Month) YearMonth
func YearMonthOf(year Year, month Month) (y YearMonth, e error)
func (y *YearMonth) Scan(src any) error
func (y *YearMonth) UnmarshalJSON(i []byte) error
func (y *YearMonth) UnmarshalText(text []byte) (e error)
func (y YearMonth) AppendText(b []byte) ([]byte, error)
func (y YearMonth) Chain() (chain YearMonthChain)
func (y YearMonth) Compare(other YearMonth) int
func (y YearMonth) IsLeapYear() bool
func (y YearMonth) IsZero() bool
func (y YearMonth) LengthOfMonth() int
func (y YearMonth) LengthOfYear() int
func (y YearMonth) MarshalJSON() ([]byte, error)
func (y YearMonth) MarshalText() (text []byte, err error)
func (y YearMonth) Month() Month
func (y YearMonth) ProlepticMonth() int64
func (y YearMonth) String() string
func (y YearMonth) Value() (driver.Value, error)
func (y YearMonth) Year() Year
```

--------------------------------

### Get Hour from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Extracts the hour component (0-23) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Hour() int
```

--------------------------------

### Get Second Component from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Extracts the second component (0-59) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Second() int
```

--------------------------------

### Month Utility Methods in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Provides utility methods for the Month type, such as determining the first day of the year, checking if the month is zero, getting the length of the month (considering leap years), and finding the maximum number of days in the month.

```Go
func (m Month) FirstDayOfYear(isLeap bool) int
func (m Month) IsZero() bool
func (m Month) Length(isLeap bool) int
func (m Month) MaxDays() int
func (m Month) String() string
```

--------------------------------

### Create LocalDateTime Instances

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Functions for creating LocalDateTime instances, including from current time, Go's time.Time, and component values. Includes constructors for parsing from string representations and combining LocalDate and LocalTime.

```Go
func LocalDateTimeNow() LocalDateTime
func LocalDateTimeNowIn(loc *time.Location) LocalDateTime
func LocalDateTimeNowUTC() LocalDateTime
func MustNewLocalDateTimeFromComponents(year Year, month Month, day, hour, minute, second, nanosecond int) LocalDateTime
func NewLocalDateTime(date LocalDate, time LocalTime) LocalDateTime
func NewLocalDateTimeByGoTime(t time.Time) LocalDateTime
func NewLocalDateTimeFromComponents(year Year, month Month, day, hour, minute, second, nanosecond int) (LocalDateTime, error)
func MustParseLocalDateTime(s string) LocalDateTime
func ParseLocalDateTime(s string) (LocalDateTime, error)
```

--------------------------------

### Get Nanosecond Component from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Extracts the nanosecond component (0-999999999) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Nanosecond() int
```

--------------------------------

### Get Minute Component from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Extracts the minute component (0-59) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Minute() int
```

--------------------------------

### LocalTime Formatting and Comparison in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Methods for formatting LocalTime objects into text, comparing two LocalTime instances, and converting them to Go's standard time.Time. Also includes methods for checking if a time is zero.

```Go
func (t LocalTime) AppendText(b []byte) ([]byte, error)
func (t LocalTime) Compare(other LocalTime) int
func (t LocalTime) GoTime() time.Time
func (t LocalTime) IsZero() bool
```

--------------------------------

### Get Millisecond Component from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Retrieves the millisecond component (0-999) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Millisecond() int
```

--------------------------------

### LocalTime Construction and Manipulation

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Functions for creating and working with LocalTime objects.

```APIDOC
## LocalTime Construction and Manipulation

### Description
Functions for creating LocalTime instances from various sources and performing time-based operations.

### Functions
- `MustNewLocalTime(hour, minute, second, nanosecond int) LocalTime`: Creates a new LocalTime, panicking on error.
- `NewLocalTime(hour, minute, second, nanosecond int) (LocalTime, error)`: Creates a new LocalTime, returning an error if invalid.
- `NewLocalTimeByGoTime(t time.Time) LocalTime`: Creates a LocalTime from a Go `time.Time` object.

### Methods
- `Scan(src any) error`: Scans a value into the LocalTime.
- `UnmarshalJSON(bytes []byte) error`: Unmarshals a JSON byte slice into a LocalTime.
- `UnmarshalText(text []byte) error`: Unmarshals a text byte slice into a LocalTime.
- `Value() (driver.Value, error)`: Returns the LocalTime value for database driver compatibility.
- `AppendText(b []byte) ([]byte, error)`: Appends the text representation of the LocalTime to a byte slice.
- `Compare(other LocalTime) int`: Compares two LocalTime instances.
- `GoTime() time.Time`: Converts the LocalTime to a Go `time.Time` object.
- `Hour() int`: Returns the hour of the LocalTime.
- `IsAfter(other LocalTime) bool`: Checks if the LocalTime is after another.
- `IsBefore(other LocalTime) bool`: Checks if the LocalTime is before another.
- `IsZero() bool`: Checks if the LocalTime is zero.
- `MarshalJSON() ([]byte, error)`: Marshals the LocalTime into JSON.
- `MarshalText() (text []byte, err error)`: Marshals the LocalTime into text.
- `Millisecond() int`: Returns the millisecond component of the LocalTime.
- `Minute() int`: Returns the minute of the LocalTime.
- `Nanosecond() int`: Returns the nanosecond component of the LocalTime.
- `Second() int`: Returns the second of the LocalTime.
- `String() string`: Returns a string representation of the LocalTime.
```

--------------------------------

### Get Day of Year from OffsetDateTime

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

DayOfYear returns the day-of-year component (1-366) from the OffsetDateTime.

```go
func (odt OffsetDateTime) DayOfYear() int
```

--------------------------------

### Zone Offset Parsing and Constants in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Enables parsing of Zone Offset strings into ZoneOffset types and provides constants for maximum and minimum offset values. Also includes a predefined ZoneOffset for UTC.

```go
type ZoneOffset
func MustZoneOffsetParse(s string) ZoneOffset
func ZoneOffsetParse(s string) (ZoneOffset, error)
const MaxOffsetSeconds
const MinOffsetSeconds
var ZoneOffsetUTC = ZoneOffset
func MustZoneOffsetOf(hours, minutes, seconds int) ZoneOffset
func MustZoneOffsetOfHours(hours int) ZoneOffset
func MustZoneOffsetOfHoursMinutes(hours, minutes int) ZoneOffset
func MustZoneOffsetOfSeconds(seconds int) ZoneOffset
func ZoneOffsetMax() ZoneOffset
func ZoneOffsetMin() ZoneOffset
func ZoneOffsetOf(hours, minutes, seconds int) (ZoneOffset, error)
func ZoneOffsetOfHours(hours int) (ZoneOffset, error)
func ZoneOffsetOfHoursMinutes(hours, minutes int) (ZoneOffset, error)
func ZoneOffsetOfSeconds(seconds int) (ZoneOffset, error)
func (z ZoneOffset) Compare(other ZoneOffset) int
func (z ZoneOffset) GetField(field Field) TemporalValue
func (z ZoneOffset) Hours() int
func (z ZoneOffset) IsSupportedField(field Field) bool
func (z ZoneOffset) Minutes() int
func (z ZoneOffset) Seconds() int
```

--------------------------------

### Get Day of Month from OffsetDateTime

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

DayOfMonth returns the day-of-month component (1-31) from the OffsetDateTime.

```go
func (odt OffsetDateTime) DayOfMonth() int
```

--------------------------------

### Go Month Utility Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Defines operations on the Month type, which is an alias for time.Month. It includes methods to determine the first day of the year, the length of the month (considering leap years), and checking if a month is zero. Constants for all months are also provided.

```go
type Month time.Month
const April
const August
const December
const February
const January
const July
const June
const March
const May
const November
const October
const September
func (m Month) FirstDayOfYear(isLeap bool) int
func (m Month) IsZero() bool
func (m Month) Length(isLeap bool) int
func (m Month) MaxDays() int
func (m Month) String() string
```

--------------------------------

### LocalTime API

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Documentation for the LocalTime type, including functions for creating, parsing, and manipulating times.

```APIDOC
## LocalTime

### Description
Represents a time of day, with nanosecond precision.

### Functions

#### `ParseLocalTime(s string) (LocalTime, error)`
Parses a time string in `HH:MM:SS` format.

#### `MustParseLocalTime(s string) LocalTime`
Parses a time string in `HH:MM:SS` format. Panics if the time is invalid.

#### `LocalTimeNow() LocalTime`
Returns the current local time.

#### `LocalTimeNowIn(loc *time.Location) LocalTime`
Returns the current time in the given location.

#### `LocalTimeNowUTC() LocalTime`
Returns the current UTC time.

### Methods

#### `(t LocalTime) GetFieldInt64(field Field) int64`
Gets the value of a specific time field.

#### `(t LocalTime) IsSupportedField(field Field) bool`
Checks if a specific time field is supported.
```

--------------------------------

### Get UTC ZoneId

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

ZoneIdUTC returns a ZoneId representing Coordinated Universal Time (UTC).

```go
func ZoneIdUTC() ZoneId
{
	// Implementation details omitted for brevity
}
```

--------------------------------

### Perform Date Arithmetic in Go using goda

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

This example illustrates how to perform basic date arithmetic using the `goda` package. Operations like adding days, months, or years return new immutable instances of `LocalDate`, preserving the original date.

```go
tomorrow := today.PlusDays(1)
nextMonth := today.PlusMonths(1)
nextYear := today.PlusYears(1)

```

--------------------------------

### Get Offset from OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Retrieves the time zone offset component (ZoneOffset) from an OffsetDateTime.

```Go
func (odt OffsetDateTime) Offset() ZoneOffset
```

--------------------------------

### ZoneOffset Properties and Conversions (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Provides methods to get the total seconds of a ZoneOffset and convert it to text or JSON representations. It also includes a method to check if the offset is zero (UTC).

```go
func (zo ZoneOffset) TotalSeconds() int
```

```go
func (zo *ZoneOffset) UnmarshalJSON(data []byte) error
```

```go
func (zo *ZoneOffset) UnmarshalText(text []byte) error
```

```go
func (zo ZoneOffset) AppendText(b []byte) ([]byte, error)
```

```go
func (zo ZoneOffset) MarshalJSON() ([]byte, error)
```

```go
func (zo ZoneOffset) MarshalText() ([]byte, error)
```

```go
func (zo ZoneOffset) IsZero() bool
```

--------------------------------

### LocalDate Methods

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Methods for manipulating and querying LocalDate objects.

```APIDOC
## LocalDate Methods

### Description
Provides methods for date manipulation such as adding/subtracting months and years, and accessing date components.

### Methods
- `MinusMonths(months int) LocalDate`: Subtracts a specified number of months from the date.
- `MinusYears(years int) LocalDate`: Subtracts a specified number of years from the date.
- `Month() Month`: Returns the month of the date.
- `PlusDays(days int) LocalDate`: Adds a specified number of days to the date.
- `PlusMonths(months int) LocalDate`: Adds a specified number of months to the date.
- `PlusYears(years int) LocalDate`: Adds a specified number of years to the date.
- `String() string`: Returns a string representation of the date.
- `UnixEpochDays() int64`: Returns the number of days since the Unix epoch.
- `Year() Year`: Returns the year of the date.
```

--------------------------------

### Get Year from LocalDate (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

The Year function extracts and returns the year component from a LocalDate.

```go
func (d LocalDate) Year() Year
```

--------------------------------

### Get String Representation of OffsetDateTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Returns the ISO 8601 string representation of an OffsetDateTime object.

```Go
func (odt OffsetDateTime) String() string

// String returns the ISO 8601 string representation (yyyy-MM-ddTHH:mm:ss[.nnnnnnnnn]±HH:mm).
```

--------------------------------

### Year Methods

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Methods for working with Year objects.

```APIDOC
## Year Methods

### Description
Methods for querying and manipulating Year objects.

### Methods
- `AppendText(b []byte) ([]byte, error)`: Appends the text representation of the Year to a byte slice.
- `Int() int`: Returns the year as an `int`.
- `Int64() int64`: Returns the year as an `int64`.
- `IsLeapYear() bool`: Checks if the year is a leap year.
- `Length() int`: Returns the number of days in the year.
- `String() string`: Returns a string representation of the year.
```

--------------------------------

### Get ZoneId as String

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

String returns the zone ID as a string, or an empty string for the zero value.

```go
func (z ZoneId) String() string
{
	// Implementation details omitted for brevity
}
```

--------------------------------

### ZoneOffset Utility Methods in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Utility methods for ZoneOffset, including checking if an offset is zero and converting the total offset to seconds. The `AppendText` method is also available for custom formatting.

```Go
func (zo ZoneOffset) AppendText(b []byte) ([]byte, error)
func (zo ZoneOffset) IsZero() bool
func (zo ZoneOffset) String() string
func (zo ZoneOffset) TotalSeconds() int
```

--------------------------------

### Get Day of Week from OffsetDateTime

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

DayOfWeek returns the day-of-week component (e.g., Monday, Tuesday) from the OffsetDateTime.

```go
func (odt OffsetDateTime) DayOfWeek() DayOfWeek
```

--------------------------------

### Creating OffsetDateTime Instances

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Functions for creating new OffsetDateTime instances from components, Go time.Time, or by parsing strings.

```APIDOC
## Creating OffsetDateTime Instances

### `MustOffsetDateTimeOf`

#### Description
Creates a new `OffsetDateTime` from individual components. Panics if any component is invalid.

#### Method
`func MustOffsetDateTimeOf(year Year, month Month, day int, hour int, minute int, second int, nanosecond int, offset ZoneOffset) OffsetDateTime`

### `MustOffsetDateTimeParse`

#### Description
Parses a date-time string with offset. Panics if the string is invalid.

#### Method
`func MustOffsetDateTimeParse(s string) OffsetDateTime`

### `OffsetDateTimeNow`

#### Description
Returns the current date-time with offset in the system's local time zone.

#### Method
`func OffsetDateTimeNow() OffsetDateTime`

#### Example Usage
```go
// Example demonstrating getting the current time with offset.
// Refer to ExampleOffsetDateTimeNow for complete code.
```

### `OffsetDateTimeNowUTC`

#### Description
Returns the current date-time with offset in UTC.

#### Method
`func OffsetDateTimeNowUTC() OffsetDateTime`

### `OffsetDateTimeOf`

#### Description
Creates a new `OffsetDateTime` from individual components. Returns an error if any component is invalid.

#### Method
`func OffsetDateTimeOf(year Year, month Month, day int, hour int, minute int, second int, nanosecond int, offset ZoneOffset) (OffsetDateTime, error)`

### `OffsetDateTimeOfGoTime`

#### Description
Creates an `OffsetDateTime` from a `time.Time`. Returns zero value if `t.IsZero()`.

#### Method
`func OffsetDateTimeOfGoTime(t time.Time) OffsetDateTime`

### `OffsetDateTimeParse`

#### Description
Parses a date-time string in RFC3339-compatible format. The format is `yyyy-MM-ddTHH:mm:ss[.nnnnnnnnn]±HH:mm[:ss]` or with 'Z' for UTC.

#### Method
`func OffsetDateTimeParse(s string) (OffsetDateTime, error)`

#### Examples
```go
// Example parsing offset date-times.
// Refer to ExampleOffsetDateTimeParse for complete code.
odt, err := OffsetDateTimeParse("2024-03-15T14:30:45.123456789+01:00")
odT, err := OffsetDateTimeParse("2024-03-15T14:30:45Z")
odT, err := OffsetDateTimeParse("2024-03-15T14:30:45+05:30")
```
```

--------------------------------

### LocalDate API

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Documentation for the LocalDate type, including functions for creating, parsing, and manipulating dates.

```APIDOC
## LocalDate

### Description
Represents a date without a time-zone in the proleptic Gregorian calendar.

### Functions

#### `NewLocalDate(year Year, month Month, dayOfMonth int) (LocalDate, error)`
Creates a new LocalDate from year, month, and day of month.

#### `MustNewLocalDate(year Year, month Month, dayOfMonth int) LocalDate`
Creates a new LocalDate from year, month, and day of month. Panics if the date is invalid.

#### `NewLocalDateByGoTime(t time.Time) LocalDate`
Creates a new LocalDate from a Go time.Time object.

#### `NewLocalDateByUnixEpochDays(days int64) LocalDate`
Creates a new LocalDate from the number of days since the Unix epoch.

#### `ParseLocalDate(s string) (LocalDate, error)`
Parses a date string in `YYYY-MM-DD` format.

#### `MustParseLocalDate(s string) LocalDate`
Parses a date string in `YYYY-MM-DD` format. Panics if the date is invalid.

#### `LocalDateNow() LocalDate`
Returns the current local date.

#### `LocalDateNowIn(loc *time.Location) LocalDate`
Returns the current date in the given location.

#### `LocalDateNowUTC() LocalDate`
Returns the current UTC date.

### Methods

#### `(d LocalDate) DayOfMonth() int`
Returns the day of the month.

#### `(d LocalDate) DayOfWeek() DayOfWeek`
Returns the day of the week.

#### `(d LocalDate) DayOfYear() int`
Returns the day of the year.

#### `(d LocalDate) GoTime() time.Time`
Converts the LocalDate to a Go time.Time object.

#### `(d LocalDate) IsAfter(other LocalDate) bool`
Checks if this date is after another date.

#### `(d LocalDate) IsBefore(other LocalDate) bool`
Checks if this date is before another date.

#### `(d LocalDate) IsLeapYear() bool`
Checks if the year is a leap year.

#### `(d LocalDate) IsZero() bool`
Checks if the date is the zero value.

#### `(d LocalDate) MarshalJSON() ([]byte, error)`
Marshals the LocalDate into JSON format.

#### `(d LocalDate) MarshalText() ([]byte, error)`
Marshals the LocalDate into text format.

#### `(d LocalDate) MinusDays(days int) LocalDate`
Subtracts a number of days from the date.

#### `(d LocalDate) Compare(other LocalDate) int`
Compares this date with another date.

#### `(d *LocalDate) Scan(src any) error`
Scans a value into the LocalDate.

#### `(d *LocalDate) UnmarshalJSON(bytes []byte) error`
Unmarshals a JSON value into the LocalDate.

#### `(d *LocalDate) UnmarshalText(text []byte) error`
Unmarshals a text value into the LocalDate.

#### `(d *LocalDate) Value() (driver.Value, error)`
Returns the LocalDate as a database driver.Value.

#### `(d LocalDate) AppendText(b []byte) ([]byte, error)`
Appends the text representation of the date to a byte slice.
```

--------------------------------

### Get Hour Component - Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Returns the hour component of the LocalTime, represented as an integer between 0 and 23.

```go
func (t LocalTime) Hour() int {
	// ... implementation ...
}

// Example Usage:
hour := t.Hour()
```

--------------------------------

### Get YearMonth from LocalDate (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

The YearMonth function returns the year and month component combined from a LocalDate.

```go
func (d LocalDate) YearMonth() YearMonth
```

--------------------------------

### ZoneId Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

API for creating and managing ZoneId objects.

```APIDOC
## ZoneId Functions

### Description
Functions for creating and retrieving ZoneId objects.

### Methods

- **`MustZoneIdOf(id string)`**: Creates a ZoneId from a string ID. Panics on error.
- **`ZoneIdDefault()`**: Returns the default ZoneId.
- **`ZoneIdOf(id string)`**: Creates a ZoneId from a string ID. Returns an error if invalid.
```

--------------------------------

### Creating LocalTime Instances in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Functions for creating LocalTime objects, including a constructor that returns an error for invalid input, a 'must' version that panics on error, and a conversion from Go's standard time.Time.

```Go
func MustNewLocalTime(hour, minute, second, nanosecond int) LocalTime
func NewLocalTime(hour, minute, second, nanosecond int) (LocalTime, error)
func NewLocalTimeByGoTime(t time.Time) LocalTime
```

--------------------------------

### Get Month from LocalDate (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

The Month function extracts and returns the month component (1-12) from a LocalDate.

```go
func (d LocalDate) Month() Month
```

--------------------------------

### Get Current Date (UTC)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

Returns the current date in UTC. This is equivalent to NewLocalDateByGoTime(time.Now().UTC()).

```go
func LocalDateNowUTC() LocalDate
```

--------------------------------

### Create and Manipulate LocalTime (Go)

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Enables the creation of LocalTime objects from individual components or Go's time.Time. It includes methods for comparison, checking for zero values, and retrieving hour, minute, second, millisecond, and nanosecond components.

```Go
func MustNewLocalTime(hour, minute, second, nanosecond int) LocalTime
func NewLocalTime(hour, minute, second, nanosecond int) (LocalTime, error)
func NewLocalTimeByGoTime(t time.Time) LocalTime
func (t *LocalTime) Scan(src any) error
func (t *LocalTime) UnmarshalJSON(bytes []byte) error
func (t *LocalTime) UnmarshalText(text []byte) error
func (t *LocalTime) Value() (driver.Value, error)
func (t LocalTime) AppendText(b []byte) ([]byte, error)
func (t LocalTime) Compare(other LocalTime) int
func (t LocalTime) GoTime() time.Time
func (t LocalTime) Hour() int
func (t LocalTime) IsAfter(other LocalTime) bool
func (t LocalTime) IsBefore(other LocalTime) bool
func (t LocalTime) IsZero() bool
func (t LocalTime) MarshalJSON() ([]byte, error)
func (t LocalTime) MarshalText() (text []byte, err error)
func (t LocalTime) Millisecond() int
func (t LocalTime) Minute() int
func (t LocalTime) Nanosecond() int
func (t LocalTime) Second() int
func (t LocalTime) String()
```

--------------------------------

### ZoneOffset Utility Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Functions to get the minimum, maximum, and UTC ZoneOffsets, and to append the text representation of a ZoneOffset.

```APIDOC
## ZoneOffset Utility Functions

### ZoneOffsetMax

Returns the maximum supported offset (+18:00).

- **Method**: `func`
- **Signature**: `ZoneOffsetMax() ZoneOffset`

### ZoneOffsetMin

Returns the minimum supported offset (-18:00).

- **Method**: `func`
- **Signature**: `ZoneOffsetMin() ZoneOffset`

### ZoneOffsetUTC

Returns UTC offset (+00:00).

- **Method**: `func`
- **Signature**: `ZoneOffsetUTC() ZoneOffset`

### AppendText

Implements encoding.TextAppender. Appends the text representation of the ZoneOffset to a byte slice.

- **Method**: `func (ZoneOffset) AppendText`
- **Signature**: `AppendText(b []byte) ([]byte, error)`
```

--------------------------------

### LocalDateNow API

Source: https://pkg.go.dev/github.com/iseki0/goda/index

Provides functions to get the current date in local time, UTC, or a specified time zone.

```APIDOC
## LocalDateNow API

This API provides functions to retrieve the current date in different time zone contexts.

### Functions

- **LocalDateNow() LocalDate**: Returns the current date in the system's local time zone.
- **LocalDateNowUTC() LocalDate**: Returns the current date in UTC.
- **LocalDateNowIn(loc *time.Location) LocalDate**: Returns the current date in the specified time zone.

### Usage Examples

```go
// Get current local date
currentDate := LocalDateNow()

// Get current UTC date
currentDateUTC := LocalDateNowUTC()

// Get current date in a specific timezone (e.g., "America/New_York")
loc, _ := time.LoadLocation("America/New_York")
currentDateInZone := LocalDateNowIn(loc)
```
```

--------------------------------

### LocalDate Functions

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0_tab=versions

Functions for creating LocalDate instances from Go time and epoch days.

```APIDOC
## LocalDate Functions

### Description
Functions to construct `LocalDate` objects.

### LocalDateOfGoTime

```go
func LocalDateOfGoTime(t time.Time) LocalDate
```

**Description:** Creates a `LocalDate` from a `time.Time` object.

### LocalDateOfUnixEpochDays

```go
func LocalDateOfUnixEpochDays(days int64) LocalDate
```

**Description:** Creates a `LocalDate` from a number of days since the Unix epoch.
```

--------------------------------

### Get LocalDateTime Chainable Operations

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v1.0

Returns a LocalDateTimeChain object, enabling chained method calls for manipulating the LocalDateTime object.

```Go
func (dt LocalDateTime) Chain() (chain LocalDateTimeChain)
```

--------------------------------

### LocalDate Creation and Field Access in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Provides functionalities to create LocalDate instances from Go time and Unix epoch days. It also allows retrieving specific fields from a LocalDate object.

```go
type LocalDate
func LocalDateOfGoTime(t time.Time) LocalDate
func LocalDateOfUnixEpochDays(days int64) LocalDate
func (d LocalDate) GetField(field Field) TemporalValue
func (d LocalDate) AtTime(time LocalTime) LocalDateTime
```

--------------------------------

### Get Millisecond for LocalDateTime

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0

Retrieves the millisecond component from a LocalDateTime instance. The returned value is an integer representing the millisecond (0-999).

```go
func (dt LocalDateTime) Millisecond() int
```

--------------------------------

### YearMonth Creation and Parsing in Go

Source: https://pkg.go.dev/github.com/iseki0/goda/index_tab=versions

Functions for creating YearMonth objects, including 'must' versions that panic on error and standard versions that return an error. Also includes methods for scanning from different sources and unmarshalling from JSON or text.

```Go
func MustYearMonthOf(year Year, month Month) YearMonth
func YearMonthOf(year Year, month Month) (y YearMonth, e error)
func (y *YearMonth) Scan(src any) error
func (y *YearMonth) UnmarshalJSON(i []byte) error
func (y *YearMonth) UnmarshalText(text []byte) (e error)
```

--------------------------------

### Constants and Fields

Source: https://pkg.go.dev/github.com/iseki0/goda/%40v0.0_tab=versions

Defines constants and fields used for date and time manipulation.

```APIDOC
## Constants and Fields

### Description
Provides definitions for various date and time fields and constants.

### Constants

- **`MicroOfSecond`**: Microsecond of the second.
- **`MilliOfDay`**: Millisecond of the day.
- **`MilliOfSecond`**: Millisecond of the second.
- **`MinuteOfDay`**: Minute of the day.
- **`MinuteOfHour`**: Minute of the hour.
- **`MonthOfYear`**: Month of the year.
- **`NanoOfDay`**: Nanosecond of the day.
- **`NanoOfSecond`**: Nanosecond of the second.
- **`OffsetSeconds`**: Offset in seconds.
- **`ProlepticMonth`**: Proleptic month.
- **`SecondOfDay`**: Second of the day.
- **`SecondOfMinute`**: Second of the minute.
- **`YearField`**: Year field.
- **`YearOfEra`**: Year of the era.

### Types

#### `Field`
Represents a field in a date or time.

#### `DayOfWeek`
Represents the day of the week.

- **Constants**: `Friday`, `Monday`, `Saturday`, `Sunday`, `Thursday`, `Tuesday`, `Wednesday`.
- **Functions**: `DayOfWeekFromGoWeekday(w time.Weekday) DayOfWeek`, `(d DayOfWeek) GoWeekday() time.Weekday`, `(d DayOfWeek) IsZero() bool`, `(d DayOfWeek) String() string`.

#### `Error`
Represents an error in the date/time package.

- **Functions**: `(e Error) Error() string`.
```
Tokens:
Raw