# Scala, Python quick reference

syntax | Scala | Python |
---|---|---|

immutable variable | `val x = 1` |
Starlark:`REV = "1.1.0"` |

lazy variable | `lazy val x = 1` |
n/a |

mutable variable | `var x = 1` |
in function:`x = 1` |

if expression | `if (x > 1) "a" else "b"` |
`"a" if x > 1 else "b"` |

———————- | —————————- | —————————- |

function | `def add3(x: Int): Int =` ` x + 3` |
`def add3(x):` ` return x + 3` |

anonymous function | `_ * 2` |
not in Starlark:`lambda x: x * 2` |

———————- | —————————- | —————————- |

List | `val xs = List(1, 2, 3, 4)` |
`xs = [1, 2, 3, 4]` |

size | `xs.size` |
`len(xs)` |

empty test | `xs.isEmpty` |
`not xs` |

head | `xs.head` |
`xs[0]` |

tail | `// List(2, 3, 4)` `xs.tail` |
`# [2, 3, 4]` `xs[1:]` |

take | `// List(1, 2)` `xs.take(2)` |
`# [1, 2]` `xs[:2]` |

drop | `// List(3, 4)` `xs.drop(2)` |
`# [3, 4]` `xs[2:]` |

drop right | `// List(1, 2, 3)` `xs.dropRight(1)` |
`# [1, 2, 3]` `xs[:-1]` |

nth element | `xs(2)` |
`xs[2]` |

map | `xs.map(_ * 2)` `for {` ` x <- xs` `} yield x * 2` |
`map(lambda x: x * 2, xs)` `[x * 2 for x in xs]` |

filter | `xs.filter(_ % 2 == 0)` `for {` ` x <- xs if x % 2 == 0` `} yield x` |
`filter(lambda x: not x % 2, xs)` `[x for x in xs if not x % 2 ]` |

fold from left | `// "a1234"` `xs.foldLeft("a") { _ + _ }` |
`from functools import reduce` `# "a1234"` `reduce(lambda a,x: a + str(x), xs, "a")` |

membership | `xs.contains(3)` |
`3 in xs` |

———————- | —————————- | —————————- |

String | `val s = "hello"` |
`s = "hello"` |

variable interpolation | `val count = 3` `s"$count items"` |
not in Starlark:`count = 3` `f"{count} items"` |

split | `// Array(1.2.3, M1)` `"1.2.3-M1".split("-")` |
`# ['1.2.3', 'M1']` `"1.2.3-M1".split("-")` |

substring test | `s.contains("el")` |
`"el" in s` |

———————- | —————————- | —————————- |

Map | `val d = Map("a" -> 1,` ` “b” -> 2)` |
`d = { "a": 1, "b": 2 }` |

- Skylark one-page overview
- Many of the examples were borrowed from Hyperpolyglot: Rust, Swift, Scala

### notes

I’m picking up Python and its Bazel dialect Skylark lately. On the other hand, I’m familiar with Scala and its sbt dialect. Often I know exactly what I want to express, and I am fairly certain Python has the equivalent concept as Scala, but just don’t remember the exact incantation. For people starting Scala, maybe they could use this table in reverse.