Programming-Idioms.org

IO.puts "Hello World"

"Hello World" |> IO.puts

1..10 |> Enum.each(fn _ -> IO.puts "Hello" end)

def finish(name) do
  IO.puts "My job here is done. Goodbye #{name}"
end

@spec square(integer) :: integer
def square(x) when is_integer(x), do: x*x

p = [ x: 1.122, y: 7.45 ]

{x, y}
defmodule Point do
  defstruct x: 0.0, y: 0.0
end

Enum.each(items, &IO.inspect/1)

for x <- items do
  IO.inspect(x)
end

items
|> Enum.with_index
|> Enum.each(fn({x, i}) ->
  IO.puts("#{i} => #{x}")
end)

x = %{"one" => 1, "two" => 2}

x = %{one: 1, two: 2}

defmodule BinaryTree do
	defstruct data: nil, left: nil, right: nil
end

y = Enum.shuffle x

Enum.random(x)

Enum.member?(list, x)

x in list

Enum.each(mymap, fn({k, x}) ->
  IO.puts("#{k} => #{x}")
end)

for {k, x} <- mymap do
  IO.puts("#{k} => #{x}")
end

a + :rand.uniform() * (b-a)

defmodule MyRandomPicker do
  def pick(a, b), do: a + (b - a) * :rand.uniform()
end

:crypto.rand_uniform(a, b)

a - 1 + :rand.uniform(b-a+1)

x = Enum.reverse(x)

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

{a, b} = {b, a}

i = String.to_integer(s)

s = Float.to_string(x, decimals: 2)

s = "ネコ"

pid = spawn fn ->
  receive do
    {:hello, name} ->
      IO.puts("Hello, #{name}")
    _ ->
      IO.puts(:stderr, "Unexpected message received")
  end
end

send pid, {:hello, "Alan"}

x = for _ <- 1..m, do: for _ <- 1..n, do: 0.0

  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

Enum.sort_by(items, &(&1.p))

List.delete_at(items, i)

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)

defmodule Factorial do
  def f(0), do: 1
  def f(i) when i > 0 do
    n * f(i-1)
  end
end

:math.pow(x, n)

def compose(f, g) do
  fn a ->
    g.(f.(a))
  end
end

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

t = String.slice(s, i..j-1)

ok = String.contains?(s, word)

t = String.reverse(s)

  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

List.insert_at(s, i, x)

Process.sleep(5000)

t = String.slice(s, 0, 5)

t = String.slice(s, -5, 5)

<<_ :: binary-5>> <> t = s

s = "Spanning
string
works"

s = """
multiline
heredoc
"""

s = ~S"""
This will print multiline
and escape char like \G
"""

chunks = String.split(s)

defmodule Looping do
	def infinite do
		# Write code here	
		infinite
	end
end

Map.has_key?(m, k)

Map.values(m) |> Enum.member?(v)

y = Enum.join(x, ", ")

s = Enum.sum(x)

s = Integer.to_string(i)

s = to_string(i)

s = "#{i}"

# 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")
 

y = Enum.filter(x, p)

y = for item <- x, p.(item), do: item

lines = File.read!(f)

IO.puts :stderr, "#{x} is negative"

d = :calendar.local_time

defmodule Dry do
  def indexOf(x, y, default \\ -1) do
    case String.split(x, y, parts: 2) do
      [head, _] -> String.length(head)
      [_] -> default
    end
  end
end

x2 = String.replace(x, y, z)

x = :math.pow(3, 247)

s = "#{Float.round(x * 100, 1)}%"

z = :math.pow(x, n)

:random.seed(s)

Enum.join(args, " ")

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)

x = Integer.gcd(a, b)

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

s = Integer.to_string(x, 2)

Integer.digits(x, 2) |> Enum.join("")

def main(condition) do
  case condition do
    true -> main(condition)
    false -> nil
  end
end

y = x / 1

y = trunc(x)

