{placekitten}

├── .classpath ├── .gitignore ├── .project ├── README.md ├── files ├── LoremIpsum.txt ├── ObjectStore ├── data.tab ├── data2.tab ├── numbers n more.txt ├── numbers.txt ├── placekitten.com.html └── scanned-file.txt └── src └── exercises ├── Chapter1.scala ├── Chapter2.scala ├── Chapter3.scala ├── Chapter4.scala ├── Chapter5.scala ├── Chapter5_Java.java ├── Chapter6.scala ├── Chapter7 ├── Q1 │ ├── Q1_MultiPackage.scala │ ├── Q1_Setup.scala │ └── Q1_SinglePackage.scala ├── Q2 │ ├── Q2_Hack.scala │ └── Q2_Run.scala └── Q3 │ └── random.scala ├── Chapter7Runner.scala ├── Chapter8.scala └── Chapter9.scala /.classpath: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | .cache 2 | .settings/ 3 | bin/ 4 | scala-impatient.pdf -------------------------------------------------------------------------------- /.project: -------------------------------------------------------------------------------- 1 | 2 | 3 | Scala for the Impatient 4 | 5 | 6 | 7 | 8 | 9 | org.scala-ide.sdt.core.scalabuilder 10 | 11 | 12 | 13 | 14 | 15 | org.scala-ide.sdt.core.scalanature 16 | org.eclipse.jdt.core.javanature 17 | 18 | 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | Hi. If you are reading this, you are brave, brave person. I have collected my answers to _Scala for the Impatient_ 2 | since I could not find a complete set of answers anywhere. 3 | 4 | My environment is of Scala 2.9.1 using Scala IDE/Eclipse, which some of the examples questions in the text do not seem to match. The text does 5 | not indicate the version it was written against, and so I have no idea and have not yet been able to infer. Answers that 6 | seem out of alignment in the text have been commented on as such. I also google a lot in answering, since the questions 7 | often say to "search the scala doc", which is extremely difficult for a newbie. Suffice it to say, some answers may 8 | include tricks not yet introduced explicitly in the text. 9 | 10 | This is my first earnest effort to learn Scala (as a derivative interest to the 11 | Play (2.0) framework), and so far that I've seen. There are often 12 | many atomically-concise styles of answering problems with equivalent outcomes, but perhaps non-equivalent nuances. 13 | -------------------------------------------------------------------------------- /files/LoremIpsum.txt: -------------------------------------------------------------------------------- 1 | Proin pulvinar tincidunt pulvinar. Integer quis malesuada ante. Ut tellus ante, ultricies quis mattis eu, tristique in leo. Etiam dapibus nunc id risus feugiat porttitor. Vestibulum ornare ornare nisl, a egestas orci mattis et. Etiam sit amet massa at eros ullamcorper auctor. Nullam tincidunt porttitor hendrerit. Nam est nibh, porta quis fermentum a, varius eu leo. Vivamus luctus pellentesque blandit. Sed in tortor nibh. Vestibulum gravida placerat sem at feugiat. Nulla augue lectus, sollicitudin vel dictum tristique, fermentum eu libero. Quisque molestie, arcu eu tincidunt malesuada, justo odio luctus elit, in elementum leo magna sed risus. 2 | Nulla lectus quam, rhoncus nec lobortis eget, venenatis at libero. Donec egestas imperdiet nisi, nec faucibus mauris tempus nec. Donec justo urna, porta vitae vehicula vel, mattis sed purus. Donec magna magna, tempor at aliquet vel, pellentesque id est. Suspendisse potenti. Cras tincidunt ipsum in ipsum ultrices tempus. Donec dignissim, dolor sed suscipit imperdiet, tortor massa dictum elit, at consequat metus ligula a lacus. 3 | Quisque eget nulla tellus. Nullam porta ante non erat rutrum ut condimentum magna vulputate. Integer condimentum laoreet purus ut dictum. Integer pharetra dui quis lectus convallis ac vulputate libero fermentum. Vestibulum dolor mauris, facilisis non vestibulum et, porttitor ut massa. Nullam facilisis elementum risus eu ullamcorper. Nulla viverra fringilla odio eget accumsan. In hac habitasse platea dictumst. Mauris rhoncus consequat ante ut tempor. Ut id posuere mauris. Nullam gravida feugiat arcu non volutpat. Nunc suscipit, quam quis scelerisque malesuada, neque magna pellentesque nisl, at accumsan quam eros quis ligula. Praesent nec velit sed turpis varius venenatis et quis tortor. Integer iaculis, mauris vel cursus vestibulum, purus orci sodales magna, quis scelerisque enim lorem non sapien. Nam tempor risus ac diam molestie facilisis. Praesent eleifend, neque at sodales laoreet, quam velit auctor metus, vitae vehicula metus enim in lectus. 4 | Proin id velit nisi. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. In nisl orci, sollicitudin eget hendrerit suscipit, congue ac velit. Praesent id elit quis metus porta lobortis accumsan id ante. Phasellus mauris leo, accumsan quis hendrerit non, tristique in orci. In lacinia ipsum vel tellus vehicula euismod. Duis nec tortor eu lorem consectetur egestas. 5 | Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec aliquam consequat velit aliquam faucibus. Ut eu leo dui, at mattis magna. Nullam interdum sapien non justo vulputate tristique nec nec odio. Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vestibulum dapibus arcu nec tellus imperdiet pulvinar vel et urna. In pretium condimentum nisi, et imperdiet arcu condimentum at. Ut commodo mattis erat quis congue. Nunc et convallis nisi. 6 | Vestibulum posuere lectus id lorem tristique molestie et sit amet est. Nam fermentum facilisis rutrum. Nam condimentum lobortis nisl id eleifend. Sed nulla lectus, rutrum sed adipiscing vitae, posuere et lectus. In tristique vehicula est id porta. Quisque facilisis, libero vitae luctus lobortis, massa magna hendrerit enim, eu placerat ligula libero accumsan libero. Etiam a lectus leo, ac gravida ligula. 7 | Proin vitae enim turpis. Curabitur et lectus laoreet libero dictum mattis nec a quam. Vestibulum bibendum mi eu sem malesuada imperdiet. In ac imperdiet tellus. Nulla nec ante dui, et venenatis sem. Nam nec purus sit amet enim tempor accumsan accumsan ac ante. Pellentesque sed enim vel turpis porttitor condimentum. Integer luctus odio nec felis condimentum iaculis. Sed sit amet nisi tortor, at tincidunt urna. Nulla quis lectus ac massa dapibus volutpat. 8 | Praesent lacinia hendrerit sagittis. Proin commodo libero ut nibh aliquam at lobortis diam facilisis. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Nunc id purus sapien. Donec laoreet, nulla ut accumsan ultricies, erat magna egestas libero, bibendum feugiat mauris ligula a augue. Maecenas porttitor mi at libero hendrerit ut laoreet elit malesuada. Aliquam accumsan orci sed tortor porta iaculis. Mauris eu magna leo, ut condimentum dui. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; 9 | Etiam scelerisque blandit lorem in pretium. Cras nec neque vitae metus vulputate tempor. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Vivamus commodo, libero fringilla venenatis tincidunt, nunc velit varius nibh, vitae rhoncus urna libero at nulla. Ut laoreet risus ut sem scelerisque eget lobortis justo rutrum. Proin imperdiet accumsan massa, non tincidunt quam malesuada id. Curabitur eleifend ullamcorper erat. Nunc eget orci tortor. Fusce nulla odio, tempus et volutpat ac, mollis quis orci. Donec venenatis imperdiet felis, nec commodo ligula sagittis eu. Fusce venenatis auctor euismod. Nulla facilisi. Aenean pulvinar malesuada erat in porta. 10 | Cras nibh leo, hendrerit et porta vitae, mollis porttitor nulla. Nulla pellentesque ante neque. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Morbi pulvinar auctor mi, nec tristique elit adipiscing tincidunt. Integer volutpat semper arcu, nec bibendum tellus facilisis non. In euismod metus vel metus adipiscing egestas. Duis sagittis, lacus et vulputate lobortis, augue purus rutrum sem, a pellentesque sapien ligula at mauris. Donec id vulputate ante. 11 | Aliquam et libero purus, congue interdum dui. Nullam congue, erat id sodales dignissim, velit purus dapibus ligula, vel scelerisque nulla dolor vel mauris. Quisque dictum magna dictum augue consectetur malesuada. Integer convallis urna sed erat iaculis a sollicitudin orci posuere. Sed tempus, nisi ac accumsan cursus, est massa ornare nisl, non lacinia nisl leo eu ligula. In hac habitasse platea dictumst. Sed venenatis facilisis felis sed sagittis. Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia Curae; Cras felis turpis, laoreet ut fringilla dictum, tempus vitae ligula. Proin et nisl id ligula pulvinar pellentesque. Sed varius porta elit a dapibus. Curabitur magna libero, scelerisque scelerisque pellentesque condimentum, congue quis est. Nam dignissim augue at lorem convallis non ornare nisl consectetur. Cras arcu turpis, rhoncus consequat aliquet sit amet, cursus sit amet diam. Aliquam tincidunt, enim a adipiscing rhoncus, libero nisi lacinia elit, eu ultricies sapien odio id massa. Nam tempus, erat hendrerit varius vestibulum, libero nunc semper nulla, vitae facilisis enim nunc sed nisl. 12 | Suspendisse interdum consectetur vulputate. Sed id consectetur massa. Suspendisse pretium ultrices purus, ut aliquet justo venenatis id. Quisque eu nunc neque, et bibendum ipsum. Donec at nisi congue diam consequat interdum. Nullam sagittis nibh id nisi dapibus congue. Proin mattis lectus sed massa tempus mattis. Ut laoreet cursus elementum. Integer lacus orci, fermentum ut sodales eu, suscipit sit amet libero. Ut et risus felis, eget aliquam nunc. 13 | Proin ac risus ut nisl eleifend tincidunt. Praesent vel odio ac tellus gravida mollis. Integer interdum condimentum tellus feugiat vestibulum. Phasellus dictum nibh at tortor feugiat pretium. Nam elementum est vel massa tincidunt tempor et nec tortor. Vivamus rutrum eros id nisi ornare vulputate. Maecenas quis ultrices sem. Pellentesque vehicula rutrum urna, nec elementum elit suscipit id. Nullam scelerisque, eros eget volutpat ultricies, nisi neque tincidunt mauris, vel convallis arcu erat eu sem. Sed sed nulla augue, sed euismod felis. Duis risus mauris, pharetra id sagittis sed, aliquam eget tellus. Vestibulum vulputate, ante a varius auctor, sapien augue pellentesque tellus, id facilisis lacus libero sit amet sapien. 14 | Duis id tristique dolor. Integer eget nisi quis justo volutpat varius eget non ante. Nulla sed velit est. In et purus id quam imperdiet vulputate sed ut nibh. Vivamus dolor dolor, dapibus ac eleifend sed, pretium ac sapien. Mauris leo eros, accumsan iaculis volutpat tincidunt, ultricies quis orci. Proin at ligula leo. Proin sit amet justo sit amet tellus dapibus mattis non ac massa. Integer at orci ultrices ante convallis elementum in ut risus. Morbi ac congue orci. 15 | Cras gravida feugiat consequat. Integer aliquet laoreet nibh, at consequat elit tincidunt quis. Mauris interdum varius purus, non blandit orci porta nec. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. Sed blandit, velit et egestas lacinia, nulla magna tempus libero, eu posuere arcu erat ut metus. Pellentesque at tincidunt urna. Curabitur ut rhoncus nisl. Suspendisse potenti. Proin imperdiet congue vehicula. Nam neque ipsum, congue id fermentum in, rutrum in arcu. Donec libero odio, molestie quis consequat in, feugiat eu orci. Donec sed augue ac purus vestibulum rutrum at vitae dolor. Morbi pretium imperdiet condimentum. Aliquam condimentum ligula a erat volutpat accumsan. Aliquam aliquet laoreet odio eget pellentesque. Etiam eget elit vitae tortor semper scelerisque quis eu tortor. 16 | Vestibulum sagittis ultricies sollicitudin. Fusce mollis, magna quis eleifend lobortis, odio justo imperdiet enim, quis pretium orci risus ut risus. In tortor lacus, lacinia vitae volutpat id, viverra sit amet elit. Sed feugiat purus eu nibh varius vel vestibulum dui dignissim. Aliquam erat volutpat. Duis vel quam ipsum. Vivamus laoreet, diam quis porttitor aliquam, eros erat tincidunt sem, et sagittis diam nunc vitae turpis. Donec bibendum, ligula eget lobortis facilisis, augue massa bibendum est, non sagittis felis nibh sit amet diam. Maecenas placerat, sapien et cursus convallis, felis enim vehicula arcu, et dapibus urna velit non tortor. Curabitur auctor, orci eget scelerisque aliquam, augue diam ultricies nisl, sit amet tincidunt risus est sed tellus. Maecenas et enim dui. 17 | Morbi faucibus magna et eros tincidunt malesuada. Duis velit leo, pharetra quis dignissim sed, sodales vel elit. Pellentesque ut pulvinar lorem. Etiam tempus justo tempus lacus laoreet quis blandit neque porta. In venenatis arcu a dolor cursus a suscipit arcu euismod. Nullam tempor tincidunt neque a molestie. Praesent suscipit dignissim nulla, congue convallis neque pellentesque ut. Aliquam ligula dolor, scelerisque id vulputate et, pretium sollicitudin ligula. Ut lacus lacus, placerat nec vehicula et, hendrerit quis neque. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Donec at hendrerit nisi. Phasellus ac velit egestas odio pretium viverra. Duis et lorem non magna eleifend consequat eu nec mi. Nulla suscipit consequat massa, eu tempus tortor dapibus sit amet. 18 | Sed tincidunt imperdiet porta. Cras in tellus in velit bibendum dignissim ut pretium ligula. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Etiam vel nunc a elit tempus ultricies sit amet vitae massa. Duis aliquet, nulla vitae pellentesque volutpat, velit magna elementum lorem, vitae tempor tellus diam et lorem. Duis ultricies ante dui. Vivamus ligula mauris, convallis sit amet ultrices eget, gravida at ante. Class aptent taciti sociosqu ad litora torquent per conubia nostra, per inceptos himenaeos. 19 | Sed faucibus lectus eget est blandit porttitor. Aenean urna nisi, sodales vitae auctor et, vestibulum sit amet justo. Sed mollis laoreet neque, vitae lobortis turpis ultricies id. Curabitur sem elit, feugiat id porttitor sed, eleifend ut urna. Etiam sem dui, consectetur et commodo id, viverra et diam. Cras a tellus in justo porttitor mattis eu non risus. Nam posuere lobortis nunc eu convallis. Quisque neque diam, aliquet in blandit vitae, placerat sit amet magna. Maecenas pharetra imperdiet libero, ac elementum diam ornare quis. Mauris ultricies est purus. Curabitur eget ligula eget tortor accumsan semper ut id felis. In hac habitasse platea dictumst. Aliquam erat volutpat. Nunc lacinia cursus feugiat. Cras feugiat est vel tellus ornare in rhoncus neque faucibus. 20 | Etiam libero justo, placerat ac semper in, consequat sed mauris. Proin vitae lacus at tellus laoreet semper eget sit amet magna. Fusce laoreet tristique mi, sed blandit ligula laoreet facilisis. Curabitur at diam non leo volutpat volutpat in dapibus massa. Quisque in diam nisl. Sed venenatis posuere augue id dignissim. Mauris sit amet tristique sapien. Vivamus scelerisque, tortor sed mattis tincidunt, turpis arcu eleifend eros, ut feugiat est ante at dolor. Integer congue, arcu in lobortis gravida, nisl nisl bibendum tortor, id molestie tellus est eget felis. Suspendisse blandit nulla sed tellus rutrum eget eleifend sem congue. Integer ac elit eget ante vulputate volutpat eu eget augue. Vestibulum dapibus enim eu leo ultricies elementum non vitae lacus. Sed eu massa risus, eu egestas lectus. Ut feugiat scelerisque tristique. Nunc in nisi felis, vehicula ornare neque. 21 | -------------------------------------------------------------------------------- /files/ObjectStore: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/dirkraft/ScalaImpatient-AnswersAndNotes/44f9109f21096fcac781e49ac6d0c1ccbb73a50d/files/ObjectStore -------------------------------------------------------------------------------- /files/data.tab: -------------------------------------------------------------------------------- 1 | FRUIT FRUITINESS COLOR CHARACTERISTIC 2 | Apple 1 Red Angry 3 | Orange 3 Orange Warm 4 | Lemon 0.5 Yellow Sour 5 | Lime 0.25 Green Sleazy 6 | Blueberry 2 Blue Stubby 7 | Eggplant 0.1 Purple Stolid -------------------------------------------------------------------------------- /files/data2.tab: -------------------------------------------------------------------------------- 1 | FRUIT FRUITINESS COLOR CHARACTERISTIC 2 | Apple 1 Red Angry 3 | Orange 3 Orange Warm 4 | Lemon 0.5 Yellow Sour 5 | Lime 0.25 Green Sleazy 6 | Blueberry 2 Blue Stubby 7 | Eggplant 0.1 Purple Stolid 8 | -------------------------------------------------------------------------------- /files/numbers n more.txt: -------------------------------------------------------------------------------- 1 | 1.1 2 | 2.5 Random lorem ipsum in here 3 | -8.1 4 | 4.5 2.6 .0 5 | korruptin in ur data filez! 6 | 3.!!!-.2 7 | 8 | -------------------------------------------------------------------------------- /files/numbers.txt: -------------------------------------------------------------------------------- 1 | 1.1 2 | 2.5 3 | -8.1 4 | 4.5 2.6 0.0 5 | 6 | 3.0 7 | -------------------------------------------------------------------------------- /files/placekitten.com.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 29 | 30 | 31 | 32 | 33 | 34 | {placekitten} 35 | 36 | 37 | 38 | 39 | 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 | 49 | 50 | 51 | 52 | 53 | 54 | 55 | 56 | 57 | 58 | 59 | 60 | 61 | 62 | 63 | 64 | 65 | 66 | 67 | 68 | 69 | 70 | 71 | 72 | 82 | 83 | 84 | 85 | 86 |

