gandora-std 0.1.0__py3-none-any.whl

gandora_std/_gan/gandora_std/enum.gan

@@ -0,0 +1,222 @@
+defmodule Enum do
+  @moduledoc "Eager, data-first collection functions (GEP-0010). Every subject comes first, so everything pipes."
+  @moduledoc_trans zh_CN: "急切求值、数据优先的集合函数（GEP-0010）。主语在首位，全部可入管道。"
+
+  @doc "Applies `f` to every element."
+  @doc_trans zh_CN: "对每个元素应用 `f`。"
+  @example """
+      gan> Enum.map([1, 2, 3], fn x -> x * 10 end)
+      [10, 20, 30]
+  """
+  def map(xs, f), do: :builtins.list(:builtins.map(f, xs))
+
+  @doc "Keeps elements for which `f` is truthy."
+  @doc_trans zh_CN: "保留 `f` 为真值的元素。"
+  @example """
+      gan> Enum.filter([1, 2, 3, 4], fn x -> rem(x, 2) == 0 end)
+      [2, 4]
+  """
+  def filter(xs, f), do: ~python([x for x in <%= xs %> if <%= f %>(x)])
+
+  @doc "Drops elements for which `f` is truthy."
+  @doc_trans zh_CN: "丢弃 `f` 为真值的元素。"
+  def reject(xs, f), do: ~python([x for x in <%= xs %> if not <%= f %>(x)])
+
+  @doc "Folds left with Elixir argument order: `f` receives (element, acc)."
+  @doc_trans zh_CN: "左折叠，参数顺序与 Elixir 一致：`f` 接收 (元素, 累积值)。"
+  @example """
+      gan> Enum.reduce([1, 2, 3, 4], 0, fn x, acc -> acc + x end)
+      10
+  """
+  def reduce(xs, acc, f) do
+    :functools.reduce(fn a, x -> f.(x, a) end, xs, acc)
+  end
+
+  @doc "Sum of the elements."
+  @doc_trans zh_CN: "元素之和。"
+  def sum(xs), do: :builtins.sum(xs)
+
+  @doc "Number of elements."
+  @doc_trans zh_CN: "元素个数。"
+  def count(xs), do: :builtins.len(xs)
+
+  @doc "Ascending sort."
+  @doc_trans zh_CN: "升序排序。"
+  def sort(xs), do: :builtins.sorted(xs)
+
+  @doc "Sorts by the key computed by `f` (Python `key=`, not a comparator)."
+  @doc_trans zh_CN: "按 `f` 计算的键排序（Python 的 `key=`，非比较器）。"
+  @example """
+      gan> Enum.sort_by(["ccc", "a", "bb"], fn s -> String.length(s) end)
+      ['a', 'bb', 'ccc']
+  """
+  def sort_by(xs, f), do: :builtins.sorted(xs, key: f)
+
+  @doc "Elements in reverse order."
+  @doc_trans zh_CN: "逆序排列的元素。"
+  def reverse(xs), do: ~python(list(reversed(<%= xs %>)))
+
+  @doc "Joins elements (converted by `to_string`) with `sep`."
+  @doc_trans zh_CN: "以 `sep` 连接各元素（先经 `to_string` 转换）。"
+  @example """
+      gan> Enum.join([1, 2, 3], "-")
+      '1-2-3'
+  """
+  def join(xs, sep), do: sep.join(~python([str(x) for x in <%= xs %>]))
+
+  @doc "The element at `index` (negative counts from the end), or nil."
+  @doc_trans zh_CN: "位于 `index` 的元素（负数从尾部数起），越界返回 nil。"
+  def at(xs, index) do
+    if index < :builtins.len(xs) and index >= -:builtins.len(xs) do
+      ~python(<%= xs %>[<%= index %>])
+    else
+      nil
+    end
+  end
+
+  @doc "The first `n` elements."
+  @doc_trans zh_CN: "前 `n` 个元素。"
+  def take(xs, n), do: ~python(<%= xs %>[:<%= n %>])
+
+  @doc "The elements after the first `n`."
+  @doc_trans zh_CN: "跳过前 `n` 个之后的元素。"
+  def drop(xs, n), do: ~python(<%= xs %>[<%= n %>:])
+
+  @doc "Pairs up two lists into `{a, b}` tuples, stopping at the shorter."
+  @doc_trans zh_CN: "将两个列表配成 `{a, b}` 元组，止于较短者。"
+  def zip(xs, ys), do: :builtins.list(:builtins.zip(xs, ys))
+
+  @doc "Each element paired with its index: `{element, index}`."
+  @doc_trans zh_CN: "每个元素与其下标配对：`{元素, 下标}`。"
+  @example """
+      gan> Enum.with_index([:a, :b])
+      [('a', 0), ('b', 1)]
+  """
+  def with_index(xs), do: ~python([(x, i) for i, x in enumerate(<%= xs %>)])
+
+  @doc "Whether `x` is an element."
+  @doc_trans zh_CN: "`x` 是否为其中元素。"
+  def member?(xs, x), do: ~python(<%= x %> in <%= xs %>)
+
+  @doc "Whether `f` is truthy for every element."
+  @doc_trans zh_CN: "`f` 是否对所有元素为真值。"
+  def all?(xs, f), do: ~python(all(<%= f %>(x) for x in <%= xs %>))
+
+  @doc "Whether `f` is truthy for any element."
+  @doc_trans zh_CN: "`f` 是否对任一元素为真值。"
+  def any?(xs, f), do: ~python(any(<%= f %>(x) for x in <%= xs %>))
+
+  @doc "Whether the collection has no elements."
+  @doc_trans zh_CN: "集合是否为空。"
+  def empty?(xs), do: :builtins.len(xs) == 0
+
+  @doc "Removes duplicates, keeping first occurrences in order."
+  @doc_trans zh_CN: "去重，按序保留首次出现者。"
+  def uniq(xs), do: ~python(list(dict.fromkeys(<%= xs %>)))
+
+  @doc "Maps `f` (which returns a list) and concatenates the results."
+  @doc_trans zh_CN: "对每个元素应用返回列表的 `f`，并拼接全部结果。"
+  @example """
+      gan> Enum.flat_map([1, 2], fn x -> [x, x * 10] end)
+      [1, 10, 2, 20]
+  """
+  def flat_map(xs, f), do: ~python([y for x in <%= xs %> for y in <%= f %>(x)])
+
+  @doc "Runs `f` on each element for its side effects; returns :ok."
+  @doc_trans zh_CN: "对每个元素执行 `f`（取其副作用）；返回 :ok。"
+  def each(xs, f) do
+    ~python([<%= f %>(x) for x in <%= xs %>])
+    :ok
+  end
+
+  @doc "The smallest element."
+  @doc_trans zh_CN: "最小元素。"
+  def min(xs), do: :builtins.min(xs)
+
+  @doc "The largest element."
+  @doc_trans zh_CN: "最大元素。"
+  def max(xs), do: :builtins.max(xs)
+  @doc "The first element for which `f` is truthy, or nil."
+  @doc_trans zh_CN: "首个使 `f` 为真值的元素，无则 nil。"
+  @example """
+      gan> Enum.find([1, 2, 3, 4], fn x -> x > 2 end)
+      3
+  """
+  def find(xs, f), do: ~python(next((x for x in <%= xs %> if <%= f %>(x)), None))
+
+  @doc "The index of the first element for which `f` is truthy, or nil."
+  @doc_trans zh_CN: "首个使 `f` 为真值的元素下标，无则 nil。"
+  def find_index(xs, f),
+    do: ~python(next((i for i, x in enumerate(<%= xs %>) if <%= f %>(x)), None))
+
+  @doc "A map from each distinct element to its occurrence count."
+  @doc_trans zh_CN: "从每个不同元素到其出现次数的映射。"
+  @example """
+      gan> Enum.frequencies(["a", "b", "a"])
+      {'a': 2, 'b': 1}
+  """
+  def frequencies(xs), do: :builtins.dict(:collections.Counter(xs))
+
+  @doc "Groups elements by the key computed by `f`, preserving order."
+  @doc_trans zh_CN: "按 `f` 计算的键分组，保持顺序。"
+  @example """
+      gan> Enum.group_by([1, 2, 3, 4, 5], fn x -> rem(x, 2) end)
+      {1: [1, 3, 5], 0: [2, 4]}
+  """
+  def group_by(xs, f),
+    do: ~python({k: [x for x in <%= xs %> if <%= f %>(x) == k] for k in dict.fromkeys(<%= f %>(x) for x in <%= xs %>)})
+
+  @doc "The element maximizing the key computed by `f`; raises on empty."
+  @doc_trans zh_CN: "使 `f` 计算的键最大的元素；空集合抛错。"
+  def max_by(xs, f), do: :builtins.max(xs, key: f)
+
+  @doc "The element minimizing the key computed by `f`; raises on empty."
+  @doc_trans zh_CN: "使 `f` 计算的键最小的元素；空集合抛错。"
+  def min_by(xs, f), do: :builtins.min(xs, key: f)
+
+  @doc "The product of the elements (1 for an empty collection)."
+  @doc_trans zh_CN: "元素之积（空集合为 1）。"
+  def product(xs), do: :math.prod(xs)
+
+  @doc "Leading elements while `f` stays truthy."
+  @doc_trans zh_CN: "自头部起 `f` 持续为真值的元素。"
+  def take_while(xs, f), do: :builtins.list(:itertools.takewhile(f, xs))
+
+  @doc "Drops leading elements while `f` stays truthy, keeps the rest."
+  @doc_trans zh_CN: "丢弃头部 `f` 持续为真值的元素，保留其余。"
+  def drop_while(xs, f), do: :builtins.list(:itertools.dropwhile(f, xs))
+
+  @doc "Splits into chunks of `n` elements; the last chunk may be shorter."
+  @doc_trans zh_CN: "按每组 `n` 个元素分块；末组可较短。"
+  @example """
+      gan> Enum.chunk_every([1, 2, 3, 4, 5], 2)
+      [[1, 2], [3, 4], [5]]
+  """
+  def chunk_every(xs, n),
+    do: ~python([<%= xs %>[i:i + <%= n %>] for i in range(0, len(<%= xs %>), <%= n %>)])
+
+  @doc "Concatenates a list of lists (one level)."
+  @doc_trans zh_CN: "拼接列表的列表（单层）。"
+  def concat(xss), do: ~python([y for x in <%= xss %> for y in x])
+
+  @doc "Puts `sep` between every two elements."
+  @doc_trans zh_CN: "在每两个元素之间放入 `sep`。"
+  @example """
+      gan> Enum.intersperse([1, 2, 3], :x)
+      [1, 'x', 2, 'x', 3]
+  """
+  def intersperse(xs, sep), do: ~python([v for x in <%= xs %> for v in (x, <%= sep %>)][:-1])
+
+  @doc "`count` elements starting at `start` (negative start counts from the end)."
+  @doc_trans zh_CN: "自 `start` 起的 `count` 个元素（负的 start 从尾部数起）。"
+  def slice(xs, start, count), do: ~python(<%= xs %>[<%= start %>:] [:<%= count %>])
+
+  @doc "Collapses consecutive duplicate elements."
+  @doc_trans zh_CN: "折叠连续的重复元素。"
+  @example """
+      gan> Enum.dedup([1, 1, 2, 2, 2, 1])
+      [1, 2, 1]
+  """
+  def dedup(xs),
+    do: ~python([x for i, x in enumerate(<%= xs %>) if i == 0 or x != <%= xs %>[i - 1]])
+end

