funcy

https://funcy.readthedocs.io/en/stable
Admin
funcy is a Python library that enhances functional programming with a collection of useful functions...
Tokens:174,927
Snippets:1,956
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Funcy

Source: https://funcy.readthedocs.io/en/stable/overview

Installs the Funcy library using pip. This is the first step to using Funcy in your Python projects.

```Python
pip install funcy
```

--------------------------------

### Funcy split_at() example

Source: https://funcy.readthedocs.io/en/stable/seqs

Provides an example of the `split_at` and `lsplit_at` functions, which split a sequence at a specified position into two parts.

--------------------------------

### Funcy mapcat() and lmapcat() examples

Source: https://funcy.readthedocs.io/en/stable/seqs

Shows how `mapcat` and `lmapcat` can be used to map sequences and concatenate the results. Examples include flattening lists of lines and extracting numbers from strings.

```Python
# Get all the lines of all the texts in single flat list
mapcat(str.splitlines, bunch_of_texts)
```

```Python
# Extract all numbers from strings
mapcat(partial(re_all, r'\d+'), bunch_of_strings)
```

--------------------------------

### Funcy keep() and lkeep() examples

Source: https://funcy.readthedocs.io/en/stable/seqs

Illustrates the usage of `keep` and `lkeep` functions for filtering out falsy elements after mapping or directly. Examples include data extraction using regular expressions and dictionary lookups.

```Python
keep(f, seq)  == filter(bool, map(f, seq))
```

```Python
keep(seq)     == filter(bool, seq)
```

```Python
lkeep(f, seq) == lfilter(bool, map(f, seq))
```

```Python
lkeep(seq)    == lfilter(bool, seq)
```

```Python
# Extract numbers from words
lkeep(re_finder(r'\d+'), words)
```

```Python
# Recognize as many colors by name as possible
lkeep(COLOR_BY_NAME.get, color_names)
```

```Python
first(keep(COLOR_BY_NAME.get, color_name_candidates))
```

```Python
keep(description.splitlines())
```

```Python
keep(f.name for f in fields)     # sugar generator expression
```

```Python
keep(attrgetter('name'), fields) # pure functions
```

--------------------------------

### Funcy takewhile() examples

Source: https://funcy.readthedocs.io/en/stable/seqs

Shows how `takewhile` and its iterator-aware version yield elements from a sequence as long as a predicate is true, stopping at the first falsy element. Examples include extracting paragraphs and building paths.

```Python
# Extract first paragraph of text
takewhile(re_tester(r'\S'), text.splitlines())
```

```Python
# Build path from node to tree root
takewhile(bool, iterate(attrgetter('parent'), node))
```

--------------------------------

### Generate Arithmetic Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Creates an infinite iterator of numbers starting from `start` with a given `step`.

```python
count(_start=0, _step=1_)
```

--------------------------------

### Lazy Object Creation

Source: https://funcy.readthedocs.io/en/stable/funcs

Creates an object that initializes itself upon its first use, deferring setup until necessary.

```python
class LazyObject(init)
```

--------------------------------

### Funcy split_by() example

Source: https://funcy.readthedocs.io/en/stable/seqs

Demonstrates the `split_by` and `lsplit_by` functions, which split a sequence by grouping consecutive items that satisfy a predicate.

```Python
lsplit_by(bool, iter([-2, -1, 0, 1, 2]))
# [-2, -1], [0, 1, 2]
```

--------------------------------

### Funcy without() example

Source: https://funcy.readthedocs.io/en/stable/seqs

Demonstrates the use of the `without` function to remove specific items from a sequence while preserving order. An example shows removing empty lists.

```Python
non_empty_lists = without(lists, [])
```

--------------------------------

### Get First Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Returns the first item of a sequence, or `None` if the sequence is empty.

```python
first(_seq_)
```

--------------------------------

### Funcy dropwhile() example

Source: https://funcy.readthedocs.io/en/stable/seqs

Explains that `dropwhile` is the mirror of `takewhile`, skipping elements from the beginning of a sequence while a predicate holds true and yielding the rest.

--------------------------------

### Get Empty Collection of Same Type

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Returns an empty collection that has the same type as the input collection `coll`. For example, if `coll` is a list, it returns an empty list.

```Python
empty(coll)
```

--------------------------------

### Import Funcy Functions

Source: https://funcy.readthedocs.io/en/stable/overview

Demonstrates how to import specific functions from the Funcy library. You can import any function you need to utilize its capabilities.

```Python
from funcy import whatever, you, need
```

