Funções Built In no Elixir
Tags: elixir, erlang, beginners, webdev
Published: 2022-10-28 23:36:34

Também conhecidas como **funções internas,** as funções _built in_ são recursos muito uteis encontrados na maioria das linguagens de programação.

Nesse capítulo exploraremos algumas que são bastante uteis para diversas situações.

![ready](https://media.giphy.com/media/MqyWCZbMMFFL2/giphy.gif)

## String

Comecemos com algumas bem simples para trabalharmos com string.

```Elixir
String.reverse("Trybe")
# "ebyrT"

String.split("Trybe escola de programação")
# ["Trybe", "escola", "de", "programação"]

String.replace("meen", "e", "o")
# "moon"

String.replace("Vamos usar Javascript", "Javascript", "Elixir")
# "Vamos usar Elixir"
```

## Enum

![couting](https://media.giphy.com/media/5zbj7HTomGwJa37pWO/giphy.gif)

Agora que já deu pra sentir um gostinho, falaremos do módulo **Enum**.

O **Enum** é o módulo que utilizamos no Elixir para trabalhar com dados “enumeráveis”, como _Lists_, _Maps_ e _Ranges_.

O `Enum.map()`, por exemplo, é muito parecido com o `.map` do Python ou do Javascript, o primeiro argumento é uma coleção e o segundo argumento é uma função, que pode ser anônima, que lida com os valores passados e retorna uma nova coleção.

```Elixir
Enum.map([10, 20, 30], fn num -> num * 2 end)
# [20, 40, 60]
```
O `Enum.reduce()` pega uma coleção de elementos e reduz eles a um único resultado, segundo os critérios que passarmos.

Observe o exemplo abaixo:

```Elixir
students = [
	%{name: "Paracelso", media_final: 10},
	%{name: "Rasputin", media_final: 8},
	%{name: "Eliphas Levi", media_final: 9},
]

Enum.reduce(students, 0, fn (%{media_final: media_final}, acc) -> acc + media_final end)
# 27
```
Uma maneira muito útil de acessarmos uma determinada posição em uma lista é usando `Enum.at()`

Observe o exemplo:

```Elixir
Enum.at(students, -1)
# %{name: "Eliphas Levi", media_final: 9}

Enum.at(students, 2)
# %{name: "Rasputin", media_final: 8}
```
É importante ressaltar que estamos utilizando listas nos exemplos, mas também podemos realizar as operações diretamente nos maps.

```Elixir
Enum.map(%{name: "Eliphas Levi", media_final: 9}, fn {_key, value} -> value end)
# ["Eliphas Levi", 9]
```
![borat](https://media.giphy.com/media/TcdpZwYDPlWXC/giphy.gif)

## Stream

Agora para fechar a seção de funções _Built In_ é importante falarmos sobre **Stream!**

Muitas vezes precisaremos lidar com uma enorme quantidade de dados e a função _Enum_ armazena seu resultado direto, na memória, o que pode trazer problemas de desempenho.

Com o _Stream_ armazenamos o resultado na memória somente quando ele é **implicitamente invocado,** ou seja, “**Lazy method”.** 

Observe o exemplo:

```Elixir
Stream.map(students, fn (%{name: name}) -> name end)

#Stream<[
  enum: [
    %{media_final: 10, name: "Paracelso"},
    %{media_final: 8, name: "Rasputin"},
    %{media_final: 9, name: "Eliphas Levi"}
  ],
  funs: [#Function<47.58486609/1 in Stream.map/2>]
]>
```
No exemplo anterior vemos que o _map_ não foi feito ainda e somente sera efetuado quando invocarmos o resultado, assim otimizamos o nosso fluxo:

```Elixir
Stream.map(students, fn (%{name: name}) -> name end) |> Enum.to_list()
# ["Paracelso", "Rasputin", "Eliphas Levi"]
```

## Conclusão

Nesse artigo aplicamos algumas funções *Built in* uteis para o nosso dia a dia.

O próximo artigo encerra a série [“Meus primeiros passos no Elixir”](https://dev.to/trybe/meus-primeiro-passos-no-elixir-1n1j) e falarei sobre a **Phoenix** uma poderosa framework Elixir para desenvolvimento web.

![phoenix](https://media.giphy.com/media/NpXecaHPKbdVm/giphy.gif)