gandora_std/_gan/gandora_std/keyword.gan

@@ -0,0 +1,43 @@
+defmodule Keyword do
+  @moduledoc "Functions over keyword lists — lists of {atom, value} tuples (GEP-0010)."
+  @moduledoc_trans zh_CN: "关键字列表（{原子, 值} 元组的列表）上的函数（GEP-0010）。"
+
+  @doc "The first value for `key`, or nil."
+  @doc_trans zh_CN: "键 `key` 的首个值，不存在时为 nil。"
+  @example """
+      gan> Keyword.get([a: 1, b: 2], :a)
+      1
+  """
+  def get(kw, key), do: ~python(next((v for k, v in <%= kw %> if k == <%= key %>), None))
+
+  @doc "Replaces `key` with `value`, prepending it (Elixir Keyword.put)."
+  @doc_trans zh_CN: "以 `value` 替换 `key` 并将其前置（Elixir 的 Keyword.put）。"
+  def put(kw, key, value) do
+    [{key, value}] ++ Enum.reject(kw, fn {k, _} -> k == key end)
+  end
+
+  @doc "The keys, in order, duplicates included."
+  @doc_trans zh_CN: "按序的全部键（含重复）。"
+  def keys(kw), do: Enum.map(kw, fn {k, _} -> k end)
+
+  @doc "The values, in order."
+  @doc_trans zh_CN: "按序的全部值。"
+  def values(kw), do: Enum.map(kw, fn {_, v} -> v end)
+
+  @doc "Whether `key` is present."
+  @doc_trans zh_CN: "是否存在键 `key`。"
+  def has_key?(kw, key), do: Enum.any?(kw, fn {k, _} -> k == key end)
+  @doc "Removes every entry for `key`."
+  @doc_trans zh_CN: "移除键为 `key` 的全部条目。"
+  def delete(kw, key), do: Enum.reject(kw, fn {k, _} -> k == key end)
+
+  @doc "Merges `kw2` into `kw1`; `kw2` wins, its entries appended."
+  @doc_trans zh_CN: "将 `kw2` 并入 `kw1`；`kw2` 胜出，其条目附加在后。"
+  @example """
+      gan> Keyword.merge([a: 1, b: 2], [b: 9, c: 3])
+      [('a', 1), ('b', 9), ('c', 3)]
+  """
+  def merge(kw1, kw2) do
+    Enum.reject(kw1, fn {k, _} -> has_key?(kw2, k) end) ++ kw2
+  end
+end