--------------------------------

### Get Sequence Except First Item

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Yields all items from a sequence, excluding the very first item. Useful for processing sequences starting from the second element.

```python
rest(seq)
```

--------------------------------

### Get empty collection of same type

Source: https://funcy.readthedocs.io/en/stable/funcs

Returns an empty collection that has the same type as the input collection 'coll'. For example, if 'coll' is a list, it returns an empty list.

```Python
empty(coll)
```

--------------------------------

### Sequence Splitting with split_at and lsplit_at

Source: https://funcy.readthedocs.io/en/stable/funcs

These functions split a sequence at a specified position n, returning a tuple containing the start and the tail of the sequence.

```python
split_at(n, seq)
lsplit_at(n, seq)
```

--------------------------------

### Monkey-patch class or module

Source: https://funcy.readthedocs.io/en/stable/objects

The @monkey decorator allows for monkey-patching a class or module by adding a decorated function or property. It saves the original method to an 'original' attribute, facilitating a form of inheritance. This example demonstrates caching all get requests for QuerySet objects.

```python
@monkey(QuerySet)
def get(self, *args, **kwargs):
    if not args and list(kwargs) == ['pk']:
        cache_key = '%s:%d' % (self.model, kwargs['pk'])
        result = cache.get(cache_key)
        if result is None:
            result = get.original(self, *args, **kwargs)
            cache.set(cache_key, result)
        return result
    else:
        return get.original(self, *args, **kwargs)
```

--------------------------------

### Create Lazy Object

Source: https://funcy.readthedocs.io/en/stable/primitives

Creates an object that sets itself up on first use, using the LazyObject class.

```Python
class LazyObject _(init)_
```

--------------------------------

### Lazy Object Initialization

Source: https://funcy.readthedocs.io/en/stable/strings

Creates an object that sets itself up on its first use, defined by an initialization function, using the LazyObject class.

```Python
class LazyObject _(init)_
```

--------------------------------

### Sequence Splitting with split_at, lsplit_at, split_by, lsplit_by

Source: https://funcy.readthedocs.io/en/stable/primitives

Funcy provides functions to split sequences at specific points. `split_at` and `lsplit_at` divide a sequence at a given index, returning a tuple of the start and tail. `split_by` and `lsplit_by` split the sequence into a prefix of items satisfying a predicate and the remainder.

```python
split_at(n, seq)
```

```python
lsplit_at(n, seq)
```

```python
split_by(pred, seq)
```

```python
lsplit_by(pred, seq)
```

--------------------------------

### Lazy Object Initialization

Source: https://funcy.readthedocs.io/en/stable/seqs

Creates an object that sets itself up on its first use, defined by an initialization function, using the LazyObject class.

```Python
class LazyObject _(init)_
```

--------------------------------

### Split sequence by predicate using Funcy

Source: https://funcy.readthedocs.io/en/stable/seqs

Explains and demonstrates the `split` and `lsplit` functions, which divide a sequence into two based on a predicate. Examples include separating private and public attributes and splitting URLs.

```Python
private, public = lsplit(re_tester('^_'), dir(instance))
```

```Python
absolute, relative = lsplit(r'^http://', urls)
```

--------------------------------

### Partition Sequence with Sliding Window

Source: https://funcy.readthedocs.io/en/stable/seqs

Iterates over a sequence using a sliding window of a specified size 'n' with a given step. This allows processing elements in the context of their neighbors, for example, for calculating moving averages.

```Python
from funcy import partition

# Smooth data by averaging out with a sliding window
# n = 3
# data_points = [1, 2, 3, 4, 5]
# [sum(window) / n for window in partition(n, 1, data_points)]
```

--------------------------------

### Create Infinite Iterator with count()

Source: https://funcy.readthedocs.io/en/stable/flow

The count() function creates an infinite iterator that yields values starting from 'start' with a given 'step'.

```python
count(start=0, step=1)
```

--------------------------------

### Split Sequence at Position

Source: https://funcy.readthedocs.io/en/stable/strings

Splits a sequence into two parts at a given position, returning a tuple of the start and the tail.

```python
split_at(_n, _seq_)
```

```python
lsplit_at(_n, _seq_)
```

--------------------------------

### Create Lazy Object

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Creates an object that sets itself up on first use, using the LazyObject class.

```Python
class LazyObject _(init)_
```

--------------------------------

### Lazy Object Creation

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

A class for creating objects that defer their initialization until they are first used. This can improve performance by delaying expensive setup operations.

