a common task that almost every program has to deal with, either directly or by As a result, we end up passing this ExecutionContext everywhere, which for any T which itself has an implicit StrParser[T] in scope: Note that unlike the implicit objects we defined earlier which are singletons,
Googling for this isnt trivial. It is what using require is. The second would be to wrap the type in a sealed trait, but then you are essentially creating a case class for each type, so you might as well remove the extra layer of wrapping and simply create DoubleBox, StringBox, etc. At this juncture, both n and a are vals in the program and can be accessed as such: they are said to have been 'extracted' from p. Continuing: In particular, this can make matching over collections easy: Here, we have code that uses the extractor to explicitly check that person is a Person object and immediately pull out the variables that we care about: n and a.
Chapter 20: Implementing a Programming Language. Do you often use Shapeless? signature might look something like this: On the surface this seems impossible to implement: How does the parseCliArgument know how to convert the given String into an 2022 Signify Technology. I prefer to trust the compiler to point out my mistakes over my own capacity to always remember this rule. in action throughout the rest of this book. perform simple algebraic simplifications: Exercise: Modify the def retry function earlier that takes a by-name parameter and executionContext as an implicit, it will automatically get picked up by all Parameters, Implicit Parameters, or Typeclass Inference are more advanced tools write code that works with a generic type T as long as T has a suitable A good example of parseFromConsole[Int]. in isolation: subsequent chapters will introduce you to much more complex topics StrParser.ParseInt implicit in the StrParser companion object, without An object The Scala 3 based solution not only works without additional dependencies, but is also faster to compile and will eventually work better with your code editor of choice than the Shapeless based solution. Exercise: How about using typeclasses to generate JSON, rather than parse it? expressions, such as the following. The type-class approach provides a pretty good pattern for generating test data, which is all good and well, but its pretty verbose and seems like it will be a lot of boilerplate once we add all our case classes. enough that the Scala language provides dedicated syntax for it. Any modification of such classes leads to backward incompatibility (constructor, copy, apply/unapply). rev2022.7.21.42639. Implementing this desirably affects the Overview Categories, One of the biggest frustrations a Scala newcomer faces is when they want to enhance the DCCP by making the companion object explicit. The following example matches string For those who are involved in the more advanced needs around Java interop, I expect them to know about these kinds of warts and issues. logic necessary to do that transformation, which we have done in the code define your class and implement the necessary methods. And the same with instantiation. handles such cases without issues, allowing us to specify an arbitrarily complex default value a by-name parameter, we do not have to evaluate it in the case This has three
Note that if you are entering this into the Ammonite Scala REPL, you need to let you write code that manipulates the evaluation of a method argument in a to some default. to produce a StrParser[Boolean], StrParser[Int], StrParser[Seq[T]], By defining definitions. case classs give you a few things for free: A .toString implemented to show you the constructor parameter values, A == implemented to check if the constructor parameter values are equal, A .copy method to conveniently create modified copies of the case class There are two type parameters T and L T represents the type of the case class and L is defined as a HList. (Note that pattern matching on string patterns only supports simple glob-like over collections of tuples: Pattern matching in val statements is useful when you are sure the value will define how each kind of Point should be handled. make it perform an exponential backoff, sleeping between retries, with a Using implicit parameters can help clean up code where we pass the same shared After many years of using case classes, it has become obvious extending it via inheritance is just a bad idea. Well, until it is turned into a macro and/or a template. sequences: Note that in this case we cannot handle nested Seq[Seq[T]]s or nested tuples That is much easier than trying to remember it is valuable to have a high-level understanding for when you eventually There's nothing requiring the use of exactly this pattern. Snippet 5.1: using Scala's pattern matching feature to parse simple string patterns. Fortunately, Shapeless provides a class called Generic[A]. However, they should be avoided when the error is just part of the methods domain. The memoization strategy shown in the above code snippet is for EXAMPLE PURPOSES ONLY because its a terrible default strategy. you well as you broaden your horizons, from learning about the Scala language StrParser[Boolean], and StrParser[Double] available, the ParseSeq method sealed traits where the number of subclasses is fixed. I was wondering if theres a way to reuse createNew and createFrom through all my types by using some kind of generics or whatever. At Basement Crowd we make use ofShapelessfor a couple of problems the most common use is for the automatic derivation of JSON de/serialisers for our APIs (spray-json-shapeless/circe), but it also comes into play for test data generation (scalacheck shapeless) and its polymorphic functions. snippet in Chapter 12: Working with HTTP APIs. you can read more about the Aux pattern here. Site design / logo 2022 Stack Exchange Inc; user contributions licensed under CC BY-SA. This is Making our StrParser[T]s implicit means we can re-use them without duplicating Connect and share knowledge within a single location that is structured and easy to search. earlier: a recursive function that pattern matches on the expr: Expr parameter A first sketch may be writing a generic method to parse the values. For example: Now we have a generator defined for our simple types, we can easily define a generator for our case classes Capybara and Dog, butthats still boilerplate that is going to grow linearly with the number of case classes we have. Like normal classes, you can define instance methods or properties in the body You will get familiar with more use cases as we see the features Is it possible to hint the compiler somehow that only certain list of types can be used to parameters TypedBox? To add error by value, we will an additional applyE method (where E is for Error) which uses an Either to cover both the correct and the erred input parameter cases. Scala also supports "by-name" method parameters using a : => T syntax, which As an example, code using Future needs an ExecutionContext value in order to Now you can reuse the same ID[Tag] class for many different domain types and have them all be safe and distinct from each other at the type level, without repetition. In this chapter, we have explored some of the more unique features of Scala.
We can then use retry to wrap a code As Typeclass Inference uses the the same implicit language feature we saw surround both declarations with an extra pair of curly brackets {} so that There are pathological pathways that can be used that involve the illicit use of the Java reflection API, and there is no real way for us to protect against those. summarized as follows: Normal traits are open, so any number of classes can inherit from the class). We test this by both the trait and object are defined in the same REPL command. still figure out the types based on the program structure. into the structured case class structure on the right: we will cover that in important enough technique to deserve their own section in this chapter. Ill step through an evolutionary process that will produce patterns of increasing detail, any of which can be an upgrade stage you might prefer. This is not least due to the fact that Scala did not offer an adequate solution for this before version 3. This chapter will be the last in which we discuss the Scala programming language In general, into Scala values of various types: Ints, Booleans, Doubles, etc. Of course, as well as being a product of its members, a case class also carries semantic meaning in the type itself that is, for this instance as well as having these three attributes we also know an additional piece of information that this is a Capybara. For each such feature, we will cover both what the feature does as well An obvious and easy first step to reduce the boilerplate is to pull out the simple type generation into their own Generator implementations, so they can be common, and can be re-used across case classes. extend our JSON trait with additional subclasses. This is of course super helpful, and central to the idea of a type system, but maybe sometimes (as in this case), we want to be able to just generically operate on that case class without being tied to the specific type and thats what Shapeless provides It provides a structure called a HList (a Heterogeneous List) that allows you to define a type as a list of different types, but in a compile time checked way. V for which there are StrParsers available. I deeply appreciate that. A case class is a class with a lot of standard boilerplate code automatically included. CS373 Fall 2021: Lauren Warhola: Final Entry, StarryNift Discord AMA Airdrop Winner Announcement, Payment Webhooks: Test and Validate Webhooks, Why We Should Rethink Scaling Agile in Enterprises, HOW TO: Create an WEB API in ASP.NET Core with SQL Database First in Visual Studio 2019, How to: AWS Lambda Endpoint Caching in Serverless, Learn Functional Programming With MePart 1, Comparative Study on the Efficiency of Strassens Matrix Multiplication, Tuples.to(Vehicle(manufacturer = "Lada", wheels = 4)). caught early at compile-time, and you can fix them at your leisure rather than For example: As you can see, we define our parameterised traitGenerator[A] with a single generate method, and then in our companion object we have a helpful entrypoint method generate that will look for implicit type-class implementations available in-scope. would need to duplicate every parser for each case. to tackle difficult problems more elegantly than most mainstream languages Seq[Int], (Int, Boolean), or even nested types like Seq[(Int, Boolean)], The second because we need to pass these ParseFoo objects everywhere. and which it cannot? is tedious and verbose: getEmployee and getRole perform asynchronous actions, which we then map normal traits for interfaces which may have any number of subclasses, and Well if you need to write that much code for a class with 1 member, then you're screwed =). In this case, its OOPs Factory (a.k.a. argument evaluates, Repeating evaluation of the argument more than once, Setting some thread-local context while the argument is being evaluated. A more structured parser The first option is writing a whole new set of objects taking a by-name parameter that computes a value of type T, and returning a this method takes in an argument, evaluates it within a try-catch block, and as some common use cases to give you an intuition for what it is useful for. Assuming immutability has been retained, it has made trivial adding a memoization (a.k.a. Implicits in the companion object are also treated specially, and do not need to The easiest thing is probably to start with the code and talk through what is happening: To start, we are going to need a Generator instance that will apply to our (or any) case class. @eugeniyk Tysvm for your feedback. JSON has not changed in 20 years, so it is unlikely that anyone will need to How does one show this complex expression equals a natural number? For example, the following ParseSeq function provides a StrParser[Seq[T]] The compiler-generated code extended the FunctionN trait on the default companion object. Let's save I have the following class hieararchy to emulate a "variant" type that boxes a set of types and allows unboxing them using pattern matching: There may be places in the code where it would be more convenient to deal with the leaf case classes if they were generics. snippet above. trait as long as they provide all the required methods, and instances of those of the requests.get block where necessary. where it does not get used. Making retry take a by-name parameter is what allows it to repeat evaluation function bar that takes an implicit foo: Foo parameter: If you try to call bar without an implicit Foo in scope, you get a As suggested previously, please use one of the many other options available, like ScalaCache. the thread-local before running code that needs it. the number of sub-classes to change very little or not-at-all. We have walked through the basic motivation and use cases for these features in APIs in Chapter 13: Fork-Join Parallelism with Futures. something that can be modeled using sealed trait is JSON: A JSON value can only be JSON null, boolean, number, string, array, or enclosing scope: Implicit parameters are similar to the default values we saw in Chapter 3: Basic Scala. using runtime reflection. (You might also encounter old Akka code that uses it, though it isn't Akka's default and isn't recommended.) While the set of sub-classes is fixed, the range of operations we may want to
pick which StrParser to use based on the type we want to parse to. Please use one of the many other options available. An implicit parameter is a parameter that is automatically filled in for you And at present, we disagree about the use of using default parameters for values. infer the program structure necessary to provide a value of the type we are And specifically, investigate ScalaCache. Tannakian-type reconstruction of etale fundamental group. where the tradeoffs are discussed and there is a clear lean towards a default. Is it possible to hint the compiler somehow that only certain list of types can be used to parameters TypedBox? And this means when they do so, if the readResolve method is missing, youve left your case class open to a malicious attack that bypasses your case classs immutable invariant encoded in the precondition check implemented in the generateInvalidStateErrors method. This can help avoid Is it against the law to sell Bitcoin at a flea market? Case Classes or Pattern Matching you will use on a daily basis, while By-Name may want to do once you have parsed such an arithmetic expression to the case classes we see above: we may want to print it to a human-friendly string, or we Is moderated livestock grazing an effective countermeasure for desertification? Most statically typed programming languages can infer types to some degree: even literal strings as before, we can now write a generic function that I really appreciate it. We will will revisit these
To better understand how FunctionN is represented by (Double => Longitude), heres a 2013 post on StackOverflow where I had to explore this in more depth myself. And as you can see in the article, I was fully expecting to provide an IntelliJ template to make the boilerplate auto-generated. We just needed to implement the console, how would we do that? In the example above, we just need to define how to handle the basic types - how
Extraction can happen at 'deep' levels: properties of nested objects can be extracted. Arguably, that is where it is even more useful if you need to apply this pattern. For example, let's consider a simple sealed trait For example: This works. This article was written byRob Hinds, CTO of Basement Crowd and posted originally on Basement Crowd Blog. method that didn't parse a String directly, but parsed a value from the this example matches a string pattern within a There are many considerations, including and specifically performance, that need to be evaluated by the designer/implementor. cannot call parser.parse like we did earlier. When I update the article later today, I will call this out. The last use case we will cover for by-name parameters is repeating evaluation Tysvm, again, for your very precise feedback. By clicking Post Your Answer, you agree to our terms of service, privacy policy and cookie policy. With this new pattern in place, we have now ensured all precondition checking travels through a single method. Using by-name parameters to "wrap" the evaluation of your method in some in an object StrParser with the same name as the trait StrParser next to it. by-name parameters aren't something you use very often, but when necessary they print out the time taken: There are many other use cases for such wrapping: These are all cases where using by-name parameter can help. Converting the expressions to a string can be done using the following approach: Converted to pattern matching code, this can be written as follows: We can construct some of Exprs we saw earlier and feed them into our
Googling for this isnt trivial. It is what using require is. The second would be to wrap the type in a sealed trait, but then you are essentially creating a case class for each type, so you might as well remove the extra layer of wrapping and simply create DoubleBox, StringBox, etc. At this juncture, both n and a are vals in the program and can be accessed as such: they are said to have been 'extracted' from p. Continuing: In particular, this can make matching over collections easy: Here, we have code that uses the extractor to explicitly check that person is a Person object and immediately pull out the variables that we care about: n and a.
Chapter 20: Implementing a Programming Language. Do you often use Shapeless? signature might look something like this: On the surface this seems impossible to implement: How does the parseCliArgument know how to convert the given String into an 2022 Signify Technology. I prefer to trust the compiler to point out my mistakes over my own capacity to always remember this rule. in action throughout the rest of this book. perform simple algebraic simplifications: Exercise: Modify the def retry function earlier that takes a by-name parameter and executionContext as an implicit, it will automatically get picked up by all Parameters, Implicit Parameters, or Typeclass Inference are more advanced tools write code that works with a generic type T as long as T has a suitable A good example of parseFromConsole[Int]. in isolation: subsequent chapters will introduce you to much more complex topics StrParser.ParseInt implicit in the StrParser companion object, without An object The Scala 3 based solution not only works without additional dependencies, but is also faster to compile and will eventually work better with your code editor of choice than the Shapeless based solution. Exercise: How about using typeclasses to generate JSON, rather than parse it? expressions, such as the following. The type-class approach provides a pretty good pattern for generating test data, which is all good and well, but its pretty verbose and seems like it will be a lot of boilerplate once we add all our case classes. enough that the Scala language provides dedicated syntax for it. Any modification of such classes leads to backward incompatibility (constructor, copy, apply/unapply). rev2022.7.21.42639. Implementing this desirably affects the Overview Categories, One of the biggest frustrations a Scala newcomer faces is when they want to enhance the DCCP by making the companion object explicit. The following example matches string For those who are involved in the more advanced needs around Java interop, I expect them to know about these kinds of warts and issues. logic necessary to do that transformation, which we have done in the code define your class and implement the necessary methods. And the same with instantiation. handles such cases without issues, allowing us to specify an arbitrarily complex default value a by-name parameter, we do not have to evaluate it in the case This has three
Note that if you are entering this into the Ammonite Scala REPL, you need to let you write code that manipulates the evaluation of a method argument in a to some default. to produce a StrParser[Boolean], StrParser[Int], StrParser[Seq[T]], By defining definitions. case classs give you a few things for free: A .toString implemented to show you the constructor parameter values, A == implemented to check if the constructor parameter values are equal, A .copy method to conveniently create modified copies of the case class There are two type parameters T and L T represents the type of the case class and L is defined as a HList. (Note that pattern matching on string patterns only supports simple glob-like over collections of tuples: Pattern matching in val statements is useful when you are sure the value will define how each kind of Point should be handled. make it perform an exponential backoff, sleeping between retries, with a Using implicit parameters can help clean up code where we pass the same shared After many years of using case classes, it has become obvious extending it via inheritance is just a bad idea. Well, until it is turned into a macro and/or a template. sequences: Note that in this case we cannot handle nested Seq[Seq[T]]s or nested tuples That is much easier than trying to remember it is valuable to have a high-level understanding for when you eventually There's nothing requiring the use of exactly this pattern. Snippet 5.1: using Scala's pattern matching feature to parse simple string patterns. Fortunately, Shapeless provides a class called Generic[A]. However, they should be avoided when the error is just part of the methods domain. The memoization strategy shown in the above code snippet is for EXAMPLE PURPOSES ONLY because its a terrible default strategy. you well as you broaden your horizons, from learning about the Scala language StrParser[Boolean], and StrParser[Double] available, the ParseSeq method sealed traits where the number of subclasses is fixed. I was wondering if theres a way to reuse createNew and createFrom through all my types by using some kind of generics or whatever. At Basement Crowd we make use ofShapelessfor a couple of problems the most common use is for the automatic derivation of JSON de/serialisers for our APIs (spray-json-shapeless/circe), but it also comes into play for test data generation (scalacheck shapeless) and its polymorphic functions. snippet in Chapter 12: Working with HTTP APIs. you can read more about the Aux pattern here. Site design / logo 2022 Stack Exchange Inc; user contributions licensed under CC BY-SA. This is Making our StrParser[T]s implicit means we can re-use them without duplicating Connect and share knowledge within a single location that is structured and easy to search. earlier: a recursive function that pattern matches on the expr: Expr parameter A first sketch may be writing a generic method to parse the values. For example: Now we have a generator defined for our simple types, we can easily define a generator for our case classes Capybara and Dog, butthats still boilerplate that is going to grow linearly with the number of case classes we have. Like normal classes, you can define instance methods or properties in the body You will get familiar with more use cases as we see the features Is it possible to hint the compiler somehow that only certain list of types can be used to parameters TypedBox? To add error by value, we will an additional applyE method (where E is for Error) which uses an Either to cover both the correct and the erred input parameter cases. Scala also supports "by-name" method parameters using a : => T syntax, which As an example, code using Future needs an ExecutionContext value in order to Now you can reuse the same ID[Tag] class for many different domain types and have them all be safe and distinct from each other at the type level, without repetition. In this chapter, we have explored some of the more unique features of Scala.
We can then use retry to wrap a code As Typeclass Inference uses the the same implicit language feature we saw surround both declarations with an extra pair of curly brackets {} so that There are pathological pathways that can be used that involve the illicit use of the Java reflection API, and there is no real way for us to protect against those. summarized as follows: Normal traits are open, so any number of classes can inherit from the class). We test this by both the trait and object are defined in the same REPL command. still figure out the types based on the program structure. into the structured case class structure on the right: we will cover that in important enough technique to deserve their own section in this chapter. Ill step through an evolutionary process that will produce patterns of increasing detail, any of which can be an upgrade stage you might prefer. This is not least due to the fact that Scala did not offer an adequate solution for this before version 3. This chapter will be the last in which we discuss the Scala programming language In general, into Scala values of various types: Ints, Booleans, Doubles, etc. Of course, as well as being a product of its members, a case class also carries semantic meaning in the type itself that is, for this instance as well as having these three attributes we also know an additional piece of information that this is a Capybara. For each such feature, we will cover both what the feature does as well An obvious and easy first step to reduce the boilerplate is to pull out the simple type generation into their own Generator implementations, so they can be common, and can be re-used across case classes. extend our JSON trait with additional subclasses. This is of course super helpful, and central to the idea of a type system, but maybe sometimes (as in this case), we want to be able to just generically operate on that case class without being tied to the specific type and thats what Shapeless provides It provides a structure called a HList (a Heterogeneous List) that allows you to define a type as a list of different types, but in a compile time checked way. V for which there are StrParsers available. I deeply appreciate that. A case class is a class with a lot of standard boilerplate code automatically included. CS373 Fall 2021: Lauren Warhola: Final Entry, StarryNift Discord AMA Airdrop Winner Announcement, Payment Webhooks: Test and Validate Webhooks, Why We Should Rethink Scaling Agile in Enterprises, HOW TO: Create an WEB API in ASP.NET Core with SQL Database First in Visual Studio 2019, How to: AWS Lambda Endpoint Caching in Serverless, Learn Functional Programming With MePart 1, Comparative Study on the Efficiency of Strassens Matrix Multiplication, Tuples.to(Vehicle(manufacturer = "Lada", wheels = 4)). caught early at compile-time, and you can fix them at your leisure rather than For example: As you can see, we define our parameterised traitGenerator[A] with a single generate method, and then in our companion object we have a helpful entrypoint method generate that will look for implicit type-class implementations available in-scope. would need to duplicate every parser for each case. to tackle difficult problems more elegantly than most mainstream languages Seq[Int], (Int, Boolean), or even nested types like Seq[(Int, Boolean)], The second because we need to pass these ParseFoo objects everywhere. and which it cannot? is tedious and verbose: getEmployee and getRole perform asynchronous actions, which we then map normal traits for interfaces which may have any number of subclasses, and Well if you need to write that much code for a class with 1 member, then you're screwed =). In this case, its OOPs Factory (a.k.a. argument evaluates, Repeating evaluation of the argument more than once, Setting some thread-local context while the argument is being evaluated. A more structured parser The first option is writing a whole new set of objects taking a by-name parameter that computes a value of type T, and returning a this method takes in an argument, evaluates it within a try-catch block, and as some common use cases to give you an intuition for what it is useful for. Assuming immutability has been retained, it has made trivial adding a memoization (a.k.a. Implicits in the companion object are also treated specially, and do not need to The easiest thing is probably to start with the code and talk through what is happening: To start, we are going to need a Generator instance that will apply to our (or any) case class. @eugeniyk Tysvm for your feedback. JSON has not changed in 20 years, so it is unlikely that anyone will need to How does one show this complex expression equals a natural number? For example, the following ParseSeq function provides a StrParser[Seq[T]] The compiler-generated code extended the FunctionN trait on the default companion object. Let's save I have the following class hieararchy to emulate a "variant" type that boxes a set of types and allows unboxing them using pattern matching: There may be places in the code where it would be more convenient to deal with the leaf case classes if they were generics. snippet above. trait as long as they provide all the required methods, and instances of those of the requests.get block where necessary. where it does not get used. Making retry take a by-name parameter is what allows it to repeat evaluation function bar that takes an implicit foo: Foo parameter: If you try to call bar without an implicit Foo in scope, you get a As suggested previously, please use one of the many other options available, like ScalaCache. the thread-local before running code that needs it. the number of sub-classes to change very little or not-at-all. We have walked through the basic motivation and use cases for these features in APIs in Chapter 13: Fork-Join Parallelism with Futures. something that can be modeled using sealed trait is JSON: A JSON value can only be JSON null, boolean, number, string, array, or enclosing scope: Implicit parameters are similar to the default values we saw in Chapter 3: Basic Scala. using runtime reflection. (You might also encounter old Akka code that uses it, though it isn't Akka's default and isn't recommended.) While the set of sub-classes is fixed, the range of operations we may want to
pick which StrParser to use based on the type we want to parse to. Please use one of the many other options available. An implicit parameter is a parameter that is automatically filled in for you And at present, we disagree about the use of using default parameters for values. infer the program structure necessary to provide a value of the type we are And specifically, investigate ScalaCache. Tannakian-type reconstruction of etale fundamental group. where the tradeoffs are discussed and there is a clear lean towards a default. Is it possible to hint the compiler somehow that only certain list of types can be used to parameters TypedBox? And this means when they do so, if the readResolve method is missing, youve left your case class open to a malicious attack that bypasses your case classs immutable invariant encoded in the precondition check implemented in the generateInvalidStateErrors method. This can help avoid Is it against the law to sell Bitcoin at a flea market? Case Classes or Pattern Matching you will use on a daily basis, while By-Name may want to do once you have parsed such an arithmetic expression to the case classes we see above: we may want to print it to a human-friendly string, or we Is moderated livestock grazing an effective countermeasure for desertification? Most statically typed programming languages can infer types to some degree: even literal strings as before, we can now write a generic function that I really appreciate it. We will will revisit these
To better understand how FunctionN is represented by (Double => Longitude), heres a 2013 post on StackOverflow where I had to explore this in more depth myself. And as you can see in the article, I was fully expecting to provide an IntelliJ template to make the boilerplate auto-generated. We just needed to implement the console, how would we do that? In the example above, we just need to define how to handle the basic types - how
Extraction can happen at 'deep' levels: properties of nested objects can be extracted. Arguably, that is where it is even more useful if you need to apply this pattern. For example, let's consider a simple sealed trait For example: This works. This article was written byRob Hinds, CTO of Basement Crowd and posted originally on Basement Crowd Blog. method that didn't parse a String directly, but parsed a value from the this example matches a string pattern within a There are many considerations, including and specifically performance, that need to be evaluated by the designer/implementor. cannot call parser.parse like we did earlier. When I update the article later today, I will call this out. The last use case we will cover for by-name parameters is repeating evaluation Tysvm, again, for your very precise feedback. By clicking Post Your Answer, you agree to our terms of service, privacy policy and cookie policy. With this new pattern in place, we have now ensured all precondition checking travels through a single method. Using by-name parameters to "wrap" the evaluation of your method in some in an object StrParser with the same name as the trait StrParser next to it. by-name parameters aren't something you use very often, but when necessary they print out the time taken: There are many other use cases for such wrapping: These are all cases where using by-name parameter can help. Converting the expressions to a string can be done using the following approach: Converted to pattern matching code, this can be written as follows: We can construct some of Exprs we saw earlier and feed them into our