1. (1 to 10) map { _ * 2 }
1.upto(10).map { |x| x * 2 }
2. (1 to 1000).reduceLeft( _ + _ )
1.upto(1000).inject { |a, x| a + x }
3. val wordlist = List("scala", "akka", "play framework", "sbt", "typesafe")
wordlist = ["scala", "akka", "play framework", "sbt", "typesafe"]
val tweet = "This is an example tweet talking about scala and sbt."
tweet = "This is an example tweet talking about scala and sbt"
(words.foldLeft(false)( _ || tweet.contains(_) ))
wordlist.any? { |w| tweet[w] }
4. val FileText = io.Source.fromFile("data.txt").mkString
file_text = File.read 'data.txt'
val fileLines = io.Source.fromFile("data.txt").getLines.toList
file_lines = File.read('data.txt').lines
Or, more typically,
File.open('data.txt').each { |line| ... }
5. (1 to 4).map { i => "Happy Birthday " + (if (i == 3) "dear NAME" else "to You") }.foreach { println }
4.times { |i| puts "Happy Birthday #{i == 2 ? "dear NAME" : "to You"}" }
6. val (passed, failed) = List(49, 58, 76, 82, 88, 90) partition ( _ > 60 )
passed, failed = [49, 58, 76, 82, 88, 90].partition { |x| x > 60 }
7. val results = XML.load("http://search.twitter.com/search.atom?&q=scala")
results = Nokogiri::XML open 'http://search.twitter.com/search.atom?&q=scala'
8. List(14, 35, -7, 46, 98).reduceLeft ( _ min _ )
[14, 35, -7, 46, 98].min
[14, 35, -7, 46, 98].inject { |m, i| i > m ? i : m }
I'm impressed! Scala's lambda syntax is obviously bar none. The dual _ + _ was especially pleasing, and completely unexpected. The List() construct is also entirely warranted in place of array literals, given Scala's wide variety of collection types. On the other hand, what is this io.Source.fromFile mess? I don't understand the alternating capitalization, or the need for deep namespacing of an incredibly common type.
i) For 1 & 2 remember to have `Range` loaded first.
ii). OK I cheated on 6 because there is no partition currently in the Io core lib. Here is a "simple" way I did it for the example:
Okay, here it is in Perl, the granddaddy of them all when it comes to implicit variables:
1. map { $_ * 2 } (1..10)
2. reduce { $a + $b } (1..1000)
3. scalar grep { /(scala)|(akka)|(play framework)|(sbt)|(typesafe)/ } "This is an example tweet talking about scala and sbt." # Pow, easy regex syntax!
4. open(my $fh, '<', "data.txt"); $/ = undef; my $text = <$fh>;
open(my $fh, '<', "data.txt"); my @lines = <$fh>;
7. # I'm not even going to try, because XML::Parser is disgusting. I'll just point out that you'd probably have the same amount of verbosity and disgustingness telling Scala (or Ruby) to parse $arbitrary_data_format, so XML being a one-liner really isn't a huge win.
> On the other hand, what is this io.Source.fromFile mess? I don't understand the alternating capitalization, or the need for deep namespacing of an incredibly common type
Not at all necessary, just convenient for demos since it saves you an import.
"io" : The package is scala.io (the scala part is already imported by default). Following java, package names are always lower case.
"Source": There is a singleton object in the io package called 'Source'. Again, like java, classes and constants (including singleton objects) are capitalized.
"fromFile": A method on the Source singleton. Methods are camelCase.
In 'real' scala code the line would look like:
import io.Source
(...)
val fileText = Source.fromFile("data.txt").mkString
or, even more concisely
import io.Source.fromFile
(...)
val fileText = fromFile("data.txt").mkString
Since methods are just functions (a first class data type), there's no problem importing methods directly.
(edit: I also note that you didn't include all your imports, such as nokogiri, so it's not entirely a level playing filed)
It's calling the fromFile method on the io.Source object. Package names are lower-case by convention, class and object names are capitalized camel-case, and methods are lower-case camel-case.
Also, 1.upto(10) can also be written as (1..10) in ruby