R.CodeCompared.To/Scala

The first difference is the ceremony: Scala is compiled, and a program needs an entry point — an object Main with a main method — before it prints anything. Every example on this page carries this wrapper. println adds the newline cat makes you write.

Assignment splits in two: val declares a name that can never be rebound (the overwhelming default in idiomatic Scala), var one that can. The types are there — sampleSize is an Int, meanHeight a Double — but inferred, so declarations read as lightly as R’s. Convention also switches from snake_case to camelCase.

A genuine comfort: like R (and unlike Python or Java), Scala’s if is an expression with a value, so the assign-a-conditional idiom transfers verbatim. There is no vectorized ifelse — that becomes values.map(value => if (...) ... else ...), the shape the collections section explains.

Two changes stack: counting starts at zero, and indexing uses parentheses, not brackets — heights(0) is really the method call heights.apply(0). In practice idiomatic Scala indexes rarely: head, last, and the collection methods in the next sections ask for elements by role instead of by position.

Negative indexing does not exist; every exclusion R spells with a minus sign has a named method — tail, init, drop, dropRight, take, takeRight. The names read better than the arithmetic, and there is no silent behavior change waiting when a negative number arrives at an index by accident.

There is no elementwise arithmetic on collections — doses * 2 does not compile. map is the one universal spelling for “apply this to each element,” with the underscore as shorthand for a one-argument anonymous function. Note also what base Scala lacks: no built-in mean or sd — summary statistics come from libraries (Breeze, Spark) or three characters of arithmetic.

Ranges keep R’s inclusive ends — 1 to 5 has five elements — and seq(0, 10, by = 2) becomes the almost-English 0 to 10 by 2. The until variant is half-open for the occasions zero-based indexing wants it. These read as method calls because they are: to, by, and until are ordinary methods on Int.

The for/yield comprehension covers sapply plus logical subsetting in one construct: iterate, filter with the inline if, and yield builds a new collection of the results. It is syntactic sugar for the filter/map chains of the next section — use whichever reads better case by case.

The dplyr vocabulary maps almost one-to-one onto collection methods: filter is filter, arrange is sortBy, mutate/select are map, distinct is distinct — and the chain reads exactly like a magrittr pipeline with dots for pipes. The “data frame” here is a plain Seq of case-class rows; Spark’s DataFrame API (the ecosystem section) scales this same shape to a cluster.

Split-apply-combine is groupBy followed by a map over the resulting (key, rows) pairs — more manual than a formula, but the same shape Spark’s groupBy(...).agg(...) industrializes. One habit to note: groupBy returns an unordered Map, so deterministic output means sorting at the end.

The R instinct that “my data cannot change out from under me” — the one Python and Julia break — is a design principle here: the default collections are immutable, and every “modification” (:+, updated, filter) returns a new collection. Structural sharing makes it cheap, unlike R’s full copies, and scala.collection.mutable is the explicit opt-out for hot loops.

Parameter types are mandatory (values: Seq[Double]) and the return type is good manners; in exchange, calling standardize("oops") is a compile error instead of a runtime surprise mid-analysis. One comfort survives intact: the last expression is the return value, no return keyword needed.

The full anonymous-function form is argument => expression; when the argument is used exactly once, the underscore stands in for it — _ * 2 is Scala’s tersest lambda. Each underscore in an expression is a different argument (_ + _ takes two), which surprises everyone once.

Two R conveniences most compiled languages drop both survive: default argument values in the signature, and calling any argument by name — in any order, once named. The one difference is that R’s partial name matching (cent = 20) does not exist; names must be exact, and the compiler tells you when they are not.

R’s ... becomes a typed variadic parameter — values: Double* arrives as a ready-to-use sequence, no list(...) unwrapping — and the : _* ascription splats an existing collection into the argument list, retiring do.call. Being typed, the slurp only accepts what it declares: a stray string in the arguments is a compile error.

Scala has no NA and (in idiomatic code) no NULL-alike: a lookup that can fail returns Option[Double] — either Some(value) or None — and the type forces the “what if it is missing?” decision at compile time, where R lets NULL slide silently until something downstream misbehaves. getOrElse is the one-line fallback.

A column with missing values is Seq[Option[Double]] — the missingness is in the type, not hidden in the data — and arithmetic will not compile until it is dealt with: flatten drops the Nones (the na.rm = TRUE move), map(_.getOrElse(...)) replaces them. There is no propagating NA; the compiler makes you choose up front, once. (Spark’s columns handle nulls more R-like, with na.drop/na.fill.)

R’s tagged named list becomes a case class: fields declared and typed once, accessed with . instead of $ — and misspelling a field is a compile error, where patient$aeg silently returns NULL. The case keyword bundles what R makes you improvise: readable printing, structural equality, and the destructuring the pattern-matching section uses.

What R does implicitly through copy-on-modify, Scala does explicitly through copy: name the fields that change, keep the rest, get a new value. Case-class instances are immutable, so the original genuinely cannot drift — the same safety R gives, delivered by construction rather than by copying.

match is an expression (like everything here), tries its cases top to bottom, and binds the fallback to a name instead of R’s anonymous trailing argument. This literal-matching form is the shallow end; the next row is why match is one of Scala’s defining features.

The S3 pattern — a family of classes, behavior chosen by class — becomes a sealed trait with case-class variants, and match destructures each variant’s fields right in the pattern. sealed is the payoff: the compiler knows every possible Model and warns when a case is missing, where S3 offers only the hope that every class got a method.

The s interpolator splices values inline, retiring most paste calls; the f interpolator is sprintf with the format spec attached directly to each value — and, unlike sprintf, the compiler checks that %.1f is actually applied to a number. Joining a vector inverts subject and verb: paste(words, collapse = ", ") is words.mkString(", ").

Function-wrapping becomes method-calling — toupper(x) is x.toUpperCase — and the strsplit(...)[[1]] dance disappears because split returns the array directly. replace here is literal; regular expressions use replaceAll or Scala’s Regex class with pattern matching.

R users already think of error handling as producing a value — tryCatch returns one — and Try is exactly that idea as a type: Success(value) or Failure(exception), pattern-matchable, with getOrElse as the fallback shorthand. The imperative try/catch/finally also exists, but Try is the shape that composes with everything else on this page.

No pipe operator is needed because every step is a method returning a new collection — the dot does what |> does, without the unary-function contortions R’s pipe needs for filtering. This is the same left-to-right sentence dplyr taught, and it is the native shape of the language rather than an operator bolted on.

The reason this page exists: Spark is written in Scala, and sparklyr is a translation layer over it — moving to Scala removes the translation, unlocks the typed Dataset API (case-class rows, compile-checked columns), and makes the cluster’s full API surface available the day it ships. Around it: Breeze for linear algebra, Smile for statistics and machine learning, Almond to keep the notebook workflow. Both cells are import inventories, shown display-only.