gandora_std/_gan/gandora_std/list.gan

@@ -0,0 +1,72 @@
+defmodule List do
+  @moduledoc "List-shape helpers; element-wise work lives in Enum (GEP-0010)."
+  @moduledoc_trans zh_CN: "列表形状辅助函数；逐元素操作在 Enum 中（GEP-0010）。"
+
+  @doc "The first element, or nil for an empty list."
+  @doc_trans zh_CN: "首元素，空列表为 nil。"
+  def first(xs), do: Enum.at(xs, 0)
+
+  @doc "The last element, or nil for an empty list."
+  @doc_trans zh_CN: "末元素，空列表为 nil。"
+  def last(xs), do: Enum.at(xs, -1)
+
+  @doc "Flattens nested lists to any depth."
+  @doc_trans zh_CN: "任意深度展平嵌套列表。"
+  @example """
+      gan> List.flatten([1, [2, [3, 4]], 5])
+      [1, 2, 3, 4, 5]
+  """
+  def flatten(xs) do
+    Enum.flat_map(xs, fn x ->
+      if is_list(x) do
+        flatten(x)
+      else
+        [x]
+      end
+    end)
+  end
+
+  @doc "Wraps a value in a list: nil becomes [], lists pass through, anything else becomes [value]."
+  @doc_trans zh_CN: "包装为列表：nil 变 []，列表原样返回，其余变 [值]。"
+  def wrap(value) do
+    cond do
+      is_nil(value) -> []
+      is_list(value) -> value
+      true -> [value]
+    end
+  end
+
+  @doc "A list of `n` copies of `value`."
+  @doc_trans zh_CN: "由 `n` 个 `value` 构成的列表。"
+  def duplicate(value, n), do: ~python([<%= value %>] * <%= n %>)
+
+  @doc "Inserts `value` at `index` (negative counts from the end, as in Elixir)."
+  @doc_trans zh_CN: "在 `index` 处插入 `value`（负数从尾部数起，同 Elixir）。"
+  def insert_at(xs, index, value),
+    do: ~python(<%= xs %>[:<%= index %>] + [<%= value %>] + <%= xs %>[<%= index %>:])
+
+  @doc "Removes the element at `index`; out-of-range leaves the list unchanged."
+  @doc_trans zh_CN: "删除 `index` 处的元素；越界时列表原样返回。"
+  def delete_at(xs, index),
+    do: ~python(<%= xs %>[:<%= index %>] + <%= xs %>[<%= index %>:][1:])
+  @doc "The list as a tuple."
+  @doc_trans zh_CN: "转换为元组的列表。"
+  def to_tuple(xs), do: :builtins.tuple(xs)
+
+  @doc "Whether the list starts with `prefix`."
+  @doc_trans zh_CN: "是否以 `prefix` 开头。"
+  def starts_with?(xs, prefix), do: ~python(<%= xs %>[:len(<%= prefix %>)] == <%= prefix %>)
+
+  @doc "Replaces the element at `index` (negative counts from the end)."
+  @doc_trans zh_CN: "替换 `index` 处的元素（负数从尾部数起）。"
+  def replace_at(xs, index, value),
+    do: ~python(<%= xs %>[:<%= index %>] + [<%= value %>] + <%= xs %>[<%= index %>:][1:])
+
+  @doc "Updates the element at `index` by `f`."
+  @doc_trans zh_CN: "以 `f` 更新 `index` 处的元素。"
+  @example """
+      gan> List.update_at([1, 2, 3], 1, fn v -> v * 10 end)
+      [1, 20, 3]
+  """
+  def update_at(xs, index, f), do: replace_at(xs, index, f.(Enum.at(xs, index)))
+end

gandora_std/_gan/gandora_std/map.gan

