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.
Diretiva |
Descrição |
|---|---|
#help |
Exibe informações sobre diretivas disponíveis. |
#I |
Especifica um caminho de pesquisa de assembly entre aspas. |
#load |
Lê um arquivo de origem, o compila e executa-lo. |
#quit |
Finaliza uma sessão interativa F#. |
#r |
Referencia um assembly. |
#time ["on"|"off"] |
Por si só, #time alterna-se exibir informações de desempenho. Quando ele estiver ativado, F# interativo mede tempo real, tempo de CPU e informações de coleta de lixo para cada seção do código que é interpretado e executado. |
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
Título |
Descrição |
|---|---|
Descreve a sintaxe de linha de comando e opções de F# interativo, FSI. exe. |
|
Descreve a funcionalidade da biblioteca disponível ao executar o código em F# interativo. |
Histórico de alterações
Date |
History |
Motivo |
|---|---|---|
|
Outubro de 2010 |
Tabela adicionada das diretivas suportadas. |
Aprimoramento de informações. |