```Python
class LazyObject_(init)_
```

--------------------------------

### Create Dictionary from Keys and Values

Source: https://funcy.readthedocs.io/en/stable/debug

Creates a dictionary by mapping elements from a `keys` sequence to corresponding elements in a `vals` sequence. Ensures keys and values are paired correctly.

```python
zipdict(keys, vals)
```

--------------------------------

### Create Decorators with Funcy

Source: https://funcy.readthedocs.io/en/stable/overview

Provides a `decorator` utility to simplify the creation of custom decorators. This allows for cleaner and more reusable code.

```Python
@decorator
def log(call):
    print call._func.__name__, call._args
    return call()
```

--------------------------------

### Python: Create infinite iterators with count

Source: https://funcy.readthedocs.io/en/stable/types

The `count` function generates an infinite iterator of values starting from a specified number and incrementing by a step. It defaults to starting at 0 with a step of 1.

```Python
count(start=0, step=1)
```

--------------------------------

### Get empty collection of same type

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Returns an empty collection that has the same type as the input collection.

```python
empty(coll)
```

--------------------------------

### Partial Application with Funcy

Source: https://funcy.readthedocs.io/en/stable/primitives

Provides functions like `partial` and `rpartial` for creating new functions with some arguments pre-filled. `func_partial` is a variant that returns a real function.

```Python
from funcy import partial, rpartial, func_partial

# Example usage of partial
add_one = partial(lambda x: x + 1)
print(add_one(5))  # Output: 6

# Example usage of rpartial
subtract_from_ten = rpartial(lambda x, y: x - y, 10)
print(subtract_from_ten(3)) # Output: 7

# Example usage of func_partial
add_two = func_partial(lambda x, y: x + y, 2)
print(add_two(3)) # Output: 5
```

--------------------------------

### Get length of iterator

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Consumes an iterator and returns its total length. This is a destructive operation.

```python
ilen(seq)
```

--------------------------------

### Create Lazy Object

Source: https://funcy.readthedocs.io/en/stable/colls

The `LazyObject(init)` class creates an object that sets itself up on its first use. This is beneficial for delaying initialization of potentially expensive objects.

```Python
from funcy import LazyObject

def expensive_init():
    print('Initializing...')
    return 'initialized_value'

lazy_obj = LazyObject(expensive_init)

# Initialization happens here:
print(lazy_obj.get())
# Output:
# Initializing...
# initialized_value
```

--------------------------------

### Get object wrapped by function

Source: https://funcy.readthedocs.io/en/stable/decorators

Retrieves the object that is wrapped by the given function.

```Python
unwrap(func)
```

--------------------------------

### Split sequence by predicate (Funcy)

Source: https://funcy.readthedocs.io/en/stable/decorators

Splits the start of a sequence, consisting of items passing a predicate, from the rest of it. Returns a tuple of the matching prefix and the remaining suffix.

```Python
from funcy import split_by, lsplit_by

# Example usage:
# result_split = split_by(lambda x: x < 3, [1, 2, 3, 4, 1, 2])
# print(result_split)  # Output: ([1, 2], [3, 4, 1, 2])
# result_lsplit = lsplit_by(lambda x: x < 3, [1, 2, 3, 4, 1, 2])
# print(result_lsplit) # Output: ([1, 2], [3, 4, 1, 2])
```

--------------------------------

### Functional Programming Utilities in Funcy

Source: https://funcy.readthedocs.io/en/stable/overview

Offers utilities for functional programming paradigms, including partial application, currying, function composition, creating complements, and combining functions.

```Python
partial(add, 1)             # inc
curry(add)(1)(2)            # 3
compose(inc, double)(10)    # 21
complement(even)            # odd
all_fn(isa(int), even)      # is_even_int

one_third = rpartial(operator.div, 3.0)
has_suffix = rcurry(str.endswith, 2)
```

--------------------------------

### Funcy: Get the rest of a sequence

Source: https://funcy.readthedocs.io/en/stable/calc

Yields all elements of a sequence except for the first one.

```python
rest(seq)
```

--------------------------------

### Cut Prefix from String

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Cuts a specified prefix from a given string if the string starts with that prefix, using the cut_prefix function.

```Python
cut_prefix _(s, prefix)_
```

--------------------------------

### Autocurrying Function

Source: https://funcy.readthedocs.io/en/stable/strings

Creates a version of a function that returns its partial applications until sufficient arguments are passed.

```Python
def autocurry(func):
  """Creates a version of _func_ returning its partial applications until sufficient arguments are passed."""
  pass
```

