coproduto

defmodule DeepMerge do
  def deep_merge(m1, m2) do
    Map.new(m1, fn {k, v1} -> 
      case Map.get(m2, k) do
        nil -> {k, v1}
        v2 -> {k, deep_merge_values(v1, v2)}
      end
    end)
  end
  

coproduto

fetch('firstUrl')
  .then((firstResponse) => fetch('secondUrl', { method: 'POST', body: mkSecondReqBody(firstResponse) }))
  .then((secondResponse) => fetch('thirdUrl', { method: 'POST', body: mkThirdReqBody(secondResponse) }))
  .catch((error) => handleError(error));

coproduto

Promise.all([
  fetch('firstUrl'),
  fetch('secondUrl'),
  fetch('thirdUrl')
]).then(([firstResponse, secondResponse, thirdResponse] => {
  // faz o que quiser aqui
}).catch((error) => { /* trata erro aqui */ });

coproduto

// Como era sem Promises (callback hell)
firstStep(
  function (firstResult) { 
    secondStep(
      firstResult, 
      function (secondResult) {
        thirdStep(secondResult);
      },
      errorHandler
    ),

coproduto

defmodule RecordGrouping do
  def group(records) do
    records
    |> Enum.group_by(&Map.get(&1, "data"), &Map.get(&1, "qtd"))
    |> Map.new(fn {k, v} -> {k, Enum.sum(v)} end)
  end
end

coproduto

defmodule PicaPauServer do
  ## Um GenServer é um "servidor" dentro do programa que pode ter estado interno.
  ## Ele recebe mensagens e responde a elas de uma forma baseada no estado.
  use GenServer
  
  # Interface pública
  ## É convenção os módulos que implementam processos que têm a intenção de serem duradouros
  ## em Elixir exporem uma função `start_link/1` que inicia o processo e retorna o seu PID.
  ## Aqui delegamos para o `start_link/2` padrão do módulo GenServer.
  def start_link(things) do

coproduto

Toda Monad é um tipo genérico. Para um tipo genérico ser uma monad, ele tem que suportar a seguinte "interface":

Dado que nossa monad é o tipo M onde A é algum tipo de parâmetro, devem existir as seguintes funçÕes:

function pure(A): M<A>
function bind<B>(M<A>, A -> M<B>): M<B>

A função pure "injeta" um valor dentro da monad com contexto "neutro".

coproduto

Covariância e Contravariância

Suponhamos, como exemplo, tipos Animal, Gato e Cachorro, tais que Gato e Cachorro herdam de Animal. Nesse caso, é claro que na maioria dos casos onde a gente recebe um Animal, a gente pode receber ou um Gato ou um Cachorro. E se queremos um array de Animais, a princípio não deveria ter problema ter Gatos e Cachorros nesse array, pois todas as funcionalidades que manipulam Animais são implementadas por estes. Portanto, Array é um tipo covariante (na sintaxe de Scala, Array[+T]). Um lugar que espera um array de Ts também pode receber um array de T's, onde

coproduto

defmodule LongestCommonPrefix do
  @spec run([String.t()]) :: String.t()
  def run(strings) do
    strings
    |> Stream.map(&String.graphemes/1)
    |> Stream.zip_with(&Function.identity/1)
    |> Stream.take_while(&all_same?/1)
    |> Stream.map(&hd/1)
    |> Enum.join()
  end    

coproduto

const validateRequest(request: Request): boolean {
  return [
    request.body,
    request.body.value,
    request.body.country,
    request.body.email,
    request.body.number
  ].some();
}