vim-iced help

vim-iced.txt Clojure interactive development environment for Vim8/Neovim

Version: 3.15.3283

Author : Masashi Iizuka <liquidz.uo+vim@gmail.com>

License: MIT LICENSE

==============================================================================

@CONTENTS vim-iced-contents

Introduction vim-iced-introduction

Install vim-iced-install

Iced command vim-iced-install-command

Manual Install vim-iced-install-manually

Leiningen vim-iced-manual-leiningen

Boot vim-iced-manual-boot

shadow-cljs vim-iced-manual-shadow-cljs

Rebel Readline vim-iced-manual-rebel-readline

Boost by Python vim-iced-install-python

Boost by Vim9 script vim-iced-vim9-script

Docker vim-iced-install-docker

REPL Connection vim-iced-repl-connection

ClojureScript vim-iced-clojurescript

Piggieback vim-iced-piggieback

FigwheelMain vim-iced-figwheel-main

shadow-cljs vim-iced-shadow-cljs

Evaluating vim-iced-evaluating

Stdout Buffer vim-iced-stdout-buffer

Yank the result vim-iced-yank-the-result

Evaluating in context vim-iced-eval-in-context

Evaluating spinner vim-iced-evaluating-spinner

Stacktrace vim-iced-stacktrace

Testing vim-iced-testing

Plain nREPL vim-iced-testing-plain-nrepl

Debugging vim-iced-debugging

Tracing function calls vim-iced-debugging-tracing-function-calls

Browsing tapped values vim-iced-debugging-browsing-tapped-values

Floating Window vim-iced-debugging-floating-window

Skeleton vim-iced-skeleton

Jump to definition vim-iced-jump-to-def

Editing S-exp vim-iced-editing-s-exp

Formatting vim-iced-formatting

Format on writing files vim-iced-formatting-on-writing-files

Indenting vim-iced-indenting

Refactoring vim-iced-refactoring

Static analysis vim-iced-static-analysis

clj-kondo vim-iced-static-analysis-clj-kondo

Notification vim-iced-notification

Interface vim-iced-interface

Commands vim-iced-commands

Functions vim-iced-functions

Key Mappings vim-iced-key-mappings

Customizing vim-iced-customizing

Stdout buffer vim-iced-customizing-stdout-buffer

Formatter vim-iced-customizing-formatter

Indent rules vim-iced-customizing-indents

Tonsky's rule vim-iced-customizing-tonsky-rule

Documents vim-iced-customizing-documents

Auto document vim-iced-customizing-auto-document

Auto indent vim-iced-customizing-auto-indent

Signs vim-iced-customizing-signs

Command palettes vim-iced-customizing-palette

Hooks vim-iced-customizing-hooks

Popup window vim-iced-customizing-popup-window

Notification vim-iced-customizing-notification

Default keys vim-iced-customizing-default-keys

Changelog vim-iced-changelog

==============================================================================

@INTRODUCTION vim-iced-introduction

Clojure interactive development environment for Vim8/Neovim.

Requirement:

- Vim 8.1.0614 or later, Neovim 0.4.0 or later

- Clojure 1.8 or later

1.10 or later is recommended

- For Leiningen user

2.8.2 or later

Latest Version:

- https://github.com/liquidz/vim-iced

==============================================================================

@INSTALL vim-iced-install

Vim plugin dependencies:

- vim-sexp

https://github.com/guns/vim-sexp

- selector

One of following is required when selecting multiple candidates

- ctrlp.vim

https://github.com/ctrlpvim/ctrlp.vim

- fzf

https://github.com/junegunn/fzf

- vim-clap

https://github.com/liuchengxu/vim-clap

------------------------------------------------------------------------------

@ICED COMMAND vim-iced-install-command

vim-iced provides iced command to use vim-iced easily.

Currently supports following tools.

- Leiningen

https://github.com/technomancy/leiningen

- Boot

https://github.com/boot-clj/boot

- Clojure CLI

https://clojure.org/guides/deps_and_cli

- shadow-cljs

https://github.com/thheller/shadow-cljs

See also:

- g:iced#eval#popup_spinner_texts

- g:iced#eval#popup_spinner_interval

------------------------------------------------------------------------------

@STACKTRACE vim-iced-stacktrace

