def get_user_data(user) do
  Api.get_data(user)
  |> filter_sensitive_info()
  |> IO.inspect()
  |> add_timestamps()
  |> downcase_username()
end

user = {"Alexander", "iteam"}

{"Alexander", employer} = user
IO.puts(employer)
# iteam

{"Andreas", employer} = user
# == Compilation error in file lib/test.ex ==
# ** (MatchError) no match of right hand side value: {"Andreas", "iteam"}
# lib/test.ex:22: Test.greet/0
# (elixir) lib/kernel/parallel_compiler.ex:229: anonymous fn/4 in Kernel.ParallelCompiler.spawn_workers/7

def greet(), do: IO.puts "hejsan anonym!"
def greet("Stefan"), do: IO.puts "Nämen, hallå hallå!"
def greet("Christian"), do: IO.puts "God afton direktören!"


greet()
# hejsan anonym!

greet("Stefan")
# Nämen, hallå hallå!

greet("Christian")
# God afton direktören!

def greet([]), do: IO.puts "Det finns ingen att hälsa på!"
def greet([first | tail]), 
  do: IO.puts "Nämen, hallå #{first} och #{tail}.."

greet([])
# Det finns ingen att hälsa på :(

greet(["Andreas", "Kristoffer", "Maria", "Izabella"])
# Nämen, hallå Andreas och KristofferMariaIzabella..



def greet(["Stefan" | tail]), 
  do: IO.puts "Nämen, hallå Stefan och #{tail}.."
def greet([_first | _tail]), 
  do: IO.puts "Jag vill hälsa på Stefan först ju.."

greet(["Emma-Klara", "Maria", "Izabella", "Stefan"])
# Jag vill hälsa på Stefan först ju..

greet(["Stefan", "Emma-Klara", "Maria", "Izabella"])
# Nämen, hallå Stefan och Emma-KlaraMariaIzabella..

def greet([]), do: :ok

def greet([first | []]),
  do: IO.puts "Sist men inte minst, hallå #{first}!"

def greet([first | tail]) do
  IO.puts "Hallå #{first}!"
  greet(tail)
end


greet(["Emil", "Mikaela", "Erik", "Alexander"])
# Hallå Emil!
# Hallå Mikaela!
# Hallå Erik!
# Sist men inte minst, hallå Alexander!

def create(params) do

  %User{}
    |> parse_firstname(params["firstname"])
    |> parse_lastname(params["lastname"])
    |> parse_age(params["age"])

end

def parse_lastname({:error, _} = err, _name), do: err
def parse_lastname(user, nil), do: {:error, "name is required"}
def parse_lastname(user, ""), do: parse_lastname(user, nil)

def parse_lastname(user, name), do: %{user | lastname: name}



def create(params) do
  with {:ok, firstname} <- parse_firstname(params["firstname"]),
    {:ok, lastname} <- parse_lastname(params["lastname"])
    {:ok, age} <- parse_age(params["age"])
     
  do
    %User{firstname: firstname, lastname: lastname, age: age }
  else
    err -> err
  end
end


def parse_lastname(nil), do: {:error, "name is required"}
def parse_lastname(""), do: parse_lastname(nil)

def parse_lastname(name), do: {:ok, name}

defmodule Test do

  @doc ~S"""
  Says Hallå to the first element of the list

  ## Examples

    iex> Test.greet(["Rebecca"])
    "Hallå Rebecca!"

    iex> Test.greet(["Martin", "Rebecca"])
    "Hallå Martin!"

  """
  def greet([first | _]) do
    "Hallå #{first}!"
  end
end

### Språkkonventioner från verkliga livet
def is_night? (argument) do
  argument === "MOON"
end

def do_the_thing! do
  raise "Not possible"
end


### function guards

def is_night? (argument) when is_string(argument) do
  argument === "MOON"
end

def is_night? (_)
  false
end


### Sigils

naive_date = ~N{2000-01-01 23:00:07}
# Ett Date-object

~r{foo|bar}
# Regex

~w{foo bar baz}
# ["foo", "bar", "baz"]

### Inga instance-methods, konsekvent och lätt att pipe:a
Enum.map(...)

String.replace(...)