Por que expressões compostas?

Este é um exemplo de um livro que estou lendo:

volume = begin
    len = 10
    breadth = 20
    height = 30
    len * breadth * height
end

Por que preciso de expressões compostas ?? Eu poderia apenas escrever volume = 10 * 20 * 30ou volume = len * breadth * heightescrever uma função para essa ou uma função anônima ...

Por que eu uso begine end? Ou a pergunta provavelmente melhor: quando eu os uso, como acho que o exemplo acima do livro provavelmente não é muito bom.

Eu acho que existem muitas situações em que os begin ... endblocos são úteis, mas como você observou, muitas vezes também é possível obter um efeito semelhante com outras construções, como funções, etc.

Para que begin ... endblocos podem ser usados?

• Para simplesmente "conter" variáveis e seus nomes: len, breadthe heightsó existirá dentro do bloco e não poluir o namespace circundante.
• Para aplicar macros a um bloco de código, em vez de instruções individuais. Por exemplo, @inbounds begin <all my code without bounds checking goes here> endou envolvendo @time begin ... endum pedaço de código.
• Criar um escopo local em um escopo global circundante (para evitar confusões de escopo global, por exemplo). (Observe que, conforme indicado nos comentários begin ... end, não introduz um escopo local, mas o argumento é válido para o let ... endbloco semelhante .)

Em particular, o segundo ponto é para o que eu os uso nos meus códigos.

Para generalizar o que todo mundo já disse: os blocos permitem converter uma lista de declarações ("frases" sintáticas que não possuem valores, ou seja, não podem ser atribuídas) em uma expressão (uma "frase" que representa valores e pode ser atribuída )

Por exemplo, embora não deva, você pode escrever

x = begin
    s = 0
    for i = 1:10
        s += i^2
    end
    s
end

para atribuir xao resultado de uma operação de loop. (Com a restrição de que a última instrução na sequência deve realmente ser uma expressão - caso contrário, você não teria valor para a expressão.)

Um caso de uso legítimo disso é o código gerado. Por exemplo, você pode ativar

x = @somthing bla blub

para dentro

x = begin
   (stuff involving bla and blub)
end

transparente para o usuário, enquanto ele @somethingpode gerar livremente qualquer construção de linguagem.

Ou se você deseja escrever uma função anônima com um corpo mais longo (e não usar o functionformulário):

f = x -> begin
   ...
end

Um uso para esses blocos está nas compreensões:

A = [ begin
           x = y^2
           x - x^2 + 2
         end
         for y = 1:5 ]

Você pode criar uma função e usá-la dentro da compreensão, mas às vezes isso é conveniente. É usado sempre que você deseja usar um bloco de código com várias linhas em algum lugar, por exemplo, para passar como argumento para uma macro (que é muito comumente usada @testsetna biblioteca padrão de teste).

Simplificando: "begin" apenas indica um bloco de código (consulte os documentos sobre isso: https://docs.julialang.org/en/v1/base/base/#begin ).

No exemplo acima, não está claro se existe algum valor em usar um bloco de início versus declarar uma função.

Não vejo essa palavra-chave sendo muito usada no código e pessoalmente nunca a usei na prática. Minha sugestão é usar apenas uma função, pois ela fará a mesma coisa.