Skip to content

Instantly share code, notes, and snippets.

View coproduto's full-sized avatar

Cast coproduto

View GitHub Profile
View deep_merge.ex
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
View promises_dependencies.js
fetch('firstUrl')
.then((firstResponse) => fetch('secondUrl', { method: 'POST', body: mkSecondReqBody(firstResponse) }))
.then((secondResponse) => fetch('thirdUrl', { method: 'POST', body: mkThirdReqBody(secondResponse) }))
.catch((error) => handleError(error));
View promises_corrected.js
Promise.all([
fetch('firstUrl'),
fetch('secondUrl'),
fetch('thirdUrl')
]).then(([firstResponse, secondResponse, thirdResponse] => {
// faz o que quiser aqui
}).catch((error) => { /* trata erro aqui */ });
View promises_callback_hell.js
// Como era sem Promises (callback hell)
firstStep(
function (firstResult) {
secondStep(
firstResult,
function (secondResult) {
thirdStep(secondResult);
},
errorHandler
),
View record_grouping.ex
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
View picapau_server.ex
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
View monads.md

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

View variancia.md

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

View longest_common_prefix.ex
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
View validate.ts
const validateRequest(request: Request): boolean {
return [
request.body,
request.body.value,
request.body.country,
request.body.email,
request.body.number
].some();
}