--------------------------------

### Ease Debugging with Funcy

Source: https://funcy.readthedocs.io/en/stable/overview

Offers utilities to simplify debugging, such as tapping values during execution, logging function calls and exits, and timing code blocks. These tools help in understanding program flow and performance.

```Python
squares = {tap(x, 'x'): tap(x * x, 'x^2') for x in [3, 4]}
# x: 3
# x^2: 9
# ...

@print_exits
def some_func(...):
    "..."

@log_calls(log.info, errors=False)
@log_errors(log.exception)
def some_suspicious_function(...):
    "..."

with print_durations('Creating models'):
    Model.objects.create(...)
    # ...
# 10.2 ms in Creating models
```

--------------------------------

### Get All Elements Except Last

Source: https://funcy.readthedocs.io/en/stable/seqs

Returns an iterator of all elements in a sequence except for the last one.

```Python
butlast(_seq_)
```

--------------------------------

### Get Last Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Retrieves the last item from a sequence. Returns None if the sequence is empty.

```python
last(seq)
```

--------------------------------

### Take First N Elements with Funcy take

Source: https://funcy.readthedocs.io/en/stable/seqs

The `take` function returns a list containing the first `n` elements of a sequence. If the sequence has fewer than `n` elements, it returns all available elements.

```python
take(_n_ , _seq_)
```

```python
take(3, [2, 3, 4, 5]) # [2, 3, 4]
take(3, count(5))     # [5, 6, 7]
take(3, 'ab')         # ['a', 'b']
```

--------------------------------

### Get First Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Retrieves the first item from a sequence. Returns None if the sequence is empty.

```python
first(seq)
```

--------------------------------

### Partial Application of Function

Source: https://funcy.readthedocs.io/en/stable/strings

Returns a partial application of a given function 'func' with provided arguments.

```Python
def partial(func, *args, **kwargs):
  """Returns partial application of _func_."""
  pass
```

--------------------------------

### Create a partial application of a function

Source: https://funcy.readthedocs.io/en/stable/calc

Returns a new function that behaves like the original function but with some arguments pre-filled. This is a standard functional programming technique.

```python
partial(func, *args, **kwargs)
```

--------------------------------

### Get Iterator Length

Source: https://funcy.readthedocs.io/en/stable/primitives

Consumes an iterator and returns its total length. This is achieved using the `ilen` function.

```Python
ilen(seq)
```

--------------------------------

### Partial Application (Real Function)

Source: https://funcy.readthedocs.io/en/stable/decorators

Creates a new function that is a partial application of the given function 'func' with specified positional and keyword arguments. Unlike standard partial, it returns a real function.

```python
func_partial_(func, *args, **kwargs)
```

--------------------------------

### Get Wrapped Function Object

Source: https://funcy.readthedocs.io/en/stable/objects

Retrieves the original function object that was wrapped by a decorator or other function transformation.

```Python
unwrap(func)
```

--------------------------------

### Logging and Debugging Utilities

Source: https://funcy.readthedocs.io/en/stable/primitives

Funcy provides `tap`, `@log_calls`, and `@print_calls` for debugging and logging function execution details.

```Python
from funcy import tap, log_calls, print_calls

# Example: tap to print a value and return it
result = tap(10, label='my_value') # Output: my_value: 10
print(result) # Output: 10

# Example: @log_calls to log function calls
def add_numbers(a, b):
    return a + b

logged_add = log_calls(add_numbers)
logged_add(5, 3)

# Example: @print_calls to print function calls
@print_calls
def subtract_numbers(a, b):
    return a - b

subtract_numbers(10, 4)

# Example: @log_calls with custom print function
def custom_logger(msg):
    print(f"CUSTOM LOG: {msg}")

logged_add_custom = log_calls(add_numbers, print_func=custom_logger)
logged_add_custom(7, 2)
```

--------------------------------

### Get the Last Item of a Sequence

Source: https://funcy.readthedocs.io/en/stable/objects

Returns the last item in a sequence. Returns None if the sequence is empty.

```python
from funcy import last

my_list = [10, 20, 30]
print(last(my_list))

empty_list = []
print(last(empty_list))
```

--------------------------------

### Python: Create partial function application with partial

Source: https://funcy.readthedocs.io/en/stable/funcs

The `partial` function from Funcy allows creating a new function with some arguments pre-filled. It is a re-export of `functools.partial` and is useful for creating Domain-Specific Languages (DSLs).

