Remove %zone slot from <time>

cgay · cgay · commit 309552629d53 · 2024-10-23T19:20:01.000-04:00
There's no need for each `&lt;time&gt;` instance to contain a zone and since `&lt;time&gt;`
objects may be created frequently we don't want unnecessary slots taking up
space. Instead, the zone should always be specified when displaying times.

`compose-time` and `time-components` now accept a `zone:` keyword argument
with which to interpret the components.

Also marked `test-us-eastern-sanity-check` as expected to fail for now.
diff --git a/sources/formatting-test.dylan b/sources/formatting-test.dylan
@@ -113,20 +113,20 @@ define test test-rfc3339-format ()
   // Verify that negative zone offset overflow displays as previous day.
   assert-equal("1969-12-31T19:00:00.000000-05:00",
                with-output-to-string (s)
-                 let t = time-in-zone($epoch, make(<naive-zone>,
-                                                   offset-seconds: -5 * 60 * 60,
-                                                   name: "x"));
-                 format-time(s, $rfc3339-microseconds, t)
+                 format-time(s, $rfc3339-microseconds, $epoch,
+                             zone: make(<naive-zone>,
+                                        offset-seconds: -5 * 60 * 60,
+                                        name: "x"))
                end);
   // Verify that positive zone offset overflow displays as next day.
   // (Throw in a test for leap day Feb 29 because why not.)
   assert-equal("2020-02-29T00:00:00.000000+05:00",
                with-output-to-string (s)
-                 let t = time-in-zone(compose-time(2020, $february, 28, 19, 0, 0, 0, $utc),
-                                      make(<naive-zone>,
-                                           offset-seconds: 5 * 60 * 60,
-                                           name: "x"));
-                 format-time(s, $rfc3339-microseconds, t)
+                 let t = compose-time(2020, $february, 28, 19, 0, 0, 0);
+                 format-time(s, $rfc3339-microseconds, t,
+                             zone: make(<naive-zone>,
+                                        offset-seconds: 5 * 60 * 60,
+                                        name: "x"))
                end);
 end test;
 
diff --git a/sources/formatting.dylan b/sources/formatting.dylan
@@ -72,54 +72,53 @@ define function parse-time-format (descriptor :: <string>) => (_ :: <sequence>)
 end function;
 
 // Each value is a pair of #(time-component . formatter-function) where
-// time-component is the index into the return values list of the
-// time-components function. 0 = year, 1 = month, etc
+// time-component is a keyword that matches the select statement used in
+// format-time.
 //
 // TODO: BC/AD, BCE/CE (see ISO 8601)
-// TODO: make this extensible
 define table $time-format-map :: <string-table>
