cluster1's questions

Tento me familiarizar com a simultaneidade do Swift, especialmente com o MainActor.

Eu criei para mim esta classe de demonstração :

@MainActor
class ThreadsDemo {
  let range1000 = 0.. < 1000
  var randomNumber = 0

  init() {
    randomNumber = Int.random(in: range1000)
  }

  func modifyRandomNumber() async {
    print("2. isMain: \(Thread.isMainThread)")
    let newRandomNumber = Int.random(in: range1000)
    print("Generated random-number -> \(newRandomNumber)")
    Timer.scheduledTimer(withTimeInterval: 3.0, repeats: false) {
      _ in
        print("4. isMain (within wait): \(Thread.isMainThread)")
    }
    print("5. isMain: \(Thread.isMainThread)")
    randomNumber = newRandomNumber
  }
}

Invocando o método ThreadDemo:

.task {
  print("1. isMain: \(Thread.isMainThread)")
  print("Initial random-number -> \(threadsDemo.randomNumber)")
  await threadsDemo.modifyRandomNumber()
  print("Modified random-number -> \(threadsDemo.randomNumber)")
  print("6. isMain: \(Thread.isMainThread)")
}

Resultado:

1. isMain: true
Initial random-number -> 455
2. isMain: true
Generated random-number -> 578
5. isMain: true
Modified random-number -> 578
6. isMain: true
4. isMain (within wait): true

Obviamente executa tudo no thread principal, até mesmo o bloco dentro do temporizador agendado.

Estou confuso, porque pensei que ele usaria threads em segundo plano para evitar que a interface do usuário travasse e parasse de responder.

Se ele executa tudo no thread principal de qualquer maneira, então qual é o propósito de usar tarefas?

Mas o que eu realmente tentei descobrir:

A anotação @MainActor resulta na execução de tudo no thread principal (todo o código executável) ou resulta apenas em fazer alterações no estado (atribuições, etc.), sempre no thread principal?

Eu vi esse código em um dos vídeos de Paul Hudson. Acessível somente para membros, mas aqui está o texto correspondente: Desafio de codificação

struct Friend: Hashable, Identifiable, Codable {
    let id: UUID
    /* ... */
}

Conheço o Hashable como uma alternativa ao identifiable, quando você quer usar o objeto com uma lista/ForEach e o objeto não tem ID e você não quer adicioná-lo.

Qual é o propósito de ter ambos (Hashable e Identifiable)?

Eu vi o código mostrado neste vídeo Go Rails em 05:15: Vídeo-tutorial

<%= form_with model: Link.new do |form| %>
    # ...
<% end %>

Normalmente eu teria escrito uma new-action. Algo como:

def new
  @link = Link.new
end

Obviamente, é possível pular a ação e criar o objeto necessário imediatamente, ao invocar o form_with.

Qual é o benefício de ter uma nova ação?

É para ter uma rota separada, que cria o formulário, quando invocada?

Qual é a diferença?

task {
    // ... //
}
                
Task {
    // ... //
}

Eu descobri isso por acidente.

Taské a estrutura correta, quando você quer criar uma tarefa assíncrona. Mas escrever tasknão causa um erro de sintaxe. Eu conheço o modificador de tarefa SwiftUI. Mas qual é o propósito escrito dentro do código geral?

Qual é o propósito, respectivamente o objetivo, de uma propriedade preguiçosa?

Documentação em linguagem Kotlin: https://kotlinlang.org/docs/delegated-properties.html#lazy-properties

Economizando memória? Ou é outra coisa?

Pelo que diz a documentação, eles parecem cumprir propósitos semelhantes.

Qual é a diferença entre o modificador de id e o modificador de tag no SwiftUI?

Quando devo usar qual?

Qual é a diferença aqui?

val myViewModel: MyViewModel by viewModels()

contra

val myViewModel = viewModel<MyViewModel>()

Como funciona a primeira forma? Como ele sabe qual ViewModel inicializar? Da anotação de tipo após o nome da variável?

Alguém pode explicar o que "by" faz aqui?

val viewModel by viewModels<ProductsVM>()

Respectivamente, como esse código funciona? O que acontece lá?

Eu realmente tento entrar no costume lendo a documentação oficial da Apple. Mas, para ser sincero: tive problemas para conseguir as coisas.

Qual é aqui a diferença entre os quatro 'String init (descrevendo: Assunto)'?

Fonte: documentação da Apple - String