The snippets are under the CC-BY-SA license.

Creative Commons Attribution-ShareAlike 3.0 # Programming-Idioms.org

• The snippets are under the CC-BY-SA license.
• Please consider keeping a bookmark
• (instead of printing) Elixir
1
Print a literal string on standard output
`IO.puts "Hello World"`
Alternative implementation:
`"Hello World" |> IO.puts`
2
Loop to execute some code a constant number of times
`1..10 |> Enum.each(fn _ -> IO.puts "Hello" end)`
3
Like a function which doesn't return any value, thus has only side effects (e.g. Print to standard output)
```def finish(name) do
IO.puts "My job here is done. Goodbye #{name}"
end```
4
Create a function which returns the square of an integer
```@spec square(integer) :: integer
def square(x) when is_integer(x), do: x*x```
5
Declare a container type for two floating-point numbers x and y
```p = [ x: 1.122, y: 7.45 ]
```
Alternative implementation:
```{x, y}
defmodule Point do
defstruct x: 0.0, y: 0.0
end```
6
Do something with each item x of an array-like collection items, regardless indexes.
`Enum.each(items, &IO.inspect/1)`
Alternative implementation:
```for x <- items do
IO.inspect(x)
end```
7
Print each index i with its value x from an array-like collection items
```items
|> Enum.with_index
|> Enum.each(fn({x, i}) ->
IO.puts("#{i} => #{x}")
end)```
8
Create a new map object x, and provide some (key, value) pairs as initial content.
`x = %{"one" => 1, "two" => 2}`
9
The structure must be recursive because left child and right child are binary trees too. A node has access to children nodes, but not to its parent.
```defmodule BinaryTree do
defstruct data: nil, left: nil, right: nil
end```
10
Generate a random permutation of the elements of list x
`y = Enum.shuffle x`
11
The list x must be non-empty.
```Enum.random(x)
```
12
Check if the list contains the value x.
list is an iterable finite container.
`Enum.member?(list, x)`
Alternative implementation:
`x in list`
13
Access each key k with its value x from an associative array mymap, and print them.
```Enum.each(mymap, fn({k, x}) ->
IO.puts("#{k} => #{x}")
end)```
Alternative implementation:
```for {k, x} <- mymap do
IO.puts("#{k} => #{x}")
end```
14
Pick a random number greater than or equals to a, strictly inferior to b. Precondition : a < b.
`a + :rand.uniform() * (b-a)`
Alternative implementation:
```defmodule MyRandomPicker do
def pick(a, b), do: a + (b - a) * :rand.uniform()
end```
15
Pick a random integer greater than or equals to a, inferior or equals to b. Precondition : a < b.
`:crypto.rand_uniform(a, b)`
Alternative implementation:
`a - 1 + :rand.uniform(b-a+1)`
19
Reverse the order of the elements of the list x.
This may reverse "in-place" and destroy the original ordering.
`x = Enum.reverse(x)`
20
Implement a function search which looks for item x in a 2D matrix m.
Return indices i, j of the matching cell.
Think of the most idiomatic way in the language to return the two values at the same time.
```def search(m, x) do
Enum.reduce_while(m, {0, 0}, fn list, {index, _inner_index} ->
{found?, inner_index} =
Enum.reduce_while(list, {false, 0}, fn item, {_found?, acc} ->
if x == item, do: {:halt, {true, acc}}, else: {:cont, {false, acc + 1}}
end)

if found?, do: {:halt, {index, inner_index}}, else: {:cont, {index + 1, inner_index}}
end)
end```
21
Swap the values of the variables a and b
`{a, b} = {b, a}`
22
Extract the integer value i from its string representation s (in radix 10)
`i = String.to_integer(s)`
23
Given a real number x, create its string representation s with 2 decimal digits following the dot.
`s = Float.to_string(x, decimals: 2)`
24
Declare a new string s and initialize it with the literal value "ネコ" (which means "cat" in japanese)
`s = "ネコ"`
25
Share the string value "Alan" with an existing running process which will then display "Hello, Alan"
```pid = spawn fn ->
{:hello, name} ->
IO.puts("Hello, #{name}")
_ ->
IO.puts(:stderr, "Unexpected message received")
end
end

send pid, {:hello, "Alan"}```
26
Declare and initialize a matrix x having m rows and n columns, containing real numbers.
`x = for _ <- 1..m, do: for _ <- 1..n, do: 0.0`
27
Declare and initialize a 3D array x, having dimensions boundaries m, n, p, and containing real numbers.
```  def main(m, n, p) do
if m == 0 or n == 0 or p == 0 do
[]
else
for _ <- 1..m, do: for _ <- 1..n, do: for _ <- 1..p, do: 0
end
end```
28
Sort the elements of the list (or array-like collection) items in ascending order of x.p, where p is a field of the type Item of the objects in items.
`Enum.sort_by(items, &(&1.p))`
29
Remove i-th item from list items.
This will alter the original list or return a new list, depending on which is more idiomatic.
Note that in most languages, the smallest valid value for i is 0.
`List.delete_at(items, i)`
30
Launch the concurrent execution of procedure f with parameter i from 1 to 1000.
Tasks are independent and f(i) doesn't return any value.
Tasks need not run all at the same time, so you may use a pool.
```f = fn x -> x * :rand.uniform() end

tasks = Enum.map(1..1000, fn i ->
f.(i)
end)
end)

# Optional, if you care for the result
IO.inspect Enum.map(results, fn {_, {:ok, val}} -> val end)```
31
Create the recursive function f which returns the factorial of the non-negative integer i, calculated from f(i-1)
```defmodule Factorial do
def f(0), do: 1
def f(i) when i > 0 do
n * f(i-1)
end
end```
32
Create function exp which calculates (fast) the value x power n.
x and n are non-negative integers.
`:math.pow(x, n)`
35
Implement a function compose (A -> C) with parameters f (A -> B) and g (B -> C), which returns the composition function g ∘ f
```def compose(f, g) do
fn a ->
g.(f.(a))
end
end```
37
Transform a function that takes multiple arguments into a function for which some of the arguments are preset.
```defmodule Curry do

def curry(fun) do
{_, arity} = :erlang.fun_info(fun, :arity)
curry(fun, arity, [])
end

def curry(fun, 0, arguments) do
apply(fun, Enum.reverse arguments)
end

def curry(fun, arity, arguments) do
fn arg -> curry(fun, arity - 1, [arg | arguments]) end
end

end```
38
Find substring t consisting in characters i (included) to j (excluded) of string s.
Character indices start at 0 unless specified otherwise.
Make sure that multibyte characters are properly handled.
`t = String.slice(s, i..j-1)`
39
Set boolean ok to true if string word is contained in string s as a substring, or to false otherwise.
`ok = String.contains?(s, word)`
41
Create string t containing the same characters as string s, in reverse order.
Original string s must remain unaltered. Each character must be handled correctly regardless its number of bytes in memory.
`t = String.reverse(s)`
43
Look for a negative value v in 2D integer matrix m. Print it and stop searching.
```  def main([]), do: nil
def main([row | rows]), do: main(row, rows)
def main([], rows), do: main(rows)
def main([number | numbers], rows) when number >= 0, do: main(numbers, rows)
def main([number | _], _), do: number```
44
Insert the element x at position i in the list s. Further elements must be shifted to the right.
`List.insert_at(s, i, x)`
45
Sleep for 5 seconds in current thread, before proceeding with the next instructions.
```Process.sleep(5000)
```
46
Create string t consisting of the 5 first characters of string s.
Make sure that multibyte characters are properly handled.
`t = String.slice(s, 0, 5)`
47
Create string t consisting in the 5 last characters of string s.
Make sure that multibyte characters are properly handled.
`t = String.slice(s, -5, 5)`
Alternative implementation:
`<<_ :: binary-5>> <> t = s`
48
Assign to variable s a string literal consisting in several lines of text, including newlines.
```s = "Spanning
string
works"```
Alternative implementation:
```s = """
multiline
heredoc
"""```
Alternative implementation:
```s = ~S"""
This will print multiline
and escape char like \G
"""

```
49
Build list chunks consisting in substrings of input string s, separated by one or more space characters.
`chunks = String.split(s)`
50
Write a loop that has no end clause.
```defmodule Looping do
def infinite do
# Write code here
infinite
end
end```
51
Determine whether the map m contains an entry for the key k
`Map.has_key?(m, k)`
52
Determine whether the map m contains an entry with the value v, for some key.
`Map.values(m) |> Enum.member?(v)`
53
Concatenate elements of string list x joined by the separator ", " to create a single string y.
`y = Enum.join(x, ", ")`
54
Calculate the sum s of the integer list or array x.
`s = Enum.sum(x)`
55
Create the string representation s (in radix 10) of the integer value i.
`s = Integer.to_string(i)`
Alternative implementation:
`s = to_string(i)`
Alternative implementation:
`s = "#{i}"`
56
Fork-join : launch the concurrent execution of procedure f with parameter i from 1 to 1000.
Tasks are independent and f(i) doesn't return any value.
Tasks need not run all at the same time, so you may use a pool.
Wait for the completion of the 1000 tasks and then print "Finished".
```# 1
f = &(IO.puts(&1))

# 2
printTimes = &(for n <- 1..&1, do: spawn(fn -> f.(n) end))

# 3
fn -> printTimes.(1000) end |> Task.async |> Task.await
IO.puts("Finished")
```
57
Create the list y containing the items from the list x that satisfy the predicate p. Respect the original ordering. Don't modify x in-place.
`y = Enum.filter(x, p)`
Alternative implementation:
`y = for item <- x, p.(item), do: item`
58
Create string lines from the content of the file with filename f.
`lines = File.read!(f)`
59
Print the message "x is negative" to standard error (stderr), with integer x value substitution (e.g. "-2 is negative").
`IO.puts :stderr, "#{x} is negative"`
61
Assign to the variable d the current date/time value, in the most standard type.
`d = :calendar.local_time`
63
Assign to x2 the value of string x with all occurrences of y replaced by z.
Assume occurrences of y are not overlapping.
`x2 = String.replace(x, y, z)`
64
Assign to x the value 3^247
`x = :math.pow(3, 247)`
65
From the real value x in [0,1], create its percentage string representation s with one digit after decimal point. E.g. 0.15625 -> "15.6%"
`s = "#{Float.round(x * 100, 1)}%"`
66
Calculate the result z of x power n, where x is a big integer and n is a positive integer.
`z = :math.pow(x, n)`
71
Basic implementation of the Echo program: Print all arguments except the program name, separated by space, followed by newline.
The idiom demonstrates how to skip the first argument if necessary, concatenate arguments as strings, append newline and print it to stdout.
`Enum.join(args, " ")`
74
Compute the greatest common divisor x of big integers a and b. Use an integer type able to handle huge numbers.
```defmodule Gcd do
def gcd(x, 0), do: x
def gcd(x, y), do: gcd(y, rem(x,y))
end

x = Gcd.gcd(a, b)```
75
Compute the least common multiple x of big integers a and b. Use an integer type able to handle huge numbers.
```defmodule BasicMath do
def gcd(a, 0), do: a
def gcd(0, b), do: b
def gcd(a, b), do: gcd(b, rem(a,b))

def lcm(0, 0), do: 0
def lcm(a, b), do: (a*b)/gcd(a,b)
end```
76
Create the string s of integer x written in base 2.

