---

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

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

Copy// 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

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

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

Sets

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

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

Transformation Operations

Map

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

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

Filter

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

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

Reduce/Fold

Copy# 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)

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

FlatMap

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

Copy// 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

Access

Membership

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

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

Concatenation

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

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

Sorting

Copy# 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

Copy// 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

Copy# Python
from itertools import groupby
from collections import defaultdict

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

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

Aggregations

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

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

Finding Elements

Copy# 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)

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

Zipping

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

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

Dictionary/Map Operations

Copy# 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}

Copy// 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.

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

Copy// 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.

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

Copyobject 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:

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