@@ -0,0 +1,91 @@
+defmodule Map do
+  @moduledoc "Data-first dict functions; all updates return new maps (GEP-0010)."
+  @moduledoc_trans zh_CN: "数据优先的 dict 函数；所有更新都返回新映射（GEP-0010）。"
+
+  @doc "The value for `key`, or `default` (nil unless given) when absent."
+  @doc_trans zh_CN: "键 `key` 的值；不存在时为 `default`（未给出则为 nil）。"
+  @example """
+      gan> Map.get(%{a: 1}, :b, 0)
+      0
+  """
+  def get(m, key, default \\ nil), do: m.get(key, default)
+
+  @doc "A new map with `key` set to `value`."
+  @doc_trans zh_CN: "设置 `key` 为 `value` 后的新映射。"
+  @example """
+      gan> Map.put(%{a: 1}, :b, 2)
+      {'a': 1, 'b': 2}
+  """
+  def put(m, key, value), do: ~python({**<%= m %>, <%= key %>: <%= value %>})
+
+  @doc "A new map without `key`."
+  @doc_trans zh_CN: "移除 `key` 后的新映射。"
+  def delete(m, key), do: ~python({k: v for k, v in <%= m %>.items() if k != <%= key %>})
+
+  @doc "The keys as a list."
+  @doc_trans zh_CN: "键的列表。"
+  def keys(m), do: :builtins.list(m.keys())
+
+  @doc "The values as a list."
+  @doc_trans zh_CN: "值的列表。"
+  def values(m), do: :builtins.list(m.values())
+
+  @doc "Merges `m2` into `m1`; `m2` wins on conflicts."
+  @doc_trans zh_CN: "将 `m2` 并入 `m1`；冲突时 `m2` 胜出。"
+  def merge(m1, m2), do: ~python({**<%= m1 %>, **<%= m2 %>})
+
+  @doc "Whether `key` is present."
+  @doc_trans zh_CN: "是否存在键 `key`。"
+  def has_key?(m, key), do: ~python(<%= key %> in <%= m %>)
+
+  @doc "The entries as a list of `{key, value}` tuples."
+  @doc_trans zh_CN: "以 `{键, 值}` 元组列表表示的条目。"
+  def to_list(m), do: :builtins.list(m.items())
+
+  @doc "An empty map."
+  @doc_trans zh_CN: "空映射。"
+  def new(), do: %{}
+
+  @doc "Updates `key` by `f`; uses `default` when the key is absent (Elixir Map.update/4)."
+  @doc_trans zh_CN: "以 `f` 更新 `key`；键不存在时使用 `default`（Elixir 的 Map.update/4）。"
+  @example """
+      gan> Map.update(%{a: 1}, :a, 0, fn v -> v + 10 end)
+      {'a': 11}
+  """
+  def update(m, key, default, f) do
+    if has_key?(m, key) do
+      put(m, key, f.(get(m, key)))
+    else
+      put(m, key, default)
+    end
+  end
+  @doc "The value for `key`; raises Python KeyError when absent."
+  @doc_trans zh_CN: "键 `key` 的值；不存在时抛 Python KeyError。"
+  def fetch!(m, key), do: ~python(<%= m %>[<%= key %>])
+
+  @doc "Sets `key` only when absent."
+  @doc_trans zh_CN: "仅当 `key` 不存在时设置。"
+  def put_new(m, key, value) do
+    if has_key?(m, key) do
+      m
+    else
+      put(m, key, value)
+    end
+  end
+
+  @doc "The submap with only `keys` (missing keys ignored)."
+  @doc_trans zh_CN: "仅含 `keys` 的子映射（缺失的键忽略）。"
+  def take(m, keys), do: ~python({k: v for k, v in <%= m %>.items() if k in <%= keys %>})
+
+  @doc "The map without `keys`."
+  @doc_trans zh_CN: "移除 `keys` 后的映射。"
+  def drop(m, keys), do: ~python({k: v for k, v in <%= m %>.items() if k not in <%= keys %>})
+
+  @doc "Keeps entries for which `f` (receiving a `{key, value}` tuple) is truthy."
+  @doc_trans zh_CN: "保留使 `f`（接收 `{键, 值}` 元组）为真值的条目。"
+  @example """
+      gan> Map.filter(%{"a" => 1, "b" => 5}, fn pair -> elem(pair, 1) > 2 end)
+      {'b': 5}
+  """
+  def filter(m, f), do: ~python({k: v for k, v in <%= m %>.items() if <%= f %>((k, v))})
+end

gandora_std/_gan/gandora_std/string.gan

@@ -0,0 +1,117 @@
+defmodule String do
+  @moduledoc "Data-first string functions over Python str (GEP-0010)."
+  @moduledoc_trans zh_CN: "基于 Python str 的数据优先字符串函数（GEP-0010）。"
+
+  @doc "Uppercases the string."
+  @doc_trans zh_CN: "转为大写。"
+  def upcase(s), do: s.upper()
+
+  @doc "Lowercases the string."
+  @doc_trans zh_CN: "转为小写。"
+  def downcase(s), do: s.lower()
+
+  @doc "Uppercases the first character, lowercases the rest."
+  @doc_trans zh_CN: "首字符大写，其余小写。"
+  def capitalize(s), do: s.capitalize()
+
+  @doc "Splits on whitespace runs, dropping empty parts (Elixir semantics)."
+  @doc_trans zh_CN: "按连续空白切分并丢弃空段（Elixir 语义）。"
+  @example """
+      gan> String.split("  a  b c ")
+      ['a', 'b', 'c']
+  """
+  def split(s), do: s.split()
+
+  @doc "Splits on the separator `sep`."
+  @doc_trans zh_CN: "按分隔符 `sep` 切分。"
+  def split_on(s, sep), do: s.split(sep)
+
+  @doc "Removes leading and trailing whitespace."
+  @doc_trans zh_CN: "去除首尾空白。"
+  def trim(s), do: s.strip()
+
+  @doc "Replaces every occurrence of `pattern` with `replacement`."
+  @doc_trans zh_CN: "将每处 `pattern` 替换为 `replacement`。"
+  def replace(s, pattern, replacement), do: s.replace(pattern, replacement)
+
+  @doc "Whether the string contains `part`."
+  @doc_trans zh_CN: "是否包含子串 `part`。"
+  def contains?(s, part), do: ~python(<%= part %> in <%= s %>)
+
+  @doc "Whether the string starts with `prefix`."
+  @doc_trans zh_CN: "是否以 `prefix` 开头。"
+  def starts_with?(s, prefix), do: s.startswith(prefix)
+
+  @doc "Whether the string ends with `suffix`."
+  @doc_trans zh_CN: "是否以 `suffix` 结尾。"
+  def ends_with?(s, suffix), do: s.endswith(suffix)
+
+  @doc "The number of characters (Unicode code points, Python `len`)."
+  @doc_trans zh_CN: "字符数（Unicode 码点，即 Python 的 `len`）。"
+  def length(s), do: :builtins.len(s)
+
+  @doc "The substring of `len` characters starting at `start` (negative start counts from the end)."
+  @doc_trans zh_CN: "自 `start` 起、长 `len` 的子串（负的 start 从尾部数起）。"
+  @example """
+      gan> String.slice("gandora", 3, 4)
+      'dora'
+  """
+  def slice(s, start, len), do: ~python(<%= s %>[<%= start %>:] [:<%= len %>])
+
+  @doc "Pads on the left with spaces to `width`."
+  @doc_trans zh_CN: "左侧以空格填充至 `width`。"
+  def pad_leading(s, width), do: s.rjust(width)
+
+  @doc "Pads on the right with spaces to `width`."
+  @doc_trans zh_CN: "右侧以空格填充至 `width`。"
+  def pad_trailing(s, width), do: s.ljust(width)
+
+  @doc "Parses an integer; raises Python ValueError on bad input."
+  @doc_trans zh_CN: "解析整数；非法输入抛 Python ValueError。"
+  def to_integer(s), do: :builtins.int(s)
+
+  @doc "Parses a float; raises Python ValueError on bad input."
+  @doc_trans zh_CN: "解析浮点数；非法输入抛 Python ValueError。"
+  def to_float(s), do: :builtins.float(s)
+  @doc "The character at `index` (negative counts from the end), or nil."
+  @doc_trans zh_CN: "位于 `index` 的字符（负数从尾部数起），越界为 nil。"
+  def at(s, index) do
+    if index < :builtins.len(s) and index >= -:builtins.len(s) do
+      ~python(<%= s %>[<%= index %>])
+    else
+      nil
+    end
+  end
+
+  @doc "The string reversed."
+  @doc_trans zh_CN: "反转后的字符串。"
+  def reverse(s), do: ~python(<%= s %>[::-1])
+
+  @doc "The string repeated `n` times."
+  @doc_trans zh_CN: "重复 `n` 次的字符串。"
+  def duplicate(s, n), do: ~python(<%= s %> * <%= n %>)
+
+  @doc "Removes leading whitespace."
+  @doc_trans zh_CN: "去除首部空白。"
+  def trim_leading(s), do: s.lstrip()
+
+  @doc "Removes trailing whitespace."
+  @doc_trans zh_CN: "去除尾部空白。"
+  def trim_trailing(s), do: s.rstrip()
+
+  @doc "The characters as a list of one-character strings."
+  @doc_trans zh_CN: "以单字符字符串列表表示的全部字符。"
+  @example """
+      gan> String.codepoints("héllo") |> Enum.take(2)
+      ['h', 'é']
+  """
+  def codepoints(s), do: :builtins.list(s)
+
+  @doc "Whether the compiled regex (`~r/.../`) matches anywhere in the string."
+  @doc_trans zh_CN: "编译后的正则（`~r/.../`）是否在字符串中命中。"
+  @example """
+      gan> String.match?("gandora-2026", ~r/\\d+/)
+      True
+  """
+  def match?(s, regex), do: not is_nil(regex.search(s))
+end

