Adding the operators counterpart

[RuiAAPeres]

Small intro, before getting to the point:

From some of tweets @stephencelis sent and the overall idea of this library, is to make FP more accessible. There is also this tweet:

If our Prelude library seems a lil too intense with all of its custom operators, then perhaps its Overture is more your tune!

— Point-Free (@pointfreeco) April 9, 2018

There is indeed a big difference between them, both in terms of size, but also necessary knowledge to use one over the other.

What I propose is to provide the operators counterparts of these functions (e.g. pipe, composition). When an Overture user feels confident about using operators, he/she can still use Overture to make that switch, instead of importing Prelude.

In my particular case, I use a very small subset of what Prelude provides, so Overture actually makes sense for my use case. Not having operators, is upsetting.

What do you think?

[stephencelis]

We're definitely interested in closing the gap here. Prelude's been our fast/loose space to experiment, whereas Overture currently represents an introductory culmination of some core concepts. One vision of the future from here. I think we'd like to refine/simplify Prelude to the point where it's just a combination of Overture and an operator module. Something like:

@_exported import Overture
@_exported import Opera

It might take awhile to get there, though. In the meantime, having an extra module in here that just defines the operators could work. Then it's a matter of changing import Overture to import Opera. @mbrandonw and I will have to discuss.

[RuiAAPeres]

I might be missing something, but what's Opera?

[stephencelis]

Ah, sorry to be confusing! That's just a theoretical name for a module that provides symbol operators 😄

[RuiAAPeres]

I see! 😅 In any case, for now, I will provide my own operators on top of Overture then.

[stephencelis]

Going to move to a discussion for any further...discussion. Thanks Rui! 👁️‍🗨️

[RoBo-Inc]

So where is the Opera? 🥺🥺🥺

[randomeizer]

For anyone interested in operators for the current swift-overture package, I've added swift-rhapsody, which is a drop-in replacement for Overture (it exports Overture 0.5.0) and adds some initial operators for common functions defined therein.

You can check out the tests for some examples.

Because I'm re-exporting Overture, you can take the following:

import Overture

let inc: (Int) -> Int = { $0 + 1 }
let double: (Int) -> Int = { $0 * 2 }
let incAndDouble = pipe(inc, double)

and turn it into this:

import Rhapsody

let inc: (Int) -> Int = { $0 + 1 }
let double: (Int) -> Int = { $0 * 2 }
let incAndDouble = inc >>> double

You can still use any Overture functions like pipe directly, but also switch to operators when you wish.