Metadata-Version: 2.1
Name: 2us
Version: 0.0.1.post1
Summary: Glueing functionals with __.
Home-page: https://github.com/strongrex2001/2us
Author: flandre.info
Author-email: flandre@scarletx.cn
License: UNKNOWN
Description: # __ (Double Underscores, 2us)
        [![PyPI version](https://badge.fury.io/py/2us.svg)](https://badge.fury.io/py/2us)
        
        Glueing functionals by `import __` for python!
        
        ## Install
        The package is written in pure python, with no dependencies other than the Python language. Just do:
        
        ```sh
        pip install 2us
        ```
        
        Requires Python 3.5 or higher.
        
        ## Why this?
        Python is a great language for creating convenient wrappers around native code and implementing simple, human-friendly functions.
        In python, a bunch of builtin higher-order methods (which means that they accept functions as arguments) such as `map`, `filter` are available.
        They enable streamed data processing on containers that focus on the processing itself,
        in contrast with *noisy code* on traditional command-based languages that is heavily involved in loops.
        
        However, you may occasionally run into the situatiion where you find that there is no standard library functions to implement in-line unpacking of tuples,
        adding all numbers in a list by a constant shift, so you will have to write:
        ```python
        map(lambda x: x + 1, some_list)
        map(lambda x: x[0], some_list)
        ```
        which seems rather dumb due to the inconvenient definition of lambda functions in python.
        
        ## Using __
        Start using the package by importing `__`:
        ```python
        import __
        ```
        And then `__` can be used to create convenient functions that are identical to those written with `lambda`. Examples:
        ```python
        assert sum(map(__ + 1, range(1000))) == sum(map(lambda x: x + 1, range(1000)))
        assert set(map(__[0], {1: 2, 4: 6}.items())) == {1, 4}
        assert functools.reduce(__ + __, range(1000)) == sum(range(1000))
        ```
        Currently there is a drawback: python do not support overriding `__contains__` returning non-boolean values, so the `in` condition should be handled separately.
        ```python
        assert tuple(map(__.is_in([1, 2]), [3, 1, 5, 0, 2])) == (False, True, False, False, True)
        assert list(map(__.contains('1'), '13')) == [True, False]
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3 :: Only
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Operating System :: OS Independent
Requires-Python: ~=3.5
Description-Content-Type: text/markdown