gandora_std/enum.py

@@ -0,0 +1,278 @@
+"""Eager, data-first collection functions (GEP-0010). Every subject comes first, so everything pipes."""
+
+import builtins
+import collections
+import functools
+import itertools
+import math
+import gandora_std.string
+
+
+def _gan_div(a, b):
+    q = a // b
+    if q < 0 and q * b != a:
+        q += 1
+    return q
+
+
+def _gan_rem(a, b):
+    return a - _gan_div(a, b) * b
+
+
+def map(xs, f):
+    """Applies `f` to every element.
+
+
+      >>> map([1, 2, 3], lambda x: x * 10)
+      [10, 20, 30]
+"""
+    return builtins.list(builtins.map(f, xs))
+
+
+def filter(xs, f):
+    """Keeps elements for which `f` is truthy.
+
+
+      >>> filter([1, 2, 3, 4], lambda x: _gan_rem(x, 2) == 0)
+      [2, 4]
+"""
+    return ([x for x in (xs) if (f)(x)])
+
+
+def reject(xs, f):
+    """Drops elements for which `f` is truthy."""
+    return ([x for x in (xs) if not (f)(x)])
+
+
+def reduce(xs, acc, f):
+    """Folds left with Elixir argument order: `f` receives (element, acc).
+
+
+      >>> reduce([1, 2, 3, 4], 0, lambda x, acc: acc + x)
+      10
+"""
+    return functools.reduce(lambda a, x: f(x, a), xs, acc)
+
+
+def sum(xs):
+    """Sum of the elements."""
+    return builtins.sum(xs)
+
+
+def count(xs):
+    """Number of elements."""
+    return builtins.len(xs)
+
+
+def sort(xs):
+    """Ascending sort."""
+    return builtins.sorted(xs)
+
+
+def sort_by(xs, f):
+    """Sorts by the key computed by `f` (Python `key=`, not a comparator).
+
+
+      >>> sort_by(["ccc", "a", "bb"], lambda s: gandora_std.string.length(s))
+      ['a', 'bb', 'ccc']
+"""
+    return builtins.sorted(xs, key=f)
+
+
+def reverse(xs):
+    """Elements in reverse order."""
+    return (list(reversed((xs))))
+
+
+def join(xs, sep):
+    """Joins elements (converted by `to_string`) with `sep`.
+
+
+      >>> join([1, 2, 3], "-")
+      '1-2-3'
+"""
+    return sep.join(([str(x) for x in (xs)]))
+
+
+def at(xs, index):
+    """The element at `index` (negative counts from the end), or nil."""
+    if (index < builtins.len(xs)) and (index >= -(builtins.len(xs))):
+        return ((xs)[(index)])
+    else:
+        return None
+
+
+def take(xs, n):
+    """The first `n` elements."""
+    return ((xs)[:(n)])
+
+
+def drop(xs, n):
+    """The elements after the first `n`."""
+    return ((xs)[(n):])
+
+
+def zip(xs, ys):
+    """Pairs up two lists into `{a, b}` tuples, stopping at the shorter."""
+    return builtins.list(builtins.zip(xs, ys))
+
+
+def with_index(xs):
+    """Each element paired with its index: `{element, index}`.
+
+
+      >>> with_index(["a", "b"])
+      [('a', 0), ('b', 1)]
+"""
+    return ([(x, i) for i, x in enumerate((xs))])
+
+
+def member_p(xs, x):
+    """Whether `x` is an element."""
+    return ((x) in (xs))
+
+
+def all_p(xs, f):
+    """Whether `f` is truthy for every element."""
+    return (all((f)(x) for x in (xs)))
+
+
+def any_p(xs, f):
+    """Whether `f` is truthy for any element."""
+    return (any((f)(x) for x in (xs)))
+
+
+def empty_p(xs):
+    """Whether the collection has no elements."""
+    return builtins.len(xs) == 0
+
+
+def uniq(xs):
+    """Removes duplicates, keeping first occurrences in order."""
+    return (list(dict.fromkeys((xs))))
+
+
+def flat_map(xs, f):
+    """Maps `f` (which returns a list) and concatenates the results.
+
+
+      >>> flat_map([1, 2], lambda x: [x, x * 10])
+      [1, 10, 2, 20]
+"""
+    return ([y for x in (xs) for y in (f)(x)])
+
+
+def each(xs, f):
+    """Runs `f` on each element for its side effects; returns :ok."""
+    ([(f)(x) for x in (xs)])
+    return "ok"
+
+
+def min(xs):
+    """The smallest element."""
+    return builtins.min(xs)
+
+
+def max(xs):
+    """The largest element."""
+    return builtins.max(xs)
+
+
+def find(xs, f):
+    """The first element for which `f` is truthy, or nil.
+
+
+      >>> find([1, 2, 3, 4], lambda x: x > 2)
+      3
+"""
+    return (next((x for x in (xs) if (f)(x)), None))
+
+
+def find_index(xs, f):
+    """The index of the first element for which `f` is truthy, or nil."""
+    return (next((i for i, x in enumerate((xs)) if (f)(x)), None))
+
+
+def frequencies(xs):
+    """A map from each distinct element to its occurrence count.
+
+
+      >>> frequencies(["a", "b", "a"])
+      {'a': 2, 'b': 1}
+"""
+    return builtins.dict(collections.Counter(xs))
+
+
+def group_by(xs, f):
+    """Groups elements by the key computed by `f`, preserving order.
+
+
+      >>> group_by([1, 2, 3, 4, 5], lambda x: _gan_rem(x, 2))
+      {1: [1, 3, 5], 0: [2, 4]}
+"""
+    return ({k: [x for x in (xs) if (f)(x) == k] for k in dict.fromkeys((f)(x) for x in (xs))})
+
+
+def max_by(xs, f):
+    """The element maximizing the key computed by `f`; raises on empty."""
+    return builtins.max(xs, key=f)
+
+
+def min_by(xs, f):
+    """The element minimizing the key computed by `f`; raises on empty."""
+    return builtins.min(xs, key=f)
+
+
+def product(xs):
+    """The product of the elements (1 for an empty collection)."""
+    return math.prod(xs)
+
+
+def take_while(xs, f):
+    """Leading elements while `f` stays truthy."""
+    return builtins.list(itertools.takewhile(f, xs))
+
+
+def drop_while(xs, f):
+    """Drops leading elements while `f` stays truthy, keeps the rest."""
+    return builtins.list(itertools.dropwhile(f, xs))
+
+
+def chunk_every(xs, n):
+    """Splits into chunks of `n` elements; the last chunk may be shorter.
+
+
+      >>> chunk_every([1, 2, 3, 4, 5], 2)
+      [[1, 2], [3, 4], [5]]
+"""
+    return ([(xs)[i:i + (n)] for i in range(0, len((xs)), (n))])
+
+
+def concat(xss):
+    """Concatenates a list of lists (one level)."""
+    return ([y for x in (xss) for y in x])
+
+
+def intersperse(xs, sep):
+    """Puts `sep` between every two elements.
+
+
+      >>> intersperse([1, 2, 3], "x")
+      [1, 'x', 2, 'x', 3]
+"""
+    return ([v for x in (xs) for v in (x, (sep))][:-1])
+
+
+def slice(xs, start, count):
+    """`count` elements starting at `start` (negative start counts from the end)."""
+    return ((xs)[(start):] [:(count)])
+
+
+def dedup(xs):
+    """Collapses consecutive duplicate elements.
+
+
+      >>> dedup([1, 1, 2, 2, 2, 1])
+      [1, 2, 1]
+"""
+    return ([x for i, x in enumerate((xs)) if i == 0 or x != (xs)[i - 1]])

