@shd101wyy/yo 0.1.26 → 0.1.27

package/std/sys/unix.yo

@@ -3,132 +3,113 @@
 //! Provides Unix domain socket wrappers around the low-level C runtime externs.
 //! Reuses the socket ops (bind/listen/accept/connect/send/recv/close) from the
 //! generic socket externs. Uses `sockaddr_un` helpers to build address buffers.
-
-{ GlobalAllocator } :: import "../allocator.yo";
+{ GlobalAllocator } :: import("../allocator.yo");
 { malloc, free } :: GlobalAllocator;
-{ IOFuture } :: import "./future.yo";
-{
-  __yo_async_socket_start, __yo_async_bind_start,
-  __yo_async_listen_start, __yo_async_accept_start,
-  __yo_async_connect_start, __yo_async_send_start,
-  __yo_async_recv_start, __yo_async_close_start,
-  __yo_sockaddr_un_set_path,
-  __yo_sockaddr_un_get_path, __yo_sockaddr_set_family
-} :: import "./externs.yo";
-{
-  AF_UNIX, SOCK_STREAM, SOCK_DGRAM,
-  sockaddr_un_size
-} :: import "./socket.yo";
-
+{ IOFuture } :: import("./future.yo");
+{ __yo_async_socket_start, __yo_async_bind_start, __yo_async_listen_start, __yo_async_accept_start, __yo_async_connect_start, __yo_async_send_start, __yo_async_recv_start, __yo_async_close_start, __yo_sockaddr_un_set_path, __yo_sockaddr_un_get_path, __yo_sockaddr_set_family } :: import("./externs.yo");
+{ AF_UNIX, SOCK_STREAM, SOCK_DGRAM, sockaddr_un_size } :: import("./socket.yo");
 // ============================================================================
 // UnixAddr - sockaddr_un buffer with pointer and length
 // ============================================================================
-
 UnixAddr :: struct(
   buf : ?*(u8),
   len : u32
 );
-export UnixAddr;
-
+export(UnixAddr);
 // ============================================================================
 // Core Unix Socket Operations (return IOFuture, use with await)
 // ============================================================================
-
 // Create a Unix domain socket (SOCK_STREAM).
 // Returns fd on success, -errno on failure.
 socket_stream :: (fn() -> IOFuture)(
   __yo_async_socket_start(AF_UNIX, SOCK_STREAM, i32(0))
 );
-
 // Create a Unix domain socket (SOCK_DGRAM).
 // Returns fd on success, -errno on failure.
 socket_dgram :: (fn() -> IOFuture)(
   __yo_async_socket_start(AF_UNIX, SOCK_DGRAM, i32(0))
 );
-
 // Bind a socket to a local Unix address.
 // Returns 0 on success, -errno on failure.
-bind :: (fn(sockfd: i32, addr: *(u8), addrlen: u32) -> IOFuture)(
+bind :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
   __yo_async_bind_start(sockfd, addr, addrlen)
 );
-
 // Listen for incoming connections on a Unix socket.
 // Returns 0 on success, -errno on failure.
