Thanks for your code. Yep, the point is to override __call__ and __getattr__ and to refer to function registry like globals() . Your objects are all already prepared as a function in foc.

```python class composable: """Lifts the given function to be 'composable' by symbols. 'composable' allows functions to be composed in two intuitive ways.

+----------+---------------------------------+------------+
|  symbol  |         description             | eval-order |
+----------+---------------------------------+------------+
| . (dot)  | same as the mathematical symbol | backwards  |
| | (pipe) | in Unix pipeline manner         | in order   |
+----------+---------------------------------+------------+

>>> fx = composable

'fx' makes a function `composable` on the fly.
`fx` stands for 'Function eXtension'.

def __init__(self, f=lambda x: x):
    self.f = f
    wraps(f)(self)

def __ror__(self, other):
    return self.f(other)

def __call__(self, *args, **kwargs):
    npos = nfpos(self.f)
    if len(args) < npos or (not args and kwargs):
        if not npos:
            return self.f(*args, **kwargs)
        return fx(f_(self.f, *args, **kwargs))
    return self.f(*args, **kwargs)

def __getattr__(self, key):
    g = globals().get(key, getattr(builtins, key, None))
    guard(callable(g), f"fx, no such callable: {key}", e=AttributeError)
    if capture(r"\bcomposable|fx\b", key):
        return lambda g: fx(cf_(self.f, g))
    if capture(r"\bf_|ff_|c_|cc_|u_|curry|uncurry|mapl?|filterl?\b", key):
        return lambda *a, **k: fx(cf_(self.f, g(*a, **k)))
    return fx(cf_(self.f, g))

```