gandora_std/gandora.toml

@@ -0,0 +1,27 @@
+schema = 1
+compiler = "0.1.0"
+
+[[modules]]
+name = "Enum"
+python = "gandora_std/enum.py"
+source = "gandora_std/_gan/gandora_std/enum.gan"
+
+[[modules]]
+name = "Keyword"
+python = "gandora_std/keyword.py"
+source = "gandora_std/_gan/gandora_std/keyword.gan"
+
+[[modules]]
+name = "List"
+python = "gandora_std/list.py"
+source = "gandora_std/_gan/gandora_std/list.gan"
+
+[[modules]]
+name = "Map"
+python = "gandora_std/map.py"
+source = "gandora_std/_gan/gandora_std/map.gan"
+
+[[modules]]
+name = "String"
+python = "gandora_std/string.py"
+source = "gandora_std/_gan/gandora_std/string.gan"

gandora_std/keyword.py

@@ -0,0 +1,82 @@
+"""Functions over keyword lists — lists of {atom, value} tuples (GEP-0010)."""
+
+import gandora_std.enum
+
+
+class GanMatchError(Exception):
+    pass
+
+
+def get(kw, key):
+    """The first value for `key`, or nil.
+
+
+      >>> get([("a", 1), ("b", 2)], "a")
+      1
+"""
+    return (next((v for k, v in (kw) if k == (key)), None))
+
+
+def put(kw, key, value):
+    """Replaces `key` with `value`, prepending it (Elixir Keyword.put)."""
+    def _gan_fn0(*_gan_args):
+        match _gan_args:
+            case ((k, _) as _gan_t0,) if isinstance(_gan_t0, tuple):
+                return k == key
+        raise GanMatchError("no clause of _gan_fn0/1 matched " + repr(_gan_args))
+    return [(key, value)] + gandora_std.enum.reject(kw, _gan_fn0)
+
+
+def keys(kw):
+    """The keys, in order, duplicates included."""
+    def _gan_fn1(*_gan_args):
+        match _gan_args:
+            case ((k, _) as _gan_t1,) if isinstance(_gan_t1, tuple):
+                return k
+        raise GanMatchError("no clause of _gan_fn1/1 matched " + repr(_gan_args))
+    return gandora_std.enum.map(kw, _gan_fn1)
+
+
+def values(kw):
+    """The values, in order."""
+    def _gan_fn2(*_gan_args):
+        match _gan_args:
+            case ((_, v) as _gan_t2,) if isinstance(_gan_t2, tuple):
+                return v
+        raise GanMatchError("no clause of _gan_fn2/1 matched " + repr(_gan_args))
+    return gandora_std.enum.map(kw, _gan_fn2)
+
+
+def has_key_p(kw, key):
+    """Whether `key` is present."""
+    def _gan_fn3(*_gan_args):
+        match _gan_args:
+            case ((k, _) as _gan_t3,) if isinstance(_gan_t3, tuple):
+                return k == key
+        raise GanMatchError("no clause of _gan_fn3/1 matched " + repr(_gan_args))
+    return gandora_std.enum.any_p(kw, _gan_fn3)
+
+
+def delete(kw, key):
+    """Removes every entry for `key`."""
+    def _gan_fn4(*_gan_args):
+        match _gan_args:
+            case ((k, _) as _gan_t4,) if isinstance(_gan_t4, tuple):
+                return k == key
+        raise GanMatchError("no clause of _gan_fn4/1 matched " + repr(_gan_args))
+    return gandora_std.enum.reject(kw, _gan_fn4)
+
+
+def merge(kw1, kw2):
+    """Merges `kw2` into `kw1`; `kw2` wins, its entries appended.
+
+
+      >>> merge([("a", 1), ("b", 2)], [("b", 9), ("c", 3)])
+      [('a', 1), ('b', 9), ('c', 3)]
+"""
+    def _gan_fn5(*_gan_args):
+        match _gan_args:
+            case ((k, _) as _gan_t5,) if isinstance(_gan_t5, tuple):
+                return has_key_p(kw2, k)
+        raise GanMatchError("no clause of _gan_fn5/1 matched " + repr(_gan_args))
+    return gandora_std.enum.reject(kw1, _gan_fn5) + kw2