When exceptions are thrown, vim-iced will show stacktraces in stdout buffer.

- vim-iced-stdout-buffer

See also:

- :IcedPrintLastStackTrace

- g:iced#nrepl#eval#ignoring_vars_in_stacktrace

==============================================================================

@TESTING vim-iced-testing

vim-iced provides following test commands.

- :IcedTestUnderCursor

When tests are failed, vim-iced sets error positions to quickfix.

:cwindow command enables you to show this information.

To show quickfix automatically, following autocmd is useful.

  aug VimIcedAutoOpenQuickfix
    au!
    au QuickFixCmdPost vim-iced cwindow
  aug END

------------------------------------------------------------------------------

@PLAIN NREPL vim-iced-testing-plain-nrepl

vim-iced basically requires nREPL with some middlewares.

But in some case, you may need to use plain nREPL such as babashka.nrepl.

- https://book.babashka.org/#_nrepl

In this case, vim-iced provides simple test integration which has less

functionality than cider-nrepl's one.

To use this simple test integration, you don't need to recognize whether

your nREPL is plain or not.

Following commands are also support simple test integration,

so you just execute these commands as usual.

- :IcedTestUnderCursor

- :IcedTestNs

- :IcedTestAll

NOTE: :IcedTestAll depends on current namespace.

(e.g. foo.core will search all vars in foo.*).

So it's still not really the whole test.

==============================================================================

@DEBUGGING vim-iced-debugging

vim-iced supports cider's #dbg and #break reader literals.

The easiest way is to put #dbg to your code, and evaluate it.

  (defn fib [n]
    #dbg (loop [a 0 b 1 n n]
           (if (<= n 0)
             a
             (recur b (+ a b) (dec n)))))

Related options:

- g:iced#debug#value_max_length

------------------------------------------------------------------------------

@TRACING FUNCTION CALLS vim-iced-debugging-tracing-function-calls

vim-iced provides 2 ways for tracing function calls.

- :IcedToggleTraceVar

- :IcedToggleTraceNs

Traced result will be displayed in stdout buffer.

- vim-iced-stdout-buffer

------------------------------------------------------------------------------

@BROWSING TAPPED VALUES vim-iced-debugging-browsing-tapped-values

WARNING: To use tap>, Clojure 1.10.0 or later is required

If you have a big data structure and want to dig into it,

browsing tapped values is useful.

When you evaluate (tap> YOUR_DATA), :IcedBrowseTapped shows tapped values.

Select the value you want to dig into, then browsing value start.

See :IcedBrowseTapped for browsing key details.

All tapped values are stored in memory.

So if you would like to delete them, execute following commands.

- :IcedDeleteTapped (delete one)

- :IcedClearTapped (delete all)

------------------------------------------------------------------------------

@FLOATING WINDOW vim-iced-debugging-floating-window

vim-iced supports both of popup window in Vim

and floating window in Neovim.

This feature is very experimental, but works.

If your environment meets followings,

debugging information will be shown in floating window automatically.

- Vim 8.1 patch 1-1408 or later

- Neovim 0.4.0 or later

Related options:

- g:iced#popup#time

- g:iced#popup#max_height

- g:iced#popup#neovim#winhighlight

- g:iced#popup#neovim#style

==============================================================================

@SKELETON vim-iced-skeleton

vim-iced provides code skeleton when you open new clojure files.

Currently, these extensions are supported.

- *.clj

- *.cljs

- *.cljc

==============================================================================

JUMP TO DEFINITION vim-iced-tag-jump vim-iced-jump-to-def

:IcedDefJump to jump to definition.

It is also supported to jump to qualified keywords and local vars.

If the jump destination for keyword is inaccurate or the jump is slow,

enabling clj-kondo feature may improve the result.

- vim-iced-static-analysis-clj-kondo

To jump back, you can use default key mapping(<C-t>).

See also:

- g:iced#navigate#prefer_local_jump

- g:iced#navigate#jump_fallback_command

- vim-iced-protocol-jump

------------------------------------------------------------------------------

@JUMP TO PROTOCOL vim-iced-protocol-jump

WARNING: This feature requires clj-kondo v2022.02.09 or later.

:IcedDefJump also supports jumping to protocol implementations.

