On Sat, Feb 08, 2014 at 11:55:56AM -0600, Ron Adam wrote:

What if these *calls* were equivalent...

S(x, y, z) == S(x)(y)(z)

If you want Haskell, you know where to find it :-) http://www.haskell.org/haskellwiki/Currying But seriously, I think that is a perfectly fine design decision for a functional language like Haskell, but it's one which would be awful for a multi-paradigm language like Python which is aimed at a more general programming audience. That means you would never again get an explicit TypeError from leaving out a mandatory argument[1], since *no* arguments are mandatory, you'd just get a mysterious partial application object. When a beginner, or Java programmer, writes: result = getattr(obj) # Oops, forgot the attribute name. # much later on... print(result + 1) I wouldn't like to be the one to explain the eventual error they get. Or worse, they do this: method = getattr(obj) # Oops, forgot the method name. result = method(some_string) which is likely to mysteriously succeed for some strings, and fail for others. I think that for Python, having to explicitly perform partial application is a good thing. [1] With the possible exception of not providing any arguments at all. -- Steven

On Sat, Feb 8, 2014 at 4:41 PM, Ron Adam wrote:

On 02/08/2014 11:55 AM, Ron Adam wrote:

...

On 02/06/2014 05:14 AM, Nick Coghlan wrote:> On 6 February 2014 20:34, Ron Adam wrote:

Hmmm... Could the @ syntax be generalised in this case?

...

@foo(func) Partial waiting for rest...

Then the more general case...

a_op = @foo(op) # Partial waiting for rest. a_x = @a_op(x) a = a_x(y)

That would be cool, unifies decorators and partials with decorator syntax!

I think it's even back-words compatible if you allow this equivalency.

def foo(x, y): ...

@foo(x, y) == foo(x, y) # An identity partial

And the decorator case becomes...

@partial def func(): ...

And we get this equivalency as well....

@partial == partial # I think this could work.

The reason these things are interesting to me is that, I've been thinking about the order of function arguments and if there could be some generalised concepts that can be applied to that problem. Being able to use normal functions effectively in these ways, (with partials, and continuations), is related to the order of the arguments and how they are commonly used.

Here's a rough python version... It currently gets tripped up on optional arguments, but it does work for non optional cases.

I think a builtin, along with the new signatures capabilities could fix those cases.

(and to address Stevens conserns.. It would be explicit and won't effect the beginner cases if you don't use the @...

In this example I'm using P. And a builtin function could work just as well. Although I would like the @ syntax to just work without the function.

It's just a first attempt, with probably a lot of issues to be handled still, but it does show it's doable.

Cheers, Ron

#-------------------------------

# A builtin could do this much better. class P: def __init__(self, f, *args, **kwds): self.f = f self.args = args self.kwds = kwds def __call__(self, *args, **kwds): args = list(self.args) + list(args) kwds.update(self.kwds) try: return self.f(*args, **kwds) except TypeError: return self.__class__(self.f, *args, **kwds)

# This the easy way to write decorators!!! :-) @P def deco(f, *args): print("Got: ", args) return f(*args)

# And a partial function example with it. :-) @P @deco def foo(x, y, z): return x + y + z

print(foo(1, 2, 3)) print(foo(1, 2)(3)) print(foo(1)(2)(3)) #-------------------------

The output...

ra:~ >python3 partial_deco.py Got: () Got: (1, 2, 3) 6 Got: (1, 2) Got: (1, 2, 3) 6 Got: (1,) Got: (1, 2) Got: (1, 2, 3)

6

I experimented with something similar over at https://github.com/sigmavirus24/curryer but never released it. It's fairly well tested but I'm not sure I'd use it for anything other than a toy.

That got de-indented.... so here it is again... :-/ """ ### NOTE: NOT FULLY TESTED!!! Especially with keywords. A PARTIAL PROTOCOL: Takes partial number of args and applies them to a callable. Calls the callable when all it's functions are present, else returns an updated partial object. THE RULES: * A partial is equivalent to the sum of it's partials. P(f, a, b, c) == P(f)(a)(b)(c) * A complete partial is equivalent to the function f When all the parts are provided. P(f, a, b, c) == f(a, b, c) * If f takes no arguments. (same rule) P(f) == f() * And empty partial evaluates to a partial. P() == P * If f requires at least one (not provided) argument. P(f)() == P(f) P()(f) == P(f) ERROR CASES: P(1)() # P(1) --> 1, 1 is not a callable. (* probably more) CONTROLS: It's possible to add controls for both the number of args, and number of Partial calls. Author: Ronald Adam (ron3200@gmail.com) """ class CollectMore: """ Collect more args and keywords. """ def __init__(self, f, *args, **kwds): self.f = f self.args = list(args) self.kwds = kwds def __call__(self, *args, **kwds): args = self.args + list(args) self.kwds.update(kwds) return self.f(*args, **self.kwds) def P(*args, **kwds): """ P - Partial function """ if len(args) == len(kwds) == 0: return P if len(args) > 0: f = args[0] if callable(f): a = args[1:] try: # No required args needed. # or all required args present. return f(*a, **kwds) except TypeError: # Better way to do this? pass elif len(args) == 1 and len(kwds) == 0: return f return CollectMore(P, *args, **kwds) # The implementation above also makes the functions that # use partial decorators become partials too. To avoid # that you can use an N-partial (vs impartial) partial # decorator. @P def NP(n, f, *args, **kwds): """ NP - N-Partial function Example: # Pass only 3 arguments for foo. @NP(3) def foo(*args): return args """ print("NP", n, f, *args, **kwds) if len(args) == 0: raise TypeError # Ready for rest, Partial catches this. elif len(args) < n: raise ValueError("%s is partial to %s values" % (f.__name__, n)) elif len(args) > n: raise ValueError("%s is partial to %s values" % (f.__name__, n)) else: return f(*args, **kwds)