gandora_std/list.py

@@ -0,0 +1,83 @@
+"""List-shape helpers; element-wise work lives in Enum (GEP-0010)."""
+
+import builtins
+import gandora_std.enum
+
+
+def _gan_truthy(value):
+    return value is not None and value is not False
+
+
+def first(xs):
+    """The first element, or nil for an empty list."""
+    return gandora_std.enum.at(xs, 0)
+
+
+def last(xs):
+    """The last element, or nil for an empty list."""
+    return gandora_std.enum.at(xs, -1)
+
+
+def flatten(xs):
+    """Flattens nested lists to any depth.
+
+
+      >>> flatten([1, [2, [3, 4]], 5])
+      [1, 2, 3, 4, 5]
+"""
+    def _gan_fn0(x):
+        if _gan_truthy(isinstance(x, list)):
+            return flatten(x)
+        else:
+            return [x]
+    return gandora_std.enum.flat_map(xs, _gan_fn0)
+
+
+def wrap(value):
+    """Wraps a value in a list: nil becomes [], lists pass through, anything else becomes [value]."""
+    if _gan_truthy((value is None)):
+        return []
+    elif _gan_truthy(isinstance(value, list)):
+        return value
+    else:
+        return [value]
+
+
+def duplicate(value, n):
+    """A list of `n` copies of `value`."""
+    return ([(value)] * (n))
+
+
+def insert_at(xs, index, value):
+    """Inserts `value` at `index` (negative counts from the end, as in Elixir)."""
+    return ((xs)[:(index)] + [(value)] + (xs)[(index):])
+
+
+def delete_at(xs, index):
+    """Removes the element at `index`; out-of-range leaves the list unchanged."""
+    return ((xs)[:(index)] + (xs)[(index):][1:])
+
+
+def to_tuple(xs):
+    """The list as a tuple."""
+    return builtins.tuple(xs)
+
+
+def starts_with_p(xs, prefix):
+    """Whether the list starts with `prefix`."""
+    return ((xs)[:len((prefix))] == (prefix))
+
+
+def replace_at(xs, index, value):
+    """Replaces the element at `index` (negative counts from the end)."""
+    return ((xs)[:(index)] + [(value)] + (xs)[(index):][1:])
+
+
+def update_at(xs, index, f):
+    """Updates the element at `index` by `f`.
+
+
+      >>> update_at([1, 2, 3], 1, lambda v: v * 10)
+      [1, 20, 3]
+"""
+    return replace_at(xs, index, f(gandora_std.enum.at(xs, index)))

gandora_std/map.py

@@ -0,0 +1,116 @@
+"""Data-first dict functions; all updates return new maps (GEP-0010)."""
+
+import builtins
+
+
+def _gan_truthy(value):
+    return value is not None and value is not False
+
+class GanMatchError(Exception):
+    pass
+
+
+def get(*_gan_args):
+    """The value for `key`, or `default` (nil unless given) when absent.
+
+
+      >>> get({"a": 1}, "b", 0)
+      0
+"""
+    match _gan_args:
+        case (m, key, default,):
+            return m.get(key, default)
+        case (m, key,):
+            return get(m, key, None)
+    raise GanMatchError("no clause of get/2,3 matched " + repr(_gan_args))
+
+
+def put(m, key, value):
+    """A new map with `key` set to `value`.
+
+
+      >>> put({"a": 1}, "b", 2)
+      {'a': 1, 'b': 2}
+"""
+    return ({**(m), (key): (value)})
+
+
+def delete(m, key):
+    """A new map without `key`."""
+    return ({k: v for k, v in (m).items() if k != (key)})
+
+
+def keys(m):
+    """The keys as a list."""
+    return builtins.list(m.keys())
+
+
+def values(m):
+    """The values as a list."""
+    return builtins.list(m.values())
+
+
+def merge(m1, m2):
+    """Merges `m2` into `m1`; `m2` wins on conflicts."""
+    return ({**(m1), **(m2)})
+
+
+def has_key_p(m, key):
+    """Whether `key` is present."""
+    return ((key) in (m))
+
+
+def to_list(m):
+    """The entries as a list of `{key, value}` tuples."""
+    return builtins.list(m.items())
+
+
+def new():
+    """An empty map."""
+    return {}
+
+
+def update(m, key, default, f):
+    """Updates `key` by `f`; uses `default` when the key is absent (Elixir Map.update/4).
+
+
+      >>> update({"a": 1}, "a", 0, lambda v: v + 10)
+      {'a': 11}
+"""
+    if _gan_truthy(has_key_p(m, key)):
+        return put(m, key, f(get(m, key)))
+    else:
+        return put(m, key, default)
+
+
+def fetch_bang(m, key):
+    """The value for `key`; raises Python KeyError when absent."""
+    return ((m)[(key)])
+
+
+def put_new(m, key, value):
+    """Sets `key` only when absent."""
+    if _gan_truthy(has_key_p(m, key)):
+        return m
+    else:
+        return put(m, key, value)
+
+
+def take(m, keys):
+    """The submap with only `keys` (missing keys ignored)."""
+    return ({k: v for k, v in (m).items() if k in (keys)})
+
+
+def drop(m, keys):
+    """The map without `keys`."""
+    return ({k: v for k, v in (m).items() if k not in (keys)})
+
+
+def filter(m, f):
+    """Keeps entries for which `f` (receiving a `{key, value}` tuple) is truthy.
+
+
+      >>> filter({"a": 1, "b": 5}, lambda pair: pair[1] > 2)
+      {'b': 5}
+"""
+    return ({k: v for k, v in (m).items() if (f)((k, v))})

