Question

When declaring a block what’s the rationale behind using this syntax (i.e. surrounding brackets and caret on the left)?

(^myBlock) 

For example:

int (^myBlock)(int) = ^(int num) {
    return num * multiplier;
};

Answer 1

C BLOCKS: Syntax and Usage

Variables pointing to blocks take on the exact same syntax as variables pointing to functions, except * is substituted for ^. For example, this is a function pointer to a function taking an int and returning a float:

float (*myfuncptr)(int);

and this is a block pointer to a block taking an int and returning a float:

float (^myblockptr)(int);

As with function pointers, you’ll likely want to typedef those types, as it can get relatively hairy otherwise. For example, a pointer to a block returning a block taking a block would be something like void (^(^myblockptr)(void (^)()))();, which is nigh impossible to read. A simple typedef later, and it’s much simpler:

typedef void (^Block)();
Block (^myblockptr)(Block);

Declaring blocks themselves is where we get into the unknown, as it doesn’t really look like C, although they resemble function declarations. Let’s start with the basics:

myvar1 = ^ returntype (type arg1, type arg2, and so on) {
    block contents;
    like in a function;
    return returnvalue;
};

This defines a block literal (from after = to and including }), explicitly mentions its return type, an argument list, the block body, a return statement, and assigns this literal to the variable myvar1.

A literal is a value that can be built at compile-time. An integer literal (The 3 in int a = 3;) and a string literal (The “foobar” in const char *b = “foobar”;) are other examples of literals. The fact that a block declaration is a literal is important later when we get into memory management.

Finding a return statement in a block like this is vexing to some. Does it return from the enclosing function, you may ask? No, it returns a value that can be used by the caller of the block. See ‘Calling blocks’. Note: If the block has multiple return statements, they must return the same type.

Finally, some parts of a block declaration are optional. These are:

• The argument list. If the block takes no arguments, the argument list can be skipped entirely.

Examples:

myblock1 = ^ int (void) { return 3; }; // may be written as:
myblock2 = ^ int { return 3; }

• The return type. If the block has no return statement, void is assumed. If the block has a return statement, the return type is inferred from it. This means you can almost always just skip the return type from the declaration, except in cases where it might be ambiguous.

Examples:

myblock3 = ^ void { printf("Hello.\n"); }; // may be written as:
myblock4 = ^ { printf("Hello.\n"); };

// Both succeed ONLY if myblock5 and myblock6 are of type int(^)(void)
myblock5 = ^ int { return 3; }; // can be written as:
myblock6 = ^ { return 3; };

source: http://thirdcog.eu/pwcblocks/