87 | 88 |

89 | 90 |

91 | 92 | 95 | 96 |

A quick and simple service for getting pictures of kittens for use as placeholders in your designs or code. Just put your image size (width & height) after our URL and you'll get a placeholder.

97 | 98 |

99 | Like this: http://placekitten.com/200/300
100 | or: http://placekitten.com/g/200/300 101 |

102 | 103 |

104 | 105 |

106 | 107 |

108 |

109 |

110 |

111 |

112 |

113 |

114 |

115 |

116 | 117 |

118 | 119 | 122 | 123 |

124 | 125 | 126 | -------------------------------------------------------------------------------- /files/scanned-file.txt: -------------------------------------------------------------------------------- 1 | scanned-file.txt says Hello and Hello again says scanned-file.txt 2 | 3 | scanned-file.txt is creepy. scanned-file.txt knows your darkest secrets. 4 | 5 | 6 | 7 | 8 | scanned-file.txt is impatient with you. -------------------------------------------------------------------------------- /src/exercises/Chapter1.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | object Chapter1 extends App { 4 | // 1 5 | // Do it. 6 | 7 | // 2 8 | println(3 - math.pow(math.sqrt(3), 2)) 9 | 10 | // 3 11 | // val 12 | 13 | // 4 14 | println("crazy"*3) 15 | 16 | // 5 17 | println(10 max 2) 18 | 19 | // 6 20 | println(BigInt(2) pow 1024) 21 | 22 | // 7 23 | import BigInt.probablePrime, util.Random 24 | probablePrime(100, Random) 25 | 26 | // 8 27 | println(BigInt(100, Random) toString 36) 28 | 29 | // 9 30 | println("astring"(0), "astring".last) 31 | 32 | // 10 33 | println("abcdefg" take 3, "abcdefg" drop 3, "abcdefg" takeRight 3, "abcdefg" dropRight 3) 34 | } 35 | -------------------------------------------------------------------------------- /src/exercises/Chapter2.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | object Chapter2 extends App { 4 | // 1 5 | def signum(x: Int) = { 6 | if (x < 0) -1 else if (x == 0) 0 else 1 7 | } 8 | println(signum(-10), signum(0), signum(15)) 9 | 10 | // 2 11 | // Type = Unit, value = () 'no useful value' 12 | 13 | // 3 14 | // This forces x to receive the Unit () value, which is the return of the assignment of y = 1 15 | val x = y = 1 16 | 17 | // 4 18 | for (i <- 10 to (0, -1)) println(i) 19 | 20 | // 5 21 | def countdown(n: Int) { 22 | for (n <- n to (0, -1)) print(n) 23 | } 24 | countdown(5) 25 | println() 26 | 27 | // 6 28 | var prod = 1 29 | for (i <- "Hello") { prod *= i } 30 | println(prod) 31 | 32 | // 7 33 | prod = 1 34 | "Hello".foreach((c: Char) => prod *= c) 35 | println(prod) 36 | 37 | // 8 38 | def product(s: String) = { 39 | var prod = 1 40 | s.foreach((c: Char) => prod *= c) 41 | prod 42 | } 43 | println(product("Hello")) 44 | 45 | // 9 46 | def productRec(s: String): Int = { 47 | val tail = s.tail 48 | s.head * (if (tail.size == 0) 1 else productRec(s.tail)) 49 | } 50 | println(productRec("Hello")) 51 | 52 | // 10 53 | def intPow(x: Double, n: Int): Double = { 54 | if (n > 0 & n % 2 == 0) math.pow(intPow(x, n >> 1), 2) 55 | // n is odd... 56 | else if (n > 0) x * intPow(x, n - 1) 57 | else if (n == 0) 1 58 | else /*(n < 0)*/ 1 / intPow(x, -n) 59 | } 60 | println(math.pow(2, 2), intPow(2, 2)) 61 | println(math.pow(2, -2), intPow(2, -2)) 62 | } 63 | -------------------------------------------------------------------------------- /src/exercises/Chapter3.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | import scala.collection.mutable.ArrayBuffer 3 | 4 | // All the toList inside the println's are just so that the automatic toString produces something informative. 5 | object Chapter3 extends App { 6 | // 1 7 | def randArr(len: Int) = { 8 | (for (i <- 1 to len) yield util.Random.nextInt(11) - 5).toArray // Range [-5, 5] ( [] mean inclusive ) 9 | } 10 | val a = randArr(10) 11 | println(a.toList) 12 | 13 | // 2 14 | def swapPairsInPlace(arr: Array[Int]) = { 15 | for (i <- 0 until (if (arr.length % 2 == 0) arr.length else arr.length - 1, 2)) { 16 | val t = arr(i) 17 | arr(i) = arr(i + 1) 18 | arr(i + 1) = t 19 | } 20 | arr 21 | } 22 | println(swapPairsInPlace(a.clone).toList) 23 | // odd one test 24 | println(swapPairsInPlace(Array.concat(a, Array(2))).toList) 25 | 26 | // 3 27 | def swapPairs(arr: Array[Int]) = { 28 | (for (i <- 0 until arr.length) 29 | // first conditional takes care of the odd-length case 30 | yield if (i == arr.length - 1 & i % 2 == 0) arr(i) else if (i % 2 == 0) arr(i + 1) else arr(i - 1)).toArray 31 | } 32 | val q2 = swapPairs(a) 33 | println(q2.toList) 34 | // odd one test 35 | println(swapPairs(Array.concat(a, Array(3))).toList); 36 | 37 | // 4 38 | def posThenNeg(arr: Array[Int]) = { 39 | Array.concat(for (i <- arr if i > 0) yield i, for (i <- arr if i <= 0) yield i) 40 | } 41 | println(posThenNeg(a).toList) 42 | 43 | // 5 44 | val dbl = Array(0.5, 1.2, 3.7, 4.1, 2.2) 45 | println(dbl.sum / dbl.length) 46 | 47 | // 6 48 | var aClone = a.clone 49 | util.Sorting.quickSort(aClone) 50 | aClone = aClone.reverse // Warn: This creates a copy which quicksort does not. 51 | println(aClone.toList) 52 | val aBuf = a.toBuffer 53 | println(aBuf.sortWith(_ > _)) // Warn: Book example does not compile. aBuf.sortBy(-_) also works 54 | 55 | // 7 56 | println(a.distinct.toList) 57 | 58 | // 8 59 | // Warn: Maybe an older version of scala, drop behaved differently? This question is nonsense to all of 2.9.1's 60 | // IndexedSeqOptimized.drop(Int) .dropRight .dropWhile as I understand them. 61 | // Here's the example. Warn again!: Text does not compile, s.b. 'if elem' not 'if a' 62 | // println((for (elem <- a if elem % 2 == 0) yield 2 * elem).toList) 63 | // Here's a filter (to pick even numbers) and map-with-anonymous-function (to double them) solution. 64 | // _ * 2 is the shorthand for (x: Int) => 2 * x ? 65 | println(a.filter(_ % 2 == 0).map(_ * 2).toList) // filter reminds me of Django :) 66 | 67 | // 9 68 | println(java.util.TimeZone.getAvailableIDs().filter(_.startsWith("America/")).map(_.stripPrefix("America/")).toList) 69 | 70 | // 10 71 | import java.awt.datatransfer._ 72 | val flavors = SystemFlavorMap.getDefaultFlavorMap().asInstanceOf[SystemFlavorMap] 73 | println(collection.JavaConversions.asBuffer(flavors.getNativesForFlavor(DataFlavor.imageFlavor))) 74 | // Found this other fat way, but probably noms up extra cycles for no reason (fat). Interestingly you get an explicit 75 | // ArrayBuffer instead of just a Buffer like the previous line. 76 | // println(flavors.getNativesForFlavor(DataFlavor.imageFlavor).toArray.toBuffer) 77 | } 78 | -------------------------------------------------------------------------------- /src/exercises/Chapter4.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | // Simply for the sake of pure torture, I've eliminated as many '.' as possible in this exercise. Just awful. Let's just 4 | // see what the consequences are through this exercise. 5 | object Chapter4 extends App { 6 | // 1 7 | val wishlist: Map[String, Double] = Map( 8 | "Elephantine Braille Input Device" -> 322000, 9 | "Microsoft Word 95" -> 10, 10 | "4TB Ram Drive" -> 32000, 11 | "Apple" -> 0.60) 12 | println(wishlist) 13 | println(for ((k, v) <- wishlist) yield k -> (v * 0.9)) 14 | 15 | // 2 16 | { 17 | val in = new java.util.Scanner(new java.io.File("files/scanned-file.txt")) 18 | val wordCounts = collection.mutable.Map[String, Int]() withDefault (_ => 0) // awesome 19 | while (in hasNext) wordCounts(in next) += 1 // previous line's "awesome" makes this easy 20 | println(wordCounts) 21 | } 22 | 23 | // 3 24 | { 25 | val in = new java.util.Scanner(new java.io.File("files/scanned-file.txt")) 26 | var wordCounts = Map[String, Int]() withDefault (_ => 0) 27 | while (in hasNext) { 28 | val key = in next 29 | val currentCount = wordCounts(key) 30 | wordCounts = wordCounts - key + (key -> (currentCount + 1)) 31 | } 32 | println(wordCounts) 33 | } 34 | 35 | // 4 36 | { 37 | val in = new java.util.Scanner(new java.io.File("files/scanned-file.txt")) 38 | var wordCounts = collection.immutable.SortedMap[String, Int]() withDefault (_ => 0) 39 | while (in hasNext) { 40 | val key = in next 41 | val currentCount = wordCounts(key) 42 | wordCounts = wordCounts - key + (key -> (currentCount + 1)) 43 | } 44 | println(wordCounts) 45 | } 46 | 47 | // 5 48 | { 49 | val in = new java.util.Scanner(new java.io.File("files/scanned-file.txt")) 50 | val wordCounts = new java.util.TreeMap[String, Int] 51 | while (in hasNext) { 52 | val key = in next 53 | // If we omit both the . and () for "in.next()", the compiler sees ambiguity here. Need one of those or a blank line! 54 | 55 | if (!(wordCounts containsKey key)) wordCounts put (key, 0) 56 | wordCounts put (key, (wordCounts get key) + 1) // Just awful, parens (or dots) required, or else order of ops will cause wrong behavior. 57 | } 58 | println(wordCounts) 59 | } 60 | 61 | // 6 62 | import java.util.Calendar._ 63 | val stringsToCalConst = collection.mutable.LinkedHashMap( 64 | "Monday" -> MONDAY, 65 | "Tuesday" -> TUESDAY, 66 | "Wednesday" -> WEDNESDAY, 67 | "Thursday" -> THURSDAY, 68 | "Friday" -> FRIDAY, 69 | "Saturday" -> SATURDAY, 70 | "Sunday" -> SUNDAY) 71 | println(stringsToCalConst) 72 | 73 | // 7 74 | val props = collection.JavaConversions asMap (System getProperties) 75 | val maxLengthKey = ((props keySet) toList) maxBy (_ size) // '.' would make this a lot easier. Many extra parens are necessary. 76 | for ((k, v) <- props) { 77 | println(k + " " * ((maxLengthKey size) - (k size)) + " | " + v) // This makes a good case why being pro-whitespace can be dead wrong. 78 | } 79 | 80 | // 8 81 | val arr = Array(-5, 0, 5, 9, -2, 17, 3) 82 | def minmax(values: Array[Int]) = { 83 | (values min, values max) 84 | } 85 | println(minmax(arr)) 86 | 87 | // 9 88 | def lteqgt(values: Array[Int], v: Int) = { 89 | ((values filter (_ < v)) size, (values filter (_ == v)) size, (values filter (_ > v)) size) // All except tuple's parens could be eliminated with '.' 90 | } 91 | println(lteqgt(arr, 0)) 92 | 93 | // 10 94 | println("Hello".zip("World")) 95 | // Encryption? 96 | 97 | // Allowing so many '.' to be omitted can easily become detrimental as above. If it is to be, it is up to me... D.A.R.E 98 | } -------------------------------------------------------------------------------- /src/exercises/Chapter5.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | import scala.reflect.BeanProperty 3 | 4 | // Not doing the massive '.' omission this time. Going for best balance of concise (Scala generally good for this) and 5 | // most readable (Scala generally not so good for this), in my humble and perhaps naïve opinion. 6 | object Chapter5 extends App { 7 | // 1 8 | // copied and modified from page 52 9 | class Counter { 10 | private var value = Int.MaxValue - 1 11 | def increment() { if (value < Int.MaxValue) value += 1 } 12 | def current() = value 13 | override def toString() = "Counter:" + value 14 | } 15 | val c = new Counter 16 | println(c) 17 | c.increment() 18 | println(c) 19 | c.increment() 20 | println(c) 21 | 22 | // 2 seems kind of silly that balance is read only though we provide two mutators? Assuming "read-only" means only 23 | // public getters and no setters, here's a possibility. 24 | class BankAccount() { 25 | private var _balance = 0.0 26 | def balance = _balance // This sucks to have only g, yet another source of ++unreadableCode 27 | // Check for an alternative http://stackoverflow.com/questions/6641501/scala-public-getter-with-private-setter 28 | def withdraw(money: Double) = _balance -= money 29 | def deposit(money: Double) = _balance += money 30 | override def toString = "Balance:" + balance 31 | } 32 | val ba = new BankAccount 33 | println(ba) 34 | ba.withdraw(500) 35 | println(ba) 36 | ba.deposit(1000) 37 | println(ba) 38 | 39 | // 3 40 | { 41 | class Time(val hrs: Int, val min: Int) { 42 | def before(other: Time) = hrs < other.hrs || hrs == other.hrs && min < other.min 43 | override def toString = hrs + ":" + min 44 | } 45 | val noonThirty = new Time(12, 30) 46 | val sixAm = new Time(6, 0) 47 | val sleepyTime = new Time(19, 0) // <- old man 48 | println("12:30 means " + noonThirty.hrs + " hours and " + noonThirty.min + " minutes") // still needs to work in #4 49 | println("12:30 before 6:00 = " + noonThirty.before(sixAm)) 50 | println("12:30 before 19:00 = " + noonThirty.before(sleepyTime)) 51 | println("12:30 before 12:30 = " + noonThirty.before(noonThirty)) 52 | } 53 | 54 | // 4 55 | // I think this keeps the public API the same 56 | { 57 | class Time(val hrs: Int, val min: Int) { 58 | private val minSinceMidnight = hrs * 60 + min 59 | def before(other: Time) = minSinceMidnight < other.minSinceMidnight 60 | override def toString = hrs + ":" + min 61 | } 62 | val noonThirty = new Time(12, 30) 63 | val sixAm = new Time(6, 0) 64 | val sleepyTime = new Time(19, 0) // <- old man 65 | println("12:30 means " + noonThirty.hrs + " hours and " + noonThirty.min + " minutes") // still needs to work in #4 66 | println("12:30 before 6:00 = " + noonThirty.before(sixAm)) 67 | println("12:30 before 19:00 = " + noonThirty.before(sleepyTime)) 68 | println("12:30 before 12:30 = " + noonThirty.before(noonThirty)) 69 | } 70 | 71 | // 5 72 | class Student(@BeanProperty var name: String, @BeanProperty var id: Long) 73 | // Can you? Yes 74 | // Should you? Who knows. The pair of getters or setters seem identical in function according to the text. 75 | val s = new Student("The Hulk", 9001) 76 | println(s.name + " " + s.id) 77 | println(s.getName + " " + s.getId) 78 | s.name = "Dennis the Menace" 79 | s.id = 155239 80 | println(s.name + " " + s.id) 81 | s.setName("No, The Hulk") 82 | s.setId(9002) 83 | println(s.name + " " + s.id) 84 | 85 | // 6 86 | // Errata: There is no 'class Person' in 5.1 . There are many versions of 'class Person' beyond that. So forget it. 87 | // We'll just roll our own. 88 | { 89 | class Person(val name: String, ageParam: Int) { 90 | val age = if (ageParam < 0) 0 else ageParam 91 | } 92 | val p = new Person("Adrian Person", -5) 93 | println(p.name + " " + p.age) 94 | } 95 | 96 | // 7 97 | { 98 | class Person(name: String) { // plain, so we can do validation on it, and it can't become a field 99 | // mad google-fu http://stackoverflow.com/questions/2381666/multiple-assignment-of-non-tuples-in-scala 100 | val Array(firstName, lastName) = name.split(' ') 101 | } 102 | val p = new Person("Adrian Person") // throws exception if doesn't split exactly to two element Array, which I guess is good. 103 | println(p.lastName + ", " + p.firstName) 104 | } 105 | 106 | // 8 107 | { 108 | class Car( 109 | val manufacturer: String, 110 | val modelName: String, 111 | val modelYear: Int = -1, 112 | var licensePlate: String = "") { 113 | override def toString() = { 114 | "Manufacturer: " + manufacturer + " Model: " + modelName + " Year: " + modelYear + " Plate: " + licensePlate 115 | } 116 | } 117 | println(new Car("Ford", "Taurus")) 118 | println(new Car("Toyota", "Tundra", 2006)) 119 | println(new Car("Fiat", "European", licensePlate="ABC-123")) 120 | // I really don't know much about cars 121 | val c = new Car("Mystery", "Machine", 1969, "ZOINKS") 122 | println(c) 123 | c.licensePlate = "ZOINKS!" 124 | println(c) 125 | // Awkward question. There is only 1 primary constructor? Anyways, all the reqs can be satisfied in the primary 126 | // constructor. 127 | } 128 | 129 | //9 130 | { 131 | // see accompanying Java definition. Sometimes Scala IDE freaks out on this mixed code :( Have to project clean 132 | println(new Chapter5_Java.Car("Ford", "Taurus")) 133 | println(new Chapter5_Java.Car("Toyota", "Tundra", 2006)) 134 | println(new Chapter5_Java.Car("Fiat", "European", licensePlate="ABC-123")) 135 | val c = new Chapter5_Java.Car("Mystery", "Machine", 1969, "ZOINKS") 136 | println(c) 137 | c.licensePlate = "ZOINKS!" 138 | println(c) 139 | } 140 | 141 | // 10 142 | { // copied from text for reference 143 | class Employee(val name: String, var salary: Double) { 144 | def this() { this("John Q. Public", 0.0) } 145 | } 146 | } 147 | 148 | { // primary constructor + explicit fields version 149 | class Employee(defName: String = "John Q. Public", defSalary: Double = 0.0) { 150 | val name: String = defName 151 | var salary: Double = defSalary 152 | } 153 | // These constructors are implicating different interfaces. Specifically, that you can construct an Employee with 154 | // only one of either default. e.g. These are not allowed in the first form. 155 | new Employee("Frank Sinatra") 156 | new Employee(defSalary = 500.55) 157 | // If this is not desired, then the first/former might be preferred. 158 | } 159 | 160 | } -------------------------------------------------------------------------------- /src/exercises/Chapter5_Java.java: -------------------------------------------------------------------------------- 1 | package exercises; 2 | 3 | // Note this can't collide with Chapter5.scala and so is named differently. 4 | public class Chapter5_Java { 5 | 6 | // Corollary Java-equivalent of Chapter5.scala, #8 class Car 7 | public static class Car { 8 | public final String manufacturer; 9 | public final String modelName; 10 | public final Integer modelYear; 11 | public String licensePlate = ""; 12 | 13 | private final static Integer DEF_MODEL_YEAR = -1; 14 | private final static String DEF_LICENSE_PLATE = ""; 15 | 16 | public Car(String manufacturer, String modelName, Integer modelYear, String licensePlate) { 17 | this.manufacturer = manufacturer; 18 | this.modelName = modelName; 19 | this.modelYear = modelYear; 20 | this.licensePlate = licensePlate; 21 | } 22 | 23 | public Car(String manufacturer, String modelName, Integer modelYear) { 24 | this(manufacturer, modelName, modelYear, DEF_LICENSE_PLATE); 25 | } 26 | 27 | public Car(String manufacturer, String modelName, String licensePlate) { 28 | this(manufacturer, modelName, DEF_MODEL_YEAR, licensePlate); 29 | } 30 | 31 | public Car(String manufacturer, String modelName) { 32 | this(manufacturer, modelName, DEF_MODEL_YEAR, DEF_LICENSE_PLATE); 33 | } 34 | 35 | @Override 36 | public String toString() { 37 | return "Manufacturer: " + manufacturer + " Model: " + modelName + " Year: " + modelYear + " Plate: " 38 | + licensePlate; 39 | } 40 | } 41 | 42 | public static final String s1 = "This String should print for \"Chapter 9 #6\""; 43 | public static final String s2 = "This one as well \\ no problem."; 44 | } 45 | -------------------------------------------------------------------------------- /src/exercises/Chapter6.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | object Chapter6 extends App { 4 | // 1 5 | object Conversions { 6 | def inchesToCentimetres(inches: Double) = 2.54 * inches 7 | def gallonsToLitres(gallons: Double) = 3.78541178 * gallons 8 | def milesToKilometres(miles: Double) = 1.609344 * miles 9 | } 10 | 11 | // 2 12 | class UnitConversion(val conversionFactor: Double) { 13 | def convert(units: Double) = conversionFactor * units 14 | } 15 | object InchesToCentimetres extends UnitConversion(2.54) 16 | object GallonsToLitres extends UnitConversion(3.78541178) 17 | object MilesToKilometres extends UnitConversion(1.609344) 18 | 19 | // 3 20 | object Origin extends java.awt.Point 21 | // I suppose because Point has mutators, and you wouldn't want to allow moving the Origin. 22 | 23 | // 4 24 | class Point(x: Int, y: Int) extends java.awt.Point(x, y) 25 | object Point { 26 | def apply(x: Int, y: Int) = new Point(x, y) 27 | } 28 | println(Point(5, 10)) 29 | 30 | // 5 31 | // This is a bit meta (since we're already in an App) 32 | object InnerApp extends App { 33 | for (arg <- args.reverse) println(arg) 34 | } 35 | InnerApp.main(Array("1", "2", "3", "4", "5")) // I guess this is a way to simulate an App run 36 | 37 | // 6 38 | // Had to fix some Eclipse settings on this one. Went to Window->Preferences->General->Workspace: Forced 'Text File 39 | // Encoding' to Other: UTF-8. Also had to make sure all files in the project were saved in UTF-8 encoding, otherwise 40 | // the scala compiler choked and then Scala IDE choked on that (so you couldn't even really see the error). 41 | object Suits extends Enumeration { 42 | type Suits = Value // for #7 43 | val Clover = Value("♣") 44 | val Diamond = Value("♦") 45 | val Heart = Value("♥") 46 | val Spade = Value("♠") 47 | } 48 | println(Suits.values) 49 | 50 | // 7 51 | import Suits._ 52 | def isRed(suit: Suits) = suit == Heart || suit == Diamond 53 | // pairing with boolean that indicates the suit is red 54 | println(for (s <- Suits.values) yield (s, isRed(s))) 55 | 56 | // 8 57 | // I guess this is what they mean. Too lazy to Google it. Too lazy TO GOOGLE IT. So lazy... 58 | object RGBCubeCorners extends Enumeration { 59 | val Black = Value(0x000000) 60 | val Red = Value(0xff0000) 61 | val Green = Value(0x00ff00) 62 | val Blue = Value(0x0000ff) 63 | val Yellow = Value(0xffff00) 64 | val Cyan = Value(0x00ffff) 65 | val Magenta = Value(0xff00ff) 66 | val White = Value(0xffffff) 67 | } 68 | println(for (color <- RGBCubeCorners.values) yield ("0x%06x".format(0xFFFFFF & color.id), color)) 69 | // Google on... 70 | // Found and altered format String from http://stackoverflow.com/questions/6539879/how-to-convert-a-color-integer-to-a-hex-string-in-android 71 | // Adapted to Scala from http://www.scala-lang.org/node/732#comment-1356 72 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q1/Q1_MultiPackage.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7 2 | package impatient 3 | 4 | object MultiPackage { 5 | Q1TailObject // is directly visible 6 | Q1SecretishObject // is also merged into the current namespace 7 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q1/Q1_Setup.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7 2 | 3 | object Q1SecretishObject {} 4 | 5 | package impatient { 6 | 7 | object Q1TailObject {} 8 | 9 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q1/Q1_SinglePackage.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7.impatient 2 | 3 | object SinglePackage { 4 | Q1TailObject // is directly visible 5 | // Q1SecretishObject // is not in this namespace 6 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q2/Q2_Hack.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7.Q2.com.sun.servicetag 2 | 3 | class Registry -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q2/Q2_Run.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7.Q2 2 | 3 | object Q2_Run extends App { 4 | // Look I can instantiate even though it's a private constructor! 5 | new com.sun.servicetag.Registry() 6 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7/Q3/random.scala: -------------------------------------------------------------------------------- 1 | package exercises.Chapter7.Q3 2 | 3 | package object random { 4 | 5 | var seed = 0 6 | 7 | val a = 1664525 8 | val b = 1013904223 9 | val n = 32 10 | 11 | def setSeed(seed: Int) = this.seed = seed 12 | 13 | def next() = { 14 | val res = seed * a + b % (2 * n) 15 | seed = res 16 | res 17 | } 18 | 19 | def nextInt = next() 20 | 21 | // Text doesn't specify any guidelines for doubles. I'll take that to mean something easy, -1.0 to 1.0 22 | def nextDouble = 1.0 / next() 23 | } -------------------------------------------------------------------------------- /src/exercises/Chapter7Runner.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | // Sorry, can't keep it all in one file this time. I have to be somewhat careful not to pollute namespaces between 4 | // exercises too :/ 5 | object Chapter7Runner extends App { 6 | // 1 7 | // More awkward wording. This seems exactly contrary to the lesson of 7.4 which explains how these two forms can be 8 | // equivalent. I think I have an example of how they are different, but am unsure as to whether this was the intent 9 | // of the question. 10 | 11 | // Absorb Q1_Setup.scala . Then take a look at the difference between Q1_SinglePackage.scala and Q1_MultiPackage.scala 12 | 13 | // 2 14 | // Look at Q2_Run.scala, follow it through to see that the constructor I'm calling is indeed private. Figure it out? 15 | // ... Realize that there's package shadowing effect caused by Q2_Hack.scala . 16 | 17 | // 3 18 | { 19 | import Chapter7.Q3.random._ 20 | for (i <- 1 to 5) print(nextInt + " ") 21 | println 22 | setSeed(0) 23 | for (i <- 1 to 5) print(nextInt + " ") 24 | println 25 | setSeed(System.currentTimeMillis.toInt) 26 | for (i <- 1 to 5) print(nextInt + " ") 27 | println 28 | 29 | setSeed(0) 30 | for (i <- 1 to 5) print(nextDouble + " ") 31 | println 32 | setSeed(0) 33 | for (i <- 1 to 5) print(nextDouble + " ") 34 | println 35 | setSeed(System.currentTimeMillis.toInt) 36 | for (i <- 1 to 5) print(nextDouble + " ") 37 | println 38 | } 39 | 40 | // 4 41 | // Perhaps as a way to narrow unintentional consequences, e.g. accidentally putting stuff outside of defined classes 42 | // and objects. Perhaps as a way to advertise a limitation of the JVM to wary developers. 43 | 44 | // 5 45 | // private[...] is a scope modifier that customizes the private-ness (really, loosening on restrictions of 'private'). 46 | // private[com] whatever will allow access to this thingy to anything com and narrower. The scope of 'com' depends on 47 | // its context, like how question 2 introduces its own 'com' package that is actually far from the _root_ package. 48 | 49 | // 6 50 | { 51 | import java.util.{HashMap => JavaHashMap} 52 | import collection.mutable.{HashMap => ScalaHashMap} 53 | def toScalaMap[K, V](jMap: JavaHashMap[K, V]) = { 54 | val sMap = ScalaHashMap[K,V](); 55 | // The writer already mentioned conversions, right? So just using those. There's probably a JavaConverter, but 56 | // this way will definitely give us a completely new scala.collection.mutable.HashMap . I think the converter 57 | // just wraps the original Java map, though could be wrong. 58 | import collection.JavaConversions.mapAsScalaMap 59 | for ((k,v) <- jMap) sMap.put(k,v) 60 | sMap 61 | } 62 | val jMap = new JavaHashMap[String, Int](); 63 | jMap.put("one", 1) 64 | jMap.put("two", 2) 65 | jMap.put("three", 3) 66 | println(jMap) 67 | println(toScalaMap(jMap)) 68 | } 69 | 70 | // 7 71 | // I believe 6 is written with the imports at the inner-most level. 72 | 73 | // 8 74 | // It makes all the sub-packages available as starting reference points to other packages and types. 75 | // Good. Bad. It's all a matter of subjective perspective (opinion). I would be careful with this one. Because so 76 | // many package names are being mashed into the current context, you might quickly start to run into collision 77 | // problems. But sometimes we're lazy. And sometimes being lazy turns out okay. Sometimes it doesn't, and you end up 78 | // doing more work to fix the problems caused by the early laziness. 79 | 80 | // 9 81 | { // to help prove I am only doing one import, and no additional qualified names, I omitted all omittable dots 82 | import java.lang.System 83 | print("Authorization token: ") 84 | val username = System getProperty "user.name" 85 | val password = readLine 86 | if ("secret" equals password) println("Hello, " + username + ". Welcome to the real world.") 87 | else System.err println "Sorry, you are not identified. A robot death squad will be dispatched to your location after 3 failed attempts." 88 | // You can also use Console just as well. Either way requires one dot to 'err' 89 | } 90 | 91 | // 10 92 | // No way. Not doing this by eye. Have fun, guys. In any IDE that supports Scala (e.g. Eclipse>Scala IDE), put your 93 | // cursor within 'StringBuilder' below and press F3 (or however you go to the definition). You will recognize many 94 | // Java things that Scala is shadowing, and some Java things that Scala is aliasing. 95 | scala.StringBuilder 96 | } -------------------------------------------------------------------------------- /src/exercises/Chapter8.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | object Chapter8 extends App { 4 | // copied from the text, and added print statements, modified balance to 'protected' 5 | class BankAccount(initialBalance: Double) { 6 | protected var balance = initialBalance 7 | println(toString + " New account!") 8 | def deposit(amount: Double) = { 9 | balance += amount; 10 | println(toString + " Deposit") 11 | balance 12 | } 13 | def withdraw(amount: Double) = { 14 | balance -= amount; 15 | println(toString + " Withdrawal"); 16 | balance 17 | } 18 | // added toString to simplify printouts 19 | override def toString = "Balance: " + balance 20 | } 21 | 22 | 23 | // 1 24 | class CheckingAccount(initialBalance: Double) extends BankAccount(initialBalance) { 25 | // Implemented assuming 'private var balance' in the base class 26 | override def deposit(amount: Double) = { super.deposit(amount - 10) } 27 | override def withdraw(amount: Double) = { super.withdraw(amount + 10) } 28 | } 29 | { 30 | val account = new CheckingAccount(100) 31 | account.deposit(50) 32 | account.withdraw(50) 33 | } 34 | 35 | 36 | // 2 37 | class SavingsAccount(initialBalance: Double) extends BankAccount(initialBalance) { 38 | val monthlyInterestRate = 0.02 39 | private var freeMonthlyTrx = 3 40 | // Unless I'm mistaken, the BankAccount's 'private var balance' means we can't get to it at all in a subclass. So 41 | // I think the text is probably out of alignment with the intent, and I've changed the base class to have 42 | // 'protected var balance'. 43 | def earnMonthlyInterest = { 44 | balance += balance * monthlyInterestRate 45 | freeMonthlyTrx = 3 46 | println(toString + " Accrued interest") 47 | } 48 | override def deposit(amount: Double) = { 49 | super.deposit(amount - (if (freeMonthlyTrx > 0) 0 else 10)) 50 | freeMonthlyTrx -= 1 51 | balance 52 | } 53 | override def withdraw(amount: Double) = { 54 | super.withdraw(amount + (if (freeMonthlyTrx > 0) 0 else 10)) 55 | freeMonthlyTrx -= 1 56 | balance 57 | } 58 | } 59 | { 60 | val account = new SavingsAccount(1000) 61 | account.earnMonthlyInterest 62 | for (i <- 1 to 4) account.withdraw(100) 63 | account.earnMonthlyInterest 64 | for (i <- 1 to 4) account.deposit(100) 65 | } 66 | 67 | 68 | // 3 69 | // Trying to come up with a relatively original example, and some sensible members? 70 | // Manuscript 71 | // + BoundText 72 | // + Book 73 | // + Magazine 74 | // + Poster 75 | class Manuscript( 76 | val wordCount: Long, 77 | val year: Int, 78 | var condition: String) 79 | class BoundText( 80 | wordCount: Long, 81 | val pageCount: Int, 82 | year: Int, 83 | condition: String) extends Manuscript(wordCount, year, condition) { 84 | def avgWordsPerPage = wordCount / pageCount 85 | } 86 | class Book( 87 | wordCount: Long, 88 | pageCount: Int, 89 | val blankPageCount: Int, 90 | year: Int, 91 | condition: String) extends BoundText(wordCount, pageCount, year,condition) { 92 | override def avgWordsPerPage = wordCount / (pageCount - blankPageCount) 93 | } 94 | class Magazine( 95 | wordCount: Long, 96 | pageCount: Int, 97 | year: Int, 98 | condition: String) extends BoundText(wordCount, pageCount, year,condition) 99 | class Poster( 100 | wordCount: Long, 101 | year: Int, 102 | condition: String, 103 | val xDim: Float, 104 | val yDim: Float) extends Manuscript(wordCount, year,condition) { 105 | val area = xDim * yDim 106 | } 107 | // Feel free to flesh this out some more. I'm lazy. 108 | 109 | 110 | // 4 111 | abstract class Item { 112 | def price: Float 113 | def description: String 114 | // added to simplify prints 115 | override def toString = description + ": " + price 116 | } 117 | 118 | // override is optional for implementing abstracts 119 | class SimpleItem(override val price: Float, override val description: String) extends Item 120 | // Using Traversable as a sort of common type for all collection-y things. 121 | 122 | class Bundle(val items: collection.mutable.Set[Item], override val description: String) extends Item { 123 | // This trick just creates a collection of the prices of the items, and then calls sum on that. 124 | override def price = items.map(_.price).sum 125 | def add(item: Item) = items += item 126 | } 127 | { 128 | val bandaids = new SimpleItem(0.25f, "Band-aids 20pk") 129 | val gauze = new SimpleItem(1.20f, "Gauze 20m") 130 | val sanitizer = new SimpleItem(2.19f, "Sanitizer 200ml") 131 | val first_aid_kit = new Bundle(collection.mutable.HashSet(bandaids, gauze), "Patching, First-Aid Kit") 132 | println(bandaids) 133 | println(gauze) 134 | println(first_aid_kit) 135 | first_aid_kit.add(sanitizer) 136 | println(first_aid_kit) 137 | } 138 | 139 | 140 | // 5 141 | class Point(val x: Double, val y: Double) { 142 | override def toString = "(%f, %f)".format(x, y) 143 | } 144 | class LabeledPoint(val desc: String, x: Double, y: Double) extends Point(x, y) { 145 | override def toString = desc + " " + super.toString 146 | } 147 | { 148 | println(new Point(3.5, -7.12)) 149 | println(new LabeledPoint("Pointless", 0, 0)) 150 | } 151 | 152 | 153 | // 6 154 | // re-using Point here for the hell of it 155 | abstract class Shape(x: Double, y: Double) extends Point(x, y) { 156 | def centerPoint: (Double, Double) 157 | override def toString = "Center:" + centerPoint 158 | } 159 | 160 | // modeling such that (x,y) is the top left corner. The coordinate system increases left-right, up-down 161 | class Rectangle(x: Double, y: Double, val width: Double, val height: Double) extends Shape(x, y) { 162 | def centerPoint = (x + width / 2, y - height / 2) 163 | override def toString = "Location:(%f,%f), Height:%f, Width:%f, ".format(x, y, width, height) + super.toString 164 | } 165 | 166 | // modeling such that (x,y) is the center. 167 | class Circle(x: Double, y: Double, val radius: Double) extends Shape(x, y) { 168 | def centerPoint = (x, y) 169 | override def toString = "Location:(%f,%f), Radius:%f, ".format(x,y,radius) + super.toString() 170 | } 171 | 172 | { 173 | println(new Rectangle(1.5, 6.0, 3, 4.5)) 174 | println(new Circle(5, 5, 2.5)) 175 | } 176 | 177 | 178 | // 7 179 | class Square(x: Int, y: Int, width: Int) extends java.awt.Rectangle(x, y, width, width) { 180 | // This actually creates specifically, a no-arg constructor and one that only takes a width. With the primary 181 | // constructor, we have the three requested constructor forms. 182 | def this(width: Int = 0) { 183 | this(0, 0, width) 184 | } 185 | } 186 | { 187 | println(new Square) 188 | println(new Square(5)) 189 | println(new Square(2, 3, 1)) 190 | } 191 | 192 | 193 | // 8 194 | // Copied from the text on page 91 195 | class Person(val name: String) { 196 | override def toString = getClass.getName + "[name=" + name + "]" 197 | } 198 | class SecretAgent(codename: String) extends Person(codename) { 199 | override val name = "secret" // Don’t want to reveal name . . . 200 | override val toString = "secret" // . . . or class name 201 | } 202 | /* 203 | I'm not sure what you're supposed to get out of the -c option here. Anyways here's the output. 204 | 205 | C:\workspace\Scala for the Impatient\bin\exercises>javap -private Chapter8$Person 206 | Compiled from "Chapter8.scala" 207 | public class exercises.Chapter8$Person extends java.lang.Object implements scala.ScalaObject{ 208 | private final java.lang.String name; 209 | public java.lang.String name(); 210 | public java.lang.String toString(); 211 | public exercises.Chapter8$Person(java.lang.String); 212 | } 213 | 214 | C:\workspace\Scala for the Impatient\bin\exercises>javap -private Chapter8$SecretAgent 215 | Compiled from "Chapter8.scala" 216 | public class exercises.Chapter8$SecretAgent extends exercises.Chapter8$Person implements scala.ScalaObject{ 217 | private final java.lang.String name; 218 | private final java.lang.String toString; 219 | public java.lang.String name(); 220 | public java.lang.String toString(); 221 | public exercises.Chapter8$SecretAgent(java.lang.String); 222 | } 223 | 224 | */ 225 | 226 | 227 | // 9 228 | { // original text, added toString 229 | class Creature { 230 | val range: Int = 10 231 | val env: Array[Int] = new Array[Int](range) 232 | override def toString = super.toString + " Range:" + range + " Environment:" + env.toBuffer 233 | } 234 | class Ant extends Creature { 235 | override val range = 2 236 | } 237 | println(new Creature) 238 | println(new Ant) 239 | // notice Ant's env was constructed with range=0 as explained in the text, even though 2 is in the println 240 | } 241 | { // replaced Creature's 'val range' with 'def', added toString, in Ant still using 'val' 242 | class Creature { 243 | def range: Int = 10 244 | val env: Array[Int] = new Array[Int](range) 245 | override def toString = super.toString + " Range:" + range + " Environment:" + env.toBuffer 246 | } 247 | class Ant extends Creature { 248 | override val range = 2 249 | } 250 | println(new Creature) 251 | println(new Ant) // Ant's env is again constructed with range=0, even though range shows 2 in the println 252 | } 253 | { // replaced Creature's 'val range' with 'def', added toString, in Ant used 'def' 254 | class Creature { 255 | def range: Int = 10 256 | val env: Array[Int] = new Array[Int](range) 257 | override def toString = super.toString + " Range:" + range + " Environment:" + env.toBuffer 258 | } 259 | class Ant extends Creature { 260 | override def range = 2 261 | } 262 | println(new Creature) 263 | println(new Ant) // finally this does what we wanted 264 | } 265 | // This is already explained in the text (page 95), but essentially by overriding the getter directly (def), we're 266 | // ensuring the correct overridden range value is returned to the super class during construction. 267 | 268 | 269 | // 10 270 | /* I think the 'protected' outside the parens () refers to making the primary constructor only visible to extending 271 | * classes. The 'protected' inside the parens on the field (hence the 'val'), make the field only visible to extending 272 | * classes. All in the family, no outsiders. 273 | */ 274 | } -------------------------------------------------------------------------------- /src/exercises/Chapter9.scala: -------------------------------------------------------------------------------- 1 | package exercises 2 | 3 | 4 | object Chapter9 extends App { 5 | 6 | // 1 7 | { 8 | import io.Source 9 | val source = Source.fromFile("files/LoremIpsum.txt") 10 | val lines = source.getLines.toArray 11 | val out = new java.io.PrintWriter("files/LoremIpsum.txt") 12 | for (line <- lines.reverse) out.println(line) 13 | out.close() 14 | } 15 | 16 | // 2 17 | { 18 | val n = 16 19 | // This solution does not truncate column contents that are longer than the column is wide (pushing will occur). 20 | import io.Source 21 | val source = Source.fromFile("files/data.tab") 22 | val out = new java.io.PrintWriter("files/data2.tab") 23 | // Not writing to the same file on this one like the question asked. 24 | val lines = source.getLines.toArray // all into memory 25 | for (line <- lines) { 26 | val tokenz = line.split("""\t""") 27 | for (token <- tokenz) out.print(token + " " * (n - token.length)) 28 | out.println 29 | } 30 | out.close() 31 | } 32 | 33 | // 3 34 | for (line <- io.Source.fromFile("files/LoremIpsum.txt").getLines) for (word <- line.split("""\s+""") if word.size > 12) println(word) 35 | 36 | // 4 37 | { 38 | val floats = io.Source.fromFile("files/numbers.txt").mkString.split("""\s+""").map(_.toFloat) // sick 39 | println(floats.sum) 40 | println(floats.sum / floats.size) 41 | println(floats.max) 42 | println(floats.min) 43 | } 44 | 45 | // 5 46 | for (i <- 0 to 20) { 47 | val whole = math.pow(2, i).toInt.toString 48 | val frac = math.pow(2, -i) 49 | println(whole + " " * (10 - whole.size) + frac) 50 | } 51 | 52 | // 6 53 | // So this prints the String literals in a Java source file 54 | { 55 | import io.Source 56 | val file = Source.fromFile("src/exercises/Chapter5_Java.java").mkString 57 | // The regex is "(?:\\"|.)*?" . The """regex""" syntax isn't always better. I'm not sure if this is perfect, but 58 | // it gets some of the weirdness in Chapter5_Java.java alright. 59 | val strings = """"(?:\\"|.)*?"""".r.findAllIn(file).toList 60 | println(strings) 61 | } 62 | 63 | // 7 64 | { 65 | import io.Source 66 | val file = Source.fromFile("files/numbers n more.txt").mkString 67 | // The regex means (digits with a period within or ending it) or (a period in front of digits).In other words, each 68 | // token is all the stuff between valid floating point numbers, where these are all valid floating points: 69 | // 5. 2.5 -.2 (as they are in Java/Scala) 70 | val strings = file.split("""-?(\d\.\d*|\.\d+)""").toList 71 | // Printing Strings surround by ^startuntilend$ to clarify result. 72 | for (string <- strings) println("^" + string + "$") 73 | } 74 | 75 | // 8 76 | { 77 | // Shamelessly copied from placekitten.com . You should use it for your placeholders. It is appropriate for all the 78 | // sites, all the situations. 79 | import io.Source 80 | val file = Source.fromFile("files/placekitten.com.html").mkString 81 | val regex = """<\s*?img\s+[^>]*\s+src="(.*?)"\s+[^>]*>""".r 82 | for (regex(imgsrc) <- regex.findAllIn(file) ) println(imgsrc) 83 | } 84 | 85 | // 9 86 | { 87 | // Cheater way. I'm on a Windows machine which has a "find.exe" which does something else. So I've created a cyg.bat 88 | // which forces using the cygwin libs, i.e. exactly as it is, this is not portable. On most other machines, I would 89 | // imagine removing the cyg.bat will work. The counts should match between both the shell and jvm strategies. 90 | import sys.process._ 91 | // Next line commented out because it is not quite portable. 92 | //"""cyg.bat find . -name "*.class" -type f""" #| "wc -l" ! 93 | // Here's a non-shell way. Function copied from text page 105 94 | import java.io.File 95 | def subdirs(dir: File): Iterator[File] = { 96 | val children = dir.listFiles.filter(_.isDirectory) 97 | children.toIterator ++ children.toIterator.flatMap(subdirs _) 98 | } 99 | // Now count'em up. By mashing some statements into the for (loopage), we can yield all matches individually. 100 | val classFiles = for ( 101 | dir <- subdirs(new File(".")); 102 | // That f => is an anonymous function to filter, which is doing a quick and dirty regex string match. 103 | classFile <- dir.listFiles.filter(f => """^.+\.class$""".r.findFirstIn(f.getName).isDefined) 104 | ) yield classFile 105 | println(classFiles.size) 106 | } 107 | 108 | // 10 109 | // Copied from text page 106 110 | @SerialVersionUID(1L) class Person(val name: String, val age: Int) extends Serializable { 111 | override def toString = name + "(" + age + ")" 112 | } 113 | { 114 | val hal = new Person("Hal", 45) 115 | val meth = new Person("Methuselah", 969) 116 | val bob = new Person("Silent Bob", 28) 117 | val trex = new Person("T-Rex Bones", 2580450) 118 | val people = List(hal, meth, bob, trex) 119 | println(people) 120 | import java.io._ 121 | val out = new ObjectOutputStream(new FileOutputStream("files/ObjectStore")) 122 | out.writeObject(people) 123 | out.close() 124 | } 125 | { 126 | import java.io._ 127 | val in = new ObjectInputStream(new FileInputStream("files/ObjectStore")) 128 | val people = in.readObject().asInstanceOf[List[Person]] 129 | println(people) 130 | } 131 | } --------------------------------------------------------------------------------