If there is only one implementation, jump to the implementation immediately.

If there are multiple implementations, iced set them to the location-list.

==============================================================================

@EDITING S-EXP vim-iced-editing-s-exp

Provides slurp and barf function.

- :IcedSlurp

- :IcedBarf

------------------------------------------------------------------------------

@FORMATTING vim-iced-formatting

Provides following functions.

- :IcedFormat

- :IcedFormatAll

vim-sexp also provides formatting codes function.

If you want to use vim-iced's formatting function,

you should define {g:sexp_mappings} as follows.

  let g:sexp_mappings = {'sexp_indent': '', 'sexp_indent_top': ''}

@ vim-iced-formatting-on-writing-files

FORMAT ON WRITING FILES

vim-iced also provides following sync commands.

- :IcedFormatSync

- :IcedFormatSyncAll

These commands are useful to format on writing files.

  aug VimIcedAutoFormatOnWriting
    au!
    " Format whole buffer on writing files
    au BufWritePre *.clj,*.cljs,*.cljc,*.edn execute ':IcedFormatSyncAll'

    " Format only current form on writing files
    " au BufWritePre *.clj,*.cljs,*.cljc,*.edn execute ':IcedFormatSync'
  aug END

------------------------------------------------------------------------------

@INDENTING vim-iced-indenting

vim-iced provides auto indentation feature,

and it is enabled by default.

Indent level is calculated by the set formatter,

so cljfmt formatter which is used by default may lead slow down vim/nvim.

If you don't use vim-iced's auto indentation,

you can disable it by g:iced_enable_auto_indent variable.

  let g:iced_enable_auto_indent = v:false

------------------------------------------------------------------------------

@REFACTORING vim-iced-refactoring

Provides following functions powered by refactor-nrepl.

- :IcedCleanNs (<Plug>(iced_clean_ns))

- :IcedCleanAll (<Plug>(iced_clean_all))

- :IcedAddMissing (<Plug>(iced_add_missing))

- :IcedThreadFirst (<Plug>(iced_thread_first))

- :IcedThreadLast (<Plug>(iced_thread_last))

- :IcedExtractFunction (<Plug>(iced_extract_function))

- :IcedAddArity (<Plug>(iced_add_arity))

- :IcedMoveToLet (<Plug>(iced_move_to_let))

- :IcedRenameSymbol (<Plug>(iced_rename_symbol))

==============================================================================

@STATIC ANALYSIS vim-iced-static-analysis

Currently vim-iced supports static analysis by clj-kondo.

- https://github.com/borkdude/clj-kondo

------------------------------------------------------------------------------

@CLJ-KONDO vim-iced-static-analysis-clj-kondo

This feature is disabled by default.

To enable, see g:iced_enable_clj_kondo_analysis.

Analysis process is run at BufWritePost autocmd.

Analyzed data is cached at g:iced_cache_directory, and used in followings:

- :IcedBrowseReferences

- :IcedBrowseDependencies

- :IcedAddMissing

- :IcedAddNs

- :IcedDefJump

LOCAL ANALYSIS

From clj-kondo v2021.01.20, local analysis is supported.

This can be used to support jumping to local vars.

To enable, see g:iced_enable_clj_kondo_local_analysis.

ANALYSIS DIRECTORIES

vim-iced uses the project root directory for analysis by default.

If you want to analyze files only in specific directories,

see g:iced_clj_kondo_analysis_dirs.

TIPS

- Cached files will be separated to var definition/usage and

ns definition/usage automatically if you have jq or jet.

- https://github.com/stedolan/jq

- https://github.com/borkdude/jet

- For more advance, if you have jq and sqlite3,

vim-iced will store analyzed result into SQLite database.

- The performance will improve dramatically.

- https://www.sqlite.org/index.html

- This leads to make :IcedAddMissing and :IcedAddNs more faster.

==============================================================================

@NOTIFICATION vim-iced-notification

A simple area to show some notification messages.

Notification area is popuped at {topright} or {bottomright}

(closer to the cursor to minimize eye movement).

Area size is calculated by the ratio to the current window size.

To customize the size, see vim-iced-customizing-notification.

==============================================================================

@INTERFACE vim-iced-interface

