Path: csiph.com!v102.xanadu-bbs.net!xanadu-bbs.net!feeder.erje.net!eu.feeder.erje.net!newsfeed.xs4all.nl!newsfeed3.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
Date: Tue, 20 Aug 2013 00:49:16 +0100
Subject: Is this PEP-able? (syntax for functools.partial-like functionality)
From: =?ISO-8859-1?Q?F=E1bio_Santos?= <fabiosantosart@gmail.com>
To: python-list@python.org
Content-Type: multipart/alternative; boundary=001a11c252c69c061004e4559623
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.43.1376956165.19984.python-list@python.org>
Lines: 124
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:52709

--001a11c252c69c061004e4559623
Content-Type: text/plain; charset=ISO-8859-1

I had an idea for a handy syntax which I thought of while designing a
language for fun. This would be a syntax for creating, from a function, a
function which is just like it but with some parameters pre-filled. The
usage is much like functools.partials, and my proposed syntax is like this:

def spam(a, b, c):
    ...

spam_with_defaults = spam{1, 2}

Now calling spam_with_defaults is just like calling spam, but it only needs
one argument since a and b were set to 1 and 2, respectively.

spam_with_defaults(3)  # same as calling spam(1, 2, 3)

This would also work with keyword arguments, E.G. spam{c=3} would return a
callable which would only need the arguments a and b.

This is just the plain old functools.partial functionality, but of course I
won't stop here. Still on our spam function:

spam_require_b = spam{2, *, 3}
spam_require_ab = spam{*, 3}

spam_require_a(1)  # same as spam(1, 2, 3)
spam_require_ab(1, 2)  # same as above

The * sign means that the function takes positional arguments which will be
added in place of the star. This is how we would do spam_require_b in pure
python:

def spam_require_b(*args, **kwargs):
    return spam(*([1] + args + [2]), **kwargs)

Or, since we know it's only one argument,

spam_require_b = lambda b: spam(1, b, 3)

I also propose unpacking:

spam_unpacking = spam{1, (*, *)}
c = map(spam_unpacking, some_dict.items())

(Although this syntax isn't final), and receiving specific keyword
arguments.

spam_kw = spam{a, b, c=*}

The use cases this is intended to serve are mostly iteration related. There
is the case for being good plumbing for functions such as map, sorted,
filter and itertools.takewhile.

lines = filter(str.startswith{*, '#'}, open('file.cfg'))
lines = filter(bool, map(str.strip, lines))
config = dict(map(str.split{*, '=', 1}, lines))

A secondary use case is the creation of aliases.

def baz(self, callback):
    respond = callback{instance=self}
    ...

What do you think?

PS: yes, I realized that I am proposing the addition of braces to the
language syntax.

--001a11c252c69c061004e4559623
Content-Type: text/html; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable

<p dir=3D"ltr">I had an idea for a handy syntax which I thought of while de=
signing a language for fun. This would be a syntax for creating, from a fun=
ction, a function which is just like it but with some parameters pre-filled=
. The usage is much like functools.partials, and my proposed syntax is like=
 this:</p>

<p dir=3D"ltr">def spam(a, b, c):<br>
=A0=A0=A0 ...</p>
<p dir=3D"ltr">spam_with_defaults =3D spam{1, 2}</p>
<p dir=3D"ltr">Now calling spam_with_defaults is just like calling spam, bu=
t it only needs one argument since a and b were set to 1 and 2, respectivel=
y.</p>
<p dir=3D"ltr">spam_with_defaults(3)=A0 # same as calling spam(1, 2, 3)</p>
<p dir=3D"ltr">This would also work with keyword arguments, E.G. spam{c=3D3=
} would return a callable which would only need the arguments a and b.</p>
<p dir=3D"ltr">This is just the plain old functools.partial functionality, =
but of course I won&#39;t stop here. Still on our spam function:</p>
<p dir=3D"ltr">spam_require_b =3D spam{2, *, 3}<br>
spam_require_ab =3D spam{*, 3}</p>
<p dir=3D"ltr">spam_require_a(1)=A0 # same as spam(1, 2, 3)<br>
spam_require_ab(1, 2)=A0 # same as above</p>
<p dir=3D"ltr">The * sign means that the function takes positional argument=
s which will be added in place of the star. This is how we would do spam_re=
quire_b in pure python:</p>
<p dir=3D"ltr">def spam_require_b(*args, **kwargs):<br>
=A0=A0=A0 return spam(*([1] + args + [2]), **kwargs)</p>
<p dir=3D"ltr">Or, since we know it&#39;s only one argument,</p>
<p dir=3D"ltr">spam_require_b =3D lambda b: spam(1, b, 3)</p>
<p dir=3D"ltr">I also propose unpacking:</p>
<p dir=3D"ltr">spam_unpacking =3D spam{1, (*, *)}<br>
c =3D map(spam_unpacking, some_dict.items())</p>
<p dir=3D"ltr">(Although this syntax isn&#39;t final), and receiving specif=
ic keyword arguments.</p>
<p dir=3D"ltr">spam_kw =3D spam{a, b, c=3D*}</p>
<p dir=3D"ltr">The use cases this is intended to serve are mostly iteration=
 related. There is the case for being good plumbing for functions such as m=
ap, sorted, filter and itertools.takewhile.</p>
<p dir=3D"ltr">lines =3D filter(str.startswith{*, &#39;#&#39;}, open(&#39;f=
ile.cfg&#39;))<br>
lines =3D filter(bool, map(str.strip, lines))<br>
config =3D dict(map(str.split{*, &#39;=3D&#39;, 1}, lines))</p>
<p dir=3D"ltr">A secondary use case is the creation of aliases.</p>
<p dir=3D"ltr">def baz(self, callback):<br>
=A0=A0=A0 respond =3D callback{instance=3Dself}<br>
=A0=A0=A0 ...</p>
<p dir=3D"ltr">What do you think?</p>
<p dir=3D"ltr">PS: yes, I realized that I am proposing the addition of brac=
es to the language syntax.</p>

--001a11c252c69c061004e4559623--