https://github.com/eliphatfs/2us

Glueing functionals by `import __` for python!
https://github.com/eliphatfs/2us

functional-programming python

Last synced: 3 days ago
JSON representation

Glueing functionals by `import __` for python!

• Host: GitHub
• URL: https://github.com/eliphatfs/2us
• Owner: eliphatfs
• License: apache-2.0
• Created: 2020-10-30T06:46:57.000Z (about 4 years ago)
• Default Branch: master
• Last Pushed: 2020-10-30T09:50:28.000Z (about 4 years ago)
• Last Synced: 2024-11-01T02:05:57.860Z (15 days ago)
• Topics: functional-programming, python
• Language: Python
• Homepage:
• Size: 8.79 KB
• Stars: 2
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# __ (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 situation 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]

```