```Python
field = dict
json_field = partial(field, json=True)
```

--------------------------------

### Get the First Item of a Sequence

Source: https://funcy.readthedocs.io/en/stable/objects

Returns the first item in a sequence. If the sequence is empty, it returns None.

```python
from funcy import first

my_list = [10, 20, 30]
print(first(my_list))

empty_list = []
print(first(empty_list))
```

--------------------------------

### Get the First Item of a Sequence

Source: https://funcy.readthedocs.io/en/stable/debug

Returns the first item in a sequence. If the sequence is empty, it returns None. Useful for accessing the head of a collection.

```python
first(seq)
```

--------------------------------

### Partial Application

Source: https://funcy.readthedocs.io/en/stable/decorators

Returns a partial application of a function 'func' with given positional and keyword arguments. This means the returned function will be called with these arguments pre-filled.

```python
partial_(func, *args, **kwargs)
```

--------------------------------

### Decorator Utilities

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Includes decorators like `@decorator` to transform wrappers, `@wraps` to pass metadata, and `@unwrap` to get the wrapped object.

```Python
@decorator
...
@wraps
...
unwrap(func)
```

--------------------------------

### Autocurrying Function

Source: https://funcy.readthedocs.io/en/stable/seqs

Creates a version of a function that returns its partial applications until sufficient arguments are passed.

```Python
def autocurry(func):
  """Creates a version of _func_ returning its partial applications until sufficient arguments are passed."""
  pass
```

--------------------------------

### Get Iterator Length

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Consumes an iterator and returns the total number of items it contains. This is useful for iterators where the length is not readily available.

```Python
ilen(seq)
```

--------------------------------

### Funcy: Get Last Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/extended_fns

The `last` function returns the final element of a sequence. It returns `None` if the sequence is empty.

```python
last(seq)
```

--------------------------------

### Take First N Items

Source: https://funcy.readthedocs.io/en/stable/strings

Returns a list containing the first `n` items from a sequence, or all items if the sequence has fewer than `n`.

```python
take(_n, _seq_)
```

--------------------------------

### Funcy: Get First Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/extended_fns

The `first` function returns the initial element of a sequence. If the sequence is empty, it returns `None`.

```python
first(seq)
```

--------------------------------

### Create a real function for partial application

Source: https://funcy.readthedocs.io/en/stable/calc

Provides a robust implementation of partial function application, similar to `functools.partial`, ensuring a true function object is returned.

```python
func_partial(func, *args, **kwargs)
```

--------------------------------

### Get Sequence Except Last Item

Source: https://funcy.readthedocs.io/en/stable/strings

Yields all items in a sequence except for the last one.

```python
butlast(_seq_)
```

--------------------------------

### Get Sequence Except First Item

Source: https://funcy.readthedocs.io/en/stable/strings

Yields all items in a sequence except for the first one.

```python
rest(_seq_)
```

--------------------------------

### Get Last Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Returns the last item of a sequence, or `None` if the sequence is empty.

```python
last(_seq_)
```

--------------------------------

### Construct Form Field Widget with Pattern Matching

Source: https://funcy.readthedocs.io/en/stable/seqs

Uses simple pattern matching to construct a form field widget based on field properties. It iterates through a list of condition-action pairs and applies the first matching condition.

```Python
TYPE_TO_WIDGET = (
    [lambda f: f.choices,           lambda f: Select(choices=f.choices)],
    [lambda f: f.type == 'int',     lambda f: TextInput(coerce=int)],
    [lambda f: f.type == 'string',  lambda f: TextInput()],
    [lambda f: f.type == 'text',    lambda f: Textarea()],
    [lambda f: f.type == 'boolean', lambda f: Checkbox(f.label)],
)
return first(do(field) for cond, do in TYPE_TO_WIDGET if cond(field))
```

--------------------------------

### Fallback Approaches

Source: https://funcy.readthedocs.io/en/stable/strings

Tries several approaches sequentially until one succeeds. Each approach is defined as a (callable, errors) tuple.

```Python
fallback((func1, Exception), (func2, ValueError))
def my_function():
  pass
```

--------------------------------

### Create Dictionary from Keys and Values

Source: https://funcy.readthedocs.io/en/stable/primitives

Creates a dictionary by mapping keys from a `keys` sequence to corresponding values from a `vals` sequence. The `zipdict` function is used for this.

```Python
zipdict(keys, vals)
```

--------------------------------

### Get Sequence Rest with rest()

Source: https://funcy.readthedocs.io/en/stable/flow

