@shd101wyy/yo 0.1.25 → 0.1.27

package/std/time/duration.yo

@@ -9,101 +9,88 @@
 //! println(d.as_secs());    // 0
 //! println(d.as_millis());  // 500
 //! ```
-
-{ String } :: import "../string";
-{ ToString } :: import "../fmt";
-{ snprintf } :: import "../libc/stdio";
-
+{ String } :: import("../string");
+{ ToString } :: import("../fmt");
+{ snprintf } :: import("../libc/stdio");
 /// Span of time stored as seconds and nanoseconds.
 Duration :: struct(
-  secs  : i64,
+  secs : i64,
   nanos : i64
 );
-
-impl(Duration,
+impl(
+  Duration,
   // Create a Duration from whole seconds.
-  from_secs : (fn(secs: i64) -> Self)(
-    Self(secs: secs, nanos: i64(0))
+  from_secs : (fn(secs : i64) -> Self)(
+    Self(secs : secs, nanos : i64(0))
   ),
-
   // Create a Duration from milliseconds.
-  from_millis : (fn(millis: i64) -> Self)(
-    Self(secs: (millis / i64(1000)), nanos: ((millis % i64(1000)) * i64(1000000)))
+  from_millis : (fn(millis : i64) -> Self)(
+    Self(secs : (millis / i64(1000)), nanos : ((millis % i64(1000)) * i64(1000000)))
   ),
-
   // Create a Duration from microseconds.
-  from_micros : (fn(micros: i64) -> Self)(
-    Self(secs: (micros / i64(1000000)), nanos: ((micros % i64(1000000)) * i64(1000)))
+  from_micros : (fn(micros : i64) -> Self)(
+    Self(secs : (micros / i64(1000000)), nanos : ((micros % i64(1000000)) * i64(1000)))
   ),
-
   // Create a Duration of zero length.
   zero : (fn() -> Self)(
-    Self(secs: i64(0), nanos: i64(0))
+    Self(secs : i64(0), nanos : i64(0))
   ),
-
   // Create a Duration from raw nanoseconds.
-  from_nanos : (fn(nanos: i64) -> Self)(
-    Self(secs: (nanos / i64(1000000000)), nanos: (nanos % i64(1000000000)))
+  from_nanos : (fn(nanos : i64) -> Self)(
+    Self(secs : (nanos / i64(1000000000)), nanos : (nanos % i64(1000000000)))
   ),
-
   // Total whole seconds in the duration.
-  as_secs : (fn(self: *(Self)) -> i64)(
+  as_secs : (fn(self : *(Self)) -> i64)(
     self.secs
   ),
-
   // Total milliseconds (truncated).
-  as_millis : (fn(self: *(Self)) -> i64)(
-    ((self.secs * i64(1000)) + (self.nanos / i64(1000000)))
+  as_millis : (fn(self : *(Self)) -> i64)(
+    (self.secs * i64(1000)) + (self.nanos / i64(1000000))
   ),
-
   // Total microseconds (truncated).
-  as_micros : (fn(self: *(Self)) -> i64)(
-    ((self.secs * i64(1000000)) + (self.nanos / i64(1000)))
+  as_micros : (fn(self : *(Self)) -> i64)(
+    (self.secs * i64(1000000)) + (self.nanos / i64(1000))
   ),
-
   // Total nanoseconds.
-  as_nanos : (fn(self: *(Self)) -> i64)(
-    ((self.secs * i64(1000000000)) + self.nanos)
+  as_nanos : (fn(self : *(Self)) -> i64)(
+    (self.secs * i64(1000000000)) + self.nanos
   ),
-
   // Total seconds as a floating-point number.
-  as_secs_f64 : (fn(self: *(Self)) -> f64)(
-    (f64(self.secs) + (f64(self.nanos) / f64(1000000000.0)))
+  as_secs_f64 : (fn(self : *(Self)) -> f64)(
+    f64(self.secs) + (f64(self.nanos) / f64(1000000000.0))
   ),
-
   // Add two durations together.
-  add : (fn(self: *(Self), other: Duration) -> Duration)({
+  add : (fn(self : *(Self), other : Duration) -> Duration)({
     total_nanos := (self.nanos + other.nanos);
     carry := (total_nanos / i64(1000000000));
     Duration(
-      secs: ((self.secs + other.secs) + carry),
-      nanos: (total_nanos % i64(1000000000))
+      secs : ((self.secs + other.secs) + carry),
+      nanos : (total_nanos % i64(1000000000))
     )
   }),
-
   // Subtract another duration (saturates to zero if negative).
-  sub : (fn(self: *(Self), other: Duration) -> Duration)({
+  sub : (fn(self : *(Self), other : Duration) -> Duration)({
     self_ns := self.as_nanos();
     other_ns := other.as_nanos();
     cond(
       (self_ns <= other_ns) => Duration.zero(),
-      true => Duration.from_nanos((self_ns - other_ns))
+      true => Duration.from_nanos(self_ns - other_ns)
     )
   }),
-
   // Return true if this duration is zero.
-  is_zero : (fn(self: *(Self)) -> bool)(
-    ((self.secs == i64(0)) && (self.nanos == i64(0)))
+  is_zero : (fn(self : *(Self)) -> bool)(
+    (self.secs == i64(0)) && (self.nanos == i64(0))
   )
 );
-
-impl(Duration, ToString(
-  to_string : (fn(self: *(Self)) -> String)({
-    buf := Array(u8, usize(64)).fill(u8(0));
-    buf_ptr := &(buf(usize(0)));
-    snprintf(*(char)(buf_ptr), usize(64), "%llds %lldns", self.secs, self.nanos);
-    String.from_cstr(buf_ptr).unwrap()
-  })
-));
-
-export Duration;
+impl(
+  Duration,
+  ToString(
+    to_string : (fn(self : *(Self)) -> String)({
+      buf := Array(u8, usize(64)).fill(u8(0));
+      buf_ptr := &(buf(usize(0)));
+      snprintf(*(char)(buf_ptr), usize(64), "%llds %lldns", self.secs, self.nanos);
+      String.from_cstr(buf_ptr).unwrap()
+    })
+  )
+);
+export(Duration);

package/std/time/instant.yo

@@ -10,43 +10,38 @@
 //! elapsed := start.elapsed();
 //! println(elapsed.as_millis());
 //! ```
-
-{ Duration } :: import "./duration";
-{ CLOCK_MONOTONIC, clock_gettime } :: import "../sys/clock";
-
+{ Duration } :: import("./duration");
+{ CLOCK_MONOTONIC, clock_gettime } :: import("../sys/clock");
 /// Snapshot from the monotonic clock. Use `elapsed` to measure durations.
 Instant :: struct(
-  secs  : i64,
+  secs : i64,
   nanos : i64
 );
-
-impl(Instant,
+impl(
+  Instant,
   // Capture the current monotonic time.
   now : (fn() -> Self)({
-    clk    := CLOCK_MONOTONIC;
-    out_s  := i64(0);
+    clk := CLOCK_MONOTONIC;
+    out_s := i64(0);
     out_ns := i64(0);
-    clock_gettime(clk, (&out_s), (&out_ns));
-    Self(secs: out_s, nanos: out_ns)
+    clock_gettime(clk, &(out_s), &(out_ns));
+    Self(secs : out_s, nanos : out_ns)
   }),
-
   // Duration between this instant and an earlier one.
   // Returns Duration.zero() if `earlier` is actually later.
-  duration_since : (fn(self: *(Self), earlier: Instant) -> Duration)({
+  duration_since : (fn(self : *(Self), earlier : Instant) -> Duration)({
     self_ns := ((self.secs * i64(1000000000)) + self.nanos);
     earlier_ns := ((earlier.secs * i64(1000000000)) + earlier.nanos);
     cond(
       (self_ns <= earlier_ns) => Duration.zero(),
-      true => Duration.from_nanos((self_ns - earlier_ns))
+      true => Duration.from_nanos(self_ns - earlier_ns)
     )
   }),
-
   // Duration elapsed since this instant was created.
-  elapsed : (fn(self: *(Self)) -> Duration)({
+  elapsed : (fn(self : *(Self)) -> Duration)({
     current := Instant.now();
     cur_ptr := (&(current));
     cur_ptr.duration_since(self.*)
   })
 );
-
-export Instant;
+export(Instant);

package/std/time/sleep.yo

@@ -6,14 +6,10 @@
 //! { sleep } :: import "std/time/sleep";
 //! sleep(usize(100)); // sleep 100ms
 //! ```
-
-extern "Yo",
-  __yo_ms_sleep : (fn(ms: usize) -> unit)
-;
-
+extern(
+  "Yo",
+  __yo_ms_sleep : (fn(ms : usize) -> unit)
+);
 /// Block the current thread for the given number of milliseconds.
 sleep :: __yo_ms_sleep;
-
-export
-  sleep
-;
+export(sleep);