E.g. 13 -> "1101"
`s = Integer.to_string(x, 2)`
Alternative implementation:
`Integer.digits(x, 2) |> Enum.join("")`
78
Execute a block once, then execute it again as long as boolean condition c is true.
```def main(condition) do
case condition do
true -> main(condition)
false -> nil
end
end```
79
Declare the floating point number y and initialize it with the value of the integer x .
`y = x / 1`
80
Declare integer y and initialize it with the value of floating point number x . Ignore non-integer digits of x .
Make sure to truncate towards zero: a negative x must yield the closest greater integer (not lesser).
`y = trunc(x)`
81
Declare the integer y and initialize it with the rounded value of the floating point number x .
Ties (when the fractional part of x is exactly .5) must be rounded up (to positive infinity).
`y = Kernel.round x`
82
Find how many times string s contains substring t.
Specify if overlapping occurrences are counted.
`s |> String.split(t) |> Enum.drop(1) |> length()`
83
Declare regular expression r matching strings "http", "htttp", "httttp", etc.
`r = Regex.compile!("htt+p")`
87
Exit immediately.
If some extra cleanup work is executed by the program runtime (not by the OS itself), describe it.
`System.halt()`
91
Read from the file data.json and write its content into the object x.
Assume the JSON data is suitable for the type of x.
```defmodule JsonTest do
def get_json(filename) do
with {:ok, body} <- File.read(filename),
{:ok, json} <- Poison.decode(body), do: {:ok, json}
end
end

x = JsonTest.get_json("data.json")```
93
Implement procedure control which receives one parameter f, and runs f.
```def control(f) do
f()
end```
94
Print the name of the type of x. Explain if it is a static type or dynamic type.