The rest() function skips the first item in a sequence and yields the rest of the items.

```python
rest(seq)
```

--------------------------------

### Get Nth Item with nth()

Source: https://funcy.readthedocs.io/en/stable/flow

The nth() function returns the nth item in a sequence, or None if no such item exists.

```python
nth(n, seq)
```

--------------------------------

### Get Last Item with last()

Source: https://funcy.readthedocs.io/en/stable/flow

The last() function returns the last item in a sequence, or None if the sequence is empty.

```python
last(seq)
```

--------------------------------

### Create a dictionary from keys and values in Python

Source: https://funcy.readthedocs.io/en/stable/colls

Creates a dictionary by mapping a sequence of keys to a corresponding sequence of values. The lengths of `keys` and `vals` must be the same.

```Python
zipdict(keys, vals)
```

--------------------------------

### Get First Item with first()

Source: https://funcy.readthedocs.io/en/stable/flow

The first() function returns the first item in a sequence, or None if the sequence is empty.

```python
first(seq)
```

--------------------------------

### Partial Application with Funcy

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Provides `func_partial` which returns a real function, and `partial` for partial application of functions with arguments.

```Python
func_partial(func, *args, **kwargs)
partial(func, *args, **kwargs)
```

--------------------------------

### Get Nth Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Retrieves the item at a specific index (n) in a sequence. Returns None if the index is out of bounds.

```python
nth(n, seq)
```

--------------------------------

### Predicate Creation and Manipulation

Source: https://funcy.readthedocs.io/en/stable/primitives

Funcy provides functions like `re_tester`, `complement`, `all_fn`, `any_fn`, `none_fn`, `one_fn`, and `is_distinct` for creating and combining predicates.

```Python
from funcy import re_tester, complement, all_fn, any_fn, none_fn, one_fn, is_distinct

# Example: re_tester to create a predicate that tests strings with a regex
is_email = re_tester(r'^\S+@\S+\.\S+$')

print(is_email("test@example.com")) # Output: True
print(is_email("invalid-email")) # Output: False

# Example: complement to negate a predicate
is_not_digit = complement(str.isdigit)
print(is_not_digit("a")) # Output: True
print(is_not_digit("5")) # Output: False

# Example: all_fn to check if all predicates are true
all_positive = all_fn(lambda x: x > 0, lambda x: x > 1)
print(all_positive(5)) # Output: True
print(all_positive(0)) # Output: False

# Example: any_fn to check if any predicate is true
any_even = any_fn(lambda x: x % 2 == 0, lambda x: x % 3 == 0)
print(any_even(5)) # Output: False
print(any_even(4)) # Output: True

# Example: none_fn to check if no predicate is true
none_negative = none_fn(lambda x: x < 0)
print(none_negative(5)) # Output: True
print(none_negative(-5)) # Output: False

# Example: one_fn to check if exactly one predicate is true
one_positive = one_fn(lambda x: x > 0, lambda x: x < 0)
print(one_positive(5)) # Output: True
print(one_positive(0)) # Output: False
print(one_positive(-5)) # Output: True

# Example: is_distinct to check if all elements in a collection are distinct
print(is_distinct([1, 2, 3])) # Output: True
print(is_distinct([1, 2, 1])) # Output: False
```

--------------------------------

### Get Second Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

Retrieves the second item from a sequence. Returns None if the sequence has fewer than two items.

```python
second(seq)
```

--------------------------------

### Funcy: Get the last item of a sequence

Source: https://funcy.readthedocs.io/en/stable/calc

Retrieves the last element from a sequence. Returns None if the sequence is empty.

```python
last(seq)
```

--------------------------------

### Funcy Function Creation and Transformation

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

This snippet illustrates function creation and transformation utilities in Funcy. It includes functions for creating new functions, partially applying arguments, composing functions, and creating higher-order functions.

```Python
from funcy import identity, constantly, func_partial, partial, rpartial, iffy, caller, re_finder, re_tester, complement, autocurry, curry, rcurry
```

--------------------------------

### Partition Sequence into Parts

Source: https://funcy.readthedocs.io/en/stable/debug

Partitions a sequence into parts of a specified length 'n'. It skips a certain number of items between parts, and ignores the tail if it doesn't fit. 'lpartition' returns a list.

```python
partition(n, [step, ]seq)
```

```python
lpartition(n, [step, ]seq)
```

--------------------------------

### Funcy: Get the first item of a sequence

Source: https://funcy.readthedocs.io/en/stable/calc

Retrieves the first element from a sequence. Returns None if the sequence is empty.

