Scala for ruby programmers

scala
dla programistów ruby :)

Tymon Tobolski
http://teamon.eu

Scala - ???

• OOP + FP
• statycznie typowany
• kompilowany do JVM
• intergacja z Java

scala jest trudna
trait FilterMonadic[+A, +Repr] {
  def map[B, That](f: A => B)(implicit bf: CanBuildFrom[Repr, B, That]): That
  // ...
}

def zipWithIndexIf[T](list: List[T])(pred: T => Boolean): List[(T, Option[Int])] = {
    type R = List[(T, Option[Int])]
    def doZip(zipped: R, left: List[T], index: Int): R = left match {
        case x :: xs if pred(x) => doZip((x, Some(index)) :: zipped, xs, index + 1)
        case x :: xs => doZip((x, None) :: zipped, xs, index)
        case Nil => zipped
    }

    doZip(Nil, list, 0).reverse
}

serio?
List(1,2,3) map { e => e * 2 } // List[Int] = List(2, 4, 6)

serio?
List(1,2,3) map { e => e * 2 } // List[Int] = List(2, 4, 6)

List(1,2,3) map (_*2) // List[Int] = List(2, 4, 6)

List(1,2,3) map (2*) // List[Int] = List(2, 4, 6)

List(1,2,3) filter { _ > 1 } // List[Int] = List(2, 3)

(1 to 10) foreach { e => println(e) }

(1 to 10) foreach println

Monkey patching

2.days

Monkey patching
Implicit
conversions
implicit def Int2Time(i: Int) = new {
def days = i * 24* 60 * 60
}

2.days // 172800

Modules / Traits
module T1
  def foo
    "foo"
  end
end

module T2
  def bar
    "bar"
  end
end

class A
  include T1
  include T2
end

a = A.new
a.foo # => "foo"
a.bar # => "bar"

Modules / Traits
module T1
  def foo
    "foo"
  end
trait T1 {
end
  def foo = "foo"
}
module T2
  def bar
trait T2 {
    "bar"
  def bar = "bar"
  end
}
end
class A extends T1 with T2
class A
  include T1
val a = new A
  include T2
a.foo // "foo"
end
a.bar // "bar"
a = A.new
a.foo # => "foo"
a.bar # => "bar"

Singleton
class A
  def foo
    "instance"
  end

  class << self
    def foo
      "singleton"
    end
  end
end

A.new.foo # => "instance"
A.foo # => "singleton"

Singleton
class A
  def foo
    "instance" class A {
  end   def foo = "instance"
   }
  class << self
    def foo object A {
      "singleton"   def foo "singleton"
    end }
  end
end new A().foo // "instance"
A.foo // "singleton"
A.new.foo # => "instance"
A.foo # => "singleton"

Duck typing
class Duck
  def quack
  def walk
end

class Dove
  def quack
  def walk
end

class Cat
end

def quack_and_walk(animal)
  animal.quack
  animal.walk
end

quack_and_walk Duck.new
quack_and_walk Dove.new
quack_and_walk Cat.new # NoMethodError

Duck typing
class Duck class Duck {
  def quack   def quack
  def walk   def walk
end }

class Dove class Dove {
  def quack   def quack
  def walk   def walk
end }

class Cat class Cat
end
def quackAndWalk(a: { def quack; def walk }) = {
def quack_and_walk(animal)   a.quack
  animal.quack   a.walk
  animal.walk }
end
quackAndWalk(new Duck)
quack_and_walk Duck.new quackAndWalk(new Dove)
quack_and_walk Dove.new quackAndWalk(new Cat) // Compile error
quack_and_walk Cat.new # NoMethodError

DSL
class StackSpec extends FlatSpec with ShouldMatchers {

  "A Stack" should "pop values in last-in-first-out order" in {
    val stack = new Stack[Int]
    stack.push(1)
    stack.push(2)
    stack.pop() should equal (2)
    stack.pop() should equal (1)
  }

  it should "throw NoSuchElementException if an empty stack is popped" in {
    val emptyStack = new Stack[String]
    evaluating { emptyStack.pop() } should produce [NoSuchElementException]
  }
}

http://scalatest.org

DSL
class FilterExample extends ScalatraFilter {
  get("/hello") {
    <p>
      Hello world
    </p>
  }

  post("/world") {
// ...
  }
}

https://github.com/scalatra/scalatra

Immutability

val list = List(2, 3)
val list2 = 1 :: list

println(list) // List(2, 3)
println(list2) // List(1, 2, 3)

Built-in concurency
scala> (1 to 10) foreach println
1
2
3
4
5
6
7
8
9
10

Built-in concurency
scala> (1 to 10).par foreach println
1
2
3
4
5
8
9
10
6
7

Functional style
scala> Map(1 -> 2)
res9: scala.collection.immutable.Map[Int,Int] = Map(1 -> 2)

Functional style
scala> Map(1 -> 2)
scala> Map(1 -> 2) get _
res10: (Int) => Option[Int] = <function1>

Functional style
scala> Map(1 -> 2)
scala> Map(1 -> 2) get 1
res11: Option[Int] = Some(2)

Functional style
scala> Map(1 -> 2)
res12: Option[Int] = None

Functional style
scala> Map(1 -> 2)
scala> Map(1 -> 2) get 1 map (1+)

Functional style
scala> Map(1 -> 2)

Functional style
scala> Map(1 -> 2)
scala> Map(1 -> 2) get 1 map (1+) getOrElse 5
res15: Int = 3

Functional style
scala> Map(1 -> 2)
res15: Int = 3
res16: Int = 5

Web

• Play!
• Rails
• Lift
• Sinatra
• Scalatra
• ...
• ...

• Actors
• STM
• Fault Tolerance
• ...

• http://scala-lang.org
• http://akka.io
• http://typesafe.com
• http://scala.playframework.org/

• #scala @ irc.freenode.net
• #scala.pl @ irc.freenode.net

Scala for ruby programmers

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Scala for ruby programmers

Ähnlich wie Scala for ruby programmers (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Scala for ruby programmers

Hinweis der Redaktion