This may not make sense in all languages.
```[{_, type} | _] = IEx.Info.info(x)
type```
95
Assign to variable x the length (number of bytes) of the local file at path.
```def main(path) do
_x =
path
|> File.stat!()
|> Map.get(:size)
end```
96
Set boolean b to true if string s starts with prefix prefix, false otherwise.
`String.starts_with?(s,prefix)`
97
Set boolean b to true if string s ends with string suffix, false otherwise.
`b = String.ends_with?(s, suffix)`
99
Assign to the string x the value of the fields (year, month, day) of the date d, in format YYYY-MM-DD.
`x = Date.to_iso8601(d)`
100
Sort elements of array-like collection items, using a comparator c.
`Enum.sort(items, c)`
110
Set the boolean blank to true if the string s is empty, or null, or contains only whitespace ; false otherwise.
`blank = s == nil || String.length(String.trim s) == 0`
113
Print each key k with its value x from an associative array mymap, in ascending order of x.
Note that multiple entries may exist for the same value x.
```mymap
|> Map.to_list
|> Enum.sort(fn ({_k1, val1}, {_k2, val2}) -> val1 <= val2 end)
|> Enum.each(fn ({k, v}) -> IO.puts("#{k}: #{v}") end)```
114
Set boolean b to true if objects x and y contain the same values, recursively comparing all referenced elements in x and y.
Tell if the code correctly handles recursive types.
`b = x == y`
116
Remove all occurrences of string w from string s1, and store the result in s2.
`s2 = String.replace(s1, w, "")`
117
Set n to the number of elements of the list x.
`n = Enum.count(x)`
118
Create the set y from the list x.
x may contain duplicates. y is unordered and has no repeated values.
`y = x |> Enum.uniq |> List.to_tuple`
Alternative implementation:
`y = MapSet.new(x)`
119
Remove duplicates from the list x.
Explain if the original order is preserved.
`Enum.uniq(x)`
120
Read an integer value from the standard input into the variable n
`n = String.to_integer IO.gets ""`
122
Create an enumerated type Suit with 4 possible values SPADES, HEARTS, DIAMONDS, CLUBS.
```@suits %{
"HEARTS" => 2,
"DIAMONDS" => 3,
"CLUBS" => 4
}

def main, do: @suits```
125
measure the duration t, in nanoseconds, of a call to the function foo. Print this duration.
```def main(function) do
function
|> :timer.tc()
|> elem(0)
|> Kernel.*(1_000)
end```
126
Write a function foo that returns a string and a boolean value.
`def foo, do: {"bar", true}`
131
Execute f1 if condition c1 is true, or else f2 if condition c2 is true, or else f3 if condition c3 is true.
Don't evaluate a condition when a previous condition was true.
```cond do
c1 -> f1
c2 -> f2
c3 -> f3
end```
133
Set boolean ok to true if string word is contained in string s as a substring, even if the case doesn't match, or to false otherwise.
`ok = s =~ ~r/#{word}/i`
134
Declare and initialize a new list items, containing 3 elements a, b, c.
`items = [a, b, c]`
135
Remove at most 1 item from list items, having the value x.
This will alter the original list or return a new list, depending on which is more idiomatic.
If there are several occurrences of x in items, remove only one of them. If x is absent, keep items unchanged.
`List.delete(items, x)`
136
Remove all occurrences of value x from list items.
This will alter the original list or return a new list, depending on which is more idiomatic.
`Enum.filter(items, fn v -> v != x end)`
137
Set the boolean b to true if the string s contains only characters in the range '0'..'9', false otherwise.
`b =  Regex.match?(~r{\A\d*\z}, s)`
140
Delete from map m the entry having key k.

