Do you see a way these proposals can work together? I believe they are
solving different needs. Both proposals produce a new anonymous function,
but partial application deals with currying, while the placeholder proposal
tries to prevent writing a function at all. I can actually see the two
working together:

```js
const filenames = ['file1.txt', 'file2.txt' 'output.log' ]
const fileContainsContent = (filename, content) =>
fs.readFileSync(filename).toString().includes(content)

const fileSearchers = filenames.map(fileContainsContent(*, ?))
const filesContainingSearch = fileSearchers.filter(searcher =>
searcher('foobar'))
```

This isn't a very useful example, but you can see how the proposals differ
accomplish different things

On Wed, Nov 28, 2018 at 1:30 PM Jordan Harband <ljharb at gmail.com> wrote:

> You may be interested in the partial application proposal:
> https://github.com/tc39/proposal-partial-application
>
> On Wed, Nov 28, 2018 at 10:17 AM Andrew Kaiser <kaisea.rpi at gmail.com>
> wrote:
>
>> Hi all,
>>
>> I have created a short proposal to introduce syntactic sugar for
>> anonymous functions in a 'scala-like' manner, linked here
>> https://github.com/andykais/proposal-placeholder-syntax.
>>
>> I am hoping to hear feedback on whether or not this is interesting to
>> people, as well as feedback on the proposal itself (e.g. is there a better
>> operator to use than ` * `)
>> _______________________________________________
>> es-discuss mailing list
>> es-discuss at mozilla.org
>> https://mail.mozilla.org/listinfo/es-discuss
>>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://mail.mozilla.org/pipermail/es-discuss/attachments/20181128/44bc7e1e/attachment.html>

Do you see a way these proposals can work together? I believe they are
solving different needs. Both proposals produce a new anonymous function,
but partial application deals with currying, while the placeholder proposal
tries to prevent writing a function at all. I can actually see the two
working together:

```js
const filenames = ['file1.txt', 'file2.txt' 'output.log' ]
const fileContainsContent = (filename, content) =>
  fs.readFileSync(filename).toString().includes(content)

const fileSearchers = filenames.map(fileContainsContent(*, ?))
const filesContainingSearch = fileSearchers.filter(searcher =>
  searcher('foobar'))
```

This isn't a very useful example, but you can see how the proposals
accomplish different things

Do you see a way these proposals can work together? I believe they are
solving different needs. Both proposals produce a new anonymous function,
but partial application deals with currying, while the placeholder proposal
tries to prevent writing a function at all. I can actually see the two
working together:

```js
const filenames = ['file1.txt', 'file2.txt' 'output.log' ]
const fileContainsContent = (filename, content) => fs.readFileSync(filename).toString().includes(content)

const fileSearchers = filenames.map(fileContainsContent(*, ?))
const filesContainingSearch = fileSearchers.filter(searcher => searcher('foobar'))
```

This isn't a very useful example, but you can see how the proposals
accomplish different things

Do you see a way these proposals can work together? I believe they are
solving different needs. Both proposals produce a new anonymous function,
but partial application deals with currying, while the placeholder proposal
tries to prevent writing a function at all. I can actually see the two
working together:

```js
const filenames = ['file1.txt', 'file2.txt' 'output.log' ]
const fileContainsContent = (filename, content) =>

fs.readFileSync(filename).toString().includes(content)

const fileSearchers = filenames.map(fileContainsContent(*, ?))
const filesContainingSearch = fileSearchers.filter(searcher => searcher('foobar'))
```

This isn't a very useful example, but you can see how the proposals
accomplish different things