scala-collections-fp

Scala Collections and Functional Programming

Collections Overview

Immutable Collections (Preferred in Scala)

Python	Scala	Characteristics
list[T]	List[T]	Linked list, prepend fast
list[T]	Vector[T]	Indexed access fast, append ok
tuple[T, ...]	Seq[T] (umbrella type)	Immutable sequence
set[T]	Set[T]	Unordered, unique elements
dict[K, V]	Map[K, V]	Key-value pairs
range(n)	(0 until n) or Range	Lazy range

Mutable Collections

import scala.collection.mutable

val list = scala.collection.mutable.ListBuffer[Int]()
val set = scala.collection.mutable.Set[String]()
val map = scala.collection.mutable.Map[String, Int]()

Iteration Patterns

Python iteration

# List comprehension
squares = [x * x for x in range(10)]

# Generator
def gen():
    for x in range(10):
        yield x * x

# Higher-order functions
list(map(lambda x: x * x, range(10)))
list(filter(lambda x: x > 10, range(20)))

Scala equivalents

// Collection methods (eager)
val squares = (0 until 10).map(x => x * x).toList

// Iterator (lazy)
def gen: Iterator[Int] = (0 until 10).iterator.map(x => x * x)

// For-comprehension (syntactic sugar)
val squares = for (x <- 0 until 10) yield x * x

// Higher-order functions
List(1, 2, 3).map(_ * 2)    // List(2, 4, 6)
List(1, 2, 3, 4).filter(_ > 2)  // List(3, 4)

Iterator Pattern

Iterators are lazy and consume memory efficiently:

Python Generator

def tokenize_batch(self, values: Iterable[T]) -> Iterator[Token]:
    for v in values:
        yield self.tokenize(v)

# Usage
for token in tokenizer.tokenize_batch(large_list):
    process(token)  # Lazy - doesn't compute all at once

Scala Iterator

def tokenizeBatch(values: Iterable[T]): Iterator[Token] =
  values.toIterator.map(tokenize)

// Usage
tokenizer.tokenizeBatch(largeList).foreach(token => process(token))

// Or with Iterator directly
def tokenizeBatch(values: Iterator[T]): Iterator[Token] =
  values.map(tokenize)