Este texto é uma tradução gratuita de uma série de artigos de Sacha Barber de Brighton, Reino Unido, que achei bastante interessantes.Este é o primeiro post da minha série F #. Então, o que vamos cobrir? Como muitos programadores sabem bem, é habitual começar com o exemplo Hello World.
Então, faremos exatamente isso. Portanto, sem mais delongas, o que você precisa para criar um aplicativo separado "Hello World" em F #.
Aqui está:
open System [<EntryPoint>] let main argv = printfn "Hello World" Console.ReadLine() |> ignore 0
// Infelizmente, não foi possível encontrar a alocação de código para F #Isso pode não parecer suficiente para discutir, mas já há algo a considerar para se imergir em alguns dos princípios do F #.
Então, o que exatamente está acontecendo aqui?
Como esse é um aplicativo separado, obviamente precisamos de um ponto de entrada (assim como em qualquer outra linguagem .NET).
Então, como é determinado o ponto de entrada?
Bem, é quase o mesmo que em outras linguagens .NET, temos um método Main (ou uma função na terminologia F #) que utiliza uma matriz de strings e usamos o atributo [] para indicar que o método com este atributo é ponto de entrada.
O compilador e o Visual Studio nos amam por isso.
Mesmo neste exemplo, você deve ouvir sinais de alarme ou pelo menos algum sentimento de mal-entendido. Então, dissemos que existe uma função inicial que aceita uma matriz do tipo string. Tudo o que vejo é uma variável chamada "argv", que não vejo declarada como uma matriz. Essa variável "argv" é obviamente a matriz de strings que esperamos, mas por que ela não tem tipo .... Mmm, interessante.
O F # possui um sistema de inferência de tipo muito bom, o que significa que, em muitos casos, você pode omitir o tipo e o F # o produzirá corretamente. Obviamente, você ainda pode declarar completamente o tipo da variável de entrada, se desejar, onde geralmente assume o formato
(variableName: variableType)Portanto, usando o exemplo "argv" acima, poderíamos declarar o programa acima da seguinte maneira, e isso seria bom:
open System [<EntryPoint>] let main (argv :string[]) = printfn "Hello World" Console.ReadLine() |> ignore 0
Veja bem, definimos completamente o nome da variável de entrada com seu tipo, que neste caso é uma matriz de string [].
O que mais interessa lá? Bem, como eu disse, há algo para conversar.
Por que eu tenho uma linha com esse estranho
|> ignorar no final. O que é isso
Bem, como esse é um aplicativo de console F #, eu queria que o aplicativo não fosse desligado até o usuário inserir um caractere. Então, eu preciso fazer duas coisas:
- Abra o espaço para nome "Sistema", que me permite usar os tipos de espaço para nome "Sistema", como se eu estivesse usando "usando Sistema" em C # ou "Imports System" no VB .NET. "
- Como o F # é uma linguagem funcional, ele reclamará se a função, neste caso "Console.ReadLine (...)", que pode retornar uma string, não passa o resultado para a função "ignorar", que na verdade significa return () (este é o caminho em F # diz nulo, mas chama Unidade). Isso informa explicitamente ao F # para ignorar o resultado da chamada do método Console.ReadLine (..).
Por exemplo, aqui está a aparência do código se eu decidir não incluir |> ignorar
O programador C # / VB.NET pode não ver o que está sendo dito aqui. Mas o F # é bastante difícil quanto ao que uma função pode ou não fazer. E uma coisa que uma função DEVE SEMPRE fazer é retornar um resultado. No caso da função "principal", o resultado esperado será um valor inteiro 0.
Mas e o caso do Console.ReadLine (..)?
Bem, pelo menos nesse caso, o resultado não importa muito, e não estamos interessados nele, e o programa ainda funcionará bem se
ignorarmos |> ignorar , mas se você realmente não estiver interessado no resultado, deve aprender a usar
|> ignore . Caso você esteja interessado, o operador de pipeline "|>" direcionará o valor de retorno da expressão esquerda para a função correta, que nesse caso é igual a
"aceitar o valor de retorno do Console.Readline (...) e ignorar como ninguém se importa com isso" . Não se preocupe se isso não significar nada para você nesta fase, falaremos mais sobre isso mais tarde.
A última coisa que preciso fazer é garantir que a função F # sempre retorne um valor, isso é feito na linha em que você apenas vê a linha 0. Isso é suficiente para o F # entender que esse é o valor de retorno "0", que é o sistema de inferência de tipo será emitido, este é um valor Int igual a 0. O motivo pelo qual o compilador F # sabe que esse é um valor de retorno é porque, nesse caso, é a última instrução, portanto, DEVE ser um valor de retorno. Obviamente, isso pode ser complicado usando a lógica condicional se, mais, etc. É importante observar que em F # a função DEVE SEMPRE retornar um valor e, nesse caso, como o valor de 0 Int foi a última string encontrada (embora tudo possa ser mais complicado), ela é usada como valor de retorno. Obviamente, você pode retornar Unit, o que é feito usando "()", que na verdade não retorna nada (void se você quiser).
Outra coisa que gostaria de mencionar neste exemplo trivial é que o espaço desempenha um papel fundamental no desenvolvimento do F #.
Por exemplo, suponha que meu exemplo trivial tenha esta aparência em um editor (no meu caso, Visual Studio 2012):
Este é um pequeno programa, e tudo o que fiz foi remover os espaços no início da linha printfn. Mmmm, parece que o compilador F # não gostou nada disso. Sim, isso é justo.
No F #, um espaço é MUITO MUITO importante; portanto, brinque com ele, caso contrário, acostume-se a depurar erros criptográficos como o mostrado acima, causado por um simples problema de espaço semântico incorreto.
Enfim, este é um exemplo de "Hello World". Até nos encontrarmos da próxima vez, desejo tudo de bom a você.