What Does <> (Angle Brackets) Do on Class Names in Swift

const process = (str) => {

  let openCount = 0;

  let additionalLeadingOpenTags = 0;

  for (const char of str) {

    if (char === '>') {

      if (openCount === 0) {

        additionalLeadingOpenTags++;

      } else {

        openCount--;

      }

    } else {

      openCount++;

    }

  }

  return '<'.repeat(additionalLeadingOpenTags) + str + '>'.repeat(openCount);

};


console.log('Input 1: ><<><');


result = process('><<><');


console.log('Output 1: ' + result);

console.log('Expected Output 1: ' + '<><<><>>');


console.log('Input 2: <><<');


result = process('<><<');


console.log('Output 2: ' + result);


console.log('Expected Output 2: ' + '<><<>>');


console.log('Input 3: <><<<>');


result = process('<><<<>');


console.log('Output 3: ' + result);


console.log('Expected Output 3: ' + '<><<<>>>');


console.log('Input 4: <><<<><');


result = process('<><<<><');


console.log('Output 4: ' + result);


console.log('Expected Output 4: ' + '<><<<><>>>');


console.log('Input 5: ><<>');


result = process('><<>');


console.log('Output 5: ' + result);


console.log('Expected Output 5: ' + '<><<>>');


console.log('Input 6: ><<<');


result = process('><<<');


console.log('Output 6: ' + result);


console.log('Expected Output 6: ' + '<><<<>>>');

What are the angle brackets … in an Obj-C class interface for?

The angle brackets in a class interface definition indicates the protocols that your class is conforming to.

A protocol is almost like an interface in Java or C#, with the addition that methods in an Objective-C protocol can be optional.

Additionaly in Objective-C you can declare a variable, argument or instance variable to conform to several protocols as well. Example

NSObject<NSCoding, UITableViewDelegate> *myVariable;

In this case the class must be NSObject or a subclass (only NSProxy and its subclasses would fail), and it must also conform to both NSCoding and UITableViewDelegate protocols.

In Java or C# this would only be possible by actually declaring said class.

Difference between angle bracket and double quotes while including header files in C++?

It's compiler dependent. That said, in general using " prioritizes headers in the current working directory over system headers. <> usually is used for system headers. From to the specification (Section 6.10.2):

A preprocessing directive of the form

  # include <h-char-sequence> new-line

searches a sequence of implementation-defined places for a header identified uniquely by the specified sequence between the < and > delimiters, and causes the replacement of that directive by the entire contents of the header. How the places are specified or the header identified is implementation-defined.

A preprocessing directive of the form

  # include "q-char-sequence" new-line

causes the replacement of that directive by the entire contents of the source file identified by the specified sequence between the " delimiters. The named source file is searched for in an implementation-defined manner. If this search is not supported, or if the search fails, the directive is reprocessed as if it read

  # include <h-char-sequence> new-line

with the identical contained sequence (including > characters, if any) from the original
directive.

So on most compilers, using the "" first checks your local directory, and if it doesn't find a match then moves on to check the system paths. Using <> starts the search with system headers.

Syntax explanation: square brackets in Swift

Ok, this is the meaning of

var treasures: [Treasure] = []

• var: you are declaring a variable
• treasures: the name of your variable
• [Treasure]: the type of your variable, in this case the type is Array of Treasure, the compiler will allow you to insert only object of type Treasure in your Array
• []: the actual object (Array) referenced by your variable, in this case an empty Array.

E.g. if you want the Array to hold 2 elements you can write

var treasures: [Treasure] = [Treasure(), Treasure()]

Hope this helps.

Update:
My example can also be written this way

var treasures = [Treasure(), Treasure()]

Infact thanks to the Type Inference the compiler can deduce the type of the variable treasures looking at the type of the assigned value.

How does Swift disambiguate Type Arguments in Expression Contexts?

Thanks to @Martin R, I found the relevant part of the compiler source code, which contains a comment that explains how it resolves the ambiguity.

swift/ParseExpr.cpp, line 1533:

///   The generic-args case is ambiguous with an expression involving '<'
///   and '>' operators. The operator expression is favored unless a generic
///   argument list can be successfully parsed, and the closing bracket is
///   followed by one of these tokens:
///     lparen_following rparen lsquare_following rsquare lbrace rbrace
///     period_following comma semicolon

Basically, the compiler attempts to parse a list of types and then checks the token after the closing angle bracket. If that token is

• a closing parenthesis, bracket or brace,
• an opening parenthesis, bracket or period without whitespace between itself and the closing angle bracket (>(, >[, but not > (, > [),
• an opening brace or
• a comma or semicolon

It parses the expression as a generic call, otherwise it parses it as one or more relational expressions.

As described in the book Annotated C#, the problem is solved in a similar way in C#.

Related Topics