Dados Mutáveis F#

Neste artigo, você aprenderá como usar o F# mutável e quando pode ser apropriado fazê-lo. Você também descobrirá como usar estruturas de dados mutáveis comuns em F#, como matrizes e registros mutáveis .

Embora a imutabilidade seja frequentemente favorecida na programação funcional, há casos em que dados mutáveis podem ser uma solução mais conveniente ou eficiente.

No F#, as variáveis são imutáveis, o que significa que não podem ser alteradas depois de vinculadas a um valor. No entanto, existem estruturas de dados mutáveis como arrays e registros mutáveis que podem ser usados em certos casos.

Essas propriedades mutáveis são compiladas como valores estáticos que só podem ser lidos pelo aplicativo.

Importante : seja você novo em F# ou um programador funcional experiente, é importante entender quando e como usar dados mutáveis em seu código.

Aqui está um exemplo de como isso pode ser alcançado.

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
let a = 1
let b = 2
printfn "a: %i" a
printfn "b: %i" b
let a = 3
let b = 4
printfn "a: %i" a
printfn "b: %i" b
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E o erro será mostrado como:

Duplicate definition of value a
Duplicate definition of value b

Índice-

F# Dados mutáveis:

Variáveis Mutáveis F#

No F#, você pode alterar o valor de uma variável se precisar atualizá-la.

Para permitir que as variáveis mudem de valor ao longo do tempo, você pode usar a palavra-chave mutável.

Ao declarar uma variável como mutável, você pode atribuir e alterar seu valor posteriormente no programa.

Para criar uma variável mutável, você pode usar a palavra-chave let e especificar mutável na declaração da variável.

Isso atribui um valor inicial à variável, mas você pode modificá-lo posteriormente usando o operador ' <- ' .

Por exemplo,

let mutable a = 1
a <- 2

Aqui está um exemplo que ajudará você a entender o conceito:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
let mutable a = 22
let b = 46
let mutable c = a + b
printfn "Original Values:"
printfn "a: %i" a
printfn "b: %i" b
printfn "c: %i" c
printfn "Let us change the value of a"
printfn "Value of c will change too."
a <- 51
c <- a + b
printfn "New Values:"
printfn "a: %i" a
printfn "b: %i" b
printfn "c: %i" c
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

E a saída será a seguinte:

Original Values:
a: 22
b: 46
c: 68
Let us change the value of a
Value of c will change too.
New Values:
a: 51
b: 46
c: 97

Usos de dados mutáveis em F#

Muitas vezes é necessário e útil usar dados mutáveis ao processar dados, particularmente quando a estrutura de dados está relacionada a registros.

Aqui está um exemplo de como isso pode ser demonstrado:

Example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
open System
type studentData =
 { ID : int;
  mutable IsRegistered : bool;
  mutable RegisteredDate : string; }
let getStudent id =
 { ID = id;
  IsRegistered = false;
  RegisteredDate = null; }
let registerStudents (students : studentData list) =
 students |> List.iter(fun st ->
  st.IsRegistered <- true
  st.RegisteredDate <- sprintf "Registered %s" (DateTime.Now.ToString("hh:mm:ss"))
  Threading.Thread.Sleep(2000) (* Putting thread to sleep for 1 second to simulate processing overhead. *))
let printData (students : studentData list) =
 students |> List.iter (fun x -> printfn "%A" x)
let main() =
 let students = List.init 3 getStudent
 printfn "Before Process:"
 printData students
 printfn "\nAfter process:"
 registerStudents students
 printData students
 Console.ReadKey(true) |> ignore
main()
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

A saída do exemplo acima será a seguinte:

Before Process:{ID = 0;
 IsRegistered = false;
 RegisteredDate = null;}
{ID = 1;
 IsRegistered = false;
 RegisteredDate = null;}
{ID = 2;
 IsRegistered = false;
 RegisteredDate = null;}

After process:
{ID = 0;
 IsRegistered = true;
 RegisteredDate = "Registered 02:24:47";}
{ID = 1;
 IsRegistered = true;
 RegisteredDate = "Registered 02:24:49";}
{ID = 2;
 IsRegistered = true;
 RegisteredDate = "Registered 02:24:51";}

Exemplo de Explicação:

O exemplo acima define um sistema aberto simples que representa um processo de registro do aluno.

O sistema foi projetado para registrar alunos criando instâncias do tipo studentData , que representa os dados de um aluno, incluindo sua ID, status de registro ( IsRegistered ) e data de registro ( RegisteredDate ).

A função getStudent cria uma nova instância de studentData com o id fornecido , status de registro padrão e valores de data.

A função registerStudents pega uma lista de instâncias studentData e atualiza seu status e data de registro. Ele usa a função List.iter para aplicar uma determinada função a cada elemento da lista. A função aplicada aqui usa o método Threading.Thread.Sleep para simular a sobrecarga de processamento antes de definir os valores IsRegistered e RegisteredDate de cada aluno.

A função printData pega uma lista de instâncias de studentData e imprime seus valores no console usando a função printfn.

A função principal inicializa uma lista de 3 instâncias de studentData usando a função List.init e a função getStudent . Em seguida, imprime o estado inicial da lista usando a função printData.

Após a impressão do estado inicial, a função registerStudents é chamada para cadastrar os alunos. Finalmente, o estado atualizado da lista é impresso usando a função printData novamente.

Benefícios mutáveis do F#

Aqui estão alguns benefícios de usar dados mutáveis em F#:

O uso de estruturas de dados mutáveis do F#, como matrizes e registros mutáveis, pode levar a uma execução de código mais rápida em comparação com suas contrapartes imutáveis. Isso ocorre porque as estruturas de dados mutáveis podem ser modificadas no local, reduzindo a necessidade de criação de novos objetos e coleta de lixo.
As estruturas de dados mutáveis do F# são comumente usadas em linguagens de programação imperativas, como C# e Java. Usando estruturas de dados mutáveis em F#, você pode simplificar a interoperabilidade com outras linguagens e estruturas que esperam dados mutáveis.
Em alguns casos, os dados mutáveis do F# podem resultar em um código mais simples e legível em comparação com o uso de estruturas de dados imutáveis. Por exemplo, se você estiver lidando com uma grande coleção de dados que precisa ser atualizada com frequência, usar uma estrutura de dados mutável como uma matriz pode resultar em um código mais simples em comparação com o uso de uma estrutura de dados imutável como uma lista.
Usando dados mutáveis F#, você tem mais flexibilidade em como manipular e atualizar dados em seu programa. Isso pode ser especialmente útil em cenários onde o desempenho é crítico, como em computação científica ou sistemas de tempo real.

Vale a pena observar que os dados mutáveis do F# devem ser usados criteriosamente e com cuidado, pois podem introduzir complexidade e tornar o código mais difícil de raciocinar. No entanto, quando usados adequadamente, os dados mutáveis podem fornecer benefícios significativos em termos de desempenho, simplicidade e flexibilidade.

Nós valorizamos o seu feedback.

Dados Mutáveis ​​F#

Example:

Variáveis ​​Mutáveis ​​F#

Example:

Usos de dados mutáveis ​​em F#

Example:

Exemplo de Explicação:

Benefícios mutáveis ​​do F#

Sentindo entediado?

Dados Mutáveis F#

Variáveis Mutáveis F#

Usos de dados mutáveis em F#

Benefícios mutáveis do F#