A Primer on Match Expressions in Scheme - Learning Guile Scheme

so in this video I'm going to give you a short primer on Match expressions in scheme and specifically guile scheme so that you can understand why they're such a useful tool for destructuring uh information that is stored in various different data types that you would deal with in scheme code uh match expressions are pretty common in other languages because of that utility they have for D structuring you often see them being used as a pretty core pattern whenever you're having to deal with things like lists or uh array or vector types or um struct types or classes or or records or whatever type that a language normally would have and scheme is no exception to that however the thing to keep in mind is that uh record sorry match expressions in scheme are not standard in the language however there are match expression implementations across many of the scheme implementations because there is a a paper by uh I think Jonathan ree let me check the notes I have on that sorry Andrew K Wright wrong person a paper by Andrew K Wright that explains u a design for match expressions in scheme and then there's a pattern matcher implementation by Alex Shin who's also the author of Chibi scheme and also has worked on standardization of scheme Etc that um has been kind of Taken and used in various different scheme implementations and that's the basis of the ice 9 match uh module in guile So today we're going to be taking a look at how to use the match expression in guile scheme to to uh destructure some data types and sort of show how the pattern could be pretty useful and could be even something that you use in a lot of your code as a standard idiom in the scheme language so uh first of all what is the match expression well if you look at this first example here hopefully it's easy to see in fact Let Me Maybe Just bump that up a bit more the first example here is just a normal uh it looks like a normal procedure call this actually a syntax it's a ma macro effectively it's a syntax in the scheme language that produces an output that handles all of the different patterns that the match expression itself uh accepts we're going to look at a few examples of those in just a second but here the first thing to see is that we're calling match on a list so this is a normal quoted list of containing the values 1 2 3 and what we're doing here is we're going down into a sub expression under match and then in that sub expression there are two parts the first part is the pattern to match against and then the second part is the uh expression or series of Expressions to execute uh after this uh match a after the pattern match has been successful against the data that is being passed in as the first parameter to the match expression so here we're looking for three values in a list and the way that you can tell that is because we're actually um formatting it as if it's a list here so inside of that sub expression and this match expression can have multiple sub Expressions which we'll see in a moment but inside of the Sub sub expression the first thing you see is the pattern and we're just writing it as if it's a list with three symbols there what this will do is if the data that you're passing in matches that pattern it will bind those values to these symbols so that 1 2 three will turn into uh bindings of XYZ and then you will be able to use that information directly so the reason why that's nice is that you don't have to go and uh do the work of destructuring that list yourself to get those values out because in scheme um there's you know libraries for uh getting values out of data structures but uh sometimes you end up having to use plain old car and cutter and the variations on car and cutter so this is much better than having to do that yourself you can just use a match expression to say what the pattern is of the information you expect and then let it uh do the bindings for you so in this case we're going to evaluate this expression using geyser which is a package in guile sche sorry in emac for providing a reppel interface for scheme implementations gu being one of them I'm using control x contr e you can see down here in the Echo area at the very bottom it says Y is two because it destructured that list of 1 two 3 it pulled the value of y into a binding or pulled the value of two into a binding of Y and then it printed out that the value of y is two so that shows that it did actually work now the cool thing about match expressions and using these patterns is that you can even do uh nested information so here I've got another pattern that uses a that looks for a nested list inside of the original list so um it it's specifically looking for this form of a list that starts with a value and then a nested list with two items and then uh after that nested list you have another item so since I'm passing it a list that follows this form then it can actually bind all of these values from that uh the pattern of that information so if I were to go evaluate this expression at the bottom you can see that it says Z is three because Z is the second value of that nested list and it was able to bind that into Z so you can already see how if you have uh information stored in lists it could be a list it could be normal plane list whatever uh you can use match Expressions to uh to pull that information out pretty easily um another thing you can do with match Expressions is to match against specific values um and have that be as as part of the uh the pattern being matched so in this case we're matching against a one and then two other Bindings that will be uh assigned to whatever values remain in that list so we're looking for a list that starts with one and then we'll just put whatever the other two values are into bindings uh and if doesn't match we're going to return a string did not match well in this case we do have a list that starts with one so I'm going to evaluate that and it says Y is two because that did match but here I've got the same form and I'm giving it a list that has a three at the beginning and if I evaluate that it tells me did not match because that first value did not match uh what we were looking for in the pattern so not only can you do D structuring of information you can also look for specific values so this could be useful if you have a kind of like a protocol for um like records of information not record is a bad term a su list of information in a list and you're looking for like uh a value that comes at the beginning of that subl list to sort of identify what type of uh list you're trying to process then you can easily do that with a match expression and Magic Expressions become much more valuable the more complicated your information becomes because they can help you to sort of slice and dice all the information that's inside of your data structures so it could be super useful for that kind of thing uh here we're going to see see an example now of having multiple Expressions um this is a case where uh we're doing two different things um one is we're doing that value based match again so we're looking for a list that starts with one but we're giving it a list that starts with three so that one definitely won't match but we're also looking for a list that has two values but we're giving it a list with three values so now what we're going to see is that the the length of the list also can matter in terms of match Expressions if I evaluate this we'll see that it returns did not match because that we're looking for a list of two values but we gave it one with three values so even the length can uh matter in this case um there's other ways to avoid that I think like if you use like dot dot dot uh it will actually pull out the right thing but in this case what it will do is it will put the remaining items of the list into that b uh that b binding so we say that b is whatever is uh whatever that binding of B is in this case we say B dot dot dot we're basically just saying give me whatever remains in the list and call it B so in that case we're getting a list of B we could also say C dot dot dot and then evaluate that now we see that b is two so we have a little bit of flexibility in how we uh structure these things we can actually ask for you know more more items than uh what is in sorry more items than what is in the pattern and then deal with them appropriately if we want to this dot dot dot is a special syntax that's part of the match expression it's also used a lot in uh scheme syntax definitions so if you're wondering why dot dot dot there this is actually a common thing in scheme that you will see more as you write macros so uh as I said that if we you know make sure that the list link matches up we can evaluate the um the form here where 321 gets uh caught by the second pattern here for ABC so if you have multiple patterns it's going to try them one by one until one of the patterns matches then it will um activate the Bindings that you're asking for here and then it will evaluate the uh forms that come after or the Expressions that come after pattern um you can also do interesting things like Boolean matches so maybe you have a case where uh one of your your paths in your match expression might want to match one thing or another um and in this case we can use the or sub expression to then uh put together two other patterns so you're sort of nesting patterns here when you say or as a pattern then you're you're giving it one of one of many options it could be many options I don't think this is two it could be more than that and if one of them matches it will do the bindings and then uh execute the uh or evaluate the Expressions that are part of the the match at this point so in this case we're going to execute this and we'll see that oh oh okay that that that was not really an important error I think it's just telling me that the binding X is not used so we'll see that uh it did write out uh the value of y and that's because it says or a list that starts with one or just anything for that value I mean it's kind of a a contrived example but it does show you it will still work anyway because it does write out y or it does return Y is two it just says possibly Unbound variable X that's fine um next we have an and expression so it needs to uh see that both of them actually are actually match the pattern so if I evaluate this it says did not match because the first pattern does not match one XY one YZ does not match because it starts with three now in this case we have one that has an and where we do have a list that starts with 1 2 3 if I evaluate that it will tell me that Y is two now I'm guessing that I'm not sure which of these it actually binds in fact let's just put X in here and see what x does yeah so I think what happens is all the patterns in this end must match but it will use the bindings of the last one my guess is I'm not 100 100% certain about that uh mainly because let's see let's try this I want to see if B actually gets bound to something because I think it won't oh it does okay so any of the any of the things in any of the patterns will get bound so this B here does get bound which is kind of surprising to me I wouldn't have guessed that but anyway so the point is that um all of the Expressions must much must match all the patterns must match and then it will activate the bindings and then evaluate the Expressions another useful pattern for dealing with is this sort of uh first. rest or any symol name do some other symbol name pattern because this is how you can decompose a list into the first item of the list and the rest of the items of the list basically like calling car and cter on the list so if you're trying to walk every single item of a list and deal with the F the thing that's at the head of the list this is a good way to do that with a match expression so here we've got a list of 1 two three we're trying to pull first and rest off that if I evaluate that we see that first item is one and rest is 2 three the list of two three right because we're the first item is one and the cutter of this whole list here is a list of two and three or a pair that represents a a list of two and three so that does work um one place where this ends up being kind of helpful is in uh Loops if you have to write a named let Loop to process a list in a certain way maybe you have something that's a little bit more complicated than just using a normal uh map or for each then then uh it could be cleaner than doing the normal thing that you would do so normally in a loop if you've written Loops before that go through list of items uh you would have a pattern sort of like this where you have a list of items that you want to Loop over you so if you don't know what a named let is a named let is basically a let expression that uh sets up a few bindings but it has a name that could be invoked inside of the body of that let expression to basically do an a tail recursive Loop inside of the context of that LE expression so it's often used as the primary looping pattern in uh scheme implementations just for that that quality alone uh here what we do is we have our input list of items uh we first check to see if the items value is a pair if it's basically a con pair because if it is we can process that that con pair otherwise it's the empty list value meaning we've reached the end of the items list so we just you back out and we're finished so if the items value is a pair we go into a begin expression which allows us to do multiple expressions like in fact probably here we could probably just get rid of that I didn't need that because I'm not doing multiple things um but we recursively call Loop we uh manipulate the items and the strings lists so that we're sort of passing the new values forward in that Loop expression and then eventually we're going to uh call Loop and we're going to end up getting an empty list from this cutter items so once we hit pair of items as false then we return the reverse value of strings now now that's not too bad but you do have to remember to use car and cutter everywhere uh one alternative approach to this would be using a match expression to decompose that uh items list into the first item and the rest of the items so you can match over items here and uh you pull out item. rest to do what I said get the head and the tail and then use Loop the same way but here we can just use rest and items so we're not having to call car and cter directly uh we can do further processing on that this becomes even more useful if you have a more complex data structure you're trying to decompose you don't have to do use C A cadr all those other variations you can just use match to do the um uh decomposition of the values that are stored in the the nested structures that you have in your in your list that you're processing so um instead of having that if we have two different um patterns to match one is the uh car and cter pattern and the other is just the empty list pattern that once we hit that we will return the reverse list of strings so um it's about the same amount of code but I would argue that this is a bit clearer to read and a bit more flexible for the future because then the code doesn't change very much if your data structure becomes a little bit more complex you don't have to worry too much about um you know rewriting the code to be clearer or uh having really weird looking Expressions because you're doing you know checking to make sure that the values are what you expect them to be Etc okay um also I I had had mentioned before about using the dot dot dot pattern I just have another example here of that where you know you can match anything dot dot dot and then it will uh end up having um it will give you back a list of values so that's that's kind of useful oh you can also match just different data types in scheme um in scheme there's a data type uh called a vector which is like an array that you can't resize it's just an array of values that um has a fixed length and in this case um we are matching against a vector you can tell that this is a vector because we're using a hash character at the beginning so the hash is a special reader um syntax to indicate that the thing that comes after is not a list but it's actually a vector vector and you can use that same syntax in a match expression to say I'm matching against a vector so it won't be a list so if I were to actually put a list here XYZ um I could just say it's a list and then um next is the vector match with a hash in front and then I'll actually pull out the value of y much as we did before I can evaluate this and it says Y is two because uh this value is a vector if I were to go change that to be a list and um execute this expression again it will tell me it's a list so we are distinguishing between values of different types by the syntax we use in the match expression and we're going to see that again in the second we talk about matching against record types so the syntax you use in the expression um sort of indicates what type of value you expect a match expression to be dealing with at any given moment so I also want to point out you don't have to put values directly into the match expression I'm just doing it for the purpose of examples you can definitely pull them from a binding so I could say like Define V uh one 1 2 3 evaluate that and then put V here then go to the end contr x contr e and then it still still tells me that Y is two so you don't have to give it a value directly you can give it a the value of a binding you can do anything you want this this expression that's uh at the beginning of the match can be any arbitrary scheme expression you can call it call a procedure to return a value back you can do anything you want so it doesn't have to be specifically a value that you're passing in all right so next we want to take a look at defining a record type so um if you don't know scheme has the concept of record types it's actually a part of surfy 9 which is an extenstion specification to the scheme language most um scheme implementations provide surfy n implementation guile does to allows you to define something that's sort of like a struct where um it's a type that has a specific set of fields attached to it and in schem the way that it works is that you define the fields but you also Define the procedures that allow you to access the values or set the values of those fields so uh we're creating a person record type here with three Fields name age and Hometown and then uh we're going to use a match expression and we're going to create an instance of the person uh record type that we made made here so make person I'm going to evaluate make person you'll see down in the Echo area it says person named David age 132 Hometown Mars yes I'm letting you know how old I am and where I'm from um and then in the match expression the first pattern we're using here starts with dollar sign and this lets the matcher know we're looking for a record type of type person and we're trying to uh extract these three fields from the record type if I were to go and evaluate this we'll see that David is 13 to and from Mars we're we're using the um format procedure in gu to write all this out we have the bindings for name agent Hometown so that's great that's cool that means that you don't actually have to use the uh individual procedures to extract those values from that um that record instance because you're able to use a match expression to do that uh specifically now there's one little gotcha here which is that when you're trying to destructure against a um a record type you can't just give it only the fields that you want to um to destructure if I were to take age out of here and run this in fact uh let me just switch the the order of Hometown and age if I were to uh run this it doesn't actually destructure it using the name of the field it's actually the order of the field so keep this in mind when you're destructuring against a record type the order of the symbols that you put here must match up with the order of the fields in the record type in fact I can call call this whatever I want I can say n ah which is probably going to be a problem cuz I need to go change these two let's just change these I'm pretty sure they don't have to have the same names if I were to execute this yeah say David is 132 in from Mars Mars so the the the symbols you use here are irrelevant it's really the order based on the order of the uh fields in the record type I don't know if that's a guile thing or if it's a match expression thing but what I do know is that Rec types internally are basically just vectors that have fields in a certain order based on the order that you defined it so that may be how it's extracting these it's just doing a sort of indexed extraction of values from this underlying Vector that is being used for uh the record itself so keep that in mind if you're destructuring record types make sure you are putting the fields in order for the information that you're looking for I don't think you have to include all of them so uh let me just put uh zero here yeah you don't have to put all of the uh values you want however you can see here that since I removed Age and and left Hometown um it gave me the value of age because it's done in order so you have to be very careful about that because you will get stuff back that you don't expect so just just let letting you know about that um so name age Hometown just fix this Hometown we let's fix this so that uh it works in the examples yeah so matching against record types can be a little bit Troublesome sometimes if you don't know that detail so just keep that in mind uh there's other things you can do for extracting uh fields or at least they call it Fields what it really is is um applying a um procedure to the value that's coming in and then um checking the value against a pattern so let's say that we have a person here and we we use equal sign here which doesn't mean the value is equal what it means is we're going to call whatever ever the procedure is that is listed next and then compare the value that it returns to the value here and this could be any arbitrary match pattern right now we're just using 50 but it could be a listy structuring could be other things aside from that so what we're going to do is evaluate this and it's going to say not 50 years old because when we call person age on this person the value is 132 it doesn't match this 50 so it doesn't match so it goes down to this uh underscore field s the underscore pattern which underscore means match anything in this case we're just matching whatever value it is so uh not 50 years old is the value that gets returned um here if we create a person with the value of 50 for the age and evaluate this we'll see that it does say the person is 50 years old so there's that we can also use a um a predicate applier in this case so we say question mark person question mark So it if if it returns true then the it will apply the match pattern so if this is a person if the value is a person and it returns true it will it would match it using this pattern and then pull things out and in this case it is a person so it doesn't matter what age they are it will just uh it we just uh print print using the format expression that we have here so uh what can we do here just to show this I'm going to put just an arbitrary string in here because person will return false for a string if I execute that it says not 50 years old so it's just another way to sort of call any procedure in this case is expecting a predicate procedure that returns true or false and then it will uh apply a pattern here so those are a couple other useful things that you can use for uh your match Expressions so there's a couple other interesting ways to use uh match and uh those are the match Lambda and the match let Expressions so for match Lambda what it basically does is allow you to create a Lambda expression or an anonymous function let's say that is all it does is just do a match expression so in this case we have a match ex where we're looking for a list of 1 2 3 we're using an an to destructure that uh we saw an example just like that before what if we want to turn that into a function of its own that we can call somewhere else uh here we're calling uh Define match numbers we're creating a binding for a procedure called match numbers and we're calling match Lambda so this match Lambda here is effectively just creating a Lambda I mean really what it's doing is uh Lambda uh Val match Val so something like this it creates like a nested Lambda but it just sort of takes that pattern out out of the equation so that you can just call match Lambda directly so match Lambda and then Returns the procedure so that then you can call match numbers on uh any list that you give it and it will do that same match expression so it's a way to sort of create your own higher level uh procedures to do these match operations and give them a name um just so that you can use them in other places it kind of is useful for that the other useful thing to mention is uh match Lambda star are and the difference here is that uh this creates a Lambda that will take any number of arguments that you give to it not just a single argument so match Lambda expects expect expects a single argument a single value as a parameter match Lambda star takes any number of arguments as a value and it will um return that as a or turn that into a list that gets processed by um the match expression so uh in this case uh we can call match Lambda to create the same pattern as before that expects a list and here we say match numbers 1 2 3 I execute that it gives me two I execute the second one it gives me did not match because the there was not a one at the beginning so the point is that um you can turn this more into like a a fun function dispatching Lambda where you have a Lambda that can take different forms of input and different numbers of parameters and then you destructure them using a match Lambda so like a really um concise way to create a uh procedure that can take any number of forms of information um that matches match various different patterns so you can make some pretty Advanced procedures with match Lambda star uh in this case uh lastly we're going to talk about match let which is a way to do a let binding for um for a a block of expressions and uh I'm going to Define this my values uh list here it's another one of these nested lists where it has one and then a nested list of one two and then three we call U match let here and we're going to De decompose uh the my values value into a list of XYZ so I'm going to evaluate this and it's going to tell me that why is a list of one and two because we're not doing any sub list D structuring on y here we're just saying give me whatever the second value of the list is as y it's going to give you that whole subl list however um we can do some destructuring here look at this third example here if I were to evaluate this in fact let's uh oh yeah B so um that same my values that we had before we can destructure that nested expression get the values as a and b and I can print out B here which is two in this case so it's just another way to uh have a let that um uses the same functionality as the pattern matching in the normal match expression so that you can destructure some incoming value and create an expression block to to deal with that um so uh the same thing up here for uh for match let on this one matchet star so I can't remember like what the difference is match let Gile uh analogously to let Star oh okay so it's um got it so you can do Nest destructuring so look what we're doing here is we're saying my values we're we're pulling values out of my values we're looking for XYZ let Star allows us to do Bindings that refer to each other like a normal let Star so in this case we we're binding the second item of my values into Y and here we're doing another match pattern on y to bind the values of that as a and b if we execute that we'll see that b is two so actually this doesn't need to be a let star in fact I think we can probably uh put those in a different order so since we are able to uh create a binding of Y here we can refer to it in the next match pattern to do further destructuring if we wanted to do that so there another thing to keep in mind is that you can use match to form lead Expressions to do the similar type of destructuring as you can do in a normal match expression uh just for the purpose of setting up bindings and executing code as you normally would inside of a let now I don't know if those support named let match let is analogous to named let and can be also used for recursive functions which match on their arguments so it looks like you can actually do a named let with this so after looking into it for a bit it seems that uh it is possible to use match let with a named Le like expression where you can have a name for the let block and you can do looping patterns but I found it very difficult to determine how to terminate such a loop because when when you need to to destructure a list and you finally get to the empty list value at the end there doesn't seem to be a way to D structure The Binding for the uh the list that you're looping over uh as you can see in this example it actually doesn't work because the rest binding is not available at all times so it is possible to do a named let match let but I'm not 100% certain how to do it correctly so if you happen to know please leave a note in the comments uh or uh do a contribution to the show notes for this video so that other people people can see it later I'll mention that in a minute uh but that's basically how you can use match let to destructure uh incoming information into bindings like a normal let expression so I hope that uh this was useful as a way to sort of give you a primer into how to use the match expression in scheme implementations especially like G scheme as we talked about in this video um now the show notes for this video I would like to make it a place where people can contribute their own examples or information about how to use uh match Expressions so if you want to do that go to code.org system Crafters system crafter site uh that's a repository where the well that's the CI for the site that's actually not right let's see that the the link there we go uh this is the repository where the uh file will live uh check out the link in the show notes I'll put it down here before I post a video and you can click to go through to uh edit that page and add add more stuff that you would like to see there as well um and uh we could probably just try to like build up a little resource for match expressions for people who want to try to use that a little bit more in scheme so hope that video was helped for you today leave a note in the comments let me know also give the video a like if you liked it until next time happy hacking