Explain what happens if k is not an existing key in m.
`m = Map.delete(m, k)`
141
Iterate in sequence over the elements of the list items1 then items2. For each iteration print the element.
```def main(items1, items2) do
Enum.each(items1, &IO.puts/1)
Enum.each(items2, &IO.puts/1)
end```
142
Assign to string s the hexadecimal representation (base 16) of integer x.

E.g. 999 -> "3e7"
`s = Integer.to_string(x, 16)`
147
Create string t from string s, keeping only ASCII characters
```t =
s
|> String.to_charlist()
|> Enum.filter(&(&1 in 0..127))
|> List.to_string```
Alternative implementation:
`t = for <<c <- s>>, c in 0..127, into: "", do: <<c>>`
150
Remove the last character from the string p, if this character is a forward slash /
`def main(string), do: String.replace_suffix(string, "/", "")`
152
Create string s containing only the character c.
`to_string(char)`
153
Create the string t as the concatenation of the string s and the integer i.
`t =  s <>  to_string(i)`
155
Delete from filesystem the file having path filepath.
`File.rm(filepath)`
157
Initialize a constant planet with string value "Earth".
`planet = "Earth"`
161
Multiply all the elements of the list elements by a constant c
`elements = Enum.map(elements, &(&1 * c))`
165
Assign to the variable x the last element of the list items.
`x = List.last(items)`
166
Create the list ab containing all the elements of the list a, followed by all the elements of the list b.
`ab = a ++ b`
169
Assign to the integer n the number of characters of the string s.
Make sure that multibyte characters are properly handled.
n can be different from the number of bytes of s.
`n = String.length s`
182
Output the source of the program.
`q=<<"q=~p;:io.format q,[q]">>;:io.format q,[q]`
184
Assign to variable t a string representing the day, month and year of the day after the current date.
```def main() do
Date.utc_today()
|> Date.to_string()
end```
189
Produce a new list y containing the result of function T applied to all elements e of list x that match the predicate P.
```y = x
|> Enum.filter(&P/1)
|> Enum.map(&P(&T/1)```
200
Returns the hypotenuse h of the triangle where the sides adjacent to the square angle have lengths x and y.
```def sq(x) do
x*x
end

def hypo(a,b) do
sqrt(sq(a) + sq(b))
end```
203
Calculate the mean m and the standard deviation s of the list of floating point values data.
```defmodule SD do
import Enum, only: [map: 2, sum: 1]
import :math, only: [sqrt: 1, pow: 2]

def standard_deviation(data) do
m = mean(data)
data |> variance(m) |> mean |> sqrt
end

def mean(data) do
sum(data) / length(data)
end

def variance(data, mean) do
for n <- data, do: pow(n - mean, 2)
end
end

# usage
data = [1,2,3,4]
m = SD.mean(data) # => 2.5
sd = SD.standard_deviation(data) # => 1.118033988749895```
205
Read an environment variable with the name "FOO" and assign it to the string variable foo. If it does not exist or if the system does not support environment variables, assign a value of "none".
`foo = System.get_env("FOO", "none")`
222
Set i to the first index in list items at which the element x can be found, or -1 if items does not contain x.
`Enum.find_value(items, -1, fn val -> if val == x, do: x end)`
224
Insert the element x at the beginning of the list items.
`items2 = [x | items]`
230
Cancel an ongoing processing p if it has not finished after 5s.
```def main(p) do
p
end```
237
Assign to c the result of (a xor b)
`c = a ^^^ b`
243
Print the contents of the list or array a on the standard output.
`Enum.each(a, &IO.inspect/1)`
244
Print the contents of the map m to the standard output: keys and values.
`IO.inspect m`
246
Set c to the number of distinct elements in the list items.
`c = items |> Enum.uniq |> length`
250
Choose a value x from map m.
m must not be empty. Ignore the keys.
```def main(m) do
m
|> Map.values()
|> Enum.random()
end```
252
Assign to the variable x the value "a" if calling the function condition returns true, or the value "b" otherwise.
`x = if condition(), do: "a", else: "b"`
266
Assign to the string s the value of the string v repeated n times, and write it out.

E.g. v="abc", n=5 ⇒ s="abcabcabcabcabc"
`s = String.duplicate(v, n)`
273
Set the boolean b to true if the directory at filepath p is empty (i.e. doesn't contain any other files and directories)
```def main(p) do
b = File.ls!(p) == []
end```
295
Given the enumerated type T, create a function TryStrToEnum that takes a string s as input and converts it into an enum value of type T.

Explain whether the conversion is case sensitive or not.
Explain what happens if the conversion fails.
`def try_str_to_enum(t, string), do: t[string]`