Add Protocol Byline with airSlate SignNow

Add protocol byline

welcome to the final section of this course in this section we'll be covering generics and Swift and how you can use them with protocols in order to write powerful maintainable and flexible code last section we covered associated tight requirements which are placeholders that conforming types can satisfy we then covered self requirements which describes the conforming type itself then we took a look at operator requirements which allow the protocols to require that the type implement certain overloads for operators where the conforming type is the operands about operator and then finally we looked at where clauses and protocol extensions in order to constrain implementations so that they're only applicable to certain conforming types in this section we'll start with an introduction to generics showing you watch an hour exam and how you can use them we then move on to showing you the power that the use of protocols can bring to generic functions and types then we'll move on to talking about how you can use protocols in order to refine extensions on generic types so that they're only applicable when a given placeholder meets the requirements and then finally we'll cover some of the powerful standard library protocols such as equatable comparable and hashable you'll be shown both how to conform to these protocols and then how to use them when writing generic code so in this first video we'll be introducing you to generics you'll be shown how to define generic functions and generic types generics are somewhat similar to associated types in that they allow you to define placeholders which are then later satisfied the difference between them is that while associated types are satisfied by a particular conforming type generic placeholders are satisfied at the call site of the given function or generic type so let's dive in with defining our own generic placeholders you can add a generic placeholder to a function by writing a pair of angle brackets after the function name and before the parameter list you can then define one or more generic placeholders between these angle brackets so in this case we have a pick random function that takes two arguments and returns one of them at random so to do this we've defined a generic placeholder T within using this placeholder as both the argument types and the return type of the function what this means is that when pick random comes to be called the caller will have to satisfy the place oddity with an actual type this type will then be used as both the argument type and the return type therefore in this case you can see we're calling pick random with integers therefore by default t will be inferred by the compiler to be an INT therefore pick random will be inferred to be a function that takes two in parameters and returns an int therefore I here will be typed as an inlet and you can see in this case when we're calling pick random or passing in string arguments therefore the compiler will by default infer T to be a string and therefore infer pick random to be a function that takes two string parameters and returns a string therefore the result will be typed as a string with functions you must use a given generic placeholder and at least one of the places in the function signature otherwise it doesn't serve any purpose and the compiler will give you an error when you come to call the function you then satisfy the given generic case older which Swift can infer from the static type of the instance you pass for example you can see in this case we have a print static type function which has a generic placeholder T which is then used in arguments of type T you can see when we're calling this with a string T is employed to be a string however if we first cast the parameters to any and T will be inferred to be Emme we're able to print out the type of T in the function because inside a generic function you can access the meta types of the type being used to satisfy the given placeholders so for example here you can see we're printing T dot self this is the static type that the compiler in first T to be upon calling so in this case string double and then e the ability to access the static method type of seeing a function is especially useful when T is constrained to a protocol which I'll be showing in the next video it's worth quickly noting in this case there would be more efficient to mock the arguments of pick random as being at also closures what this means is that the compiler will implicitly wrap the arguments in closures therefore meaning the argument that isn't X does not need to be evaluated as the closure will not be cooled with generic type you write the angle bracket after the type thing unlike functions you don't necessarily have to use the placeholder in any method or property types however just like functions you have access to the static meta type of the given generic placeholder throughout the type whether you're at instance or static scope so for example in this case you can see we're accessing the static method type of the generic placeholder elements are both static and instance scope you'll note that we name the generic placeholder elements while a common naming convention the generic placeholders is to use the letters T U and B you are free to choose whatever name you wish in fact it's encouraged to give generic placeholders a meaningful name in places where it makes sense to do so for example if we consider array which is a generic type and has a placeholder just like in this case called elements however in places where there's no descriptive name available such as in the above example we'd pick random letters T U and B are the established convention so back to generic types you can see in this case we have a collection of to type that describes a pair of elements because element is generic placeholder it will be satisfied when we come to create an instance of a collection of two so for example in this case you can see we're explicitly satisfying the element placeholder with string therefore we're creating a collection of two of strings so you can see you are passing in two strings for both elements however in most cases the compiler can infer what type you are using in order to satisfy the generic placeholder for example in this case we're passing in doubles therefore by default collection of two is inferred to be a collection of two double and you can see that here and you can see much the same thing with for example array literals so in this case this is inferred to be an array where the element type is satisfied by the type any it's worth noting that when you refer to a generic type you must provide a type to satisfy the placeholder I don't literally by allowing the compiler to infer it or explicitly you cannot currently talk in terms of an arbitrary generic type irrespective of the type used as its placeholder for example I cannot directly have a variable of type just collection of - that won't compile because the compiler needs to know what type we're using in order to satisfy the generic placeholder another case of when the compiler is able to infer the type used in order to satisfy the generic placeholder is when a generic type refers to itself in its own scope for example you can see here we have an extension of collection of two therefore when we refer to collection of two inside with extension the compiler will by default infer this to be a collection of two elements of course elements is the generic placeholder of collection of two so when this instance method is called it will be returning a collection of two with a placeholder of the same type as it's been currently satisfied by for example calling it on a collection of two it will return a collection of two bits and you see this method is just swapping the elements finally it's worth noting that generic types are treated invariantly by the compiler what this means is that two different specializations of a given generic type are treated as completely unrelated types regardless of the type relation between the two different placeholder types so for example you can see here we have a collection of two string however we cannot simply assign this to a collection of two any because the collection of two string is a completely different type the reasoning behind this restriction is because placeholders can be used as both parameter and return types for methods inside that kind this is problematic because functions of contravariance with respect to their parameter types and covariant with respect to their return type a given generic placeholder therefore has to be invariant if it is to be used as both for example consider this class socks with a generic placeholder element and a property of type elements courtiers bogey getter and a setter just like methods with return types it is a covariance with respect to the property type and just like methods with parameters setters a contra variance with respect to the property type so for example consider if we had a box string now consider what would happen if we were able to assign this to a box any we would now be able to set the elements to anything including an integer however this is clearly illegal because box is a class and the element is of type string because we created a box string therefore it will be illegal to assign an INT to this it should clearly show you why generic types are invariants however one special exception to this rule is with some standard library collection types such as array despite being a generic type with a placeholder for each element type you can still freely convert between a raise of sub type elements to arrays of super type elements so for example here you can see we have an array of integers and we're able to convert this to an array of any the reason why this is permitted is simply because the compiler performs the conversion for you behind the scenes this conversion is safe for arrays despite using the element placeholder in both parameter and returns sessions but there's a raise of value types so therefore upon converting the resultant array is a copy of the original and therefore any changes to it cannot affect the original the reason why the compiler cannot therefore roll this out to arbitrary value types is as an arbitrary value type can contain any number of generic reference types which leads us back down the path of unsafe conversions so to recap generic placeholders are defined in angle brackets after a function or type name generic placeholders are then satisfied by an actual type at the call site of where they used the compiler can often infer what you are satisfying the generic placeholder with for example with generic types this can be done when you're initializing the site by passing in our arguments of placeholder type you cannot talk in terms of a generic type without place holder when you refer to a generic type you must include a type in order to satisfy the place holder and finally generic clothes are invariants two different specializations of the same based generic type are seen as completely unrelated types however the compiler makes exceptions for this in the case of some standard library collection types such as array and set you