y = Kernel.round x

s |> String.split(t) |> Enum.drop(1) |> length()

r = Regex.compile!("htt+p")

System.halt()

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")

def control(f) do
	f()
end

[{_, type} | _] = IEx.Info.info(x)
type

def main(path) do
  _x =
    path
    |> File.stat!()
    |> Map.get(:size)
end

String.starts_with?(s,prefix)

b = String.ends_with?(s, suffix)

x = Date.to_iso8601(d)

Enum.sort(items, c)

blank = s == nil || String.length(String.trim s) == 0

mymap 
|> Map.to_list 
|> Enum.sort(fn ({_k1, val1}, {_k2, val2}) -> val1 <= val2 end)
|> Enum.each(fn ({k, v}) -> IO.puts("#{k}: #{v}") end)

b = x == y

s2 = String.replace(s1, w, "")

n = Enum.count(x)

y = x |> Enum.uniq |> List.to_tuple

y = MapSet.new(x)

Enum.uniq(x)

n = String.to_integer IO.gets ""

@suits %{
  "SPADES" => 1,
  "HEARTS" => 2,
  "DIAMONDS" => 3,
  "CLUBS" => 4
}

def main, do: @suits

def main(function) do
  function
  |> :timer.tc()
  |> elem(0)
  |> Kernel.*(1_000)
end

def foo, do: {"bar", true}

cond do
  c1 -> f1
  c2 -> f2
  c3 -> f3
end

ok = s =~ ~r/#{word}/i

items = [a, b, c]

List.delete(items, x)

Enum.filter(items, fn v -> v != x end)

b =  Regex.match?(~r{\A\d*\z}, s)

m = Map.delete(m, k)

def main(items1, items2) do
  Enum.each(items1, &IO.puts/1)
  Enum.each(items2, &IO.puts/1)
end

items1 ++ items2 |> Enum.each(&IO.puts/1)

s = Integer.to_string(x, 16)

f = String.to_float(s)

t = 
  s 
  |> String.to_charlist()
  |> Enum.filter(&(&1 in 0..127))
  |> List.to_string

t = for <<c <- s>>, c in 0..127, into: "", do: <<c>>

def main(string), do: String.replace_suffix(string, "/", "")

to_string(char)

t =  s <>  to_string(i)

File.rm(filepath)

planet = "Earth"

elements = Enum.map(elements, &(&1 * c))

x = List.last(items)

ab = a ++ b

n = String.length s

q=<<"q=~p;:io.format q,[q]">>;:io.format q,[q]

def main() do
  Date.utc_today()
  |> Date.add(1)
  |> Date.to_string()
end

y = x
|> Enum.filter(&P/1)
|> Enum.map(&P(&T/1)

def sq(x) do
  x*x
end

def hypo(a,b) do
  sqrt(sq(a) + sq(b))
end

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

foo = System.get_env("FOO", "none")

i = Enum.find_index(items, & &1 == x)

items2 = [x | items]

def main(p) do
  p
  |> Task.async()
  |> Task.await()
end

c = a ^^^ b

Enum.each(a, &IO.inspect/1)

IO.inspect m

c = items |> Enum.uniq |> length

def main(m) do
  m
  |> Map.values()
  |> Enum.random()
end

x = if condition(), do: "a", else: "b"

s = String.duplicate(v, n)

defmodule FizzBuzz do
  def run do
    for n <- 1..100 do
      case { rem(n, 3) == 0, rem(n, 5) == 0 } do
        { true, true } -> IO.puts("FizzBuzz")
        { true, false } -> IO.puts("Fizz")
        { false, true } -> IO.puts("Buzz")
        _ -> IO.puts(to_string(n))
      end
    end
  end
end

FizzBuzz.run

def main(p) do
  b = File.ls!(p) == []
end

s = a <> b

def try_str_to_enum(t, string), do: t[string]

s = "Our sun has #{x} planets"

a = Map.values(m)