```python
first(seq)
```

--------------------------------

### Partial Application of Function

Source: https://funcy.readthedocs.io/en/stable/debug

Returns a new function object that is a partial application of the given function `func` with specified arguments and keyword arguments. This simplifies function calls by pre-filling some arguments.

```python
partial(func, *args, **kwargs)
```

--------------------------------

### Cut Prefix from String

Source: https://funcy.readthedocs.io/en/stable/primitives

Cuts a specified prefix from a given string if the string starts with that prefix, using the cut_prefix function.

```Python
cut_prefix _(s, prefix)_
```

--------------------------------

### Partial Application of Function

Source: https://funcy.readthedocs.io/en/stable/seqs

Returns a partial application of a given function 'func' with provided arguments.

```Python
def partial(func, *args, **kwargs):
  """Returns partial application of _func_."""
  pass
```

--------------------------------

### Nested Collection Access with Funcy

Source: https://funcy.readthedocs.io/en/stable/strings

Functions for safely getting, setting, updating, or deleting values at a specified path within nested collections, with options for lax error handling.

```Python
get_in(coll, path, default=None)
Returns a value at path in the given nested collection.
```

```Python
get_lax(coll, path, default=None)
Returns a value at path in the given nested collection.
Ignores `TypeError`s.
```

```Python
set_in(coll, path, value)
Creates a copy of coll with the value set at path.
```

```Python
update_in(coll, path, update, default=None)
Creates a copy of coll with a value updated at path.
```

```Python
del_in(coll, path)
Creates a copy of coll with path removed.
```

```Python
has_path(coll, path)
Tests whether path exists in a nested coll.
```

--------------------------------

### Funcy: Infinite Iterator with count

Source: https://funcy.readthedocs.io/en/stable/calc

Creates an infinite iterator that yields values starting from a specified number and incrementing by a step.

```python
count(start=0, step=1)
```

--------------------------------

### Try several approaches until one works

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

The `fallback` function takes a list of approaches, where each approach is a tuple of `(callable, errors)`. It tries each callable in order, catching specified errors, until one approach succeeds without raising an error.

```Python
from funcy import fallback
```

--------------------------------

### Logging and Timing Utilities

Source: https://funcy.readthedocs.io/en/stable/debug

Decorators and functions for logging function calls, arguments, results, exceptions, and execution durations. Includes options for printing or custom logging functions and timing iterables.

```Python
tap(x, label=None)

Prints x and then returns it.
```

```Python
@log_calls(print_func, errors=True, stack=True)
@print_calls(errors=True, stack=True)

Logs or prints all function calls, including arguments, results and raised exceptions.
```

```Python
@log_enters(print_func)
@print_enters

Logs or prints on each enter to a function.
```

```Python
@log_exits(print_func, errors=True, stack=True)
@print_exits(errors=True, stack=True)

Logs or prints on each exit from a function.
```

```Python
@log_errors(print_func, label=None, stack=True)
@print_errors(label=None, stack=True)

Logs or prints all errors within a function or block.
```

```Python
@log_durations(print_func, label=None)
@print_durations(label=None)

Times each function call or block execution.
```

```Python
log_iter_durations(seq, print_func, label=None)
print_iter_durations(seq, label=None)

Times processing of each item in seq.
```

--------------------------------

### Get the last item of a sequence

Source: https://funcy.readthedocs.io/en/stable/seqs

The `last` function returns the last item of a sequence. If the sequence is empty, it returns `None`.

```Python
last(_seq_)
```

--------------------------------

### Create a function with partial application

Source: https://funcy.readthedocs.io/en/stable/cheatsheet

The `func_partial` function is similar to Python's built-in `functools.partial` but returns a real function object. It allows you to pre-fill some arguments of a function, creating a new function with a reduced signature.

```Python
from functools import partial as func_partial
```

--------------------------------

### Create Chunks from Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Divides a sequence into chunks of a specified size `n`, with an optional `step`.

```python
chunks(_n,[_step, ]_seq)_
```

--------------------------------

### Get the first item of a sequence

Source: https://funcy.readthedocs.io/en/stable/seqs

The `first` function returns the first item of a sequence. If the sequence is empty, it returns `None`.

```Python
first(_seq_)
```

--------------------------------

### Create dictionary from keys and values

Source: https://funcy.readthedocs.io/en/stable/calc

Constructs a dictionary by mapping elements from a `keys` sequence to corresponding elements in a `vals` sequence. Requires both sequences to have the same length.

