Hi all, as I’m always trying to improve my code.
Is anyone of you Elixir Pros interested into review my following code?

This module will convert duration measurements into a human easy readable scientific format.
What I mean by this.
I always hated if an uptime / or downtime measurement told me e.g. up since 1 y 21 d 5 h 5 min 5 s.
In this case 1 y 21 d would be totally enough for myself.

So the conversion scheme I’m using here is very opinionated.
In case of any unit value below 10, I will additionally add the value of the next unit. Above I don’t.
e.g.

- `1 s _ ms` - `9 s _ ms`
- `10 s ` - `59 s`

I would be very thankful if anybody would give me his opinion to my code below.
If you would do something in Elixir best practice completely different for this use case …

defmodule Tool.Timer do
  @moduledoc """
  Time measurement tool for performance & uptime testing.
  Can convert a duration to a human easy understandable scientific format.
  """

  @base_unit :nanosecond
  @unit_shift_factor 10

  @second 1
  @minute @second * 60
  @hour @minute * 60
  @day @hour * 24
  @year @day * 365

  @doc """
  Returns monotonic system time in @base_unit
  """
  @spec now() :: integer()
  def now, do: System.monotonic_time(@base_unit)

  @doc """
  Calculate time difference to a given start time (e.g. from `now/0`).
  Return duration in @base_unit.
  """
  @spec diff(integer(), integer()) :: integer()
  def diff(start_time, end_time \\ now()) do
    end_time - start_time
  end

  @doc """
  Calculate time difference to a given start time (e.g. from `now/0`).
  Return duration in a human easy understandable scientific format.
  In: `-576460349095935368`
  Out:
  - `1 ns` - `999 ns`
  - `1 μs _ ns` - `9 μs _ ns`
  - `10 μs` - `999 μs`
  - `1 ms _ μs` - `9 ms _ μs`
  - `10 ms ` - `999 ms`
  - `1 s _ ms` - `9 s _ ms`
  - `10 s ` - `59 s`
  - `1 min _ s` - `59 min _ s`
  - `1 h _ min` - `23 h _ min`
  - `1 d _ h` - `364 d _ h`
  - `1 y _ d` - `_ y _ d`
  """
  @spec diff_human(integer(), integer(), System.time_unit()) :: binary()
  def diff_human(start_time, end_time \\ now(), base_unit \\ @base_unit) do
    diff_base = diff(start_time, end_time)
    diff_nano = System.convert_time_unit(diff_base, base_unit, :nanosecond)
    time_conversion(diff_nano)
  end

  # everything below system precision
  defp time_conversion(time) when time === 0,
    do: "< #{system_precision()}"

  # nanoseconds (ns) only
  defp time_conversion(time) when time < 1_000,
    do: unit_fraction_string(time, :nanosecond)

  # microseconds (μs) + nanoseconds (ns)
  defp time_conversion(time) when time < 1_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :microsecond),
      unit_fraction_string(time, :nanosecond)
    ])
  end

  # microseconds (μs) only
  defp time_conversion(time) when time < 1_000_000,
    do: unit_fraction_string(time, :microsecond)

  # milliseconds (ms) + microseconds (μs)
  defp time_conversion(time) when time < 1_000_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :millisecond),
      unit_fraction_string(time, :microsecond)
    ])
  end

  # milliseconds (ms) only
  defp time_conversion(time) when time < 1_000_000_000,
    do: unit_fraction_string(time, :millisecond)

  # seconds (s) + milliseconds (ms)
  defp time_conversion(time) when time < 1_000_000_000 * @unit_shift_factor do
    list_to_string([
      unit_fraction_string(time, :second),
      unit_fraction_string(time, :millisecond)
    ])
  end

  # seconds (s) only
  defp time_conversion(time) when time < @minute * 1_000_000_000,
    do: unit_fraction_string(time, :second)

  # minutes (min) + seconds (s)
  defp time_conversion(time) when time < @hour * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :minute, @minute, 60),
      unit_subset_fraction_string(time, :second, @second, 60)
    ])
  end

  # hours (h) + minutes (min)
  defp time_conversion(time) when time < @day * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :hour, @hour, 60),
      unit_subset_fraction_string(time, :minute, @minute, 60)
    ])
  end

  # days (d) + hours (h)
  defp time_conversion(time) when time < @year * 1_000_000_000 do
    list_to_string([
      unit_subset_fraction_string(time, :day, @day, 365),
      unit_subset_fraction_string(time, :hour, @hour, 24)
    ])
  end

  # years (y) + days (d)
  @spec time_conversion(integer()) :: binary()
  defp time_conversion(time) do
    list_to_string([
      unit_subset_fraction_string(time, :year, @year, 365),
      unit_subset_fraction_string(time, :day, @day, 365)
    ])
  end

  # will return the human readable system precision
  @spec system_precision :: binary
  defp system_precision do
    parts_per_second = System.convert_time_unit(1, :second, :native)
    precision_nano = round(1 / parts_per_second * 1_000_000_000)

    # to avoid a infinite loop on value 0
    precision =
      case precision_nano do
        x when x > 0 -> x
        _ -> 1
      end

    time_conversion(precision)
  end

  # unit fraction for everything below seconds
  @spec unit_fraction_string(integer(), atom()) :: binary()
  defp unit_fraction_string(time, unit) do
    fraction =
      time
      |> System.convert_time_unit(:nanosecond, unit)
      |> Integer.mod(1_000)

    human_readable_unit(fraction, unit)
  end

  # unit fraction for everything above seconds
  @spec unit_subset_fraction_string(integer(), atom(), integer(), integer()) :: binary()
  defp unit_subset_fraction_string(time, unit, fraction_divisor, subset_divisor) do
    fraction =
      time
      |> System.convert_time_unit(:nanosecond, :second)
      |> Integer.floor_div(fraction_divisor)
      |> Integer.mod(subset_divisor)

    human_readable_unit(fraction, unit)
  end

  # join value with unit
  @spec human_readable_unit(integer(), atom()) :: binary()
  defp human_readable_unit(fraction, unit) do
    cond do
      fraction > 0 -> Integer.to_string(fraction) <> " " <> unit_abbreviation(unit)
      true -> nil
    end
  end

  # unit abbreviations
  @spec unit_abbreviation(atom()) :: binary()
  defp unit_abbreviation(:nanosecond), do: "ns"
  defp unit_abbreviation(:microsecond), do: "μs"
  defp unit_abbreviation(:millisecond), do: "ms"
  defp unit_abbreviation(:second), do: "s"
  defp unit_abbreviation(:minute), do: "min"
  defp unit_abbreviation(:hour), do: "h"
  defp unit_abbreviation(:day), do: "d"
  defp unit_abbreviation(:year), do: "y"

  # join list to string
  @spec list_to_string(list()) :: binary()
  defp list_to_string(list) do
    list
    # remove nil values from list
    |> Enum.filter(& &1)
    |> Enum.join(" ")
  end
end

Edit:

• Updated with the already mentioned changes from david_ex.