gandora-std 0.2.1__tar.gz → 0.2.2__tar.gz

{gandora_std-0.2.1 → gandora_std-0.2.2}/PKG-INFO

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

{gandora_std-0.2.1 → gandora_std-0.2.2}/gandora.jsonc

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

{gandora_std-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/enum.py

@@ -22,9 +22,8 @@ def _gan_rem(a, b):
 def map(xs, f):
     """Applies `f` to every element.
 
-
-      >>> map([1, 2, 3], lambda x: x * 10)
-      [10, 20, 30]
+    >>> map([1, 2, 3], lambda x: x * 10)
+    [10, 20, 30]
 """
     return builtins.list(builtins.map(f, xs))
 
@@ -32,9 +31,8 @@ def map(xs, f):
 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]
+    >>> filter([1, 2, 3, 4], lambda x: _gan_rem(x, 2) == 0)
+    [2, 4]
 """
     return ([x for x in (xs) if (f)(x)])
 
@@ -47,9 +45,8 @@ def reject(xs, f):
 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
+    >>> reduce([1, 2, 3, 4], 0, lambda x, acc: acc + x)
+    10
 """
     return functools.reduce(lambda a, x: f(x, a), xs, acc)
 
@@ -72,9 +69,8 @@ def sort(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']
+    >>> sort_by(["ccc", "a", "bb"], lambda s: gandora_std.string.length(s))
+    ['a', 'bb', 'ccc']
 """
     return builtins.sorted(xs, key=f)
 
@@ -87,9 +83,8 @@ def reverse(xs):
 def join(xs, sep):
     """Joins elements (converted by `to_string`) with `sep`.
 
-
-      >>> join([1, 2, 3], "-")
-      '1-2-3'
+    >>> join([1, 2, 3], "-")
+    '1-2-3'
 """
     return sep.join(([str(x) for x in (xs)]))
 
@@ -120,9 +115,8 @@ def zip(xs, ys):
 def with_index(xs):
     """Each element paired with its index: `{element, index}`.
 
-
-      >>> with_index(["a", "b"])
-      [('a', 0), ('b', 1)]
+    >>> with_index(["a", "b"])
+    [('a', 0), ('b', 1)]
 """
     return ([(x, i) for i, x in enumerate((xs))])
 
@@ -155,9 +149,8 @@ def uniq(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]
+    >>> flat_map([1, 2], lambda x: [x, x * 10])
+    [1, 10, 2, 20]
 """
     return ([y for x in (xs) for y in (f)(x)])
 
@@ -181,9 +174,8 @@ def 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
+    >>> find([1, 2, 3, 4], lambda x: x > 2)
+    3
 """
     return (next((x for x in (xs) if (f)(x)), None))
 
@@ -196,9 +188,8 @@ def find_index(xs, f):
 def frequencies(xs):
     """A map from each distinct element to its occurrence count.
 
-
-      >>> frequencies(["a", "b", "a"])
-      {'a': 2, 'b': 1}
+    >>> frequencies(["a", "b", "a"])
+    {'a': 2, 'b': 1}
 """
     return builtins.dict(collections.Counter(xs))
 
@@ -206,9 +197,8 @@ def frequencies(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]}
+    >>> 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))})
 
@@ -241,9 +231,8 @@ def drop_while(xs, f):
 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]]
+    >>> 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))])
 
@@ -256,9 +245,8 @@ def concat(xss):
 def intersperse(xs, sep):
     """Puts `sep` between every two elements.
 
-
-      >>> intersperse([1, 2, 3], "x")
-      [1, 'x', 2, 'x', 3]
+    >>> intersperse([1, 2, 3], "x")
+    [1, 'x', 2, 'x', 3]
 """
     return ([v for x in (xs) for v in (x, (sep))][:-1])
 
@@ -271,8 +259,7 @@ def slice(xs, start, count):
 def dedup(xs):
     """Collapses consecutive duplicate elements.
 
-
-      >>> dedup([1, 1, 2, 2, 2, 1])
-      [1, 2, 1]
+    >>> 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-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/gandora.toml

@@ -1,5 +1,5 @@
 schema = 1
-compiler = "0.2.1"
+compiler = "0.2.2"
 
 [[modules]]
 name = "Enum"

{gandora_std-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/keyword.py

@@ -10,9 +10,8 @@ class GanMatchError(Exception):
 def get(kw, key):
     """The first value for `key`, or nil.
 
-
-      >>> get([("a", 1), ("b", 2)], "a")
-      1
+    >>> get([("a", 1), ("b", 2)], "a")
+    1
 """
     return (next((v for k, v in (kw) if k == (key)), None))
 
@@ -70,9 +69,8 @@ def delete(kw, key):
 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)]