------------------------------------------------------------------------------

@COMMANDS vim-iced-commands

@ :IcedConnect

:IcedConnect [{port}]

Make connection to nREPL.

If {port} is not passed, {port} is detected by '.nrepl-port' automatically.

See also:

- g:iced#nrepl#ns#refresh_before_fn

- g:iced#nrepl#ns#refresh_after_fn

@ :IcedRefreshAll

:IcedRefreshAll

Reload all files in all directories on the classpath.

Key is mapped to <Plug>(iced_refresh_all).

@ :IcedRefreshClear

:IcedRefreshClear

Clear refreshing status.

Key is mapped to <Plug>(iced_refresh_clear).

@ :IcedTestUnderCursor

:IcedTestUnderCursor

Run test under cursor.

If the var under cursor does not contain :test metadata

and current ns doesn't end with "-test",

vim-iced searches test vars in corresponding test ns and run them.

Target test vars include original var name in its name.

Key is mapped to <Plug>(iced_test_under_cursor).

@ :IcedTestRerunLast

:IcedTestRerunLast

Run last test again.

Key is mapped to <Plug>(iced_test_rerun_last).

@ :IcedTestSpecCheck

:IcedTestSpecCheck [{num-tests}]

Run clojure.spec.test.alpha/check for the function under cursor.

NOTE: Adding test.check dependency is required.

https://github.com/clojure/test.check

If {num-tests} is not passed, g:iced#test#spec_num_tests is used.

Key is mapped to <Plug>(iced_test_spec_check).

@ :IcedTestBufferOpen

:IcedTestBufferOpen

Open test result buffer.

Key is mapped to <Plug>(iced_test_buffer_open).

@ :IcedTestBufferClose

:IcedTestBufferClose

Close test result buffer.

Key is mapped to <Plug>(iced_test_buffer_close).

@ :IcedTestNs

:IcedTestNs

Run tests in current namespace.

Key is mapped to <Plug>(iced_test_ns).

@ :IcedTestAll

:IcedTestAll

Run all tests in current project.

Key is mapped to <Plug>(iced_test_all).

@ :IcedTestRedo

:IcedTestRedo

Re run failed tests.

Key is mapped to <Plug>(iced_test_redo).

@ :IcedStdoutBufferOpen

:IcedStdoutBufferOpen

Open stdout buffer.

Key is mapped to <Plug>(iced_stdout_buffer_open).

@ :IcedStdoutBufferClear

:IcedStdoutBufferClear

Clear all lines in stdout buffer.

Key is mapped to <Plug>(iced_stdout_buffer_clear).

@ :IcedStdoutBufferClose

:IcedStdoutBufferClose

Close stdout buffer window.

Key is mapped to <Plug>(iced_stdout_buffer_close).

@ :IcedStdoutBufferToggle

:IcedStdoutBufferToggle

Toggle stdout buffer window.

Key is mapped to <Plug>(iced_stdout_buffer_toggle).

@ :IcedDefJump

:IcedDefJump [{symbol}, {jump-cmd}]

Jump cursor to definition of {symbol} (default to symbol under cursor).

{jump-cmd} is used to specify how to open the new buffer, default to edit.

To specify {jump-cmd} while still use symbol under cursor automatically,

pass '.' as first argument.

E.g.

  :nmap <buffer> g<C-]> :<C-u>IcedDefJump . tabedit<CR>

Key is mapped to <Plug>(iced_def_jump).

@ :IcedOpenNs

:IcedOpenNs {ns-name}

Open a file corresponding to the specified {ns-name}.

If {ns-name} does not exist, make sure you open a file with a pseudo path.

@ :IcedBrowseReferences

:IcedBrowseReferences

Browse positions referencing the form under cursor.

Results are set to location-list.

@ :IcedBrowseDependencies

:IcedBrowseDependencies

Browse positions depending on the form under cursor.

Results are set to location-list.

@ :IcedBrowseVarReferences

:IcedBrowseVarReferences

Browse positions referencing the var under cursor.

Results are set to location-list.

@ :IcedBrowseVarDependencies

:IcedBrowseVarDependencies

Browse positions depending on the var under cursor.

Results are set to location-list.

@ :IcedDocumentOpen

:IcedDocumentOpen [{symbol}]

