Agent skill
python-scala-collections
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.
Install this agent skill to your Project
npx add-skill https://github.com/benchflow-ai/skillsbench/tree/main/tasks/python-scala-translation/environment/skills/python-scala-collections
SKILL.md
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" }
}
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
benchflow-ai/skillsbench
csv-processing
Use this skill when reading sensor data from CSV files, writing simulation results to CSV, processing time-series data with pandas, or handling missing values in datasets.
benchflow-ai/skillsbench
pid-controller
Use this skill when implementing PID control loops for adaptive cruise control, vehicle speed regulation, throttle/brake management, or any feedback control system requiring proportional-integral-derivative control.
benchflow-ai/skillsbench
yaml-config
Use this skill when reading or writing YAML configuration files, loading vehicle parameters, or handling config file parsing with proper error handling.
benchflow-ai/skillsbench
simulation-metrics
Use this skill when calculating control system performance metrics such as rise time, overshoot percentage, steady-state error, or settling time for evaluating simulation results.
benchflow-ai/skillsbench
vehicle-dynamics
Use this skill when simulating vehicle motion, calculating safe following distances, time-to-collision, speed/position updates, or implementing vehicle state machines for cruise control modes.
benchflow-ai/skillsbench
web-interface-guidelines
Vercel's comprehensive UI guidelines for building accessible, performant web interfaces. Use this skill when reviewing or building UI components for compliance with best practices around accessibility, performance, animations, and visual stability.
Didn't find tool you were looking for?