Referência de interativo (FSI. exe) F#

F# interativo (FSI. exe) é usado para executar o código de F# interativamente no console ou para executar scripts de F#. Em outras palavras, o F# interativo executa um REPL (Read, avaliar, Print Loop) para o idioma F#.

Programação interativa com F#

F# interativo pode ser usado para escrever código no console ou em uma janela em Visual Studio.

Para executar o F# interativo do console, execute FSI. exe. Para obter informações sobre as opções de linha de comando disponíveis, consulte F# opções interativas.

Para executar o F# interativo até 2010 de Visual Studio, você pode clicar no botão de barra de ferramentas apropriadas rotulado F# interativo, ou use as teclas ctrl + Alt + F. Isso abrirá a janela interativa, uma janela de ferramenta executando uma sessão interativa F#. Você também pode selecionar algum código que você deseja executar na janela interativa e a combinação de teclas de visitas ALT + ENTER. Inicia o F# interativo em uma janela de ferramenta rotulada F# interativo.

Se você estiver usando o console ou 2010 de Visual Studio, aparece um prompt de comando e o interpretador aguarda sua entrada. Você pode inserir o código como faria em um arquivo de código. Para compilar e executar o código, insira dois ponto e vírgula (;;) para finalizar uma linha ou várias linhas de entrada.

F# interativo tenta compilar o código e, se for bem-sucedido, ele executa o código e imprime a assinatura dos tipos e valores que ele compilado. Se ocorrerem erros, o interpretador imprime as mensagens de erro.

Código digitado na mesma sessão tem o acesso a quaisquer construções inserido anteriormente, portanto, você pode criar programas. Um buffer extensivo na janela da ferramenta permite que você copie o código em um arquivo se necessário.

Quando executado no Visual Studio, F# interativo execuções independentemente de seu projeto, então, por exemplo, é possível usar construções definidas no seu projeto no F# interativo, a menos que você copie o código da função para a janela de interativa.

Você pode controlar os argumentos de linha de comando F# interativo (Opções), ajustando as configurações. Sobre o Ferramentas menu, selecione **Opções...**e em seguida, expanda F# ferramentas. As duas configurações que podem ser alteradas são as opções de F# interativo e o caminho FSI. exe executável, que pode ser usada se você tiver uma versão do FSI. exe a partir de uma versão diferente do F# que você deseja executar.

Criando scripts com F#

Os scripts usam a extensão de arquivo .fsx ou .fsscript. Em vez de compilar o código-fonte e posterior em execução o assembly compilado, você pode executar apenas fsi.exe e especifique o nome de arquivo do script de F# código-fonte, e F# interativo lê o código e executa-lo em tempo real.

Diferenças entre os ambientes interativos, scripts e compilados

Quando estiver compilando o código de F# interativo, se você estiver executando interativamente ou executar um script, o símbolo INTERACTIVE está definido. Quando você está compilando o código no compilador, o símbolo COMPILED está definido. Assim, se o código precisa ser diferente nos modos compilados e interativos, você pode usar diretivas de pré-processamento para compilação condicional para determinar qual usar.

Algumas diretivas estão disponíveis durante a execução de scripts no F# interativo que não estão disponíveis quando você está executando o compilador. A tabela a seguir resume as diretivas que estão disponíveis quando você estiver usando o F# interativo.

Quando você especifica os arquivos ou caminhos no F# interativo, uma seqüência de caracteres literal é esperada. Portanto, arquivos e caminhos devem estar entre aspas e a aplicar os caracteres de escape usual. Além disso, você pode usar o caractere para causar F# interativo interpretar uma seqüência de caracteres que contém um caminho como uma seqüência de caracteres verbatim @. Isso faz com que F# interativo ignorar quaisquer caracteres de escape.

Uma das diferenças entre compilado e em modo interativo é a maneira em que você acessar argumentos de linha de comando. No modo compilado, use GetCommandLineArgs. Nos scripts, use fsi.CommandLineArgs.

O código a seguir ilustra como criar uma função que lê os argumentos de linha de comando em um script e também demonstra como fazer referência a outro conjunto de um script. O primeiro arquivo de código, MyAssembly.fs, é o código para o assembly referenciado. Compile este arquivo com a linha de comando: fsc -a MyAssembly.fse, em seguida, executar o segundo arquivo como um script de linha de comando: fsi --exec file1.fsxteste

// MyAssembly.fs
module MyAssembly
let myFunction x y = x + 2 * y

// file1.fsx
#r "MyAssembly.dll"

printfn "Command line arguments: "

for arg in fsi.CommandLineArgs do
    printfn "%s" arg

printfn "%A" (MyAssembly.myFunction 10 40)

A saída é o seguinte:

file1.fsx
test
60

Tópicos relacionados

Histórico de alterações