Open a window, and show documents for {symbol}.

If {symbol} is not passed, symbol under cursor is used.

Key is mapped to <Plug>(iced_document_open).

@ :IcedDocumentPopupOpen

:IcedDocumentPopupOpen [{symbol}]

Open a popup window, and show documents for {symbol}.

If {symbol} is not passed, symbol under cursor is used.

If popup is not supported, :IcedDocumentOpen is called.

Key is mapped to <Plug>(iced_document_popup_open).

@ :IcedFormDocument

:IcedFormDocument

Echo one-line document for form under cursor.

This is useful to show document while editing codes.

See details <Plug>(iced_form_document).

@ :IcedUseCaseOpen

:IcedUseCaseOpen [{symbol}]

Open a window, and show usecase for {symbol}.

If {symbol} is not passed, symbol under cursor is used.

When several usecases are found, :IcedNextUseCase and :IcedPrevUseCase

commands are useful to show next or previous usecases.

Key is mapped to <Plug>(iced_use_case_open).

@ :IcedNextUseCase

:IcedNextUseCase

Show next usecase in a window if there is.

See also:

- g:iced#clojuredocs#export_edn_url

- g:iced#clojuredocs#use_clj_docs_on_cljs

Key is mapped to <Plug>(iced_clojuredocs_open).

@ :IcedClojureDocsRefresh

:IcedClojureDocsRefresh

Clean a ClojureDocs cache file, and reload documents.

Key is mapped to <Plug>(iced_clojuredocs_refresh).

@ :IcedSlurp

:IcedSlurp

Slurp next element.

If no elements in current form, search next form and slurp.

For searching next form, g:iced#paredit#slurp_max_depth is used.

Key is mapped to <Plug>(iced_slurp).

@ :IcedBarf

:IcedBarf

Barf last element in current form.

Key is mapped to <Plug>(iced_barf).

@ :IcedFormat

:IcedFormat

Reformat current form.

Key is mapped to <Plug>(iced_format).

@ :IcedFormatAll

:IcedFormatAll

Reformat current buffer.

Key is mapped to <Plug>(iced_format_all).

@ :IcedFormatSync

:IcedFormatSync

Same as :IcedFormat, but it's done synchronously.

Key is mapped to <Plug>(iced_format_sync).

@ :IcedFormatSyncAll

:IcedFormatSyncAll

Same as :IcedFormatAll, but it's done synchronously.

Key is mapped to <Plug>(iced_format_sync_all).

@ :IcedCycleSrcAndTest

:IcedCycleSrcAndTest

Switch between source file and test file.

If the file does not exist, make sure you open a file with a pseudo path.

Key is mapped to <Plug>(iced_cycle_src_and_test).

@ :IcedGrep

:IcedGrep [{keyword}]

Execute g:iced#grep#prg command asynchronously.

If {keyword} is not passed, keyword under cursor is used.

NOTE: This command will change the current directory globally.

Configurable option are g:iced#grep#prg and g:iced#grep#format.

Key is mapped to <Plug>(iced_grep).

@ :IcedBrowseRelatedNamespace

:IcedBrowseRelatedNamespace

Browse namespaces relating to current namespace, and open selected one.

ctrlp.vim, fzf or vim-clap is required to select namespace.

Configurable option is g:iced#related_ns#tail_patterns.

Key is mapped to <Plug>(iced_browse_related_namespace).

@ :IcedBrowseSpec

:IcedBrowseSpec

Browse specs, and show spec form in document buffer.

ctrlp.vim, fzf or vim-clap is required to select spec.

Key is mapped to <Plug>(iced_browse_spec).

@ :IcedBrowseTestUnderCursor

:IcedBrowseTestUnderCursor

Browse test vars, and jump to the selected var definition.

ctrlp.vim, fzf or vim-clap is required to select a test var.

Key is mapped to <Plug>(iced_browse_test_under_cursor).

@ :IcedClearNsCache

:IcedClearNsCache

Clear all caches related to namespace.

vim-iced will cache followings currently:

- Existing all namespace aliases

Key is mapped to <Plug>(iced_clear_ns_cache).

@ :IcedClearCtrlpCache

:IcedClearCtrlpCache

Clear ctrlp cache used by vim-iced.