-listen :: (fn(sockfd: i32, backlog: i32) -> IOFuture)(
+listen :: (fn(sockfd : i32, backlog : i32) -> IOFuture)(
   __yo_async_listen_start(sockfd, backlog)
 );
-
 // Accept an incoming connection.
 // Returns fd on success, -errno on failure.
-accept :: (fn(sockfd: i32, addr: *(u8), addrlen: *(u32)) -> IOFuture)(
+accept :: (fn(sockfd : i32, addr : *(u8), addrlen : *(u32)) -> IOFuture)(
   __yo_async_accept_start(sockfd, addr, addrlen)
 );
-
 // Connect to a Unix socket address.
 // Returns 0 on success, -errno on failure.
-connect :: (fn(sockfd: i32, addr: *(u8), addrlen: u32) -> IOFuture)(
+connect :: (fn(sockfd : i32, addr : *(u8), addrlen : u32) -> IOFuture)(
   __yo_async_connect_start(sockfd, addr, addrlen)
 );
-
 // Send data on a connected Unix socket.
 // Returns number of bytes sent on success, -errno on failure.
-send :: (fn(sockfd: i32, buf: *(u8), len: usize, flags: i32) -> IOFuture)(
+send :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
   __yo_async_send_start(sockfd, buf, len, flags)
 );
-
 // Receive data from a connected Unix socket.
 // Returns number of bytes received on success, -errno on failure.
-recv :: (fn(sockfd: i32, buf: *(u8), len: usize, flags: i32) -> IOFuture)(
+recv :: (fn(sockfd : i32, buf : *(u8), len : usize, flags : i32) -> IOFuture)(
   __yo_async_recv_start(sockfd, buf, len, flags)
 );
-
 // Close a Unix socket file descriptor.
 // Returns 0 on success, -errno on failure.
-close :: (fn(fd: i32) -> IOFuture)(
+close :: (fn(fd : i32) -> IOFuture)(
   __yo_async_close_start(fd)
 );
-
 // ============================================================================
 // Unix Socket Address Helpers
 // ============================================================================
-
 // Create a sockaddr_un from a filesystem path.
 // The path must be a null-terminated C string.
 // Returns a UnixAddr with allocated buffer. Caller must free the buffer.
-make_sockaddr_un :: (fn(path: *(u8)) -> UnixAddr)({
+make_sockaddr_un :: (fn(path : *(u8)) -> UnixAddr)({
   size := sockaddr_un_size();
   cond(
     (size == usize(0)) => UnixAddr(.None, u32(0)),
     true => {
       buf := *(u8)(malloc(size).unwrap());
       i := usize(0);
-      while runtime((i < size)), {
+      while(runtime(i < size), {
         (buf &+ i).* = u8(0);
         i = (i + usize(1));
-      };
+      });
       __yo_sockaddr_set_family(buf, u16(AF_UNIX));
       __yo_sockaddr_un_set_path(buf, path);
       UnixAddr(.Some(buf), u32(size))
     }
   )
 });
-
 // Extract the path from a sockaddr_un buffer.
-get_path :: (fn(addr_buf: *(u8)) -> *(u8))(
+get_path :: (fn(addr_buf : *(u8)) -> *(u8))(
   __yo_sockaddr_un_get_path(addr_buf)
 );
-
 // Free a UnixAddr buffer.
-free_addr :: (fn(addr: UnixAddr) -> unit)(
-  match(addr.buf,
+free_addr :: (fn(addr : UnixAddr) -> unit)(
+  match(
+    addr.buf,
     .Some(p) => free(.Some(*(void)(p))),
     .None => ()
   )
 );
-
-export
-  socket_stream, socket_dgram,
-  bind, listen, accept, connect,
-  send, recv, close,
-  make_sockaddr_un, get_path, free_addr
-;
+export(
+  socket_stream,
+  socket_dgram,
+  bind,
+  listen,
+  accept,
+  connect,
+  send,
+  recv,
+  close,
+  make_sockaddr_un,
+  get_path,
+  free_addr
+);

package/std/testing/bench.yo

@@ -11,100 +11,97 @@
 //! result := bench(`sort`, u64(1000), () => { /* work */ });
 //! println(result.to_string());
 //! ```
-
-open import "../string";
-{ ToString } :: import "../fmt";
-{ snprintf } :: import "../libc/stdio";
-{ Instant } :: import "../time/instant";
-
+open(import("../string"));
+{ ToString } :: import("../fmt");
+{ snprintf } :: import("../libc/stdio");
+{ Instant } :: import("../time/instant");
 // ============================================================================
 // BenchResult
 // ============================================================================
-
 /// Timing statistics returned by `bench`.
 BenchResult :: struct(
   /// Benchmark name.
-  name       : String,
+  name : String,
   /// Total number of iterations executed.
   iterations : u64,
   /// Total elapsed nanoseconds across all iterations.
-  total_ns   : i64,
+  total_ns : i64,
   /// Average nanoseconds per iteration.
-  avg_ns     : i64,
+  avg_ns : i64,
   /// Minimum nanoseconds for a single iteration.
-  min_ns     : i64,
+  min_ns : i64,
   /// Maximum nanoseconds for a single iteration.
-  max_ns     : i64
+  max_ns : i64
 );
-
-_i64_to_string :: (fn(v: i64) -> String)({
+_i64_to_string :: (fn(v : i64) -> String)({
   buf := Array(u8, usize(32)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   snprintf(*(char)(buf_ptr), usize(32), "%lld", v);
   String.from_cstr(buf_ptr).unwrap()
 });
-
-_u64_to_string :: (fn(v: u64) -> String)({
+_u64_to_string :: (fn(v : u64) -> String)({
   buf := Array(u8, usize(32)).fill(u8(0));
   buf_ptr := &(buf(usize(0)));
   snprintf(*(char)(buf_ptr), usize(32), "%llu", v);
   String.from_cstr(buf_ptr).unwrap()
 });
-
-impl(BenchResult, ToString(
-  to_string : (fn(self: *(Self)) -> String)({
-    prefix  := String.from("bench '");
-    part1   := prefix.concat(self.name);
-    part2   := part1.concat(String.from("': iters="));
-    part3   := part2.concat(_u64_to_string(self.iterations));
-    part4   := part3.concat(String.from(" avg_ns="));
-    part5   := part4.concat(_i64_to_string(self.avg_ns));
-    part6   := part5.concat(String.from(" min="));
-    part7   := part6.concat(_i64_to_string(self.min_ns));
-    part8   := part7.concat(String.from(" max="));
-    part8.concat(_i64_to_string(self.max_ns))
-  })
-));
-
-export BenchResult;
-
+impl(
+  BenchResult,
+  ToString(
+    to_string : (fn(self : *(Self)) -> String)({
+      prefix := String.from("bench '");
+      part1 := prefix.concat(self.name);
+      part2 := part1.concat(String.from("': iters="));
+      part3 := part2.concat(_u64_to_string(self.iterations));
+      part4 := part3.concat(String.from(" avg_ns="));
+      part5 := part4.concat(_i64_to_string(self.avg_ns));
+      part6 := part5.concat(String.from(" min="));
+      part7 := part6.concat(_i64_to_string(self.min_ns));
+      part8 := part7.concat(String.from(" max="));
+      part8.concat(_i64_to_string(self.max_ns))
+    })
+  )
+);
+export(BenchResult);
 // ============================================================================
 // bench
 // ============================================================================
-
 /// Run `body` for `iterations` times and return timing statistics.
-bench :: (fn(name: String, iterations: u64, body: Impl(Fn() -> unit)) -> BenchResult)({
+bench :: (fn(name : String, iterations : u64, body : Impl(Fn() -> unit)) -> BenchResult)({
   total_ns := i64(0);
-  min_ns   := i64(9223372036854775807); // i64::MAX
-  max_ns   := i64(0);
-  i        := u64(0);
-  while (i < iterations), (i = (i + u64(1))), {
+  min_ns := i64(9223372036854775807); // i64::MAX
+  max_ns := i64(0);
+  i := u64(0);
+  while(i < iterations, i = (i + u64(1)), {
     t_start := Instant.now();
     body();
-    t_end   := Instant.now();
+    t_end := Instant.now();
     elapsed := t_end.duration_since(t_start).as_nanos();
     total_ns = (total_ns + elapsed);
     cond(
-      (elapsed < min_ns) => { min_ns = elapsed; },
+      (elapsed < min_ns) => {
+        min_ns = elapsed;
+      },
       true => ()
     );
     cond(
-      (elapsed > max_ns) => { max_ns = elapsed; },
+      (elapsed > max_ns) => {
+        max_ns = elapsed;
+      },
       true => ()
     );
-  };
+  });
   avg_ns := cond(
     (iterations > u64(0)) => (total_ns / i64(iterations)),
     true => i64(0)
   );
   BenchResult(
-    name:       name,
-    iterations: iterations,
-    total_ns:   total_ns,
-    avg_ns:     avg_ns,
-    min_ns:     min_ns,
-    max_ns:     max_ns
+    name : name,
+    iterations : iterations,
+    total_ns : total_ns,
+    avg_ns : avg_ns,
+    min_ns : min_ns,
+    max_ns : max_ns
   )
 });
-
-export bench;
+export(bench);

package/std/thread.yo

@@ -1,47 +1,42 @@
 //! OS thread creation and management with per-thread IO event loops.
-
-extern "Yo",
+extern(
+  "Yo",
   __yo_thread_get_hardware_threads : (fn() -> usize),
   __yo_get_thread_id : (fn() -> usize),
   __yo_get_cpu_id : (fn() -> i32)
-;
-
-extern "Yo",
+);
+extern(
+  "Yo",
   __yo_thread_t : Type,
   __yo_thread_spawn : (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> __yo_thread_t),
   __yo_thread_join : (fn(t : __yo_thread_t) -> unit)
-;
-
+);
 /// OS thread handle. Each spawned thread gets its own IO event loop.
 Thread :: struct(
   handle : __yo_thread_t
 );
-impl(Thread,
+impl(
+  Thread,
   /// Spawn a new OS thread running the given closure.
   /// The closure receives its own per-thread IO event loop.
   spawn : (fn(cb : Impl(Fn(using(io : IO)) -> unit, Send)) -> Self)({
     raw := __yo_thread_spawn(cb);
     Self(raw)
   }),
-  
   /// Block the current thread until this thread completes.
   join : (fn(self : *(Self)) -> unit)(
     __yo_thread_join(self.handle)
   )
 );
-
 /// Get the number of hardware threads (CPU cores) available.
 get_hardware_threads :: __yo_thread_get_hardware_threads;
-
 /// Get the current OS thread ID.
 get_thread_id :: __yo_get_thread_id;
-
 /// Get the current CPU core ID.
 get_cpu_id :: __yo_get_cpu_id;
-
-export
+export(
   get_hardware_threads,
   get_thread_id,
   get_cpu_id,
   Thread
-;
+);

package/std/time/datetime.yo

@@ -8,41 +8,45 @@
 //! now := DateTime.now_utc();
 //! println(now.to_string());   // "2026-02-26T17:41:24Z"
 //! ```
-
-{ String } :: import "../string";
-{ ToString } :: import "../fmt";
-{ CLOCK_REALTIME, clock_gettime } :: import "../sys/clock";
-{ snprintf } :: import "../libc/stdio";
-
+{ String } :: import("../string");
+{ ToString } :: import("../fmt");
+{ CLOCK_REALTIME, clock_gettime } :: import("../sys/clock");
+{ snprintf } :: import("../libc/stdio");
 /// Calendar date and time with nanosecond precision.
 /// Values are in UTC unless `utc_offset_secs` is non-zero.
 DateTime :: struct(
-  year            : i32,
-  month           : u8,
-  day             : u8,
-  hour            : u8,
-  minute          : u8,
-  second          : u8,
-  nanosecond      : u32,
+  year : i32,
+  month : u8,
+  day : u8,
+  hour : u8,
+  minute : u8,
+  second : u8,
+  nanosecond : u32,
   utc_offset_secs : i32
 );
-
 // Days per month lookup (non-leap year)
 _DAYS_IN_MONTH :: Array(u8, usize(12))(
-  u8(31), u8(28), u8(31), u8(30), u8(31), u8(30),
-  u8(31), u8(31), u8(30), u8(31), u8(30), u8(31)
+  u8(31),
+  u8(28),
+  u8(31),
+  u8(30),
+  u8(31),
+  u8(30),
+  u8(31),
+  u8(31),
+  u8(30),
+  u8(31),
+  u8(30),
+  u8(31)
 );
-
-_is_leap_year :: (fn(y: i32) -> bool)(
-  (((y % i32(4)) == i32(0)) && (((y % i32(100)) != i32(0)) || ((y % i32(400)) == i32(0))))
+_is_leap_year :: (fn(y : i32) -> bool)(
+  ((y % i32(4)) == i32(0)) && (((y % i32(100)) != i32(0)) || ((y % i32(400)) == i32(0)))
 );
-
 // Convert a Unix timestamp (seconds since 1970-01-01 UTC) into date/time fields.
-_from_unix_secs :: (fn(secs: i64, nanos: i64) -> DateTime)({
+_from_unix_secs :: (fn(secs : i64, nanos : i64) -> DateTime)({
   // Adjust epoch: number of days since Unix epoch
   days := (secs / i64(86400));
-  rem  := (secs % i64(86400));
-
+  rem := (secs % i64(86400));
   // Normalise negative remainders
   rem_adj := cond(
     (rem < i64(0)) => (rem + i64(86400)),
@@ -52,68 +56,62 @@ _from_unix_secs :: (fn(secs: i64, nanos: i64) -> DateTime)({
     (rem < i64(0)) => (days - i64(1)),
     true => days
   );
-
-  hour   := u8((rem_adj / i64(3600)));
-  min_r  := (rem_adj % i64(3600));
-  minute := u8((min_r / i64(60)));
-  second := u8((min_r % i64(60)));
-
+  hour := u8(rem_adj / i64(3600));
+  min_r := (rem_adj % i64(3600));
+  minute := u8(min_r / i64(60));
+  second := u8(min_r % i64(60));
   // Gregorian calendar computation starting from 1970-01-01
   // Using the algorithm from days since epoch → year/month/day
   z := (days_adj + i64(719468));
   era := cond(
     (z >= i64(0)) => (z / i64(146097)),
-    true => (((z - i64(146096)) / i64(146097)))
+    true => ((z - i64(146096)) / i64(146097))
   );
-  doe  := (z - (era * i64(146097)));
-  yoe  := (((doe - (doe / i64(1460))) + (doe / i64(36524))) - (doe / i64(146096)));
-  yoe  = (yoe / i64(365));
-  y    := (yoe + (era * i64(400)));
-  doy  := (doe - (((i64(365) * yoe) + (yoe / i64(4))) - (yoe / i64(100))));
-  mp   := (((i64(5) * doy) + i64(2)) / i64(153));
-  d    := (doy - (((i64(153) * mp) + i64(2)) / i64(5)));
-  m    := cond(
+  doe := (z - (era * i64(146097)));
+  yoe := (((doe - (doe / i64(1460))) + (doe / i64(36524))) - (doe / i64(146096)));
+  yoe = (yoe / i64(365));
+  y := (yoe + (era * i64(400)));
+  doy := (doe - (((i64(365) * yoe) + (yoe / i64(4))) - (yoe / i64(100))));
+  mp := (((i64(5) * doy) + i64(2)) / i64(153));
+  d := (doy - (((i64(153) * mp) + i64(2)) / i64(5)));
+  m := cond(
     (mp < i64(10)) => (mp + i64(3)),
     true => (mp - i64(9))
   );
-  y2   := cond(
+  y2 := cond(
     (m <= i64(2)) => (y + i64(1)),
     true => y
   );
-
   DateTime(
-    year:            i32(y2),
-    month:           u8(m),
-    day:             u8((d + i64(1))),
-    hour:            hour,
-    minute:          minute,
-    second:          second,
-    nanosecond:      u32(nanos),
-    utc_offset_secs: i32(0)
+    year : i32(y2),
+    month : u8(m),
+    day : u8(d + i64(1)),
+    hour : hour,
+    minute : minute,
+    second : second,
+    nanosecond : u32(nanos),
+    utc_offset_secs : i32(0)
   )
 });
-
-impl(DateTime,
+impl(
+  DateTime,
   // Current UTC date/time.
   now_utc : (fn() -> Self)({
-    sec  := i64(0);
+    sec := i64(0);
     nsec := i64(0);
-    clock_gettime(CLOCK_REALTIME, (&sec), (&nsec));
+    clock_gettime(CLOCK_REALTIME, &(sec), &(nsec));
     _from_unix_secs(sec, nsec)
   }),
-
   // Current local date/time (UTC offset not resolved; same as now_utc for now).
   now : (fn() -> Self)(
     DateTime.now_utc()
   ),
-
   // Construct from a Unix timestamp.
-  from_unix : (fn(secs: i64, nanos: i64) -> Self)(
+  from_unix : (fn(secs : i64, nanos : i64) -> Self)(
     _from_unix_secs(secs, nanos)
   ),
-
   // Convert back to a Unix timestamp (seconds since epoch).
-  to_unix : (fn(self: *(Self)) -> i64)({
+  to_unix : (fn(self : *(Self)) -> i64)({
     // Compute days since epoch using the inverse Gregorian algorithm
     y := i64(self.year);
     m := i64(self.month);
@@ -124,10 +122,10 @@ impl(DateTime,
     );
     era := cond(
       (y2 >= i64(0)) => (y2 / i64(400)),
-      true => (((y2 - i64(399)) / i64(400)))
+      true => ((y2 - i64(399)) / i64(400))
     );
     yoe := (y2 - (era * i64(400)));
-    mp  := cond(
+    mp := cond(
       (m > i64(2)) => (m - i64(3)),
       true => (m + i64(9))
     );
@@ -135,43 +133,52 @@ impl(DateTime,
     doe := ((((yoe * i64(365)) + (yoe / i64(4))) - (yoe / i64(100))) + doy);
     days := (((era * i64(146097)) + doe) - i64(719468));
     time_secs := (((i64(self.hour) * i64(3600)) + (i64(self.minute) * i64(60))) + i64(self.second));
-    ((days * i64(86400)) + time_secs)
+    (days * i64(86400)) + time_secs
   }),
-
   // True if this year is a leap year.
-  is_leap_year : (fn(self: *(Self)) -> bool)(
+  is_leap_year : (fn(self : *(Self)) -> bool)(
     _is_leap_year(self.year)
   ),
-
   // Day of week: 0 = Monday, 6 = Sunday (ISO 8601).
-  day_of_week : (fn(self: *(Self)) -> u8)({
+  day_of_week : (fn(self : *(Self)) -> u8)({
     // Tomohiko Sakamoto's algorithm
     t := Array(i32, usize(12))(
-      i32(0), i32(3), i32(2), i32(5), i32(0), i32(3),
-      i32(5), i32(1), i32(4), i32(6), i32(2), i32(4)
+      i32(0),
+      i32(3),
+      i32(2),
+      i32(5),
+      i32(0),
+      i32(3),
+      i32(5),
+      i32(1),
+      i32(4),
+      i32(6),
+      i32(2),
+      i32(4)
     );
     y := cond(
       (i32(self.month) < i32(3)) => (self.year - i32(1)),
       true => self.year
     );
-    sum := (((((y + (y / i32(4))) - (y / i32(100))) + (y / i32(400))) + t(usize((i32(self.month) - i32(1))))) + i32(self.day));
+    sum := (((((y + (y / i32(4))) - (y / i32(100))) + (y / i32(400))) + t(usize(i32(self.month) - i32(1)))) + i32(self.day));
     dow := (sum % i32(7));
     // Convert: 0=Sun → remap to 0=Mon
-    u8(cond(
-      (dow == i32(0)) => i32(6),
-      true => (dow - i32(1))
-    ))
+    u8(
+      cond(
+        (dow == i32(0)) => i32(6),
+        true => (dow - i32(1))
+      )
+    )
   }),
-
   // Day of year (1-based).
-  day_of_year : (fn(self: *(Self)) -> u16)({
+  day_of_year : (fn(self : *(Self)) -> u16)({
     m := i32(self.month);
     d := i32(self.day);
     // Sum days in preceding months
     days := d;
     i := i32(1);
-    while (i < m), (i = (i + i32(1))), {
-      idx := usize((i - i32(1)));
+    while(i < m, i = (i + i32(1)), {
+      idx := usize(i - i32(1));
       days = (days + i32(_DAYS_IN_MONTH(idx)));
       // Add leap day after Feb in a leap year
       cond(
@@ -180,20 +187,29 @@ impl(DateTime,
         },
         true => ()
       );
-    };
+    });
     u16(days)
   })
 );
-
-impl(DateTime, ToString(
-  to_string : (fn(self: *(Self)) -> String)({
-    buf := Array(u8, usize(32)).fill(u8(0));
-    buf_ptr := &(buf(usize(0)));
-    snprintf(*(char)(buf_ptr), usize(32), "%04d-%02u-%02uT%02u:%02u:%02uZ",
-      self.year, self.month, self.day,
-      self.hour, self.minute, self.second);
-    String.from_cstr(buf_ptr).unwrap()
-  })
-));
-
-export DateTime;
+impl(
+  DateTime,
+  ToString(
+    to_string : (fn(self : *(Self)) -> String)({
+      buf := Array(u8, usize(32)).fill(u8(0));
+      buf_ptr := &(buf(usize(0)));
+      snprintf(
+        *(char)(buf_ptr),
+        usize(32),
+        "%04d-%02u-%02uT%02u:%02u:%02uZ",
+        self.year,
+        self.month,
+        self.day,
+        self.hour,
+        self.minute,
+        self.second
+      );
+      String.from_cstr(buf_ptr).unwrap()
+    })
+  )
+);
+export(DateTime);