##F# support for Vim (vim-fsharp)

Syntax and indent files have been copied from fsharp-vim with kind permissions from kongo2002.

Requires vim 7.3 or higher compiled with python support.

This was adapted from http://github.com/timrobinson/fsharp-vim. The current aim is to provide a good experience for fsx scripting. On opening an fs or fsi file any project file found in the same directory will be parsed. Multiple projects are supported.

###Installing

vim-fsharp requires mono and fsharp installed.

####OSX and linux

#####Installing with pathogen

1. Install pathogen and syntastic

2. Clone vim-fsharp into your bundle directory.

3. Run make inside the vim directory. This downloads the auto completion server.

#####Installing with vim-plug

Plug 'fsharp/vim-fsharp', {
      \ 'for': 'fsharp',
      \ 'do':  'make fsautocomplete',
      \}

#####Installing with NeoBundle

By VimL way:

NeoBundle 'fsharp/vim-fsharp', {
           \ 'description': 'F# support for Vim',
           \ 'lazy': 1,
           \ 'autoload': {'filetypes': 'fsharp'},
           \ 'build': {
           \   'unix':  'make fsautocomplete',
           \ },
           \ 'build_commands': ['curl', 'make', 'mozroots', 'touch', 'unzip'],
           \}

By using TOML configuration:

[[plugins]]
description = 'F# support for Vim'
repository = 'fsharp/vim-fsharp'
lazy = 1
filetypes = 'fsharp'
build_commands = ['curl', 'make', 'mozroots', 'touch', 'unzip']
  [plugins.build]
  unix = 'make fsautocomplete'

####Windows

1. Install pathogen and syntastic

2. Run install.cmd

####Syntastic

vim-fsharp utilizes the syntastic plugin in order to supply interactive syntax and type checking. You may want to install that plugin in order to get all of the fsharpbindings functionality.

Moreover you benefit from additional syntastic features like optional integration in your status bar (i.e. vim-airline).

All you have to do is to install syntastic in your vim runtime path.

###Usage

Opening either *.fs, *.fsi or *.fsx files should trigger syntax highlighting and other depending runtime files as well.

Omnicomplete triggers the fsharp autocomplete process. (suggestion: install supertab)

###Commands

#####General

• :make Calls xbuild on the fsproj for the current file (if any).
• :FSharpParseProject Reparses all the project files and dependencies (this is done automatically when opening a .fs or .fsi file).
• :FSharpBuildProject Calls xbuild on the fsproj for the current file (if any). Can also take a path to the proj file to build.
• :FSharpRunProject Runs the project for the current file (if any).
• :FSharpRunTests If g:fsharp_test_runner is set it will build the current project and run any tests. (Currently only tested with nunit-console.exe)
• :FSharpToggleHelptext toggles g:fsharp_completion_helptext. (See below for details)
• leader<t> Echoes the type of the expression currently pointed to by the cursor.
• leader<d> go to declaration in current window.
• leader<s> Takes you back from where go to declaration was triggered. Experimental.

#####FSharp Interactive

• :FsiEval Evaluates an fsharp expression in the fsi
• leader<e> Same as FsiEval but from a vim command line
• :FsiEvalBuffer Evaluates the entire buffer in the fsi
• :FsiReset Resets the current fsharp interactive
• :FsiRead Outputs any lines written by the fsi but not yet output as vim messages
• :FsiClear Deletes all text from the fsi output buffer but doesn't reset the fsi session.
• :FsiShow Opens the fsi-out buffer in a split window.
• Alt-Enter Send either the current selection or the current line to the fsharp interactive and echoes the output the first line of the output. All output will be written to the fsi-out buffer.
• leader<i> Same as Alt-Enter

###On-the-fly syntax checking

Interactive syntax/type checking requires vim 7.4 or higher and syntastic

By default your F# files will be syntax/type checked on every open/save of a vim buffer as well as after 500ms of inactivity in Normal mode.
In case you would prefer not to have you errors checked continuously add the following to your vimrc:

let g:fsharp_only_check_errors_on_write = 1

###Settings

You can enable debug-mode in order to inspect the fsautocomplete behavior by setting the global vim variable g:fsharpbinding_debug to a non-zero value:

let g:fsharpbinding_debug = 1

This will create two log files log.txt and log2.txt in your temporary folder (i.e. /tmp/).

You can set the msbuild/xbuild path.

let g:fsharp_xbuild_path = "/path/to/xbuild/or/msbuild"

This setting needs to point to a suitable test runner (such as nunit-console.exe)

let g:fsharp_test_runner = "/path/to/test/runner"

This enables the helptext to be displayed during auto completion. Turn off if completion is too slow.

let g:fsharp_completion_helptext = 1

Maintainers

Tha maintainers of this repository appointed by the F# Core Engineering Group are:

• Robin Neatherway, Steffen Forkmann, Karl Nilsson, Dave Thomas and Guillermo López-Anglada
• The primary maintainer for this repository is Karl Nilsson