coproduto

#!/bin/bash
trap : SIGTERM SIGINT # : é um noop - só estamos dizendo que queremos receber os sinais

echo $$ # $$ contém o PID do próprio script

find / >/dev/null 2>&1 &
FIND_PID=$! # $! contém o PID do último processo iniciado

wait $FIND_PID # Esperamos até o PID encerrar ou recebermos um sinal

coproduto

int do_something(int arg) {
  if (arg > 0) {
    printf("%d", arg);
    do_something(arg - 1);
  } else { 
    /*** if arg <= 0 ***/
    return 0;
  }
  /*** END if arg > 0 ***/
}

coproduto

function ifSemElse(lol) {
  if (!lol) return 0;
  
  fazUmaCoisa();
  return fazMaisCoisas(lol);
}

// Você até poderia escrever essa função assim:
function comElse(lol) {
  if (!lol) {

coproduto

defmodule Parens do
  def generate(n) do
    n
    |> generate_trees()
    |> Enum.map(&IO.iodata_to_binary/1)
  end

  defp generate_trees(0), do: []
  defp generate_trees(1), do: [["()"]]
  defp generate_trees(n) do

coproduto

defmodule Primality do
  # O jeito "ingênuo" de checar por primalidade é você simplesmente verificar
  # se o número tem divisores. Ou seja, você pega todos os números menores
  # que o seu número-alvo (começando em 2, pois 1 divide todos os números)
  # e verifica se eles dividem o número (ou seja, se o resto da divisão -
  # função `rem/1` - é igual a 0).
  #
  # Também precisamos de um caso especial para 1, que não tem divisores mas não
  # é primo.
  def check_naive(1), do: false

coproduto

defmodule Change do
  # A intuição para resolver este problema é entender que
  # quando você vai fazer troco para um valor, dado um certo
  # conjunto de moedas, você tem duas escolhas:
  #
  # 1. Você pode usar a moeda de maior valor que você tem
  # 2. Você pode fazer troco sem usar essa moeda.
  #
  # Se você escolher a opção 1, você está implicitamente dizendo
  # que você vai usar pelo menos 1 moeda daquele tipo.

coproduto

defmodule BalancedDelimiters do
  @openers [
    ?(,
    ?[,
    ?{
  ] 

  @closers [
    ?),
    ?],

coproduto

-- Notar que Haskell não usa parênteses pra chamar funções, então `f a b` seria `f(a, b)` em 
-- outras linguagens

-- suponhamos um joguinho estilo space invaders
-- aí em cada frame você verifica se uma bala tá colidindo com algum inimigo
-- e se tiver colisões isso causa atualizações específicas do estado
evalFrame gameState =
  case getBulletCollisions gameState of
    [] -> continueEvalFrame gameState -- lista vazia, nenhuma colisão, só executamos outros updates
    collisions -> 

coproduto

-- Imagina que a gente não tivesse recursão. Isso significaria essencialmente que uma expressão não pode se referir ao nome
-- dela mesma dentro da definição dela. Por exemplo, a definição de fatorial abaixo não poderia existir:

factorialRec n = n * factorialRec (n - 1)

-- Como o nome factorialRec é citado na função e estamos proibindo citar o nome da própria função, esse termo se torna
-- ilegal. Então como poderíamos escrever a função fatorial? Bom, uma ideia é trocar a chamada recursiva por um argumento:

factorialOpen f n = n * f (n - 1)

coproduto

const makeRuleSet = (rules) => 
  new Map(
    rules
      .flat()
      .map(([lprop, rprop, effects]) => [[lprop, rprop], effects])
  );

const simpleRule = (rule) => [rule];
const commutativeRule = (rule) => [rule, reverseRule(rule)]