Print Witness Conditional with airSlate SignNow

Witness zip code field

[Music] alright welcome back and it's time to move on with the show with another really great talk our next presenter you might know him as one of the co-hosts of the point free video series which is an excellent video series about functional programming in Swift he's also a true functional programming enthusiast and he's going to talk a little bit about how protocol oriented programming which is very hyped up in Swift might not always be the right solution and instead there might be some other venues that we can explore specifically protocol witnesses which i think is going to be fun to hear about so give a very very warm welcome to Brandon Williams thanks thanks for the intro and thanks for coming today we'll be talking about alternatives to protocols as a like as a means of abstracting code and writing generic code the talk will be split up into two parts like the first part dedicated to the theory of protocol witnesses whatever that is and then an in-depth look an example where I think the idea really shines my name is Brandon that's my contact info if you have any questions also I I'm currently doing consulting for companies I do like talking about functional programming with companies I do this video series with my colleague Stephen Salas and everything I'm talking about today is joint work with my collaborators so this is his contact info you should feel free to also reach out to him and also the entire site appoint free is built in Swift server-side Swift and completely open-source and and we use these ideas in the code base so if that interest you you could go look at that so onto like the real meat of the talk protocols protocols are great I love them you probably love them Apple certainly loves them I don't think there's been a single W ODBC since Swift was announced that they haven't had some presentation dedicated to protocols I'm sure everyone has seen the epitomise protocol oriented programming talk and featuring the lovable crusty a good talk and it had a lot of great ideas in it so I think it's completely reasonable for us to walk away from those presentations thinking that protocols are a very powerful tool for abstraction the more we use them the more we will be able to write maximally generic code very reusable code and a lot of really great powerful things will come out of it however that isn't entirely true if for another reason then protocols have a lot of problems perhaps the gnarliest of all the problems is this one which I'm sure everyone has seen at some point that the moment you use an associated type or self with a capital S in your protocol it just behaves completely different than any other protocol and you can't use it in a lot of ways you would want you can't use it as the type of a variable you can't have an array of those things amongst other things but this this err won't be around forever like the Swift team is working on ways of getting around this problem and they'll fix it someday and this problem well you know be gone and in fact they've even fixed a lot of protocol shortcomings relatively recently like this it may be hard to remember but it's only been one year that we've been able to write code like this it was in Swift 4.1 which was four years after Swift was announced and it's this line right here this is conditional conformance where you say a generic type conforms to a protocol when it's generic is constrained or also conforms to a protocol so it took four years for us to get this well we got it but then there's things that protocols can't do that I'm not sure is really even on the horizon of being fixed so here we are trying to extend void to be equatable like that makes sense but we'd only has one single value and that's of course equal to itself so we should be able to do this but we can't more generally we should be able to extend a tuple of equatable x' to be equatable here this is doing two things that are actually impossible or yeah two things one you can't extend two poles but also you can't introduce generics into an extension because here a and B where they coming from they're kind of like we're like specifying generics to be used within the extension itself we also can't extend functions to conform to protocols so in this case I'm trying to make functions from A to B to be equatable when a is case iterable and B is equal and this is totally possible to do case iterable just says that you have finitely many values in your type and you can just get them all and enumerate over them but we can't do this and this is a real limitation you've probably run into it especially if you've ever tried to test against something involving tuples because because tuples are not equatable you can't do something as simple as this you'll get this area saying that tuple does not conform to equatable so it's a real problem but then protocols have another limitation and which types are only allowed to conform to a protocol in one single way and that is the definitive canonical way that that type can conform so here we have a tree type like a binary tree and we want to make it iterable by conforming it's a sequence that would unlock all types of interesting generic algorithms that the standard library gives us but what do we do do we iterate over at depth first inorder pre-order or post order or do we do breadth-first like no one of these is more important than the other one they're all important but due to the limitations of protocols we have to choose one and that will be the one way of iterating over this tree and then there's this defect of protocols which I just have a very simplified version of it and we'll run into this in a moment in a more real use case but if you have two protocols you cannot after the fact extend one protocol to to conform to another protocol even if you provide all the requirements right there you can't do this and I don't I don't know of a legitimate reason why this is not possible I think it's probably just hasn't been proposed and designed yet but so maybe someday we'll get this but this is another thing that protocols cannot do so if protocols are the primary tool for abstraction in swift and Apple pushes it very hard but there are significant problems with it what are we supposed to do and it turns out there is a very simple process in which you can convert in pretty much any protocol into just a very simple data type and when you do that most these problems go away and the ones that don't go away it starts to become very clear wide their problems like you kind of get at the root the root idea of what's going on but more importantly in my opinion is when you do this process you'll start to uncover like transformations that are very surprising and very useful that are just completely hidden from you when you're living in the protocol world so you'll you'll actually recover something that protocols can't do that's what I find most exciting so let's let's just describe the process of deep protocol ization and see what it gives us we're gonna start with the protocol a very simple one and convert it to a very plain run-of-the-mill data type and in doing so we'll get some interesting pings so this is the protocol it's called combined able and it just expresses the idea of a type that can combine itself with another value of that type to then produce a third value of that type there are a lot of types that can form to this protocol strings are compatible you just can't get them arrays are combined and pretty much the exact same way because you can concatenate to something kind of strange because array is a very specific type that can be a very specific collection that can be concatenated there's a far more general type called range replaceable collection that is a subtype of collection that adds the feature of being able to concatenate so you may be tempted to do something like this you would want all range replaceable collections to be combined Abul but of course you can't do this because range replaceable collection is a protocol and you cannot extend protocols to conform to other protocols so already we're missing out on a whole world of like potential generic code reuse because we are now tasked with defining combined Abul instances on every range replaceable collection we know about but then all the ones we don't know about we can never provide those conformance as we leave it to those people who created those range replaceable collections to to pick up pick up where we left off and that's kind of a bummer this could be very generic if we could do this all numeric types are also combined about here we just made int and double combine able by using addition but also Swift ships with like a dozen numeric types so all of those are combined upon we'd have to implement conformance for all of them but really we'd like to do this right we'd like to say if your numeric then you should also be combining because we can just add but we can't do this and that's not even the worst part for numeric types because they have another conformance it's not just one conformance we would like to say that numeric types are combined able and two equally valid mutually exclusive ways where we use multiplication instead of addition but you can't do this because a type can only conform one single time okay so and then also we would like to pools to to be combined about in the case that each of its components is combined about where you would just combined in each of the components like this and we would also like that functions in to combine Able's are also combined about where all you do is take two functions and combine them by mapping into B and then combining their but we can't do any of this all right but all those problems aside once you have your protocols you want to start writing generic algorithms on them because this is where code reviews happens you every algorithm you write on a protocol is code that you are getting for free for every single conformance of the protocol so probably everyone is familiar with the reduced function allows you to start with an initial value and then combine values from an array into it using some kind of combined function and and so we can make this a little bit nicer by saying that collections whose element is combined a ball well in order to reduce those collections we can just leave off the combined function because the element knows how to combine with itself and so only takes the initial value and we can just reduce and underneath the hood will usually combine that comes from the combine a ball and that's how you would use it you just get to simplify the call site a little bit by forgetting about the combining you're just like reduce this array into zero reduce this array into the empty string or reduce this array into the empty array so that was a very simple protocol and we ran into all the protocol problems like very quickly so in particular we would have loved if we could make existing protocols conform to combine Abul we would loved if we can make tuples and functions conform to combine able and we will loved if we could have had multiple conformance --is to combine a ball so let's deep protocol eyes and then see what that gives us this is how you deep protocol eyes the combined approach I call you replace the protocol with a struct and we rename it from the like a bull suffix to ping suffix so combine a bull becomes combining alright and we introduce a generic because this generic represents the self represents the type that is conforming to the protocol so a is basically like self with a capital S and the protocol world and then the requirement this method combined with an other self to return itself becomes just a simple function field just a field a let field alright and it takes two arguments because the first one is like the implicit self that you have in a method whenever your a method you always have access to self lowercase s self and that is of type uppercase s self that the type that is conforming and so that first day is referencing that implicit self then the next argument is the self that is actually being passed to combine and then your return a which is returning self with a capital S alright so that was the D protocol ization of our combined approach all and how do you use it well instead of conforming types to the protocol you construct instances of the struct so instead of conforming it to be combined able by doing addition we construct a combining of integers using addition and we give it a name sum and instead of conforming string to combine able we construct a combining of strings using plus well but string concatenation and then to write generic algorithms instead of constraining generics to conform to protocols you pass in explicit let me back up one second and we call these these little values can captain of the protocol because they are the proof the the concrete data proof that you have a conformance to your protocol and so then to write generic algorithms instead of constraining your generics to a protocol you pass in an explicit witness you're like you're not like my element is of combine a ball you're like it can be combined because here's the proof here's the witness to the combining requirements and then underneath the hood you just can use combining combine like you would use over in the protocol world and then at the call site you pass in the explicit witness to say this is the the way in which I want to reduce but because these protocol witnesses are just values you can construct as many of them as you want so I've got a combining of integers as addition and a combining of integers as multiplication and so I can reduce with the sum or reduce with the product I get to come up with as many combining witnesses of four integers as I want there's no clash I just have to decide at the moment I want to invoke my algorithm I have to decide which witness I want to use so protocol witnesses are solving that problem but witnesses also saw the problem that prevented us from extending numeric to conform to combine able so here I have greatly generalized sum and product so that they do not work on just integers but they work on any numeric type so I extend combining and I constrained its generic to the protocol that I want to work on numeric and now sum and product are computed variables that can be accessed for any numeric type so immediately I already get I just with those two the ability to reduce with sum and product on integers doubles CG float anything like if you created your own library of like vector math and matrix math or quaternions or whatever you would just instantly get access to this because I have made this combining algorithm work for any numeric type all right so now it solved that problem all right this is also kind of nice that the these two witnesses summit product have now been kind of namespaced also within the combining type they're not just floating around as like Global's in the module namespace they've like kind of been incurred a little bit and that's why we have these dots here so it's nice that we can still use type inference we don't have to specify combining dot sum combining dot prod so even that's kind of nice we we can do the same with range replaceable here I've made combining work on any range replaceable so that means this one implementation works for strings and arrays I don't need to separate can cats one for Strings one for arrays it also would work on array slices or anything that's range replaceable if you have your own library that has a range replaceable your own custom range replaceable collection it would work instantly and then there's even more so remember how he said that tuples cannot conform to protocols but this is doing precisely that but for witnesses and for the combining type because this says that if you give me two ways of combined weight of combining a z' and a way of combining B's I will give you back a way of combining A's and B's where we just do component wise combining the left and right right hand side alright and it may seem a little weird that I'm calling this function zip because you're probably all familiar with zip on arrays I did this because zip on arrays is a special case of a far more general idea because in words if you think about it zip on arrays is a transformation of a tuple of arrays to an array of tuples and this is saying this is a transformation of a tuple of combining z' into a combining of tuples and you can keep on going you can do this for many different types you could say a zip would be a transformation of a tuple of promises to a promise of tuples or tuple of parsers to a parser of tuples or even a tuple of optionals to an optional tuple that like zip as a general idea is able to do this transformation between generic containers and tuples so that's why i've called a zip it's also worth noting that this function is expressing the idea of conditional conformance because it's saying if a and b are combining then tuples of a and b are combining so in the Witness world conditional conformance is nothing but a function that transforms witnesses two witnesses that's all conditional conformance is just a function and then finally it's worth noting that this code would have compiled in Swift one so in Swift one we would have be able to have some resemblance of conditional conformance we have had some resemblance of conforming tuples long before we had conditional conformance during these things this code is perfectly valid swift one code so that's how simple this idea is okay and the zip function is like packing a serious punch because there we have an array of tuples and we're gonna reduce the first component the tuple of sum and the second component with concatenating and so in just one iteration of the array we're doing both those operations on the components and so this like it's I think it's backing a pretty serious punch and then you can also of course do combining on functions now if you give me a way of combining B's I will give you back the way of combining functions into B's where to combine two functions F and G I return a whole new function such that F and G just gets applied to the input and then we combine over there in the B world so we're getting conformance is conditional conformance azan functions now so that is the basic theory although I know that was a lot packed in there but that's the basics of D protocol izing and there there's a lot more to cover before you can like really use this in the real world because there's a lot more protocol features you need to figure out how to do protocol eyes like associated types and all types of stuff but that's the basics and rest assured all that can be done but maybe it'd be better to look at an example where this idea just really shines and it's in a library that I open source with my colleague Steven and it's a a snap a snapshot testing library it's been open source and in production for two years or nearly two years but we did the 1.0 last December and the 1.0 is a completely completely different from the very first version we released that's because we started in the protocol oriented style and we were like kind of constantly butting up against a lot of these problems but it was working mostly fine we're just like rolling with it and then finally we're like enough is enough let's let's see what would happen if we just convert all these protocols to data types and a lot of really amazing things happened so so first what is snapshot testing it's a it's a form of unit testing in which you don't directly assert on say the output of some computation or some function but instead you assert that the snapshot of some output is equal to some snaps to a snapshot that has been previously saved as an artifact on the desk so instead of doing this instead of importing XE test and asserting that the output of some compute function is equal to 42 you do something like this and the when this is run a snapshot is made of the output of compute 3 and then it looks up a file on disk that it can uniquely reference based off of the name of the test that we're running in and then it compares those two things and if they differ at all the test will fail you'll get a nice error message and it can be pretty powerful I think probably the most popular form of snapshot testing would be screenshot testing in the iOS community in which you your artifact is an actual image of some UI and you save that UI or that artifact that PNG to disk and then when this runs again it'll they'll load up the view controller take a snapshot and then compare a pixel-by-pixel with the image and make sure everything is is good here this is some screen with a graph and stuff but you can also screenshot test a variety of configurations for the screen so what if you want to see what it looks like when it's in German or when it's in Spanish or once in French or when it's in Japanese you can do that kind of stuff and it gets really powerful but screenshot testing isn't the only form of snapshot testing snapshot testing is far more general because you can snapshot any kind of value not just views into any kind of format not just PNG images so for example you could snapshot a request a URL request and it would print out in a kind of a nicely format as as nice as you can do format of all the different properties of that because the request has a lot it's got the URL which includes a bunch of query parameters it's got headers and got a post body and so you want to get like a really good view of what that data looks like and so here we have a post to a stripe endpoint and it's doing some URL encoding that can be tricky to get get right in the query pram it's got a header for basic authorization and that has a post body and so if you were to write a unit test for this an on snapshotting unit test you would be responsible for creating the euro request and filling in all these fields and then asserting against it and that would take many lines to do res this is one sing a line assert snapshot BAM you get this and also I think that's like so prohibitive to do all that work that you just wouldn't test maybe this part of your code the code that and your API client or stripe client or whatever prepares your URL request you just maybe what and test it because it's such a pain and that can be not so great especially in this wild-west world of server-side Swift in which Linux Foundation is subtly different from Mac Foundation we've had a lot of bugs working on point free that snapshot testing caught because of very subtle differences between the two foundations ok so this gives you some very broad coverage with very little work so let's let's talk about the protocol approach we took see the problems and then see the fix so we wanted like a set of protocols such that types conform to those protocols and then they would unlock like the generic algorithm doing all the snapshotting and saving to disk and comparing and all that stuff so we ended up with two protocols there's a difficult protocol which expresses the idea of types that can be dipped there's a requirement that takes two values and diff 'some it returns an optional tuple because if there is no difference we'll return nil it's like there was no difference but if there is a difference we'll return a string that is the error that would show in Xcode of what failed and then an array of XE attachments which are little artifacts that get saved into Xcode so you can go reference and see what went wrong and you can return any number of these all right then you need a way of serializing to data so that you can save it to disk and a way of unsee realizing data so you can resurrect an artifact from disk into memory and then we'd have a snapshot protocol or snapshot of all protocol and this expresses the idea of types that can be snapshot to have an Associated type because a type can be snapshot into a different format so we need some format that is difficult we'll need a path extension so we know how to save the file on disk the dot PNG dot txt not something and then we'll need the ability to turn ourselves into a snapshot in that difficult format so that we can then save it to disk resurrect it from disk and compare and once we have the protocols we can write our generic algorithm we can write the cert snapshot helper that says assert that we're matching some a and this does all the work of loading the current artifact from disk turning this a into a new snapshot comparing those two things failing the test if they differ and so on and we use this library and basically this form for a very long time and it did perfectly fine and even in this state it was what I think is maybe like the best way of doing snapshot testing in the iOS community but there were definitely problems of course you can't have a type b snapshot in multiple ways this is a completely valid thing even just a view you would maybe want snapshot in multiple ways for different sizes different configurations size classes and things like that also when we're doing server-side Swift we wanted a snapshot our web pages both as like the raw HTML like hierarchy and as an image of the page and then there are a lot of types that we wanted to snapshot that we couldn't snapshot as we'll see in a minute so let's do protocol eyes those those protocols diffa bol becomes dipping and it picks up a generic which is the types that can be dipped the static function from self self optional string XE attachment just becomes a field that's a function from value value to string attachment I this has two arguments and the static function has two arguments because it's static there's no implicit self we don't need to insert another implicit self value into this function the the computer property data that's just a function from self to data so from value to data and then from is a function from data to self or data to value so that's D protocol izing that and then we can do protocol eyes snapshot able become snapshotting and we pick up a value generic but then the Associated type picks up a new generic format and because format is difficult we pick up a differing witness in our snapshotting witness path extension just becomes a a field a variable and then snapshot is a function of sorry that should be value two format because it's a computer property with an implicit self I think it's a format and then our generic algorithm instead of constraining to snapshot able we take an explicit snapshotting witness we say assert snapshot matching this value but as some witness alright and we'll see an example that in a moment so the library comes with tons of snapshotting strategies and it's really easy to create new ones and you don't have to be shy about creating new ones because you're never gonna step on the toes of other possible conformance 'as it's there there's no you should create as many conformance 'as for UI view as you want or for URL request as you want so let's take a tour some of those strategies out of the box there's a dump strategy where any day structure can just call you can call Swift's a dump function which produces like this tree like structure of a description of everything in the data structure and this works on any data type any with a capital a that magical protocol that everything conforms to you can snapshot any value and just get this like this will give you very broad coverage with very little work but if your type happens to be codable and then you get of course snapshots JSON this is a strategy well the previous strategy wasn't possible in the protocol oriented world this one also because we can't extend codable to be snapshot able but we can do it here like before we can snapshot requests in this like RAW format where we kind of try to list out the headers and everything in a nice way but you also snapshot with a curl strategy so that you get an actual legitimate valid curl description here that could be copy and pasted in a terminal and then of course there's image snapshot strategies you could snapshot a view a plain UI view but then you could also snapshot it as an image but then you could also provide some custom traits so you can cut it like you couldn't test what does it look like in regular versus compact and things like that but then you could also snapshot your view controller and you could simulate an iPhone X in portrait I'll set up all the sizes all the size classes for you and then you could also do in landscape but you can also snapshot views in a textual format because there's this kind of magic debug function called recursive description that it's a private symbol but you can call it in Tesco just fine and it would print out a textual description of your view hierarchy and this is very popular to do in the react community where you snapshot virtual DOM and get like a textual output and you track how refactorings would change that Dom so you can just do this but you can also snapshot controller hierarchies this is the children controller hierarchy for a view controller we have a tab bar controller it's got five tabs that are all navigation controllers and then inside the first tab it has a UI page of your controller and so you test that you're managing your children view controllers and the right way just by snapshotting their hierarchy this is a third party one this this is a project that provides a swift wrapper around lib Haru which is AC library for generating PDFs and it's cross platform and the the maintainer of this project traded a custom PDF strategy so he could snapshot his data structures into PDFs so he gets a very broad coverage of a very difficult format to test because a even the simplest of PDFs is actually just dozens if not hundreds of lines of textual commands of how to do the whole thing and so he gets a PDF sitting in his repo of like a real-life artifact of what the PDFs look like as output from his library so that's pretty cool this is a very experimental one and and not one that's public but with Steve and I'm we're working on a animation framework and of course you'd want to test an animation framework and what better way to test an animation framework than to generate a gift artifact of the animation so you can just snapshot the canvas in which this animation is happening and you can give it some parameters like how long do you want the animation to happen and how many frames per second and now generate a gif and then you can do refactorings and see how that would change your animations you could also just slow it down and so the the artifact that you commit to your repose a very slow down version this is a animation if you go to the Apple arcade website they've got like all these little animations with icons I just want to see if I could recreate it and rice snapshot test and it was pretty easy to do but then you can also have just very focused unit tests so this is only testing what does the ease-out animation curve look like in this animation framework and so now this is just proof of what the animation curve looks like in this framework just a simple dot going across the screen but you don't only have to snapshot as a gift you could also snapshot as like an onion artifact ado this is just a static PNG where I just take a whole bunch of frames frames and then increase the opacity so you can see the evolution of the animation and just one single shot and so I really think a lot of this was only possible because of the choice to get rid of the protocols and just use the concrete data types because we have multiple snapshot strategies for a single type and so I think we're getting a lot of benefits out of this but and that's very cool but that's not even the end of it there's other things that start happening when you go this like concrete data type route you're able to derive all new strategies out of existing strategies and this is the operation that does it we'll step through it it's called pull back I'll explain why in a moment and it says that if you have a function that goes from new value to value you can then transform your snapshotting on value to a snapshotting on new value all right and you should think of this operation kind of like map on arrays which says that if you have a function from A to B you can transform arrays of A's to raise a B's here we're saying function from new value to value you can transform snapshotting of values to snapshotting of new values it goes in an opposite direction that a and B have been flipped if you sit down and write it out but they're very similar operations and so to implement it well the diffing and past extension that doesn't change at all all that stuff carries over the only thing that changes is the manner in which you snapshot and all you do is take your transformation apply it to the new value and then snapshot that all right so assume you had a way of snapshotting UI images and UI images all this does is serialize UI images to PNG z' deserialize p.m. G's back into UI images and then given to UI images does a pixel by pixel diff on them the implementation of this is kind of long but somewhat straightforward and apples api's basically give it all for you but once you have that you can derive a snapshotting strategy on CA layers where you just take the image strategy and pull it back by then rendering that a layer into a UI image using this API and then once you have that you can drive the snapshotting strategy on views by taking the layer strategy pulling it back by then plucking out the layer from the UI view and then you could from that derive a strategy on view controllers where you take the view strategy pull it back to work on UI view controllers by plucking out the view from the UI view controller and this is why the operation is called back it should kind of convey the idea of taking a very specific strategy and like pulling it back to a larger object like going from image to layer to view to controller and pretty much every view controller or every snap showing strategy that comes with the library is a pullback of some base strategy and so it's a very bit like this idea does not exist in protocols you you have no concept of taking a conformance on of a protocol and then somehow transporting it over to a conformance for some other type they're just like this just doesn't exist so that is protocol witnesses in a nutshell I want to quickly recap how we got to where we we ended up we started by understand that protocols are the de-facto way of doing abstraction and Swift it's highly pushed by Apple but they have lots of problems but they're getting better someday maybe all these problems will be fixed and we'll just be able to do more and more things and protocols so we explored the process of how you would be able to scrap protocols and just have simple data types and then we really started to see that they fix a lot of problems and they they envy or like a lot of interesting transformations but I don't want to discourage people from using protocols entirely that's that's not the point of the talk it's really just to explore explore alternatives to protocols so just and also explore the idea of not overusing protocols to know that there are alternatives so the pros are pretty clear we've talked about it like gets around a lot of shortcomings encourages multiple conformance 'iz which is something we probably don't think about a lot but is very powerful and we can build new is from old ones and they reveal lots of transformations that are completely hidden but the cons they're definitely con swift is absolutely a protocol oriented language so you're gonna have friction when you go against that model and so this doesn't play super nicely with ubiquitous protocols things that are just really kind of get their fingers in every little aspect of your application like custom string convertible you're not going to use this protocol witnessed out for that because the whole point of custom string convertibles to have like a very simple way of plucking out a string description like in string interpolation stuff like that so you're probably not gonna use it very deep proto vertical hierarchies because that turns into basically struct hierarchies where you have heavily nested struct fields and so that's going to be kind of strange if you have a whole bunch of protocols inheriting from each other you have to dive deep into all the fields of the the witness strikes and then also very advanced protocols and get more and more complicated converts so you're not going to go and convert like the entire sequencing collection API to the style because they use some of the probably all the most advanced features or protocols and it's going to become increasingly difficult to capture all that essence so that's the end thanks for listening some contact info and thanks you