Functions, a pocket show( )!!

fun main() {
  /*
  Default Functions vs Compact functions vs lambda functions vs higher-order functions.
  Estes exemplos simulam o processo de limpeza da água de um aquário pelas várias funções chamadas
  de "waterFilter".
  Cada uma das funções  fará o tratamento da água cuja quantidade de sujeira é indicada pela variável
  "dirtylevel".
  */

  //Declaração e inicialização da variável "dirtyLevel" que informará a quantidade de sujeira na água.
  var dirtyLevel = 20
  println("Considerando o nível de sujeira da água $dirtyLevel, " +
          "qual resultado cada função purificadora diz que entregará?")

  /*O exemplo abaixo é uma função nomeada tradicional.
  Para declararmos este tipo de função deve-se:
  - Iniciar a linha com a palavra reservada "fun". 
  - Dar um nome para ela, neste exemplo: "waterfilter".
  - Após o nome o operador de invocação "( )", neste caso: waterfilter( )
  - Se a função for receber parâmetros, devem ser incluídos dentro dos operadores de invocação ,
    neste caso: waterfilter(dirty : Int )
  - A função pode ou não retornar um valor, dependendo da decisão do desenvolvedor.
    O tipo do dado a ser retornado deve ser indicado após os operadores de invocação,
    neste caso a função retornará um valor inteiro: waterfilter(dirty : Int ): Int
  - Incluir o corpo da função, que é o espaço delimitado pelos operadores { },
    neste caso: waterfilter(dirty : Int ): Int {  }
  - O código da função, ou seja, aquilo que será executado pela função quando for chamada (invocada)
    é escrito neste espaço.
   - A palavra reservada "return" é usada ao final do código somente para funções que retornam algum valor.
  */
  fun  waterFilter(dirty : Int): Int {
      return dirty / 2
  }
  println("A função tradicional diz: ${waterFilter(dirtyLevel)}")

  /*O exemplo abaixo é uma função compacta ou função de expressão única.
  Ela pode ser usada quando a função retorna o resultado de uma única expressão.
  Para isso deveremos trocar os operadores "{ }" pelo sinal de "=" e escrever a expressão a ser executada em seguida.
  A palavra reservada "return" NÃO será usada.
  */
  fun  waterFilter_compact(dirty : Int) = dirty / 2
  println("A função compacta diz: ${waterFilter_compact(dirtyLevel)}")

  /*
  O exemplo abaixo é de uma função lambda ou anônima com parâmetros.
  Ela é escrita diretamente dentro ds operadores "{ }", neste exemplo:
  "{ dirty : Int -> dirty / 2}".
  Os parâmetros são escritos antes do operador "->" e o código depois.
  Neste exemplo a função lambda foi atribuida a uma variável chamada "waterFilter_lambda"
  Para invocar a função lambda devemos colocar os operadores "( )" ao lado do nome da variável,
  como foi feito dentro da função "println()" abaixo:
   */
  val waterFilter_lambda = { dirty : Int -> dirty / 2}
  println("A função Lambda (anônima) diz: ${waterFilter_lambda(dirtyLevel)}")

  /*
 O exemplo abaixo é de uma função de ordem superior chamada de "updateDirty".
 Ela é chamada assim porque ela pode receber como parâmetro uma outra função,
 neste caso: "operation: (Int) -> Int): Int {return operation(dirty)"
 o parâmetro chamado de "operation" recebe a função lambda "Int {return operation(dirty)".
 No meio dos dois deve ser colocado o operador ":".
 O que o Parâmetro "operation diz é que a função "updateDirty" quando for invocada receberá uma
 outra função lambda que usa um parâmetro inteiro como entrada e retorna um valor inteiro"
  */
  dirtyLevel = 30
  println("\nConsiderando o nível de sujeira da água $dirtyLevel:")
  fun updateDirty(dirty: Int, operation: (Int) -> Int): Int {
      return operation(dirty)
  }
  /*
  Olha que legal. Podemos criar variações de uma função lambda, todas com alguma diferença entre si,
  e colocá-las dentro de variáveis com nomes diferentes. Nos casos abaixo criamos funções purificadoras
   que se parecem mas cuja diferença é a eficiencia da limpeza.
   */
  val waterFilter_low_: (Int) -> Int = { dirty -> dirty / 2 }
  val waterFilter_normal: (Int) -> Int = { dirty -> dirty / 3 }
  val waterFilter_High: (Int) -> Int = { dirty -> dirty / 4 }
  
  /*
  Note que a função "updateDirty" é a mesma nas três linhas de código abaixo. A diferença está na 
  função lambda que ela recebeu como parâmetro.
   */

  println("A função de ordem superior e a função lambda slow dizem: ${updateDirty(dirtyLevel,    waterFilter_low_)}")
  println("A função de ordem superior e a função lambda normal dizem: ${updateDirty(dirtyLevel, waterFilter_normal)}")
  println("A função de ordem superior e a função lambda fast dizem: ${updateDirty(dirtyLevel, waterFilter_High)}")
}