ðŸŽ‰ Exercism Research is now launched. Help Exercism, help science and have some fun at research.exercism.io ðŸŽ‰

# thekeele's solution

## to List Ops in the Elixir Track

Published at May 16 2019 · 0 comments
Instructions
Test suite
Solution

#### Note:

This exercise has changed since this solution was written.

Implement basic list operations.

In functional languages list operations like length, map, and reduce are very common. Implement a series of basic list operations, without using existing functions.

## Running tests

Execute the tests with:

\$ elixir list_ops_test.exs

### Pending tests

In the test suites, all but the first test have been skipped.

Once you get a test passing, you can unskip the next one by commenting out the relevant @tag :pending with a # symbol.

For example:

# @tag :pending
test "shouting" do
assert Bob.hey("WATCH OUT!") == "Whoa, chill out!"
end

Or, you can enable all the tests by commenting out the ExUnit.configure line in the test suite.

# ExUnit.configure exclude: :pending, trace: true

If you're stuck on something, it may help to look at some of the available resources out there where answers might be found.

## Submitting Incomplete Solutions

It's possible to submit an incomplete solution so you can see how others have completed the exercise.

### list_ops_test.exs

if !System.get_env("EXERCISM_TEST_EXAMPLES") do
end

ExUnit.start()
ExUnit.configure(exclude: :pending, trace: true)

defmodule ListOpsTest do
alias ListOps, as: L

use ExUnit.Case

defp odd?(n), do: rem(n, 2) == 1

# @tag :pending
test "count of empty list" do
assert L.count([]) == 0
end

@tag :pending
test "count of normal list" do
assert L.count([1, 3, 5, 7]) == 4
end

@tag :pending
test "count of huge list" do
assert L.count(Enum.to_list(1..1_000_000)) == 1_000_000
end

@tag :pending
test "reverse of empty list" do
assert L.reverse([]) == []
end

@tag :pending
test "reverse of normal list" do
assert L.reverse([1, 3, 5, 7]) == [7, 5, 3, 1]
end

@tag :pending
test "reverse of huge list" do
assert L.reverse(Enum.to_list(1..1_000_000)) == Enum.to_list(1_000_000..1)
end

@tag :pending
test "map of empty list" do
assert L.map([], &(&1 + 1)) == []
end

@tag :pending
test "map of normal list" do
assert L.map([1, 3, 5, 7], &(&1 + 1)) == [2, 4, 6, 8]
end

@tag :pending
test "map of huge list" do
assert L.map(Enum.to_list(1..1_000_000), &(&1 + 1)) == Enum.to_list(2..1_000_001)
end

@tag :pending
test "filter of empty list" do
assert L.filter([], &odd?/1) == []
end

@tag :pending
test "filter of normal list" do
assert L.filter([1, 2, 3, 4], &odd?/1) == [1, 3]
end

@tag :pending
test "filter of huge list" do
assert L.filter(Enum.to_list(1..1_000_000), &odd?/1) == Enum.map(1..500_000, &(&1 * 2 - 1))
end

@tag :pending
test "reduce of empty list" do
assert L.reduce([], 0, &(&1 + &2)) == 0
end

@tag :pending
test "reduce of normal list" do
assert L.reduce([1, 2, 3, 4], -3, &(&1 + &2)) == 7
end

@tag :pending
test "reduce of huge list" do
assert L.reduce(Enum.to_list(1..1_000_000), 0, &(&1 + &2)) ==
Enum.reduce(1..1_000_000, 0, &(&1 + &2))
end

@tag :pending
test "reduce with non-commutative function" do
assert L.reduce([1, 2, 3, 4], 10, fn x, acc -> acc - x end) == 0
end

@tag :pending
test "append of empty lists" do
assert L.append([], []) == []
end

@tag :pending
test "append of empty and non-empty list" do
assert L.append([], [1, 2, 3, 4]) == [1, 2, 3, 4]
end

@tag :pending
test "append of non-empty and empty list" do
assert L.append([1, 2, 3, 4], []) == [1, 2, 3, 4]
end

@tag :pending
test "append of non-empty lists" do
assert L.append([1, 2, 3], [4, 5]) == [1, 2, 3, 4, 5]
end

@tag :pending
test "append of huge lists" do
assert L.append(Enum.to_list(1..1_000_000), Enum.to_list(1_000_001..2_000_000)) ==
Enum.to_list(1..2_000_000)
end

@tag :pending
test "concat of empty list of lists" do
assert L.concat([]) == []
end

@tag :pending
test "concat of normal list of lists" do
assert L.concat([[1, 2], [3], [], [4, 5, 6]]) == [1, 2, 3, 4, 5, 6]
end

@tag :pending
test "concat of huge list of small lists" do
assert L.concat(Enum.map(1..1_000_000, &[&1])) == Enum.to_list(1..1_000_000)
end

@tag :pending
test "concat of small list of huge lists" do
assert L.concat(Enum.map(0..9, &Enum.to_list((&1 * 100_000 + 1)..((&1 + 1) * 100_000)))) ==
Enum.to_list(1..1_000_000)
end
end
defmodule ListOps do
# Scheme Influenced
# https://en.wikipedia.org/wiki/Cons

@spec count(list) :: non_neg_integer
def count([]), do: 0
def count([_ | cdr]), do: 1 + count(cdr)

@spec reverse(list) :: list
def reverse([]), do: []
def reverse(l), do: reduce(l, [], &cons/2)

defp cons(car, acc), do: [car | acc]

@spec map(list, (any -> any)) :: list
def map([], _), do: []
def map([car | cdr], f), do: cons(f.(car), map(cdr, f))

@spec filter(list, (any -> as_boolean(term))) :: list
def filter([], _), do: []
def filter([car | cdr], f) do
if f.(car), do: cons(car, filter(cdr, f)), else: filter(cdr, f)
end

@type acc :: any
@spec reduce(list, acc, (any, acc -> acc)) :: acc
def reduce([], acc, _), do: acc
def reduce([car | cdr], acc, f), do: reduce(cdr, f.(car, acc), f)

@spec append(list, list) :: list
def append([], []), do: []
def append(a, []), do: a
def append([], b), do: b
def append([car | cdr], b), do: cons(car, append(cdr, b))

@spec concat([[any]]) :: [any]
def concat([]), do: []
def concat([car | cdr]), do: append(car, concat(cdr))
end

### What can you learn from this solution?

A huge amount can be learned from reading other peopleâ€™s code. This is why we wanted to give exercism users the option of making their solutions public.

Here are some questions to help you reflect on this solution and learn the most from it.

• What compromises have been made?