Swift - how to create custom operators to use in other modules?

Question

I created a sample project and a framework next to it. The framework is called "SampleFramework". Then I created a custom operator in SampleFramework. Here is what it looks like:

infix operator >>= {associativity left} public func >>=<A, B>(a: A?, f: A -> B?) -> B? {     if let a = a { return f(a) }     else { return .None } } 

Then I wanted to use it my main application. I imported the SampleFramework to my source file and then I wrote this code to test it:

NSURL(string: "www.google.com") >>= { println("\($0)") } 

It didn't compile. Here is Xcode's error message:

Ambiguous operator declarations found for operator. Operator is not a known binary operator

Answer 1

I can confirm that that what you are seeing is what really happens. I just tried it myself and I've seen the same result.

My opinion is that >>= is somehow conflicting with some other operator (probably the bite shift operator: >>) or is being declared somewhere else too (you can see why I think that here). I did successfully declared custom operators in a framework and used those in the main app code before (you can see that here for example).

What I would suggest is rename your custom operator to something else. When I did that (renamed the custom operator to >>>=) the compiler stopped complaining and my app compiled just fine.

Later edit

Ok. So this might help a bit more. Basically when an operator is already declared and you want to add extra functionality to that operator (for example doing things like 3 * "Hello" like Johan Kool said he wanted to) all you have to do is overload that operator's method.

Basically, in your specific case I am now 100% that >>= is an already declared operator and you can go ahead and just add these lines in your framework:

public func >>=<A, B>(a: A?, f: A -> B?) -> B? {     if let a = a { return f(a) }     else { return .None } } 

This will make your operator work. BUT it will inherit the precedence and associativity of the original operator thus giving you less control over how it's supposed to behave.