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

Creative Commons Attribution-ShareAlike 3.0

Logo

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 list x.
This may reverse "in-place" and destroy the original ordering.
x = Enum.reverse(x)
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 ->
  receive do
    {: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
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 ->
  Task.async(fn ->
    f.(i)
  end)
end)

results = Task.yield_many(tasks, :infinity)

# 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 of(0), do: 1
  def of(n) when n > 0 do
    n * of(n-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 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)
44
Insert element x at position i in 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 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("")
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 integer y and initialize it with the rounded value of 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")
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
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.
map 
|> 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 ""
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 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)
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>>
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 variable x the last element of 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 integer n the number of characters of 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]
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 element x at the beginning of list items.
items2 = [x | items]
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 list items.
c = items |> Enum.uniq |> length
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)