```python
zipdict(keys, vals)
```

--------------------------------

### Get the Nth Item of a Sequence

Source: https://funcy.readthedocs.io/en/stable/objects

Returns the item at the specified index (n) in a sequence. Returns None if the index is out of bounds.

```python
from funcy import nth

my_list = [10, 20, 30, 40]
print(nth(2, my_list))  # Get the item at index 2
print(nth(5, my_list))  # Index out of bounds
```

--------------------------------

### Get the Second Item of a Sequence

Source: https://funcy.readthedocs.io/en/stable/objects

Returns the second item in a sequence. Returns None if the sequence has fewer than two items.

```python
from funcy import second

my_list = [10, 20, 30]
print(second(my_list))

short_list = [10]
print(second(short_list))

empty_list = []
print(second(empty_list))
```

--------------------------------

### Create a real partial function

Source: https://funcy.readthedocs.io/en/stable/funcs

Creates a new function that is a partial application of the given function 'func' with specified positional and keyword arguments. Unlike functools.partial, this returns a true function object.

```Python
func_partial(func, *args, **kwargs)
```

--------------------------------

### Get Nth Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Returns the item at the specified index `n` in a sequence, or `None` if the index is out of bounds.

```python
nth(_n, _seq_)
```

--------------------------------

### Fallback Approaches

Source: https://funcy.readthedocs.io/en/stable/seqs

Tries several approaches sequentially until one succeeds. Each approach is defined as a (callable, errors) tuple.

```Python
fallback((func1, Exception), (func2, ValueError))
def my_function():
  pass
```

--------------------------------

### Get Second Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/strings

Returns the second item of a sequence, or `None` if the sequence has fewer than two items.

```python
second(_seq_)
```

--------------------------------

### Empty Collection Creation with Funcy

Source: https://funcy.readthedocs.io/en/stable/strings

A function to create an empty collection of the same type as a given input collection.

```Python
empty(coll)
Returns an empty collection of the same type as coll.
```

--------------------------------

### Split Sequence at Position with split_at()

Source: https://funcy.readthedocs.io/en/stable/flow

The split_at() and lsplit_at() functions split a sequence at a given position, returning a tuple of its start and tail.

```python
split_at(n, seq)
lsplit_at(n, seq)
```

--------------------------------

### Print and Return Value

Source: https://funcy.readthedocs.io/en/stable/objects

Prints a given value `x` to standard output and then returns `x`. Optionally, a label can be provided for context.

```Python
tap(x, label=None)
```

--------------------------------

### Create Predicates with all_fn, any_fn, none_fn, one_fn

Source: https://funcy.readthedocs.io/en/stable/funcs

These functions construct predicates that return True based on the results of applying a list of functions to an input. They support short-circuiting behavior for efficiency.

```python
is_public = complement(r'^_')

all_fn(_* fs_)
any_fn(_* fs_)
none_fn(_* fs_)
one_fn(_* fs_)

is_even_int = all_fn(isa(int), even)
```

--------------------------------

### Iterate and Reduce Sequences with Funcy

Source: https://funcy.readthedocs.io/en/stable/seqs

Functions for consuming iterators to get their length, and for constructing intermediate reductions or partial sums of sequences.

```Python
ilen(seq)
Consumes the given iterator and returns its length.
```

```Python
reductions(f, seq[, acc])
Constructs intermediate reductions of seq by f.
```

```Python
lreductions(f, seq[, acc])
Constructs intermediate reductions of seq by f.
```

```Python
sums(seq[, acc])
Returns a sequence of partial sums of seq.
```

```Python
lsums(seq[, acc])
Returns a sequence of partial sums of seq.
```

--------------------------------

### Get Empty Collection of Same Type

Source: https://funcy.readthedocs.io/en/stable/primitives

Returns an empty collection that has the same type as the input collection `coll`. The `empty` function provides this utility.

```Python
empty(coll)
```

--------------------------------

### Create Dictionary from Keys and Values

Source: https://funcy.readthedocs.io/en/stable/extended_fns

Creates a dictionary by mapping elements from a `keys` sequence to corresponding elements in a `vals` sequence. The length of `keys` and `vals` must be the same.

```Python
zipdict(keys, vals)
```

--------------------------------

### Funcy: Get Nth Item of Sequence

Source: https://funcy.readthedocs.io/en/stable/extended_fns

The `nth` function accesses the item at a specific index `n` within a sequence. It returns `None` if the index is out of bounds.

```python
nth(n, seq)
```
Tokens:
Raw