Scala Functional Programming Patterns

相似文件 换一批

是 否 +2 论坛币

k人 参与回答

经管之家送您一份

应届毕业生专属福利!

求职就业群

赵安豆老师微信：zhaoandou666

经管之家联合CDA

送您一个全额奖学金名额~ !

立即领取

感谢您参与论坛问题回答

经管之家送您两个论坛币！

+2 论坛币

Grok and perform effective functional programming in Scala

About This Book

• Understand functional programming patterns by comparing them with the traditional object-oriented design patterns
• Write robust, safer, and better code using the declarative programming paradigm
• An illustrative guide for programmers to create functional programming patterns with Scala
  

Who This Book Is ForIf you have done Java programming before and have a basic knowledge of Scala and its syntax, then this book is an ideal choice to help you to understand the context, the traditional design pattern applicable, and the Scala way. Having previous knowledge of design patterns will help, though it is not strictly necessary.

What You Will Learn

• Get to know about functional programming and the value Scala's FP idioms bring to the table
• Solve day-to-day programming problems using functional programming idioms
• Cut down the boiler-plate and express patterns simply and elegantly using Scala's concise syntax
• Tame system complexity by reducing the moving parts
• Write easier to reason about concurrent code using the actor paradigm and the Akka library
• Apply recursive thinking and understand how to create solutions without mutation
• Reuse existing code to compose new behavior
• Combine the object-oriented and functional programming approaches for effective programming using Scala
  

In DetailScala is used to construct elegant class hierarchies for maximum code reuse and extensibility and to implement their behavior using higher-order functions. Its functional programming (FP) features are a boon to help you design “easy to reason about” systems to control the growing software complexities. Knowing how and where to apply the many Scala techniques is challenging. Looking at Scala best practices in the context of what you already know helps you grasp these concepts quickly, and helps you see where and why to use them.
This book begins with the rationale behind patterns to help you understand where and why each pattern is applied. You will discover what tail recursion brings to your table and will get an understanding of how to create solutions without mutations. We then explain the concept of memorization and infinite sequences for on-demand computation. Further, the book takes you through Scala's stackable traits and dependency injection, a popular technique to produce loosely-coupled software systems.
You will also explore how to currying favors to your code and how to simplify it by de-construction via pattern matching. We also show you how to do pipeline transformations using higher order functions such as the pipes and filters pattern. Then we guide you through the increasing importance of concurrent programming and the pitfalls of traditional code concurrency. Lastly, the book takes a paradigm shift to show you the different techniques that functional programming brings to your plate.
This book is an invaluable source to help you understand and perform functional programming and solve common programming problems using Scala's programming patterns.

Style and approach This is a hands-on guide to Scala's game-changing features for programming.
It is filled with many code examples and figures that illustrate various Scala idioms and best practices.

扫码加我 拉你入群

请注明：姓名-公司-职位

以便审核进群资格，未注明则拒绝

分享0 收藏1 回帖

关键词：Programming Functional function Patterns Pattern comparing effective knowledge design before

1. Singletons – being one and only one
   
2. 
   
3. A singleton is a class of which only a single instance can exist. How do we prevent anyone from creating yet another instance? The solution is to make the constructor inaccessible. Here it is:
   
4. 
   
5. public class Singleton {
   
6.       // Eager initialization
   
7.   private static final Singleton instance = new Singleton(); // 1
   
8. 
   
9.   private Singleton() { // 2
   
10.   /* client code cannot create instance */
    
11. }
    
12. 
    
13.       // Static factory method
    
14. public static Singleton getInstance() { // 3
    
15.   return instance;
    
16. }
    
17. 
    
18. // Driver code
    
19. public static void main(String[] args) {
    
20.   System.out.println(Singleton.getInstance());
    
21.   System.out.println(Singleton.getInstance());
    
22. }
    
23. }
    
24. Dissecting the code:
    
25. 
    
26. At 1, the static initializer creates the instance—also the final keyword ensures that the instance cannot be redefined.
    
27. At 2, the constructor access is private, so only the class methods can access it.
    
28. At 3, the public factory method gives access to the client code.

复制代码

1. Null Objects – the Scala way
   
2. 
   
3. Instead of using null to indicate missing values, Scala provides an Option class to represent optional values. Option can hold either Some value or None value. None indicates missing values. Please see http://www.scala-lang.org/api/current/index.html#scala.Option.
   
4. 
   
5. So instead of nulls, we return None. To see why, try the following code snippets in REPL:
   
6. 
   
7. scala> val m = List(Some("on"), None, Some("us"), None)
   
8. 
   
9. m: List[Option[String]] = List(Some(on), None, Some(us), None)
   
10. scala> for {
    
11. 
    
12.      |     Some(p) <- m
    
13. 
    
14.      | } println(p)
    
15. 
    
