gandora-std 0.1.0__tar.gz

gandora_std-0.1.0/.gitignore

@@ -0,0 +1,19 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+/build/
+dist/
+wheels/
+*.egg-info
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.gandora/
+
+# Virtual environments
+.venv/
+
+# Rust-generated files
+/target/
+
+.env

gandora_std-0.1.0/PKG-INFO

@@ -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/gandora.jsonc

@@ -0,0 +1,8 @@
+{
+  // The Gandora standard library (GEP-0010): an ordinary Gandora package.
+  "source": ["src"],
+  "outDir": "pkg",
+  "targetPython": "3.12",
+  "package": true,
+  "pyPackage": "gandora_std",
+}

gandora_std-0.1.0/pkg/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-0.1.0/pkg/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-0.1.0/pkg/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-0.1.0/pkg/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-0.1.0/pkg/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