Types Package

import "github.com/gofhir/fhirpath/types"

type Value interface {
    // Type returns the FHIRPath type name (e.g., "Boolean", "Integer", "String").
    Type() string

    // Equal compares exact equality (the = operator in FHIRPath).
    Equal(other Value) bool

    // Equivalent compares equivalence (the ~ operator in FHIRPath).
    // For strings: case-insensitive, normalized whitespace.
    Equivalent(other Value) bool

    // String returns a human-readable string representation of the value.
    String() string

    // IsEmpty indicates if this value represents an empty value.
    IsEmpty() bool
}

type Comparable interface {
    Value
    // Compare returns -1 if less than, 0 if equal, 1 if greater than.
    // Returns error if types are incompatible.
    Compare(other Value) (int, error)
}

type Numeric interface {
    Value
    // ToDecimal converts the numeric value to a Decimal.
    ToDecimal() Decimal
}

type Collection []Value

func (c Collection) Empty() bool

func (c Collection) Count() int

func (c Collection) First() (Value, bool)

func (c Collection) Last() (Value, bool)

func (c Collection) Single() (Value, error)

func (c Collection) Contains(v Value) bool

func (c Collection) Tail() Collection

func (c Collection) Skip(n int) Collection

func (c Collection) Take(n int) Collection

func (c Collection) Distinct() Collection

func (c Collection) IsDistinct() bool

func (c Collection) Union(other Collection) Collection

func (c Collection) Combine(other Collection) Collection

func (c Collection) Intersect(other Collection) Collection

func (c Collection) Exclude(other Collection) Collection

func (c Collection) AllTrue() bool

func (c Collection) AnyTrue() bool

func (c Collection) AllFalse() bool

func (c Collection) AnyFalse() bool

func (c Collection) ToBoolean() (bool, error)

func (c Collection) String() string

import "github.com/gofhir/fhirpath/types"

c := types.Collection{
    types.NewString("alpha"),
    types.NewString("beta"),
    types.NewString("gamma"),
}

fmt.Println(c.Count())       // 3
fmt.Println(c.Empty())       // false

first, ok := c.First()
fmt.Println(first, ok)       // alpha true

tail := c.Tail()
fmt.Println(tail)            // [beta, gamma]

top2 := c.Take(2)
fmt.Println(top2)            // [alpha, beta]

without1 := c.Skip(1)
fmt.Println(without1)        // [beta, gamma]

single, err := c.Take(1).Single()
fmt.Println(single, err)     // alpha <nil>

type Boolean struct {
    // unexported fields
}

func NewBoolean(v bool) Boolean

t := types.NewBoolean(true)
f := t.Not()

fmt.Println(t.Bool())   // true
fmt.Println(f.Bool())   // false
fmt.Println(t.Type())   // Boolean
fmt.Println(t.Equal(f)) // false

type Integer struct {
    // unexported fields
}

func NewInteger(v int64) Integer

a := types.NewInteger(10)
b := types.NewInteger(3)

fmt.Println(a.Add(b).Value())       // 13
fmt.Println(a.Subtract(b).Value())  // 7
fmt.Println(a.Multiply(b).Value())  // 30

div, _ := a.Div(b)
fmt.Println(div.Value())            // 3

mod, _ := a.Mod(b)
fmt.Println(mod.Value())            // 1

result, _ := a.Divide(b)
fmt.Println(result)                 // 3.3333333333333333

type Decimal struct {
    // unexported fields
}

pi, _ := types.NewDecimal("3.14159")
two := types.NewDecimalFromInt(2)

fmt.Println(pi.Add(two))           // 5.14159
fmt.Println(pi.Multiply(two))      // 6.28318
fmt.Println(pi.Round(2))           // 3.14
fmt.Println(pi.Ceiling())          // 4
fmt.Println(pi.Floor())            // 3
fmt.Println(pi.IsInteger())        // false

// MustDecimal for constants
half := types.MustDecimal("0.5")
fmt.Println(half)                  // 0.5

type String struct {
    // unexported fields
}

func NewString(v string) String

s := types.NewString("Hello, World!")