gandora_std/string.py

@@ -0,0 +1,147 @@
+"""Data-first string functions over Python str (GEP-0010)."""
+
+import builtins
+import re
+import gandora_std.enum
+
+
+def _gan_truthy(value):
+    return value is not None and value is not False
+
+
+def upcase(s):
+    """Uppercases the string."""
+    return s.upper()
+
+
+def downcase(s):
+    """Lowercases the string."""
+    return s.lower()
+
+
+def capitalize(s):
+    """Uppercases the first character, lowercases the rest."""
+    return s.capitalize()
+
+
+def split(s):
+    """Splits on whitespace runs, dropping empty parts (Elixir semantics).
+
+
+      >>> split("  a  b c ")
+      ['a', 'b', 'c']
+"""
+    return s.split()
+
+
+def split_on(s, sep):
+    """Splits on the separator `sep`."""
+    return s.split(sep)
+
+
+def trim(s):
+    """Removes leading and trailing whitespace."""
+    return s.strip()
+
+
+def replace(s, pattern, replacement):
+    """Replaces every occurrence of `pattern` with `replacement`."""
+    return s.replace(pattern, replacement)
+
+
+def contains_p(s, part):
+    """Whether the string contains `part`."""
+    return ((part) in (s))
+
+
+def starts_with_p(s, prefix):
+    """Whether the string starts with `prefix`."""
+    return s.startswith(prefix)
+
+
+def ends_with_p(s, suffix):
+    """Whether the string ends with `suffix`."""
+    return s.endswith(suffix)
+
+
+def length(s):
+    """The number of characters (Unicode code points, Python `len`)."""
+    return builtins.len(s)
+
+
+def slice(s, start, len):
+    """The substring of `len` characters starting at `start` (negative start counts from the end).
+
+
+      >>> slice("gandora", 3, 4)
+      'dora'
+"""
+    return ((s)[(start):] [:(len)])
+
+
+def pad_leading(s, width):
+    """Pads on the left with spaces to `width`."""
+    return s.rjust(width)
+
+
+def pad_trailing(s, width):
+    """Pads on the right with spaces to `width`."""
+    return s.ljust(width)
+
+
+def to_integer(s):
+    """Parses an integer; raises Python ValueError on bad input."""
+    return builtins.int(s)
+
+
+def to_float(s):
+    """Parses a float; raises Python ValueError on bad input."""
+    return builtins.float(s)
+
+
+def at(s, index):
+    """The character at `index` (negative counts from the end), or nil."""
+    if (index < builtins.len(s)) and (index >= -(builtins.len(s))):
+        return ((s)[(index)])
+    else:
+        return None
+
+
+def reverse(s):
+    """The string reversed."""
+    return ((s)[::-1])
+
+
+def duplicate(s, n):
+    """The string repeated `n` times."""
+    return ((s) * (n))
+
+
+def trim_leading(s):
+    """Removes leading whitespace."""
+    return s.lstrip()
+
+
+def trim_trailing(s):
+    """Removes trailing whitespace."""
+    return s.rstrip()
+
+
+def codepoints(s):
+    """The characters as a list of one-character strings.
+
+
+      >>> gandora_std.enum.take(codepoints("héllo"), 2)
+      ['h', 'é']
+"""
+    return builtins.list(s)
+
+
+def match_p(s, regex):
+    """Whether the compiled regex (`~r/.../`) matches anywhere in the string.
+
+
+      >>> match_p("gandora-2026", re.compile("\\d+"))
+      True
+"""
+    return not (_gan_truthy((regex.search(s) is None)))

gandora_std-0.1.0.dist-info/METADATA

@@ -0,0 +1,5 @@
+Metadata-Version: 2.4
+Name: gandora-std
+Version: 0.1.0
+Summary: The Gandora standard library: Enum, String, Map, List, Keyword (GEP-0010)
+Requires-Python: >=3.12

gandora_std-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+gandora_std/enum.py,sha256=hOlt5hIUyDM-XeXXMstZ-Mc0OnE6ccbs4zUZVADHQYE,5975
+gandora_std/gandora.toml,sha256=XEu3viPEQ_XfiWQq9MuHe8Kg0MEW35AVFUuinxJKimo,577
+gandora_std/keyword.py,sha256=Bud0dZAAR8AH7MryjlbNbAf-xQsTq0-TKf1_iA61Vvc,2597
+gandora_std/list.py,sha256=4K3WJO7ich5eD5S9H2_TLzJTZrH9Ng-LHoXMof2iF4U,2031
+gandora_std/map.py,sha256=Sm4Gd0bIff6EHXlKW7JP18pxA_SNivRgAga42XtnGMs,2503
+gandora_std/string.py,sha256=jFonH5wjLPJ_cO79Uap4Ht6Tp607jql0Bqi071hQ6DA,3008
+gandora_std/_gan/gandora_std/enum.gan,sha256=I5Fykk85ZwfbpHc8cTgXZIIPlODA9irHgrhbEDYotI0,8812
+gandora_std/_gan/gandora_std/keyword.gan,sha256=mSSHmtQ1lWJSVoBR8If_LUbHf2vyRzqAt4MvPwIY_zU,1745
+gandora_std/_gan/gandora_std/list.gan,sha256=3MAv2wA5V1sHBbxbsfSEUgE-2MoghnoBamZFkllOEVE,2762
+gandora_std/_gan/gandora_std/map.gan,sha256=2mpuRllfYJkiW8lxn6kbmP8tIQvGTqw_WQUv42A6agQ,3408
+gandora_std/_gan/gandora_std/string.gan,sha256=1MWxxOILxV0B80e0jE2rh36Tbn8gzJfi_pYx9YYDrMY,4408
+gandora_std-0.1.0.dist-info/METADATA,sha256=Gk4F9PBr1r0gpAfIHAYrw43d3hsPtVrMM7JRHMou4ZA,162
+gandora_std-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+gandora_std-0.1.0.dist-info/RECORD,,

gandora_std-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any