ctrlp.vim is required.

Key is mapped to <Plug>(iced_clear_ctrlp_cache).

@ :IcedClearInlineResult

:IcedClearInlineResult

Clear all inline evaluated results.

Key is mapped to <Plug>(iced_clear_inline_result).

@ :IcedCleanNs

:IcedCleanNs

Cleanup ns form.

See https://github.com/clojure-emacs/refactor-nrepl#clean-ns

Key is mapped to <Plug>(iced_clean_ns).

@ :IcedCleanAll

:IcedCleanAll

Cleanup buffer and ns form.

Concretely :IcedCleanNs and :IcedFormatAll are executed.

Key is mapped to <Plug>(iced_clean_all).

@ :IcedAddMissing

:IcedAddMissing [{symbol}]

Add missing libspec.

If {symbol} is not passed, symbol under cursor is used.

Namespaces and its aliases are cached for performance.

:IcedClearNsCache will clear this cache.

If {symbol} is a Java class, vim-iced will find candidates by pre-defined

class mappings.

https://github.com/liquidz/iced-nrepl/blob/main/resources/java_classes.edn

To add your own classes, see g:iced#ns#class_map option.

@ :IcedAddNs

:IcedAddNs [{ns}]

Add require to ns form.

If {ns} is not passed, select namespaces in your project

via ctrlp.vim, fzf or vim-clap interface.

Namespaces and its aliases are cached for performance.

:IcedClearNsCache will clear this cache.

@ :IcedThreadFirst

:IcedThreadFirst

Convert current outer form to use -> threading macro.

E.g.

  ;; before
  (foo (bar (baz "hello")))
  ;; after
  (-> "hello" baz bar foo)

@ :IcedThreadLast

:IcedThreadLast

Convert current outer form to use ->> threading macro.

E.g.

  ;; before
  (foo yy (bar xx "hello"))
  ;; after
  (->> "hello" (bar xx) (foo yy))

@ :IcedExtractFunction

:IcedExtractFunction

Extract the form under cursor as a function.

@ :IcedAddArity

:IcedAddArity

Add an arity to defn, fn, defmacro, or defmethod.

@ :IcedMoveToLet

:IcedMoveToLet

Move the form under cursor to nearest let binding.

If there is no let form in current top list,

wrap the form with let.

@ :IcedRenameSymbol

:IcedRenameSymbol

Rename all occurrences of the symbol under cursor.

WARNING:

RenameSymbol command requires borkdude/jet.

https://github.com/borkdude/jet

vim-iced will confirm you to install jet automatically If not installed.

@ :IcedBrowseTapped

:IcedBrowseTapped [{keys}]

If {keys} are not passed, select one of tapped values, and start browsing.

ctrlp.vim, fzf or vim-clap is required to select tapped values.

If {keys} are passed, dig into tapped values.

For example, when there are following tapped values:

1st tapped value: {:foo [{:bar "baz"}]}

2nd tapped value: {:hello "world"}

The key to browse "baz" is 0 :foo 0 :bar .

(The first 0 means "browse 1st tapped value")

Key is mapped to <Plug>(iced_browse_tapped).

@ :IcedDeleteTapped

:IcedDeleteTapped

Select one tapped value via ctrlp.vim, fzf or vim-clap interface,

and delete it.

Key is mapped to <Plug>(iced_delete_tapped).

@ :IcedClearTapped

:IcedClearTapped

Clear all tapped values.

Key is mapped to <Plug>(iced_clear_tapped).

@ :IcedToggleWarnOnReflection

:IcedToggleWarnOnReflection

Toggle *warn-on-reflection* in current project.

Key is mapped to <Plug>(iced_toggle_warn_on_reflection).

@ :IcedToggleTraceVar

:IcedToggleTraceVar [{symbol}]

Toggle tracing {symbol} in current namespace.

If {symbol} is not passed, symbol under cursor is used.

Key is mapped to <Plug>(iced_toggle_trace_var).

@ :IcedToggleTraceNs

:IcedToggleTraceNs [{ns}]

Toggle tracing {ns}.

If {ns} is not passed, current buffer's ns name is used.

Key is mapped to <Plug>(iced_toggle_trace_ns).

@ :IcedJumpToNextSign