fmt.Println(s.Length())                  // 13
fmt.Println(s.Contains("World"))         // true
fmt.Println(s.StartsWith("Hello"))       // true
fmt.Println(s.Upper())                   // HELLO, WORLD!
fmt.Println(s.Lower())                   // hello, world!
fmt.Println(s.IndexOf("World"))          // 7
fmt.Println(s.Substring(0, 5))           // Hello
fmt.Println(s.Replace("World", "Go"))    // Hello, Go!

// Equivalence is case-insensitive
a := types.NewString("  hello  world  ")
b := types.NewString("Hello World")
fmt.Println(a.Equivalent(b))             // true
fmt.Println(a.Equal(b))                  // false

type Date struct {
    // unexported fields
}

type DatePrecision int

const (
    YearPrecision  DatePrecision = iota // e.g., "2024"
    MonthPrecision                       // e.g., "2024-03"
    DayPrecision                         // e.g., "2024-03-15"
)

d, _ := types.NewDate("2024-03-15")
fmt.Println(d.Year())       // 2024
fmt.Println(d.Month())      // 3
fmt.Println(d.Day())        // 15
fmt.Println(d.Precision())  // DayPrecision

// Partial date
partial, _ := types.NewDate("2024-03")
fmt.Println(partial)          // 2024-03
fmt.Println(partial.Day())   // 0 (not specified)

// Date arithmetic
next := d.AddDuration(1, "month")
fmt.Println(next)            // 2024-04-15

type DateTime struct {
    // unexported fields
}

type DateTimePrecision int

const (
    DTYearPrecision   DateTimePrecision = iota
    DTMonthPrecision
    DTDayPrecision
    DTHourPrecision
    DTMinutePrecision
    DTSecondPrecision
    DTMillisPrecision
)

dt, _ := types.NewDateTime("2024-03-15T14:30:00Z")
fmt.Println(dt.Year())        // 2024
fmt.Println(dt.Hour())        // 14
fmt.Println(dt.Minute())      // 30
fmt.Println(dt)               // 2024-03-15T14:30:00Z

// DateTime arithmetic
later := dt.AddDuration(2, "hours")
fmt.Println(later)             // 2024-03-15T16:30:00Z

// From time.Time
now := types.NewDateTimeFromTime(time.Now())
fmt.Println(now.Type())        // DateTime

type Time struct {
    // unexported fields
}

type TimePrecision int

const (
    HourPrecision   TimePrecision = iota
    MinutePrecision
    SecondPrecision
    MillisPrecision
)

t, _ := types.NewTime("14:30:00")
fmt.Println(t.Hour())        // 14
fmt.Println(t.Minute())      // 30
fmt.Println(t.Second())      // 0
fmt.Println(t)               // 14:30:00

// With milliseconds
precise, _ := types.NewTime("T08:15:30.500")
fmt.Println(precise.Millisecond()) // 500

type Quantity struct {
    // unexported fields
}

q, _ := types.NewQuantity("75.5 'kg'")
fmt.Println(q.Value()) // 75.5
fmt.Println(q.Unit())  // kg
fmt.Println(q)         // 75.5 kg

// Arithmetic
q2, _ := types.NewQuantity("2.5 'kg'")
sum, _ := q.Add(q2)
fmt.Println(sum)       // 78 kg

type ObjectValue struct {
    // unexported fields
}

func NewObjectValue(data []byte) *ObjectValue

data := []byte(`{"resourceType": "Patient", "id": "123", "active": true}`)
obj := types.NewObjectValue(data)

fmt.Println(obj.Type()) // Patient

if v, ok := obj.Get("id"); ok {
    fmt.Println(v) // 123
}

keys := obj.Keys()
fmt.Println(keys) // [resourceType id active]

type TypeError struct {
    Expected  string
    Actual    string
    Operation string
}

func NewTypeError(expected, actual, operation string) *TypeError

func (e *TypeError) Error() string
// Returns: "type error in <operation>: expected <expected>, got <actual>"

err := types.NewTypeError("Integer", "String", "comparison")
fmt.Println(err.Error()) // type error in comparison: expected Integer, got String

func JSONToCollection(data []byte) (Collection, error)