+    >>> merge([("a", 1), ("b", 2)], [("b", 9), ("c", 3)])
+    [('a', 1), ('b', 9), ('c', 3)]
 """
     def _gan_fn5(*_gan_args):
         match _gan_args:

{gandora_std-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/list.py

@@ -21,9 +21,8 @@ def last(xs):
 def flatten(xs):
     """Flattens nested lists to any depth.
 
-
-      >>> flatten([1, [2, [3, 4]], 5])
-      [1, 2, 3, 4, 5]
+    >>> flatten([1, [2, [3, 4]], 5])
+    [1, 2, 3, 4, 5]
 """
     def _gan_fn0(x):
         if _gan_truthy(isinstance(x, list)):
@@ -76,8 +75,7 @@ def replace_at(xs, index, value):
 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]
+    >>> 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-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/map.py

@@ -13,9 +13,8 @@ class GanMatchError(Exception):
 def get(*_gan_args):
     """The value for `key`, or `default` (nil unless given) when absent.
 
-
-      >>> get({"a": 1}, "b", 0)
-      0
+    >>> get({"a": 1}, "b", 0)
+    0
 """
     match _gan_args:
         case (m, key, default,):
@@ -28,9 +27,8 @@ def get(*_gan_args):
 def put(m, key, value):
     """A new map with `key` set to `value`.
 
-
-      >>> put({"a": 1}, "b", 2)
-      {'a': 1, 'b': 2}
+    >>> put({"a": 1}, "b", 2)
+    {'a': 1, 'b': 2}
 """
     return ({**(m), (key): (value)})
 
@@ -73,9 +71,8 @@ def new():
 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}
+    >>> 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)))
@@ -109,8 +106,7 @@ def drop(m, 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}
+    >>> 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-0.2.1 → gandora_std-0.2.2}/pkg/gandora_std/string.py

@@ -27,9 +27,8 @@ def capitalize(s):
 def split(s):
     """Splits on whitespace runs, dropping empty parts (Elixir semantics).
 
-
-      >>> split("  a  b c ")
-      ['a', 'b', 'c']
+    >>> split("  a  b c ")
+    ['a', 'b', 'c']
 """
     return s.split()
 
@@ -72,9 +71,8 @@ def length(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'
+    >>> slice("gandora", 3, 4)
+    'dora'
 """
     return ((s)[(start):] [:(len)])
 
@@ -130,9 +128,8 @@ def trim_trailing(s):
 def codepoints(s):
     """The characters as a list of one-character strings.
 
-
-      >>> gandora_std.enum.take(codepoints("héllo"), 2)
-      ['h', 'é']
+    >>> gandora_std.enum.take(codepoints("héllo"), 2)
+    ['h', 'é']
 """
     return builtins.list(s)
 
@@ -140,8 +137,7 @@ def codepoints(s):
 def match_p(s, regex):
     """Whether the compiled regex (`~r/.../`) matches anywhere in the string.
 
-
-      >>> match_p("gandora-2026", re.compile("\\d+"))
-      True
+    >>> match_p("gandora-2026", re.compile("\\d+"))
+    True
 """
     return not (_gan_truthy((regex.search(s) is None)))

{gandora_std-0.2.1 → gandora_std-0.2.2}/pyproject.toml

@@ -1,8 +1,8 @@
 [project]
 name = "gandora-std"
-version = "0.2.1"
+version = "0.2.2"
 description = "The Gandora standard library: Enum, String, Map, List, Keyword (GEP-0010)"
-requires-python = ">=3.12"
+requires-python = ">=3.11"
 dependencies = []
 
 [build-system]