:IcedJumpToNextSign

Jump cursor to next sign in current buffer.

If search hit BOTTOM and 'wrapscan' is enabled,

searching sign continues at TOP.

Key is mapped to <Plug>(iced_jump_to_next_sign).

@ :IcedJumpToPrevSign

:IcedJumpToPrevSign

Jump cursor to previous sign in current buffer.

If search hit TOP and 'wrapscan' is enabled,

searching sign continues at BOTTOM.

Key is mapped to <Plug>(iced_jump_to_prev_sign).

@ :IcedJumpToLet

:IcedJumpToLet

Jump cursor to nearest let form.

If let form is not found in current top list, cursor is not moved.

Key is mapped to <Plug>(iced_jump_to_let).

@ :IcedYankNsName

:IcedYankNsName

Yank the current namespace name into " register.

------------------------------------------------------------------------------

@FUNCTIONS vim-iced-functions

@ iced#status()

iced#status()

Return vim-iced's status.

This is useful to show status in status line.

E.g. working with https://github.com/itchyny/lightline.vim

  let g:lightline = {
      \ 'active': {'right': [['iced']]},
      \ 'component_function': {'iced': 'iced#status'},
      \ }

------------------------------------------------------------------------------

@KEY MAPPINGS vim-iced-key-mappings

@ <Plug>(iced_connect)

<Plug>(iced_connect)

Same as :IcedConnect.

@ <Plug>(iced_disconnect)

<Plug>(iced_disconnect)

Same as :IcedDisconnect.

@ <Plug>(iced_reconnect)

<Plug>(iced_reconnect)

Same as :IcedReconnect.

@ <Plug>(iced_interrupt)

<Plug>(iced_interrupt)

Same as :IcedInterrupt.

@ <Plug>(iced_jack_in)

<Plug>(iced_jack_in)

Same as :IcedJackIn.

@ <Plug>(iced_instant_connect)

<Plug>(iced_instant_connect)

Same as :IcedInstantConnect.

@ <Plug>(iced_start_cljs_repl)

<Plug>(iced_start_cljs_repl)

Same as :IcedStartCljsRepl.

@ <Plug>(iced_quit_cljs_repl)

<Plug>(iced_quit_cljs_repl)

Same as :IcedQuitCljsRepl.

@ <Plug>(iced_eval)

<Plug>(iced_eval)

Evaluate codes.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval)<Plug>(sexp_outer_top_list)``

This operator supports yanking.

See vim-iced-yank-the-result for more information.

@ <Plug>(iced_eval_isolatedly)

<Plug>(iced_eval_isolatedly)

Evaluate codes in a isolated(ephemeral) session.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_isolatedly)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_isolatedly)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_isolatedly)<Plug>(sexp_outer_top_list)``

@ <Plug>(iced_eval_and_print)

<Plug>(iced_eval_and_print)

Evaluate code and print result to stdout buffer.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_print)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_print)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_print)<Plug>(sexp_outer_top_list)``

@ <Plug>(iced_eval_and_tap)

<Plug>(iced_eval_and_tap)

Evaluate code and tap result by clojure.core/tap>.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_tap)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_tap)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_tap)<Plug>(sexp_outer_top_list)``

@ <Plug>(iced_eval_and_replace)

<Plug>(iced_eval_and_replace)

Evaluate code and replace it by the evaluation result.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_replace)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_replace)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_replace)<Plug>(sexp_outer_top_list)``

@ <Plug>(iced_eval_and_comment)

<Plug>(iced_eval_and_comment)

Evaluate code and add the result as a comment in current end of line.

Followings are examples for working with {vim-sexp}.

  <Plug>(iced_eval_and_comment)<Plug>(sexp_inner_element)``
  <Plug>(iced_eval_and_comment)<Plug>(sexp_outer_list)``
  <Plug>(iced_eval_and_comment)<Plug>(sexp_outer_top_list)``

@ <Plug>(iced_eval_in_context)

<Plug>(iced_eval_in_context)

Evaluate code in the user specified context.

The context is clojure.core/let style.

For example, the context foo "bar" num 10 will be expanded to

(clojure.core/let [foo "bar" num 10] ...).

The input context is saved and will be expanded at the next evaluation.