added more funcionalities

gleam.toml

···
 name = "birl"
-version = "1.3.2"
+version = "1.4.0"
 
 description = "Date / Time handling for Gleam"
 gleam = ">= 0.32.0"

src/birl.gleam

···
 
   Time(
     now,
-    offset_in_minutes
-    * 60_000_000,
+    offset_in_minutes * 60_000_000,
     option.map(timezone, fn(tz) {
       case
         zones.list
···
   )
 }
 
-/// Use this to get the current time in utc
+/// use this to get the current time in utc
 pub fn utc_now() -> Time {
   let now = ffi_now()
   let monotonic_now = ffi_monotonic_now()
   Time(now, 0, option.Some("Etc/UTC"), option.Some(monotonic_now))
 }
 
-/// Use this to get the current time with a given offset.
+/// use this to get the current time with a given offset.
 ///
-/// Some examples of acceptable offsets:
+/// some examples of acceptable offsets:
 ///
 /// `"+330", "03:30", "-8:00","-7", "-0400", "03"`
 pub fn now_with_offset(offset: String) -> Result(Time, Nil) {
···
       let monotonic_now = ffi_monotonic_now()
       Time(
         now,
-        offset
-        * 1_000_000,
+        offset * 1_000_000,
         option.Some(timezone),
         option.Some(monotonic_now),
       )
···
   ffi_monotonic_now()
 }
 
+/// returns a string which is the date part of an ISO8601 string along with the offset
+pub fn to_date_string(value: Time) -> String {
+  let #(#(year, month, day), _, offset) = to_parts(value)
+
+  int.to_string(year)
+  <> "-"
+  <> {
+    month
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> "-"
+  <> {
+    day
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> offset
+}
+
+/// like `to_date_string` except it does not contain the offset
+pub fn to_naive_date_string(value: Time) -> String {
+  let #(#(year, month, day), _, _) = to_parts(value)
+
+  int.to_string(year)
+  <> "-"
+  <> {
+    month
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> "-"
+  <> {
+    day
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+}
+
+/// returns a string which is the time part of an ISO8601 string along with the offset
+pub fn to_time_string(value: Time) -> String {
+  let #(_, #(hour, minute, second, milli_second), offset) = to_parts(value)
+
+  {
+    hour
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> ":"
+  <> {
+    minute
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> ":"
+  <> {
+    second
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> "."
+  <> {
+    milli_second
+    |> int.to_string
+    |> string.pad_left(3, "0")
+  }
+  <> offset
+}
+
+/// like `to_time_string` except it does not contain the offset
+pub fn to_naive_time_string(value: Time) -> String {
+  let #(_, #(hour, minute, second, milli_second), _) = to_parts(value)
+
+  {
+    hour
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> ":"
+  <> {
+    minute
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> ":"
+  <> {
+    second
+    |> int.to_string
+    |> string.pad_left(2, "0")
+  }
+  <> "."
+  <> {
+    milli_second
+    |> int.to_string
+    |> string.pad_left(3, "0")
+  }
+}
+
 pub fn to_iso8601(value: Time) -> String {
   let #(#(year, month, day), #(hour, minute, second, milli_second), offset) =
     to_parts(value)
···
   <> offset
 }
 
-/// If you need to parse an `ISO8601` string, this is probably what you're looking for.
+/// if you need to parse an `ISO8601` string, this is probably what you're looking for.
 /// 
-/// Given the huge surface area that `ISO8601` covers, it does not make sense for `birl`
+/// given the huge surface area that `ISO8601` covers, it does not make sense for `birl`
 /// to support all of it in one function, so this function parses only strings for which both
 /// day and time of day can be extracted or deduced. Some acceptable examples are given below:
 /// 
···
   }
 }
 
-/// This function parses `ISO8601` strings in which no date is specified, which
+/// this function parses `ISO8601` strings in which no date is specified, which
 /// means such inputs don't actually represent a particular moment in time. That's why
 /// the result of this function is an instance of `TimeOfDay` along with the offset specificed
 /// in the string. Some acceptable examples are given below:
···
 pub fn parse_time_of_day(value: String) -> Result(#(TimeOfDay, String), Nil) {
   let assert Ok(offset_pattern) = regex.from_string("(.*)([+|\\-].*)")
 
-  let value = case
+  let time_string = case
     [string.starts_with(value, "T"), string.starts_with(value, "t")]
   {
     [True, _] | [_, True] -> string.drop_left(value, 1)
···
   }
 
   use #(time_string, offset_string) <- result.then(case
-    string.ends_with(value, "Z")
-    || string.ends_with(value, "z")
+    string.ends_with(time_string, "Z")
+    || string.ends_with(time_string, "z")
   {
     True -> Ok(#(string.drop_right(value, 1), "+00:00"))
     False ->
···
   }
 }
 
+/// accepts fromats similar to the ones listed for `parse_time_of_day` except that there shoundn't be any offset information
+pub fn parse_naive_time_of_day(
+  value: String,
+) -> Result(#(TimeOfDay, String), Nil) {
+  let time_string = case
+    [string.starts_with(value, "T"), string.starts_with(value, "t")]
+  {
+    [True, _] | [_, True] -> string.drop_left(value, 1)
+    _ -> value
+  }
+
+  let time_string = string.replace(time_string, ":", "")
+
+  use #(time_string, milli_seconds_result) <- result.then(case
+    [string.split(time_string, "."), string.split(time_string, ",")]
+  {
+    [[_], [_]] -> {
+      Ok(#(time_string, Ok(0)))
+    }
+    [[time_string, milli_seconds_string], [_]]
+    | [[_], [time_string, milli_seconds_string]] -> {
+      Ok(#(
+        time_string,
+        milli_seconds_string
+        |> string.slice(0, 3)
+        |> string.pad_right(3, "0")
+        |> int.parse,
+      ))
+    }
+
+    _ -> Error(Nil)
+  })
+
+  case milli_seconds_result {
+    Ok(milli_seconds) -> {
+      use time_of_day <- result.then(parse_time_section(time_string))
+      let assert [hour, minute, second] = time_of_day
+
+      Ok(#(TimeOfDay(hour, minute, second, milli_seconds), "Z"))
+    }
+    Error(Nil) -> Error(Nil)
+  }
+}
+
 /// the naive format is the same as ISO8601 except that it does not contain the offset
 pub fn to_naive(value: Time) -> String {
   let #(#(year, month, day), #(hour, minute, second, milli_second), _) =
···
   }
 }
 
-/// Accepts fromats similar to the ones listed for `parse` except that there shoundn't be any offset information
+/// accepts fromats similar to the ones listed for `parse` except that there shoundn't be any offset information
 pub fn from_naive(value: String) -> Result(Time, Nil) {
   let value = string.trim(value)
 
···
   case mt {
     option.Some(mt) ->
       Time(
-        wall_time: wt
-        + duration,
+        wall_time: wt + duration,
         offset: o,
         timezone: timezone,
         monotonic_time: option.Some(mt + duration),
       )
     option.None ->
       Time(
-        wall_time: wt
-        + duration,
+        wall_time: wt + duration,
         offset: o,
         timezone: timezone,
         monotonic_time: option.None,
···
   case mt {
     option.Some(mt) ->
       Time(
-        wall_time: wt
-        - duration,
+        wall_time: wt - duration,
         offset: o,
         timezone: timezone,
         monotonic_time: option.Some(mt - duration),
       )
     option.None ->
       Time(
-        wall_time: wt
-        - duration,
+        wall_time: wt - duration,
         offset: o,
         timezone: timezone,
         monotonic_time: option.None,
···
 
 /// use this to change the offset of a given time value.
 ///
-/// Some examples of acceptable offsets:
+/// some examples of acceptable offsets:
 ///
 /// `"+330", "03:30", "-8:00","-7", "-0400", "03", "Z"`
 pub fn set_offset(value: Time, new_offset: String) -> Result(Time, Nil) {
···
 
 @target(erlang)
 /// calculates erlang datetime using the offset in the DateTime value
-pub fn to_erlang_datetime(value: Time) -> #(#(Int, Int, Int), #(Int, Int, Int)) {
+pub fn to_erlang_datetime(
+  value: Time,
+) -> #(#(Int, Int, Int), #(Int, Int, Int)) {
   let #(date, #(hour, minute, second, _), _) = to_parts(value)
   #(date, #(hour, minute, second))
 }
···
 
   Time(
     wall_time,
-    offset_in_minutes
-    * 60_000_000,
+    offset_in_minutes * 60_000_000,
     option.map(timezone, fn(tz) {
       case
         zones.list

src/birl/duration.gleam

···
   Duration(a + b)
 }
 
+pub fn subtract(a: Duration, b: Duration) -> Duration {
+  let Duration(a) = a
+  let Duration(b) = b
+  Duration(a - b)
+}
+
 pub fn seconds(value: Int) -> Duration {
   Duration(value * second)
 }
···
   Duration(value * year)
 }
 
-/// Use this if you need short durations where a year just means 365 days and a month just means 30 days
+/// use this if you need short durations where a year just means 365 days and a month just means 30 days
 pub fn new(values: List(#(Int, Unit))) -> Duration {
   values
   |> list.fold(0, fn(total, current) {
···
   |> Duration
 }
 
-/// Use this if you need very long durations where small inaccuracies could lead to large errors
+/// use this if you need very long durations where small inaccuracies could lead to large errors
 pub fn accurate_new(values: List(#(Int, Unit))) -> Duration {
   values
   |> list.fold(0, fn(total, current) {
···
   |> Duration
 }
 
-/// Use this if you need short durations where a year just means 365 days and a month just means 30 days
+/// use this if you need short durations where a year just means 365 days and a month just means 30 days
 pub fn decompose(duration: Duration) -> List(#(Int, Unit)) {
   let Duration(value) = duration
   let absolute_value = int.absolute_value(value)
···
   })
 }
 
-/// Use this if you need very long durations where small inaccuracies could lead to large errors
+/// use this if you need very long durations where small inaccuracies could lead to large errors
 pub fn accurate_decompose(duration: Duration) -> List(#(Int, Unit)) {
   let Duration(value) = duration
   let absolute_value = int.absolute_value(value)
···
   })
 }
 
+/// approximates the duration by only the given unit
+/// 
+/// if the duration is not an integer multiple of the unit,
+/// the remainder will be disgarded if it's less than two thirds of the unit,
+/// otherwise a single unit will be added to the multiplier
+/// 
+///   - `duration.blur_to(duration.days(16), duration.Month)` ->  0
+///   - `duration.blur_to(duration.days(20), duration.Month)` ->  1
+pub fn blur_to(duration: Duration, unit: Unit) -> Int {
+  let assert Ok(unit_value) = list.key_find(unit_values, unit)
+  let Duration(value) = duration
+  let #(unit_counts, remaining) = extract(value, unit_value)
+  case remaining >= unit_value * 2 / 3 {
+    True -> unit_counts + 1
+    False -> unit_counts
+  }
+}
+
 /// approximates the duration by a value in a single unit
 pub fn blur(duration: Duration) -> #(Int, Unit) {
-  case
-    duration
-    |> decompose
-  {
+  case decompose(duration) {
     [] -> #(0, MicroSecond)
     decomposed ->
       decomposed
···
   #(MilliSecond, milli_second_units),
 ]
 
-/// You can use this function to create a new duration using expressions like:
+/// you can use this function to create a new duration using expressions like:
 ///
 ///     "accurate: 1 Year - 2days + 152M -1h + 25 years + 25secs"
 ///
···
 ///
 ///     MilliSecond:  ms, Msec, mSecs, milliSecond, MilliSecond, ...
 ///
-/// Numbers with no unit are considered as microseconds.
-/// Specifying `accurate:` is equivalent to using `accurate_new`.
+/// numbers with no unit are considered as microseconds.
+/// specifying `accurate:` is equivalent to using `accurate_new`.
 pub fn parse(expression: String) -> Result(Duration, Nil) {
   let assert Ok(re) = regex.from_string("([+|\\-])?\\s*(\\d+)\\s*(\\w+)?")
 
···
   }
 }
 
-fn extract(duration: Int, unit: Int) -> #(Int, Int) {
-  #(duration / unit, duration % unit)
+fn extract(duration: Int, unit_value: Int) -> #(Int, Int) {
+  #(duration / unit_value, duration % unit_value)
 }