What Is the Property Block Declaration Equivalent in Swift of the Following Block Property

What is the property block declaration equivalent in swift of the following block property?

The corresponding closure property would be declared as

class MyClass {
     var completion : ((MyObject) -> Void)? // or ...! for an implicitly unwrapped optional
}

You can set the property like

completion = {
    (obj : MyObject) -> Void in
    // do something with obj ...
}

which can be shortened (due to the automatic type inference) to

completion = {
    obj in
    // do something with obj ...
}

swift : Closure declaration as like block declaration

The syntax for function types is (in) -> out.

typealias CompletionBlock = (NSString?) -> Void
// or
typealias CompletionBlock = (result: NSData?, error: NSError?) -> Void

var completion: CompletionBlock = { reason in print(reason) }
var completion: CompletionBlock = { result, error in print(error) }

Note that the parentheses around the input type are only required as of Swift 3+.

swift : Closure declaration as like block declaration

The syntax for function types is (in) -> out.

typealias CompletionBlock = (NSString?) -> Void
// or
typealias CompletionBlock = (result: NSData?, error: NSError?) -> Void

var completion: CompletionBlock = { reason in print(reason) }
var completion: CompletionBlock = { result, error in print(error) }

Note that the parentheses around the input type are only required as of Swift 3+.

Can I use Objective-C blocks as properties?

@property (nonatomic, copy) void (^simpleBlock)(void);
@property (nonatomic, copy) BOOL (^blockWithParamter)(NSString *input);

If you are going to be repeating the same block in several places use a type def

typedef void(^MyCompletionBlock)(BOOL success, NSError *error);
@property (nonatomic) MyCompletionBlock completion;

How to implement block property of Objective C category

It isn't clear what you are trying to do. Are you trying to implement a map type function on NSArray? If so, then there is no need for an @property, which would imply that you are storing something associated with they instance. You probably just want a method:

typedef id __nullable (^bt_MapBlockT)(id __nonnull);
- (NSArray *)bt_map:(bt_MapBlockT) block;
// written in browser... probably hosed the syntax slightly.

There are a slew of examples floating about that implement map-reduce-filter-whatever on NSArray, btw.

How to declare a block with arguments in swift?

The equivalent of Objective-C blocks are swift closures, so it would go as follows

{ (user: PFUser, error: NSError) in
  if (!user) {
    println("Uh oh. The user cancelled the Facebook login.");
  } else if (user.isNew) {
    println("User signed up and logged in through Facebook!");
  } else {
    println("User logged in through Facebook!");
  }
}

Swift let computed property to Objective C syntax

This is not a computed property. This is a “closure”.

So this defines a type alias for a closure that takes a Float as a parameter and returns a Float:

typealias Signal = (Float) -> (Float)

You can create an instance of this Signal closure like so:

let doubler: Signal = { $0 * 2 }

And you can call that closure like so:

print(doubler(21))     // 42

---

The equivalent Objective-C syntax to define the type for a “block”:

typedef float (^Signal)(float);

To create an instance of a Signal block:

Signal doubler = ^(float input) {
    return input * 2;
};

And to call it:

NSLog(@"%f", doubler(21));   // 42

Objective C callbacks with blocks

In Objective-C, that would look something like:

touchableObject.touched = ^(id o) { /* handler code */ };

Assuming touched is a property of an appropiate block type. If you re-use a block type (think of Func in C#), it makes sense to typedef it, since a block declaration in ObjC tends to become difficult to read very quickly.

The block syntax gets some time to get used to in Objective-C when you are coming from another language with slightly more elegant block/lambda syntax. To learn and as a reference, see this previous answer, which has helped me a lot.

To typedef a type for touched, you would use something like:

typedef void (^Handler)(id parameter);

Then simply declare the touched property as type handler.

Assigning a swift closure (block equivalent) to an existing objective-c block being accessed using a bridge

All pointers to objects in objective-C must be Optional in swift because a pointer can be nil. If you know that the variable will never actually be nil, you should use Implicitly Unwrapped Optionals (TypeName!) so that you don't have to unwrap it.

So

void(^performBlock)( UIStoryboardSegue* segue, UIViewController* svc, UIViewController* dvc )

becomes:

{(segue : UIStoryboardSegue!, svc : UIViewController!, dvc : UIViewController!) in
    // Implementation
}

If the variable might be nil, you should use a normal Optional which would look like this:

{(segue : UIStoryboardSegue?, svc : UIViewController?, dvc : UIViewController?) in
    // Implementation
}

And actually, if you are assigning it to that property, you don't even have to specify the types (they are inferred):

{(segue, svc, dvc) in
    // Implementation
}

---

Related Topics