# Beginning Rust - solving Euler problem #1

Rust is a relatively new programming language (first alpha released in 2012) which recently caught my attention. Although I'm mostly a Python hacker and Web developer, I still do lower level coding from time to time, including some open source work in C++. Besides, I enjoy the elegance of Haskell; the functional approach to solving problems is quite enlightening. Where does Rust fit into that? The language is still a work-in-progress territory (as of this post the current version is 0.10), but there are already many interesting features. Memory safety, strong typing (with type inference), pattern matching and a slick concurrency model are just a few of those. Let's jump in!

**Note**: this blogpost series (well, hopefully a series) is not intended to be a Rust tutorial; rather a collection of insights and tips I'm discovering while learning Rust.

## Euler #1

I tend to learn new languages by solving a few problems from Project Euler, so this was my natural choice for my first steps in Rust.

The first problem is stated as follows:

If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

This is rather easy, you could possibly do it in a matter of seconds with a calculator. Anyway, let's make Rust calculate that for us.

Coming from a C/C++ background, a loop seems like a natural solution.

fn solution1 () -> int { let mut sum = 0; for i in range(1, 1000) { if i % 3 == 0 || i % 5 == 0 { sum += i; } } sum }

It
works, but it irks me to write code in such an imperative way. There
should be some better alternative. Haskell, for example, has a concept
of *folds*. Folds are basically higher-order functions that take a
binary operation, a list (or other foldable type, but let's keep it
simple for a while) and a starting value and build up their return value
by reducing the list with the given operation. If that sounds
complicated, Learn You A Haskell For Great Good provides an explanation. Let's see an example of solving problem 1 with a left fold in Haskell.

solution1 = foldl (\x acc -> x + acc) 0 numbers where numbers = [x | x <- [1..999], x `mod` 3 == 0 || x `mod` 5 == 0]

or simplified by reducing lambda to just the `+`

operator:

solution1 = foldl (+) 0 numbers where -- ...

Good news - Rust also has folds!

fn solution2 () -> int { let mut numbers = range(1, 1000).filter(|i| i % 3 == 0 || i % 5 == 0); numbers.fold(0, |acc, x| acc + x) }

The return values of both `range`

and `filter`

implement an Iterator
trait, which means they have lots of useful methods like `map`

, `any`

,
`all`

and yes, `fold`

.

Can we do even better? Folding addition over a list is so common that Haskell has a builtin function `sum`

in the standard Prelude.

solution1 = sum numbers where -- ...

In case of Rust, this isn't as straightforward. `Iterator`

s don't have a `sum`

method...

... unless we magically add it by including another trait definition - AdditiveIterator.

fn solution3 () -> int { use std::iter::AdditiveIterator; let mut numbers = range(1, 1000).filter(|i| i % 3 == 0 || i % 5 == 0); numbers.sum() }

Now the sum part of the solution is as concise as it can possibly get.