In this video, I explain the 'match' expression in Scheme and show a number of examples for how it can be used both for destructuring of information in Scheme data types and to encode more complex matching logic in a concise way. Come see why 'match' is the Swiss Army knife of data processing in Scheme! #guile #scheme #match #programming LEARN GUILE SCHEME: Want to learn how to write Scheme for practical projects and tools? Check out my on-demand course titled "Hands-On Guile Scheme for Beginners" here: https://systemcrafters.net/courses/hands-on-guile-scheme-beginners/ SUPPORT THE CHANNEL: 👍 Support My Work: https://systemcrafters.net/how-to-help/#support-my-work 📰 Subscribe to the Newsletter: https://systemcrafters.net/newsletter/ 👕 https://store.systemcrafters.net 📘 Get Your Copy of Mastering Emacs: https://www.masteringemacs.org/r/systemcrafters?utm_source=yt&utm_medium=desc&utm_campaign=scme SHOW NOTES: https://systemcrafters.net/learning-guile-scheme/match-expressions/ CONTRIBUTE MORE EXAMPLES: https://codeberg.org/SystemCrafters/systemcrafters-site/src/branch/master/content/videos/learning-guile-scheme/match-expressions.org CHAPTERS: 00:00 What are Match Expressions? 01:39 Matching and Destructuring Lists 04:09 Destructuring Nested Lists 05:04 Matching Literal Values 06:28 Matching Against Multiple Patterns 08:32 Boolean Match Patterns 10:57 Matching Pairs and Looping 15:12 Matching Vectors 17:15 Matching Record Types 21:04 Matching Fields and Predicates 23:06 Match Procedures 25:39 Let Bindings with Match 29:21 Conclusion JOIN THE COMMUNITY: https://systemcrafters.net/community/ https://fosstodon.org/@daviwil MY CONFIGURATION: https://config.daviwil.com https://config.daviwil.com/emacs https://config.daviwil.com/systems (Guix) OTHER SERIES: - Emacs Essentials: https://www.youtube.com/watch?v=48JlgiBpw_I&list=PLEoMzSkcN8oPZvSdewHG8uApD7THlLLCV - Emacs From Scratch (2020 Version): https://www.youtube.com/watch?v=74zOY-vgkyw&list=PLEoMzSkcN8oPH1au7H6B7bBJ4ZO7BXjSZ - Emacs Tips: https://www.youtube.com/watch?v=wKTKmE1wLyw&list=PLEoMzSkcN8oMHJ6Xil1YdnYtlWd5hHZql - Emacs Desktop Environment: https://www.youtube.com/watch?v=f7xB2fFk1tQ&list=PLEoMzSkcN8oNPbEMYEtswOVTvq7CVddCS - Emacs IDE: https://www.youtube.com/watch?v=E-NAM9U5JYE&list=PLEoMzSkcN8oNvsrtk_iZSb94krGRofFjN - Emacs Mail: https://www.youtube.com/watch?v=yZRyEhi4y44&list=PLEoMzSkcN8oM-kA19xOQc8s0gr0PpFGJQ - Learning Emacs Lisp: https://www.youtube.com/watch?v=RQK_DaaX34Q&list=PLEoMzSkcN8oPQtn7FQEF3D7sroZbXuPZ7 - Craft Your System with GNU Guix: https://www.youtube.com/watch?v=iBaqOK75cho&list=PLEoMzSkcN8oNxnj7jm5V2ZcGc52002pQU CREDITS: Coriolis Effect by logos feat. stefsax, licensed Creative Commons 3.0 CC-BY http://ccmixter.org/files/mseq/26296 reNovation by airtone, licensed Creative Commons 3.0 CC-BY http://ccmixter.org/files/airtone/60674 ukeSounds by airtone, licensed Creative Commons 3.0 CC-BY http://ccmixter.org/files/airtone/32655 Between Worlds (Instrumental) by Aussens@iter, licensed Creative Commons 3.0 CC-BY http://ccmixter.org/files/tobias_weber/56664