---

name: python-scala-collections description: Guide for translating Python collection operations to idiomatic Scala. Use when converting Python code that uses lists, dictionaries, sets, or involves collection transformations like map, filter, reduce, sorting, and aggregations.

Python to Scala Collections Translation

Collection Creation

Lists

# Python
empty = []
nums = [1, 2, 3]
repeated = [0] * 5
from_range = list(range(1, 11))

// Scala
val empty = List.empty[Int]  // or List[Int]()
val nums = List(1, 2, 3)
val repeated = List.fill(5)(0)
val fromRange = (1 to 10).toList

Dictionaries → Maps

# Python
empty = {}
person = {"name": "Alice", "age": 30}
from_pairs = dict([("a", 1), ("b", 2)])

// Scala
val empty = Map.empty[String, Int]
val person = Map("name" -> "Alice", "age" -> 30)
val fromPairs = List(("a", 1), ("b", 2)).toMap

Sets

# Python
empty = set()
nums = {1, 2, 3}
from_list = set([1, 2, 2, 3])

// Scala
val empty = Set.empty[Int]
val nums = Set(1, 2, 3)
val fromList = List(1, 2, 2, 3).toSet

Transformation Operations

Map

# Python
doubled = [x * 2 for x in nums]
doubled = list(map(lambda x: x * 2, nums))

// Scala
val doubled = nums.map(_ * 2)
val doubled = nums.map(x => x * 2)

Filter

# Python
evens = [x for x in nums if x % 2 == 0]
evens = list(filter(lambda x: x % 2 == 0, nums))

// Scala
val evens = nums.filter(_ % 2 == 0)
val evens = nums.filter(x => x % 2 == 0)

Reduce/Fold

# Python
from functools import reduce
total = reduce(lambda a, b: a + b, nums)
total = sum(nums)
product = reduce(lambda a, b: a * b, nums, 1)

// Scala
val total = nums.reduce(_ + _)
val total = nums.sum
val product = nums.foldLeft(1)(_ * _)
// Use foldLeft when you need an initial value

FlatMap

# Python
nested = [[1, 2], [3, 4]]
flat = [x for sublist in nested for x in sublist]

// Scala
val nested = List(List(1, 2), List(3, 4))
val flat = nested.flatten
// or with transformation:
val flat = nested.flatMap(identity)

Common Operations

Length/Size

| Python | Scala | |--------|-------| | len(lst) | lst.length or lst.size | | len(dct) | map.size |

Access

| Python | Scala | |--------|-------| | lst[0] | lst(0) or lst.head | | lst[-1] | lst.last | | lst[1:3] | lst.slice(1, 3) | | lst[:3] | lst.take(3) | | lst[3:] | lst.drop(3) | | dct["key"] | map("key") (throws if missing) | | dct.get("key") | map.get("key") (returns Option) | | dct.get("key", default) | map.getOrElse("key", default) |

Membership

# Python
if x in lst: ...
if key in dct: ...

// Scala
if (lst.contains(x)) ...
if (map.contains(key)) ...

Concatenation

# Python
combined = list1 + list2
merged = {**dict1, **dict2}

// Scala
val combined = list1 ++ list2
val merged = map1 ++ map2

Sorting

# Python
sorted_list = sorted(items)
sorted_desc = sorted(items, reverse=True)
sorted_by_key = sorted(items, key=lambda x: x.name)
items.sort()  # in-place

// Scala
val sortedList = items.sorted
val sortedDesc = items.sorted(Ordering[Int].reverse)
val sortedByKey = items.sortBy(_.name)
// Note: Scala collections are immutable by default, no in-place sort

Grouping

# Python
from itertools import groupby
from collections import defaultdict

# Group by key
grouped = defaultdict(list)
for item in items:
    grouped[item.category].append(item)

// Scala
val grouped = items.groupBy(_.category)
// Returns Map[Category, List[Item]]

Aggregations

# Python
total = sum(nums)
minimum = min(nums)
maximum = max(nums)
average = sum(nums) / len(nums)

// Scala
val total = nums.sum
val minimum = nums.min
val maximum = nums.max
val average = nums.sum.toDouble / nums.length

Finding Elements

# Python
first_even = next((x for x in nums if x % 2 == 0), None)
all_evens = all(x % 2 == 0 for x in nums)
any_even = any(x % 2 == 0 for x in nums)

// Scala
val firstEven = nums.find(_ % 2 == 0)  // Returns Option[Int]
val allEvens = nums.forall(_ % 2 == 0)
val anyEven = nums.exists(_ % 2 == 0)

Zipping

# Python
pairs = list(zip(list1, list2))
indexed = list(enumerate(items))

// Scala
val pairs = list1.zip(list2)
val indexed = items.zipWithIndex

Dictionary/Map Operations

# Python
keys = list(dct.keys())
values = list(dct.values())
items = list(dct.items())

for key, value in dct.items():
    process(key, value)

# Update
dct["new_key"] = value
updated = {**dct, "new_key": value}

// Scala
val keys = map.keys.toList
val values = map.values.toList
val items = map.toList  // List[(K, V)]

for ((key, value) <- map) {
  process(key, value)
}

// Update (creates new map, immutable)
val updated = map + ("new_key" -> value)
val updated = map.updated("new_key", value)

Mutable vs Immutable

Python collections are mutable by default. Scala defaults to immutable.

# Python - mutable
lst.append(4)
lst.extend([5, 6])
dct["key"] = value

// Scala - immutable (creates new collection)
val newList = lst :+ 4
val newList = lst ++ List(5, 6)
val newMap = map + ("key" -> value)

// Scala - mutable (when needed)
import scala.collection.mutable
val mutableList = mutable.ListBuffer(1, 2, 3)
mutableList += 4
mutableList ++= List(5, 6)

enum type

Use UPPERCASE for enum and constant names in Scala (same as in Python) E.g.

class TokenType(Enum):
    STRING = "string"
    NUMERIC = "numeric"
    TEMPORAL = "temporal"
    STRUCTURED = "structured"
    BINARY = "binary"
    NULL = "null"

object BaseType {
  case object STRING extends BaseType { val value = "string" }
  case object NUMERIC extends BaseType { val value = "numeric" }
  case object TEMPORAL extends BaseType { val value = "temporal" }
  case object STRUCTURED extends BaseType { val value = "structured" }
  case object BINARY extends BaseType { val value = "binary" }
}

Do not use PascalCase. E.g. the following is against the principle:

object BaseType {
  case object String extends BaseType { val value = "string" }
}