diff options
Diffstat (limited to 'scala.html.markdown')
| -rw-r--r-- | scala.html.markdown | 419 |
1 files changed, 318 insertions, 101 deletions
diff --git a/scala.html.markdown b/scala.html.markdown index e8cde611..8e00f135 100644 --- a/scala.html.markdown +++ b/scala.html.markdown @@ -1,40 +1,35 @@ --- -language: scala -author: Dominic Bou-Samra -author_url: http://dbousamra.github.com -filename: learnscala.scala +language: Scala +contributors: + - ["George Petrov", "http://github.com/petrovg"] + - ["Dominic Bou-Samra, "http://dbousamra.github.com"] +filename: learn.scala --- -Scala is a <insert something nice here> +Scala - the scalable language -```scala +```c -/////////////////////////////////////// -// Basic syntax -/////////////////////////////////////// -// Single line comments start with two forward slashes -/* -Multi line comments look like this. + +/* + Set yourself up: + + 1) Download Scala - http://www.scala-lang.org/downloads + 2) unzip/untar in your favourite location and put the bin subdir on the path + 3) Start a scala REPL by typing scala. You should see the prompt: + + scala> + + This is the so called REPL. You can run commands in the REPL. Let's do just that: */ -// Import packages -import scala.collection.immutable.List -// Import all "sub packages" -import scala.collection.immutable._ -// Import multiple classes in one statement -import scala.collection.immutable.{List, Map} -// Rename an import using '=>' -import scala.collection.immutable{ List => ImmutableList } -// Import all classes, except some. The following excludes Map and Set: -import scala.collection.immutable.{Map => _, Set => _, _} +println(10) // prints the integer 10 -// Your programs entry point is defined in an scala file using an object, with a single method, main: -object Application { - def main(args: Array[String]): Unit = { - // stuff goes here. - } -} +println("Boo!") // printlns the string Boo! + + +// Some basics // Printing, and forcing a new line on the next print println("Hello world!") @@ -48,20 +43,10 @@ x = 20 // error: reassignment to val var x = 10 x = 20 // x is now 20 -/////////////////////////////////////// -// Types -/////////////////////////////////////// - -// Almost all types are objects. - -// You have numbers -3 //3 - -// Math is as per usual -1 + 1 // 2 -2 - 1 // 1 -5 * 3 // 15 -6 / 2 // 3 +// Single line comments start with two forward slashes +/* +Multi line comments look like this. +*/ // Boolean values true @@ -73,75 +58,48 @@ false true == false // false 10 > 5 // true -// Strings and characters -"Scala strings are surrounded by double quotes" // -'a' // A Scala Char -'Single quote strings don't exist' // Error -"Strings have the usual Java methods defined on them".length -"They also have some extra Scala methods.".reverse // See scala.collection.immutable.StringOps +// Math is as per usual +1 + 1 // 2 +2 - 1 // 1 +5 * 3 // 15 +6 / 2 // 3 -/////////////////////////////////////// -// Basic control constructs -/////////////////////////////////////// -// if statements (else statements are optional) -if (10 > 5) println("10 is greater than 5") -// an else -if (x > 5) println("x is greater than 5") -else println("No it's not.") +// Evaluating a command in the REPL gives you the type and value of the result -// Iteration +1 + 7 -// A while loop -while (x < 10) { - println("x is still less then 10") - x += 1 -} +/* The above line results in: -// A do while loop -do { - println("x is still less then 10"); - x += 1 -} while (x < 10) + scala> 1 + 7 + res29: Int = 8 -// A for loop -for (x <- 0 until 10) { - println(x) -} + This means the result of evaluating 1 + 7 is an object of type Int with a value of 8 -// Any object implementing the map/filter/flatMap methods allows the use of a for loop: -val aListOfNumbers: List[Int] = List(1, 2, 3) -for (x <- aListOfNumbers) { - println(x) -} + 1+7 will give you the same result +*/ -// Pattern matching (see respective section) -x match { - case 5 => println("x is 5") - case 10 => println("x is 10") - case _ => println("default case") -} -/////////////////////////////////////// -// Functions, methods and classes -/////////////////////////////////////// +// Everything is an object, including a function. Type these in the REPL: -// Scala has classes +7 // results in res30: Int = 7 (res30 is just a generated var name for the result) -// classname is Dog -class Dog { - //A method called bark, returning a String - def bark: String = { - // the body of the method - "Woof, woof!" - } -} +// The next line gives you a function that takes an Int and returns it squared +(x:Int) => x * x + +// You can assign this function to an identifier, like this: +val sq = (x:Int) => x * x + +/* The above says this + + sq: Int => Int = <function1> -// They can contain nearly any other construct, including other classes, functions, methods, objects, case classes, traits etc. + Which means that this time we gave an explicit name to the value - sq is a function that take an Int and returns Int. -/////////////////////////////////////// -// Higher-order functions -/////////////////////////////////////// + sq can be executed as follows: +*/ + +sq(10) // Gives you this: res33: Int = 100. The result is the Int with a value 100 // Scala allows methods and functions to return, or take as parameters, other functions or methods. @@ -158,10 +116,64 @@ TODO // If the anonymous block AND the function you are applying both take one a List("Dom", "Bob", "Natalia") foreach println -// Scala collections have rich higher-order functions defined on them. Some examples: -// The map function takes a function/method, and applies it to each element in the structure -List(1, 2, 3) map (number => number.toString) +// Data structures + +val a = Array(1, 2, 3, 5, 8, 13) +a(0) +a(3) +a(21) // Throws an exception + +val m = Map("fork" -> "tenedor", "spoon" -> "cuchara", "knife" -> "cuchillo") +m("fork") +m("spoon") +m("bottle") // Throws an exception + +val safeM = m.withDefaultValue("no lo se") +safeM("bottle") + +val s = Set(1, 3, 7) +s(0) +s(1) + +/* Look up the documentation of map here - http://www.scala-lang.org/api/current/index.html#scala.collection.immutable.Map + * and make sure you can read it + */ + + +// Tuples + +(1, 2) + +(4, 3, 2) + +(1, 2, "three") + +(a, 2, "three") + +// Why have this? +val divideInts = (x:Int, y:Int) => (x / y, x % y) + +divideInts(10,3) // The function divideInts gives you the result and the remainder + +// To access the elements of a tuple, use _._n where n is the 1-based index of the element +val d = divideInts(10,3) + +d._1 + +d._2 + + + +// Combinators + +s.map(sq) + +val sSquared = s. map(sq) + +sSquared.filter(_ < 10) + +sSquared.reduce (_+_) // The filter function takes a predicate (a function from A -> Boolean) and selects all elements which satisfy the predicate List(1, 2, 3) filter (_ > 2) // List(3) @@ -176,3 +188,208 @@ aListOfNumbers foreach (x => println(x)) aListOfNumbers foreach println + + +// For comprehensions + +for { n <- s } yield sq(n) + +val nSquared2 = for { n <- s } yield sq(n) + +for { n <- nSquared2 if n < 10 } yield n + +for { n <- s; nSquared = n * n if nSquared < 10} yield nSquared + +/* NB Those were not for loops. The semantics of a for loop is 'repeat', whereas a for-comprehension + defines a relationship between two sets of data. Research this further */ + + + +// Loops and iteration + +1 to 5 +val r = 1 to 5 +r.foreach( println ) + +r foreach println +// NB: Scala is quite lenien when it comes to dots and brackets - study the rules separately. This +// helps write DSLs and APIs that read like English + +(5 to 1 by -1) foreach ( println ) + +// A while loops +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + +while (i < 10) { println("i " + i); i+=1 } // Yes, again. What happened? Why? + +i // Show the value of i. Note that while is a loop in the classical sense - it executes + // sequentially while changing the loop variable. while is very fast, faster that Java + // loops, but using the combinators and comprehensions above is easier to understand + // and parallelize + +// A do while loop +do { + println("x is still less then 10"); + x += 1 +} while (x < 10) + +// Tail recursion is an idiomatic way of doing recurring things in Scala. Recursive functions need an +// explicit return type, the compiler can't infer it. Here it's Unit. +def showNumbersInRange(a:Int, b:Int):Unit = { print(a); if (a < b) showNumbersInRange(a+1, b) } + + + +// Conditionals + +val x = 10 + +if (x == 1) println("yeah") +if (x == 10) println("yeah") +if (x == 11) println("yeah") +if (x == 11) println ("yeah") else println("nay") + +println(if (x == 10) "yeah" else "nope") +val text = if (x == 10) "yeah" else "nope" + +var i = 0 +while (i < 10) { println("i " + i); i+=1 } + + + +// Object oriented features + +// Classname is Dog +class Dog { + //A method called bark, returning a String + def bark: String = { + // the body of the method + "Woof, woof!" + } +} + +// Classes can contain nearly any other construct, including other classes, functions, methods, objects, case classes, traits etc. + + + +// Case classes + +case class Person(name:String, phoneNumber:String) + +Person("George", "1234") == Person("Kate", "1236") + + + + +// Pattern matching + +val me = Person("George", "1234") + +me match { case Person(name, number) => "We matched someone : " + name + ", phone : " + number } + +me match { case Person(name, number) => "Match : " + name; case _ => "Hm..." } + +me match { case Person("George", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", number) => "Match"; case _ => "Hm..." } + +me match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + +val kate = Person("Kate", "1234") + +kate match { case Person("Kate", _) => "Girl"; case Person("George", _) => "Boy" } + + + +// Regular expressions + +val email = "(.*)@(.*)".r // The suffix .r invokes method r on String, which makes it a Regex + +val email(user, domain) = "henry@zkpr.com" + +"mrbean@pyahoo.com" match { + case email(name, domain) => "I know your name, " + name +} + + + +// Strings + +"Scala strings are surrounded by double quotes" // +'a' // A Scala Char +'Single quote strings don't exist' // Error +"Strings have the usual Java methods defined on them".length +"They also have some extra Scala methods.".reverse // See scala.collection.immutable.StringOps + +println("ABCDEF".length) +println("ABCDEF".substring(2, 6)) +println("ABCDEF".replace("C", "3")) + +val n = 45 +println(s"We have $n apples") + +val a = Array(11, 9, 6) +println(s"My second daughter is ${a(2-1)} years old") + +// Some characters need to be 'escaped', e.g. a double quote inside a string: +val a = "They stood outside the \"Rose and Crown\"" + +// Triple double-quotes allow for strings to span multiple rows and contain funny characters +val html = """<form id="daform"> + <p>Press belo', Joe</p> + | <input type="submit"> + </form>""" + + + +// Application structure and organization + +// Importing things +import scala.collection.immutable.List + +// Import all "sub packages" +import scala.collection.immutable._ + +// Import multiple classes in one statement +import scala.collection.immutable.{List, Map} + +// Rename an import using '=>' +import scala.collection.immutable{ List => ImmutableList } + +// Import all classes, except some. The following excludes Map and Set: +import scala.collection.immutable.{Map => _, Set => _, _} + +// Your programs entry point is defined in an scala file using an object, with a single method, main: +object Application { + def main(args: Array[String]): Unit = { + // stuff goes here. + } +} + +// Files can contain multiple classes and objects. Compile with scalac + + + + +// Input and output + +// To read a file line by line +import scala.io.Source +for(line <- Source.fromPath("myfile.txt").getLines()) + println(line) + +// To write a file use Java's PrintWriter + + +``` + +## Further resources + +[Scala for the impatient](http://horstmann.com/scala/) + +[Twitter Scala school(http://twitter.github.io/scala_school/) + +[The scala documentation] + +Join the [Scala user group](https://groups.google.com/forum/#!forum/scala-user) + |