Programming-Idioms.org

println("Hello, World!")

(0 until 10).foreach( _ => println("Hello"))

println("Hello\n"*10)

def doSomething(name: String): Unit = {
  println(s"My job here is done. Goodbye ${name}")
}

def square(x:Int): Int = x*x

case class Point(x: Float, y: Float)

items.foreach{doSomething(_)}

items.foreach(doSomething)

for {
  x <- items
} doSomething(x)

val items = List("a", "b", "c")
items.zipWithIndex.foreach{ case (item, index) => 
  println(s"$index => $item")
}

val x = Map("a" -> 1, "b" -> 2, "c" -> 3)

case class BinaryTree[T <: Ordered[T]](
	value: T,
	left: Option[BinaryTree[T]],
	right: Option[BinaryTree[T]]
)

sealed trait Tree[T <: Ordered[T]]:
  def search(x: T): Boolean
final case class Nil[T <: Ordered[T]]() extends Tree[T]:
  override def search(x: T): Boolean = false
final case class Node[T <: Ordered[T]](
    item: T,
    left: Tree[T],
    right: Tree[T]
) extends Tree[T]:
  override def search(other: T): Boolean =
    item compare other match
      case 0          => true
      case n if n < 0 => left.search(other)
      case n if n > 0 => right.search(other)

val shuffled = Random.shuffle(x)

val x = List(1, 2, 3, 4)
x.apply(Random.nextInt(x.size))

list.contains(x)

val x = Map("a" -> 1, "b" -> 2, "c" -> 3)
x.foreach{ case (key, value) => println(s"$key => $value")}

mymap.foreach { case (k, x) => println(s"$k => $x") }

def randomDraw(min: Double, max: Double): Double = {
  val range = max - min
  (random.doubleValue * range) + min
}

a + Random.nextInt(b + 1)

case class Node[T](value: T, children: List[Node[T]] = Nil)

x = x.reverse

def search[T](m: Iterable[Iterable[T]], x: T): Option[(Int, Int)] = {
  for ((row, i) <- m.view.zipWithIndex; (column, j) <- row.view.zipWithIndex if column == x)
    return Some((i, j))
  None
}

val tmp = a
a = b
b = tmp

s.toInt

val s = "ネコ"

val x = Array.ofDim[Double](m,n)

case class S(x: Int)
val items = List(S(3), S(4), S(2))
items.sortBy( item: S => item.x )

items.sortBy(_.x)

val without = {
  val (left, right) = items.splitAt(i)
  left ++ right.drop(1)
}

def f(i: Int): Int =
  if (i > 1){
    i * f(i-1) 
  } else{
    1
  }

def exp(x: Int, n: Int): Int {
  if(n == 0) {
    1
  } else if(n == 1) {
    x
  } else if(n%2 == 0) {
    exp(x*x, n/2)
  } else {
    x * exp(x*x, (n-1)/2)
  }
}

val x = Set[T]()

def add(x: Int, y: Int) = x + y
def add5 = add(5, _)
val seven = add5(2)

def add(x: Int)(y: Int) = x + y
val add5 = add(5)_

val t = s.substring(i, j)

val ok = s.contains(word)

s.reverse

Thread.sleep(5000)

val t = s.take(5)

val s = """line 1
line 2
line 3"""

val s = """line 1
          |line 2
          |line 3""".stripMargin

val chunks = s.split(" ")

while(true){
  println(3)
}

m.contains(k)

m.valuesIterator.contains(v)

val y = x.mkString(",")

val s = x.sum()

val s = i.toString

val y = x.filter(p)

val lines = Source.fromFile(filename).getLines().mkString("\n")

System.err.println(s"$x is negative")

println(args.mkString(" "))

val s = x.toString(2)

do {
  someThing()
  someOtherThing()
} while (c)

val b = s.startsWith(prefix)

val b = s.endsWith(suffix)

val c: Ordering[Int] = Ordering.Int
val sortedItems = items.sorted(c)

// Or using implicits:

val sortedItems = items.sorted

val s = scala.io.Source.fromURL(u).getLines().mkString("\n")

val xml = XML.loadFile("data.xml")

val blank = Option(s).forall(_.trim.isEmpty)

SortedMap.from(mymap).foreach{ case (k, x) => println(s"$k => $x") }

case class A(a: Int, b: Float, c: String)
val x = A(1,2.2f,"hello")
val y = A(1,2.2f,"hello")

b = x == y 

val n = x.size

val y = x.toSet

x = x.distinct

val n = Try(StdIn.readInt())

sealed trait Suit
case object Spades extends Suit
case object Hearts extends Suit
case object Diamonds extends Suit
case object Clubs extends Suit

def foo(): (String, Boolean) = ("bar", true)

true match {
  case _ if c1 => f1()
  case _ if c2 => f2()
  case _ if c3 => f3()
}

if (c1) {
  f1()
} else if (c2) {
  f2()
} else if (c3) {
  f3()
}

val items = List(a, b, c)

items.filter(_ != x)

def onlyDigits(s: String) = s.forall(_.isDigit) 

m - k

m -= k

val s = x.toString(16)

p.stripSuffix("/")

val t = s + i

val planet = "Earth"

elements.map(_ * c)

for (pair <- list.grouped(2))
  println(s"(${pair(0)}, ${pair(1)})")

val x = items.last

val ab = a ++ b

val ab = a ::: b

val n = s.length()

val n = mymap.size

"%,d".format(n)

object Quine extends App {
  val s = 
    """object Quine extends App {
      |  val s = 
      |    ""%2$s%1$s%2$s""
      |  print(s.stripMargin.format(s, "\""))
      |}"""
  print(s.stripMargin.format(s, "\""))
}

sys.exit(0)

val y = x.collect { case e if P(e) => T(e) }

val foo = sys.env.getOrElse("FOO", "none")

val newList = x :: items

x = if (condition()) "a" else "b"

x = if condition() then "a" else "b"