-  = { "yyyy"   => pair(0, curry(format-ndigit-int, 4)),
-      "yy"     => pair(0, curry(format-ndigit-int-mod, 2, 100)),
-      "mm"     => pair(1, method (stream, month)
-                            format-ndigit-int(2, stream, month.month-number)
-                          end),
-      "mon"    => pair(1, format-short-month-name),
-      "month"  => pair(1, format-long-month-name),
-      "dd"     => pair(2, curry(format-ndigit-int, 2)),
-      "HH"     => pair(3, curry(format-ndigit-int, 2)),
-      "hh"     => pair(3, format-hour-12),
-      "am"     => pair(3, format-lowercase-am-pm),
-      "pm"     => pair(3, format-lowercase-am-pm),
-      "AM"     => pair(3, format-uppercase-am-pm),
-      "PM"     => pair(3, format-uppercase-am-pm),
-      "MM"     => pair(4, curry(format-ndigit-int, 2)),
-      "SS"     => pair(5, curry(format-ndigit-int, 2)),
-      "millis" => pair(6, curry(format-ndigit-int-mod, 3, 1000)),
-      "micros" => pair(6, curry(format-ndigit-int-mod, 6, 1_000_000)),
-      "nanos"  => pair(6, curry(format-ndigit-int-mod, 9, 1_000_000_000)),
+  = { "yyyy"   => pair(#"year", curry(format-ndigit-int, 4)),
+      "yy"     => pair(#"year", curry(format-ndigit-int-mod, 2, 100)),
+      "mm"     => pair(#"month", method (stream, month)
+                                   format-ndigit-int(2, stream, month.month-number)
+                                 end),
+      "mon"    => pair(#"month", format-short-month-name),
+      "month"  => pair(#"month", format-long-month-name),
+      "dd"     => pair(#"day-of-month", curry(format-ndigit-int, 2)),
+      "HH"     => pair(#"hour", curry(format-ndigit-int, 2)),
+      "hh"     => pair(#"hour", format-hour-12),
+      "am"     => pair(#"hour", format-lowercase-am-pm),
+      "pm"     => pair(#"hour", format-lowercase-am-pm),
+      "AM"     => pair(#"hour", format-uppercase-am-pm),
+      "PM"     => pair(#"hour", format-uppercase-am-pm),
+      "MM"     => pair(#"minute", curry(format-ndigit-int, 2)),
+      "SS"     => pair(#"second", curry(format-ndigit-int, 2)),
+      "millis" => pair(#"nanosecond", curry(format-ndigit-int-mod, 3, 1000)),
+      "micros" => pair(#"nanosecond", curry(format-ndigit-int-mod, 6, 1_000_000)),
+      "nanos"  => pair(#"nanosecond", curry(format-ndigit-int-mod, 9, 1_000_000_000)),
       // f = fractional seconds with minimum digits. fN outputs exactly N digits.
-      "f"      => pair(6, format-nanos-with-minimum-digits),
+      "f"      => pair(#"nanosecond", format-nanos-with-minimum-digits),
       // Not sure if some of these will be used, but might as well be complete.
-      "f1"     => pair(6, curry(format-ndigit-int-mod, 1, 10)),
-      "f2"     => pair(6, curry(format-ndigit-int-mod, 2, 100)),
-      "f3"     => pair(6, curry(format-ndigit-int-mod, 3, 1000)),
-      "f4"     => pair(6, curry(format-ndigit-int-mod, 4, 10_000)),
-      "f5"     => pair(6, curry(format-ndigit-int-mod, 5, 100_000)),
-      "f6"     => pair(6, curry(format-ndigit-int-mod, 6, 1_000_000)),
-      "f7"     => pair(6, curry(format-ndigit-int-mod, 7, 10_000_000)),
-      "f8"     => pair(6, curry(format-ndigit-int-mod, 8, 100_000_000)),
-      "f9"     => pair(6, curry(format-ndigit-int-mod, 9, 1_000_000_000)),
-
-      "zone"     => pair(7, format-zone-name),       // UTC, PST, etc
+      "f1"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 1, 10)),
+      "f2"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 2, 100)),
+      "f3"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 3, 1000)),
+      "f4"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 4, 10_000)),
+      "f5"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 5, 100_000)),
+      "f6"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 6, 1_000_000)),
+      "f7"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 7, 10_000_000)),
+      "f8"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 8, 100_000_000)),
+      "f9"     => pair(#"nanosecond", curry(format-ndigit-int-mod, 9, 1_000_000_000)),
+
+      "zone"     => pair(#"zone", format-zone-name),       // UTC, PST, etc
 
       // TODO: these fail for <aware-zone>s. Need some refactoring to make sure the
       // offset is found for the correct time.
-      "offset"   => pair(7, rcurry(format-zone-offset, colon?: #f, utc-name: #f)), // +0000
-      "offset:"  => pair(7, rcurry(format-zone-offset, colon?: #t, utc-name: #f)), // +00:00
-      "offset:Z" => pair(7, rcurry(format-zone-offset, colon?: #t, utc-name: "Z")), // Z or +02:00
+      "offset"   => pair(#"zone", rcurry(format-zone-offset, colon?: #f, utc-name: #f)), // +0000
+      "offset:"  => pair(#"zone", rcurry(format-zone-offset, colon?: #t, utc-name: #f)), // +00:00
+      "offset:Z" => pair(#"zone", rcurry(format-zone-offset, colon?: #t, utc-name: "Z")), // Z or +02:00
 
-      "day"     => pair(8, format-short-weekday),
-      "weekday" => pair(8, format-long-weekday),
+      "day"     => pair(#"day-of-week", format-short-weekday),
+      "weekday" => pair(#"day-of-wook", format-long-weekday),
      };
 
 define function format-nanos-with-minimum-digits
@@ -256,23 +255,32 @@ define /* inline */ method format-time
   format-time(stream, parse-time-format(fmt), time, zone: zone);
 end method;
 
-define /* inline */ method format-time
+define method format-time
     (stream :: <stream>, fmt :: <sequence>, time :: <time>, #key zone :: <zone>?)
  => ()
-  // I'm assuming that v is stack allocated. Verify.
-  let (#rest v) = time-components(time);
-  if (zone)
-    v[7] := zone;
-  end;
+  let zone :: <zone> = zone | $utc;
+  let (year, month, day-of-month, hour, minute, second, nanosecond, day-of-week)
+    = time-components(time, zone: zone);
   for (item in fmt)
     select (item by instance?)
       <string>
         => write(stream, item);
       <pair>
         => begin
-             let index :: <integer> = item.head;
+             let value
+               = select (item.head)
+                   #"year" => year;
+                   #"month" => month;
+                   #"day-of-month" => day-of-month;
+                   #"hour" => hour;
+                   #"minute" => minute;
+                   #"second" => second;
+                   #"nanosecond" => nanosecond;
+                   #"day-of-week" => day-of-week;
+                   #"zone" => zone;
+                 end;
              let formatter :: <function> = item.tail;
-             formatter(stream, v[index]);
+             formatter(stream, value);
            end;
       otherwise  => time-error("invalid time format element: %=", item);
     end;
diff --git a/sources/library.dylan b/sources/library.dylan
@@ -25,16 +25,7 @@ define module time
     // Time
     <time>,
     time-now,
-    time-components,            // returns the following nine values, in order
-      time-year,
-      time-month,
-      time-day-of-month,
-      time-hour,
-      time-minute,
-      time-second,
-      time-nanosecond,
-      time-zone,
-      time-day-of-week,
+    time-components,            // => year, month, day, hour, minute, second, nanosecond
     $epoch,
     $minimum-time,
     $maximum-time,
@@ -68,7 +59,6 @@ define module time
     // Conversions
     compose-time,               // make a <time> from its components
     time-components,            // break a <time> into its components
-    time-in-zone,
     parse-time,                 // TODO: $iso-8601-format etc?
     parse-duration,
     parse-day,                  // TODO: not sure about this
diff --git a/sources/specification.dylan b/sources/specification.dylan
@@ -3,22 +3,13 @@ Module: time-test-suite
 define interface-specification-suite time-specification-suite ()
   // Time
   sealed instantiable class <time> (<object>);
-  function time-now(#"key", #"zone") => (<time>);
+  function time-now() => (<time>);
   sealed generic function compose-time
-      (<integer>, <month>, <integer>, <integer>, <integer>, <integer>, <integer>, <zone>)
+      (<integer>, <month>, <integer>, <integer>, <integer>, <integer>, <integer>, #"key", #"zone")
    => (<time>);
   sealed generic function time-components
-      (<time>)
-   => (<integer>, <month>, <integer>, <integer>, <integer>, <integer>, <integer>, <zone>, <day>);
-  sealed generic function time-year         (<time>) => (<integer>);
-  sealed generic function time-month        (<time>) => (<month>);
-  sealed generic function time-day-of-month (<time>) => (<integer>);
-  sealed generic function time-hour         (<time>) => (<integer>);
-  sealed generic function time-minute       (<time>) => (<integer>);
-  sealed generic function time-second       (<time>) => (<integer>);
-  sealed generic function time-nanosecond   (<time>) => (<integer>);
-  sealed generic function time-zone         (<time>) => (<zone>);
-  sealed generic function time-day-of-week  (<time>) => (<day>);
+      (<time>, #"key", #"zone")
+   => (<integer>, <month>, <integer>, <integer>, <integer>, <integer>, <integer>, <day>);
   constant $epoch :: <time>;
 
   // Durations
diff --git a/sources/time-test.dylan b/sources/time-test.dylan
@@ -6,41 +6,50 @@ define test test-current-time ()
   assert-true(t.%nanoseconds >= 0 & t.%nanoseconds < 1_000_000_000 * 60 * 60 * 24);
 end test;
 
-define constant $components-test-cases
-  = list(list(list(1970, $january, 1, 0, 0, 0, 0, $utc, $monday),
-              list(0, 0)),
-         list(list(1970, $january, 2, 1, 1, 1, 1, $utc, $monday),
-              list(1, 3_661_000_000_001)),
-         list(list(1969, $december, 31, 0, 0, 0, 1, $utc, $monday),
-              list(-1, 1)),
-         list(list(1969, $december, 31, 23, 59, 59, 999_999_999, $utc, $monday),
-              list(-1, 86_399_999_999_999)),
-         list(list(2020, $october, 18, 0, 0, 0, 0, $utc, $monday),
-              list(18553, 0)));
-
+// TODO: test non-UTC zone
 define test test-compose-time ()
-  for (tc in $components-test-cases)
-    let (args, want) = apply(values, tc);
-    let args = copy-sequence(args, end: args.size - 1); // remove the day
-    let t = apply(compose-time, args);
-    let (want-days, want-nanos) = apply(values, want);
-    assert-equal(t.%days, want-days,
-                 format-to-string("for %= got days %=, want %=",
-                                  args, t.%days, want-days));
-    assert-equal(t.%nanoseconds, want-nanos,
-                 format-to-string("for %= got nanoseconds %=, want %=",
-                                  args, t.%nanoseconds, want-nanos));
-  end;
+  let t1 = compose-time(1970, $january, 1, 0, 0, 0, 0, zone: $utc);
+  assert-equal(0, t1.%days);
+  assert-equal(0, t1.%nanoseconds);
+
+  let t2 = compose-time(1970, $january, 2, 1, 1, 1, 1, zone: $utc);
+  assert-equal(1, t2.%days);
+  assert-equal(3_661_000_000_001, t2.%nanoseconds);
+
+  let t3 = compose-time(1969, $december, 31, 0, 0, 0, 1, zone: $utc);
+  assert-equal(-1, t3.%days);
+  assert-equal(1, t3.%nanoseconds);
+
+  let t4 = compose-time(1969, $december, 31, 23, 59, 59, 999_999_999, zone: $utc);
+  assert-equal(-1, t4.%days);
+  assert-equal(86_399_999_999_999, t4.%nanoseconds);
+
+  let t5 = compose-time(2020, $october, 18, 0, 0, 0, 0, zone: $utc);
+  assert-equal(18553, t5.%days);
+  assert-equal(0, t5.%nanoseconds);
 end test;
 
+// TODO: test non-UTC zone
 define test test-time-components ()
-  for (tc in $components-test-cases)
-    let (args, want) = apply(values, reverse(tc));
-    let t = make(<time>, days: args[0], nanoseconds: args[1]);
-    let (#rest got) = time-components(t);
-    assert-equal(got, want,
-                 format-to-string("for %= got %=, want %=", args, got, want));
-  end;
+  let t1 = make(<time>, days: 0, nanoseconds: 0);
+  let (#rest c1) = time-components(t1, zone: $utc);
+  assert-equal(vector(1970, $january, 1, 0, 0, 0, 0, $monday), c1);
+
+  let t2 = make(<time>, days: 1, nanoseconds: 3_661_000_000_001);
+  let (#rest c2) = time-components(t2, zone: $utc);
+  assert-equal(vector(1970, $january, 2, 1, 1, 1, 1, $monday), c2);
+
+  let t3 = make(<time>, days: -1, nanoseconds: 1);
+  let (#rest c3) = time-components(t3, zone: $utc);
+  assert-equal(vector(1969, $december, 31, 0, 0, 0, 1, $monday), c3);
+
+  let t4 = make(<time>, days: -1, nanoseconds: 86_399_999_999_999);
+  let (#rest c4) = time-components(t4, zone: $utc);
+  assert-equal(vector(1969, $december, 31, 23, 59, 59, 999_999_999, $monday), c4);
+
+  let t5 = make(<time>, days: 18553, nanoseconds: 0);
+  let (#rest c5) = time-components(t5, zone: $utc);
+  assert-equal(vector(2020, $october, 18, 0, 0, 0, 0, $monday), c5);
 end test;
 
 
@@ -66,14 +75,9 @@ define test test-time+duration ()
 end test;
 
 define test test-time-= ()
+  // Two times with the same UTC seconds and nanoseconds should be equal.
   let t1 = time-now();
   assert-equal(t1, make(<time>, days: t1.%days, nanoseconds: t1.%nanoseconds));
-
-  // Two times with the same UTC seconds and nanoseconds should be equal
-  // regardless of zone.
-  assert-equal(make(<time>, days: 1, nanoseconds: 1, zone: $utc),
-               make(<time>, days: 1, nanoseconds: 1,
-                    zone: make(<naive-zone>, name: "x", offset-seconds: 5 * 60 * 60)));
 end test;
 
 define test test-time-< ()
@@ -87,6 +91,7 @@ end test;
 
 define test test-print-object ()
   assert-equal("1970-01-01T00:00:00.0Z", format-to-string("%s", $epoch));
-  assert-true(regex-search(compile-regex("{<time> 0d 0ns \\+00:00 \\d+}"),
-                           format-to-string("%=", $epoch)));
+  assert-true(regex-search(compile-regex("{<time> 0d 0ns UTC \\d+}"),
+                           format-to-string("%=", $epoch)),
+              "%= didn't match the regular expression", $epoch);
 end test;
diff --git a/sources/time.dylan b/sources/time.dylan
diff --git a/sources/tzif-test.dylan b/sources/tzif-test.dylan