16. on
    
17. 
    
18. us
    
19. 
    
20. scala> val m = List(Some("on"), None, Some("us"), None)
    
21. 
    
22. m: List[Option[String]] = List(Some(on), None, Some(us), None)
    
23. 
    
24. scala> val p = m.flatten
    
25. 
    
26. p: List[String] = List(on, us)

复制代码

1. Scala singletons
   
2. 
   
3. Scala has singleton objects called companion objects. A companion object is an object with the same name as a class. A companion object also can access private methods and fields of its companion class. Both a class and its companion object must be defined in the same source file. The companion object is where the apply() factory method may be defined. Let's have a look at the following example of a companion class:
   
4. 
   
5. class Singleton {  // Companion class
   
6.   def m() {
   
7.     println("class")
   
8.   }         
   
9. }
   
10. And then its companion object as:
    
11. 
    
12. object Singleton { // Companion Object
    
13.   def m() {
    
14.     println("companion")
    
15.   }         
    
16. }

复制代码

1. The apply() factory method
   
2. 
   
3. If a companion object defines an apply() method, the Scala compiler calls it when it sees the class name followed by (). So, for example, when Scala sees something like:
   
4. 
   
5.                  Singleton(arg1, arg2, …, argN) // syntactic sugar
   
6. It translates the call into:
   
7. 
   
8.                  Singleton.apply(arg1, arg2,...,argN)
   
9. Open a Scala console and enter the following:
   
10. 
    
11. scala> val p = Map("one" -> 1, "two" -> 2)
    
12. p: scala.collection.immutable.Map[String,Int] = Map(one -> 1, two -> 2)
    
13. When we say Map("one" -> 1, "two" -> 2), it seems like we are calling a function named Map with the arguments—however, this form is just syntactic sugar. Under the hood, Map has a companion object whose apply method is being called, then the apply() method creates the Map object and assigns it to p.

复制代码

Builders

1. public class UsedCar {
   
2. private String make;
   
3. private String model;
   
4. private int kmDriven;
   
5. private int yearOfManufacturing;
   
6. 
   
7. private boolean hasGps;
   
8. private boolean hasAc;
   
9. private boolean hasAirBags;
   
10. private boolean hasAbs;
    
11.       // Setters/Getters not shown
    
12. }
    
13. 
    
14. public class UsedCarBuilder {
    
15. 
    
16. private final UsedCar car;
    
17. 
    
18. public UsedCarBuilder() {
    
19.   car = new UsedCar();
    
20. }
    
21. 
    
22. public UsedCarBuilder hasAirBags(final boolean b) {
    
23.   car.setHasAirBags(b);
    
24.   return this;
    
25. }
    
26. 
    
27. public UsedCarBuilder hasAbs(final boolean b) {
    
28.   car.setHasAbs(b);
    
29.   return this;
    
30. }
    
31. 
    
32. public UsedCarBuilder hasAc(final boolean b) {
    
33.   car.setHasAc(b);
    
34.   return this;
    
35. }
    
36. 
    
37. public UsedCarBuilder hasGps(final boolean b) {
    
38.   car.setHasGps(b);
    
39.   return this;
    
40. }
    
41. 
    
42. public UsedCarBuilder yearOfManufacturing(final int year) {
    
43.   car.setYearOfManufacturing(year);
    
44.   return this;
    
45. }
    
46. 
    
47. public UsedCarBuilder kmDriven(final int km) {
    
48.   car.setKmDriven(km);
    
49.   return this;
    
50. }
    
51. 
    
52. public UsedCarBuilder model(final String itsModel) {
    
53.   car.setModel(itsModel);
    
54.   return this;
    
55. }
    
56. 
    
57. public UsedCarBuilder make(final String itsMake) {
    
58.   car.setMake(itsMake);
    
59.   return this;
    
60. }
    
61. 
    
62. public UsedCar build() {
    
63.   // set sensible defaults for optional attributes - gps, ac, airbags, abs
    
64.   // check make and model are consistent
    
65.   // check year of manufacturing is sensible
    
66.   // check kmDriven is not negative
    
67.   return car;
    
68. }
    
69. }
    
70. 
    
71. public class Driver {
    
72. public static void main(String[] args) {
    
73.   // Note the method chaining
    
74.   UsedCar car = new UsedCarBuilder().make("Maruti").model("Alto")
    
75. .kmDriven(10000).yearOfManufacturing(2006).hasGps(false)
    
76. .hasAc(false).hasAbs(false).hasAirBags(false).build();
    
77.   System.out.println(car);
    
78. }
    
79. }
    
80. We design it like this for method chaining. Note the build() method of UsedCarBuilder. We get one place where we can check all the parameters rigorously before we return the UsedCar object. Making sure all fields satisfy the preconditions ensures the client code is not violating the contract.

复制代码