add datetime function

Author: kaikalii

Cargo.lock

@@ -35,6 +35,7 @@ serde_json = "1"
 serde_tuple = "0.5.0"
 term_size = "=1.0.0-beta.2"
 thread_local = "1"
+time = "0.3.36"
 tinyvec = {version = "1", features = ["alloc", "serde"]}
 toml = "0.8.10"
 unicode-segmentation = "1.10"

Cargo.toml

@@ -16,6 +16,7 @@ This version is not yet released. If you are reading this on the website, then t
   - For example, `X__1` will format to `X₁`
 - Add new [Scoped Modules](https://uiua.org/tutorial/modules#scoped-modules)
   - These allow you to create a module without creating a file
+- Add the [`datetime`](https://uiua.org/docs/datetime) function, which splits a time into its date and time components
 - [`un °`](https://uiua.org/docs/un) [`shape △`](https://uiua.org/docs/shape) now generates an array with the given shape and incrementing elements
 - [`un °`](https://uiua.org/docs/un) [`pick ⊡`](https://uiua.org/docs/pick) is now equivalent to [`range ⇡`](https://uiua.org/docs/range) [`shape △`](https://uiua.org/docs/shape) [`duplicate .`](https://uiua.org/docs/duplicate)
 - [`keep ▽`](https://uiua.org/docs/keep) will now cycle counts if the counts array is shorter than the counted array

changelog.md

@@ -500,6 +500,12 @@
     "class": "Encoding",
     "description": "Encode an array into a CSV string"
   },
+  "datetime": {
+    "args": 1,
+    "outputs": 1,
+    "class": "Misc",
+    "description": "Get the date and time information from a time"
+  },
   "deal": {
     "args": 2,
     "outputs": 1,

site/primitives.json

@@ -338,7 +338,7 @@ impl SysBackend for WebBackend {
         self.play_audio(bytes)
     }
     fn now(&self) -> f64 {
-        *START_TIME.get().unwrap() + instant::now() / 1000.0
+        *START_TIME.get_or_init(|| instant::now() / 1000.0) + instant::now() / 1000.0
     }
     fn set_clipboard(&self, contents: &str) -> Result<(), String> {
         _ = window()

site/src/backend.rs

@@ -112,6 +112,7 @@ fn prim_inverse(prim: Primitive, span: usize) -> Option<Instr> {
         Csv => Instr::ImplPrim(UnCsv, span),
         Xlsx => Instr::ImplPrim(UnXlsx, span),
         Fft => Instr::ImplPrim(UnFft, span),
+        DateTime => Instr::ImplPrim(UnDatetime, span),
         _ => return None,
     })
 }
@@ -141,6 +142,7 @@ fn impl_prim_inverse(prim: ImplPrimitive, span: usize) -> Option<Instr> {
         UnCsv => Instr::Prim(Csv, span),
         UnXlsx => Instr::Prim(Xlsx, span),
         UnFft => Instr::Prim(Fft, span),
+        UnDatetime => Instr::Prim(DateTime, span),
         TraceN(n, inverse) => Instr::ImplPrim(TraceN(n, !inverse), span),
         _ => return None,
     })

src/algorithm/invert.rs

@@ -8,10 +8,12 @@ use std::{
     iter::{self, repeat},
     mem::size_of,
     ptr, slice,
+    time::Duration,
 };
 
 use ecow::{eco_vec, EcoVec};
 use rayon::prelude::*;
+use time::{Date, Month, OffsetDateTime, Time};
 
 use crate::{
     array::*,
@@ -1979,4 +1981,132 @@ impl Value {
         }
         s
     }
+    /// Get the `datetime` of a value
+    pub fn datetime(&self, env: &Uiua) -> UiuaResult<Array<f64>> {
+        let mut arr = match self {
+            Value::Num(arr) => arr.clone(),
+            Value::Byte(arr) => arr.convert_ref(),
+            value => return Err(env.error(format!("Cannot get datetime of {}", value.type_name()))),
+        };
+        let mut new_data = eco_vec![0.0; arr.data.len() * 6];
+        let slice = new_data.make_mut();
+        for (i, &n) in arr.data.iter().enumerate() {
+            let dur = Duration::try_from_secs_f64(n.abs())
+                .map_err(|_| env.error(format!("{n} is not a valid time")))?;
+            let dt = if n >= 0.0 {
+                OffsetDateTime::UNIX_EPOCH + dur
+            } else {
+                OffsetDateTime::UNIX_EPOCH - dur
+            };
+            slice[i * 6] = dt.year() as f64;
+            slice[i * 6 + 1] = dt.month() as u8 as f64;
+            slice[i * 6 + 2] = dt.day() as f64;
+            slice[i * 6 + 3] = dt.hour() as f64;
+            slice[i * 6 + 4] = dt.minute() as f64;
+            slice[i * 6 + 5] = dt.second() as f64;
+        }
+        arr.data = new_data.into();
+        arr.shape.push(6);
+        arr.validate_shape();
+        Ok(arr)
+    }
+    pub(crate) fn undatetime(&self, env: &Uiua) -> UiuaResult<Array<f64>> {
+        let mut arr = match self {
+            Value::Num(arr) => arr.clone(),
+            Value::Byte(arr) => arr.convert_ref(),
+            value => {
+                return Err(env.error(format!("Cannot decode datetime from {}", value.type_name())))
+            }
+        };
+        let convert = |chunk: &[f64]| -> UiuaResult<f64> {
+            let mut year = chunk.first().copied().unwrap_or(0.0);
+            let mut month = chunk.get(1).copied().unwrap_or(0.0) - 1.0;
+            let mut day = chunk.get(2).copied().unwrap_or(0.0) - 1.0;
+            let mut hour = chunk.get(3).copied().unwrap_or(0.0);
+            let mut minute = chunk.get(4).copied().unwrap_or(0.0);
+            let mut second = chunk.get(5).copied().unwrap_or(0.0);
+            let mut frac = chunk.get(6).copied().unwrap_or(0.0);
+            frac += second.fract();
+            if frac >= 1.0 {
+                second += frac.floor();
+                frac = 1.0 - frac.fract();
+            } else if frac < 0.0 {
+                second += frac.ceil();
+                frac = -frac.fract();
+            }
+            if second >= 60.0 {
+                minute += (second / 60.0).floor();
+                second %= 60.0;
+            } else if second < 0.0 {
+                minute += (second / 60.0).ceil();
+                second = 60.0 + (second % 60.0);
+            }
+            if minute >= 60.0 {
+                hour += (minute / 60.0).floor();
+                minute %= 60.0;
+            } else if minute < 0.0 {
+                hour += (minute / 60.0).ceil();
+                minute = 60.0 + (minute % 60.0);
+            }
+            if hour >= 24.0 {
+                day += (hour / 24.0).floor();
+                hour %= 24.0;
+            } else if hour < 0.0 {
+                day += (hour / 24.0).ceil();
+                hour = 24.0 + (hour % 24.0);
+            }
+            let day_delta = if day >= 28.0 {
+                let delta = day - 27.0;
+                day -= delta;
+                delta
+            } else if day < 0.0 {
+                let delta = day;
+                day = 0.0;
+                delta
+            } else {
+                day.fract()
+            };
+            if month >= 12.0 {
+                year += (month / 12.0).floor();
+                month %= 12.0;
+            } else if month < 1.0 {
+                year += (month / 12.0).ceil();
+                month = 12.0 - (month % 12.0);
+            }
+            let year = year as i32;
+            let month = month as u8 + 1;
+            let day = day as u8 + 1;
+            let hour = hour as u8;
+            let minute = minute as u8;
+            let second = second as u8;
+            let mut dt = OffsetDateTime::new_utc(
+                Date::from_calendar_date(year, Month::January.nth_next(month - 1), day).map_err(
+                    |e| env.error(format!("Invalid date {year:04}-{month:02}-{day:02}: {e}")),
+                )?,
+                Time::from_hms(hour, minute, second).map_err(|e| {
+                    env.error(format!(
+                        "Invalid time {hour:02}:{minute:02}:{second:02}: {e}"
+                    ))
+                })?,
+            );
+            if day_delta > 0.0 {
+                dt += Duration::from_secs_f64(day_delta * 86400.0);
+            } else if day_delta < 0.0 {
+                dt -= Duration::from_secs_f64(day_delta.abs() * 86400.0);
+            }
+            Ok(dt.unix_timestamp() as f64 + frac)
+        };
+        let &[.., n] = &*arr.shape else {
+            return Err(env.error("Cannot decode datetime from scalar"));
+        };
+        let mut new_data = eco_vec![0.0; arr.data.len() / n];
+        let slice = new_data.make_mut();
+        for (i, chunk) in arr.data.chunks_exact(n).enumerate() {
+            slice[i] = convert(chunk)?;
+        }
+        arr.shape.pop();
+        arr.data = new_data.into();
+        arr.validate_shape();
+        Ok(arr)
+    }
 }

src/algorithm/monadic.rs

@@ -2308,10 +2308,40 @@ primitive!(
     (1, Type, Misc, "type"),
     /// Get the current time in seconds
     ///
+    /// Time is expressed in seconds since the Unix epoch.
     /// ex: now
     /// [under][now] can be used to time a function.
     /// ex: ⍜now(5&sl1)
     (0, Now, Misc, "now", Impure),
+    /// Get the date and time information from a time
+    ///
+    /// You can use [now] to get the current time in seconds since the Unix epoch.
+    /// [datetime] turns a time into an array with 6 numbers:
+    /// - Year
+    /// - Month (1-12)
+    /// - Day (1-31)
+    /// - Hour (0-23)
+    /// - Minute (0-59)
+    /// - Second (0-59)
+    ///
+    /// ex: datetime now
+    /// The time is always in UTC.
+    /// [datetime] is semi-pervasive.
+    /// ex: datetime [1e8 1e9 1e10]
+    /// You can format the time like this:
+    /// ex: datetime now         # Time
+    ///   : ⍚(⬚@0↙¯⊙°⋕) [4....2] # Pad
+    ///   : °[°$"_-_-_ _:_:_"]   # Format
+    ///
+    /// You can use [un][datetime] to convert an array back into a time.
+    /// An array with fewer than 6 numbers will be padded with zeros.
+    /// ex: °datetime [2023 2 28 1 2 3]
+    /// ex: °datetime [2014_4_1 2022_3_31]
+    /// Invalid numbers in the datetime will be normalized.
+    /// ex: ⍜°datetime∘ [2023 2 29]
+    /// ex: ⍜°datetime∘ [1917 5 0]
+    /// ex: ⍜°datetime∘ [1996 12 ¯100]
+    (1, DateTime, Misc, "datetime"),
     /// The number of radians in a quarter circle
     ///
     /// Equivalent to `divide``2``pi` or `divide``4``tau`
@@ -2785,6 +2815,7 @@ impl_primitive!(
     (1, UnCsv),
     (1, UnXlsx),
     (1, UnFft),
+    (1, UnDatetime),
     (2(0), MatchPattern),
     // Unders
     (1, UndoFix),

src/primitive/defs.rs

@@ -176,6 +176,7 @@ impl fmt::Display for ImplPrimitive {
             UnCsv => write!(f, "{Un}{Csv}"),
             UnXlsx => write!(f, "{Un}{Xlsx}"),
             UnFft => write!(f, "{Un}{Fft}"),
+            UnDatetime => write!(f, "{Un}{DateTime}"),
             UndoTake => write!(f, "{Under}{Take}"),
             UndoDrop => write!(f, "{Under}{Drop}"),
             UndoSelect => write!(f, "{Under}{Select}"),
@@ -787,6 +788,7 @@ impl Primitive {
                 env.try_recv(id)?;
             }
             Primitive::Now => env.push(env.rt.backend.now()),
+            Primitive::DateTime => env.monadic_ref_env(Value::datetime)?,
             Primitive::SetInverse => {
                 let f = env.pop_function()?;
                 let _inv = env.pop_function()?;
@@ -1031,6 +1033,7 @@ impl ImplPrimitive {
                 env.push(val);
             }
             ImplPrimitive::UnFft => algorithm::unfft(env)?,
+            ImplPrimitive::UnDatetime => env.monadic_ref_env(Value::undatetime)?,
             ImplPrimitive::UndoInsert => {
                 let key = env.pop(1)?;
                 let _value = env.pop(2)?;

src/primitive/mod.rs

@@ -573,6 +573,10 @@ B ← |1 (⨬(+⊃(B-1|B-2)|1)<2.)
 ⍤⟜≍: [{"1" "2" ""} {"3" "" ""} {"4" "5" "6"}] °csv "1,2\n3\n4,5,6\n"
 ⍤⟜≍: "1,2\n3\n4,5,6\n" csv {1_2 3 4_5_6}
 
+# Datetime
+⍤⟜≍: [2023 2 28 1 2 3] ⍜°datetime∘ [2023 2 28 1 2 3]
+⍤⟜≍: [2023 3 1 1 2 3] ⍜°datetime∘ [2023 2 29 1 2 3]
+
 # On
 ⍤⟜≍: [1 1 3] [⟜⊙⋅⊙◌ 1 2 3 4]
 ⍤⟜≍: [1 1 2 2 4] [⟜⊙⟜⊙⋅∘ 1 2 3 4]