Sfida:

Nel linguaggio di programmazione che preferisci, non inserire input e produrre il nome del tuo linguaggio di programmazione.

Abbastanza giusto, vero?

restrizioni:

• Non puoi usare alcun carattere incluso nel nome del tuo linguaggio di programmazione nel tuo codice. Ad esempio, se uso Batch, non devo usare i caratteri 'B' 'a' t '' c '' h 'nel mio codice. Si noti che questo è case sensitive. Posso ancora usare il carattere 'b' perché è diverso da 'B'.
• Puoi avere "output spazzatura" prima o dopo il nome della lingua
• Il numero di versione non conta come parte del nome della lingua. Ad esempio, posso usare il numero 3 nel codice nella mia risposta se è in Python 3
• L'output del nome del linguaggio di programmazione non fa distinzione tra maiuscole e minuscole.
• È vietato forzare brutalmente tutte le possibili combinazioni di lettere e sperare di ottenere il nome della tua lingua.

Output di esempio: (diciamo che il mio linguaggio di programmazione si chiama Lingua) (✔ se valido, altrimenti ✖)

• Language ✔
• Body language is a type of non-verbal communication in which physical behavior, as opposed to words, is used to express or convey information. Such behavior includes facial expressions, body posture, gestures, eye movement, touch and the use of space. ✔
• Language 2.0 - © 1078 AD some company ✔
• foobar ✖

Questo è code-golf, quindi vince il codice più breve.

Uscite a STDERR

L'output a STDERR è ora a + 33 / -21 come default consentito, che è positivo ma contestato. Questa è una risposta CW per raccogliere risposte che invocano un errore in una lingua in cui i messaggi di errore includono il nome della lingua.

Haskell, 1 byte

1

Errore:

Parse error: naked expression at top level
Perhaps you intended to use TemplateHaskell

Lua, 1 byte

1

Errore:

lua: .code.tio:1: syntax error near <eof>

(il nome del file non è importante)

Lotto, 1 byte

~

Errore:

'~' is not recognized as an internal or external command,
operable program or batch file.

tinylisp, 5 byte

(c()1

Errore:

Error: cannot cons to Int in tinylisp

R, 1 byte

)

Errore:

Error: unexpected ')' in ")"

Bytecode Java, 0 byte

Errore:

Exception in thread "main" java.lang.ClassFormatError: Truncated class file

Groovy, 1 byte

a

Nota che apuò essere sostituito con qualsiasi altro personaggio

Errore:

groovy.lang.MissingPropertyException: No such property: a ...

MATLAB, 1 byte

\

Errore:

Error: Unexpected MATLAB operator.

PHP, 3 byte

<?=

Errore:

PHP Parse error:  syntax error, unexpected end of file in /home/runner/.code.tio on line 1

CJam, 1 byte

/

Errore:

/
^
RuntimeException: The stack is empty
Java exception:
java.lang.RuntimeException: The stack is empty
    at net.aditsu.cjam.CJam.pop(CJam.java:75)
    at net.aditsu.cjam.Op2.run(Op2.java:10)
    at net.aditsu.cjam.Block.run(Block.java:304)
    at net.aditsu.cjam.CJam.runCode(CJam.java:210)
    at net.aditsu.cjam.CJam.main(CJam.java:240)

Ramoscello, 2 byte

Twig è un linguaggio modello scritto in PHP. È possibile che questo sia un poliglotta.

{{
{%
{#

Errore:

PHP Fatal error:  Uncaught exception 'Twig_Error_Syntax' with message [...] in [...][...]:n:
Stack trace:
#0 [...]

Il messaggio varia a seconda del programma scelto.

SILOS , 2 byte

x+

Provalo online! Invoca in modo banale comportamenti non documentati. Silos è il nome della lingua.

Python, 6 byte

pYTHON

Poiché la restrizione del carattere non fa distinzione tra maiuscole e minuscole e l'output non deve essere nel caso corretto, questa è una risposta valida. Il messaggio di errore che produce è qualcosa del genere:

Traceback (most recent call last):
  File ".code.tio", line 1, in <module>
    pYTHON
NameError: name 'pYTHON' is not defined

Provalo online! (output nella scheda 'debug')

JavaScript, 10 byte

jAVAsCRIPT

Questo produce il seguente messaggio di errore o simile in tutti gli ambienti:

ReferenceError: jAVAsCRIPT is not defined

QBIC , 6 byte

?b(12)

In 6 byte, possiamo mettere l'errore QBIC rilevato: 9 sullo schermo, indicando un errore fuori limite.

ForceLang, 2 byte

()

Errore prodotto:

Exception in thread "main" lang.exceptions.IllegalInvocationException: null is not a function.
    at lang.ForceLang.parse(ForceLang.java:99)
    at lang.ForceLang.main(ForceLang.java:129)

Pip, 5 byte

1~`[`

(Nota: funziona nella versione corrente al momento della stesura del presente documento, 0.17.09.01 . Nessuna garanzia l'interprete non cambierà per gestire questo errore in modo diverso in futuro.)

Cerca di far coincidere regex con un modello sintatticamente non valido. L'errore prodotto sarà simile al seguente:

Traceback (most recent call last):
  File "/opt/pip/pip.py", line 221, in <module>
    pip(interactive=False)
  File "/opt/pip/pip.py", line 206, in pip
    state.executeProgram(tree, args)
  File "/opt/pip/execution.py", line 56, in executeProgram
    returnVal = self.functionCall(mainFunction, cmdLineArgs)
  File "/opt/pip/execution.py", line 368, in functionCall
    returnVal = self.getRval(returnExpr)
  File "/opt/pip/execution.py", line 235, in getRval
    expr = self.evaluate(expr)
  File "/opt/pip/execution.py", line 213, in evaluate
    result = opFunction(*args)
  File "/opt/pip/execution.py", line 1134, in FIRSTMATCH
    matchObj = regex.asRegex().search(str(string))
  File "/opt/pip/ptypes.py", line 175, in asRegex
    self._compiled = re.compile(pyRegex)
  File "/usr/lib64/python3.6/re.py", line 233, in compile
    return _compile(pattern, flags)
  File "/usr/lib64/python3.6/re.py", line 301, in _compile
    p = sre_compile.compile(pattern, flags)
  File "/usr/lib64/python3.6/sre_compile.py", line 562, in compile
    p = sre_parse.parse(p, flags)
  File "/usr/lib64/python3.6/sre_parse.py", line 855, in parse
    p = _parse_sub(source, pattern, flags & SRE_FLAG_VERBOSE, 0)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 765, in _parse
    p = _parse_sub(source, state, sub_verbose, nested + 1)
  File "/usr/lib64/python3.6/sre_parse.py", line 416, in _parse_sub
    not nested and not items))
  File "/usr/lib64/python3.6/sre_parse.py", line 523, in _parse
    source.tell() - here)
sre_constants.error: unterminated character set at position 8

Stax, 2 byte

0u

Errore:

Stax runtime error: rational divide by zero

zh funziona anche.

inchiostro, 1 byte

~

~all'inizio di una riga indica che la riga è un'istruzione da eseguire, anziché il testo da stampare. A partire da qualunque versione di TIO Inklecate stia utilizzando, se non c'è nulla dopo ~, l'interprete si arresta in modo anomalo con il seguente errore:

System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
[ERROR] FATAL UNHANDLED EXCEPTION: System.NullReferenceException: Object reference not set to an instance of an object
  at Ink.InkParser.LogicLine () [0x000b1] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.OneOf (Ink.StringParser+ParseRule[] array) [0x0000a] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementAtLevel (Ink.InkParser+StatementLevel level) [0x00009] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser+<>c__DisplayClass134_0.<StatementsAtLevel>b__0 () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.ParseObject (Ink.StringParser+ParseRule rule) [0x00012] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.StringParser.Interleave[T] (Ink.StringParser+ParseRule ruleA, Ink.StringParser+ParseRule ruleB, Ink.StringParser+ParseRule untilTerminator, System.Boolean flatten) [0x00040] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.StatementsAtLevel (Ink.InkParser+StatementLevel level) [0x0004f] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.InkParser.Parse () [0x00000] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.Compiler.Compile () [0x00033] in <b1e5e74f4ee842fc961297862cf23e07>:0 
  at Ink.CommandLineTool..ctor (System.String[] args) [0x001a3] in <d64e27e7788347b2a5377c9e19bbdcab>:0 
  at Ink.CommandLineTool.Main (System.String[] args) [0x00000] in <d64e27e7788347b2a5377c9e19bbdcab>:0 

SmileBASIC, 11 byte

sPsET.,1474

Equivalente a SPSET 0,1474. Imposta sprite 0 sulla definizione 1474, che è il logo SmileBASIC.

MATL , 1 byte

Y

L'output avviene tramite STDERR, che è consentito per impostazione predefinita .

L'output del compilatore offline è

Error using matl_parse (line 339)
MATL error while parsing: Y not recognized at position 1
Error in matl (line 234)
    S = matl_parse(s, useTags); 

Oppure provalo online! (espandi la sezione "debug").

R, 1 byte:

T

Tè un alias per la costante TRUE. Quindi l'output per quanto sopra è:

[1] TRUE

Poiché la spazzatura è consentita intorno al nome, la "R" in là è il nome della lingua.

( Come notato in un commento altrove , praticamente ogni singola lettera e molti glifi funzioneranno ugualmente bene perché attivano il messaggio "Errore: ...", che contiene "r".)

HTML, 24 20 byte

HTML

HTML, 16 byte

Come sottolineato da @Bob , i browser moderni riconosceranno le entità HTML senza punto e virgola, sebbene sia HTML tecnicamente non valido. Naturalmente, è perfettamente valido per il golf del codice.

&#72&#84&#77&#76

HTML, 4 byte

E, naturalmente, la risposta poco interessante.

html

Inoltre, vedi la mia risposta CSS .

Vim, 0 byte

Quando avvii Vim, l'editor visualizza una schermata iniziale simile a questa:

Puoi vedere che dice Vimqui:

Risposta precedente:

Vim, 1 byte

<Ctrl-C>

In Vim 8, premendo verrà visualizzato Type :quit<Enter> to exit Vimsull'ultima riga. Non sono completamente sicuro se questo conta.

Python, 15 byte

Python 2 (15)

exec"\150elp()"

E 'concatena le stringhe usa l'ottale 150che è he "elp()"e gestisce il risultato. Questo stampa il help()comando che dice "Welcome to Python 3.5's help utility!", soddisfacendo i requisiti.

Python 3 (17)

exec("\150elp()")

Provalo online!

C, 0 byte.

/usr/lib/gcc/i586-linux-gnu/5/../../../i386-linux-gnu/crt1.o: In function `_start':
(.text+0x18): undefined reference to `main'
collect2: error: ld returned 1 exit status

Provalo online!

Eh ?, 0 byte

^{(no, non c'è niente in quel blocco di codice)}

La lingua è chiamata per il suo output, quindi ...

Nell'implementazione che ho verificato , l'interprete prende la lunghezza mod 8 di ogni riga di un dato file e cambia a seconda del risultato. Per zero, stampa Huh?. Dal momento che rimuove le nuove righe finali, è possibile eseguire anche una versione da 1 byte ( \n).

Si noti che non sta generando stderr o casewapping o altri trucchi. È solo che l'interprete molto confuso di Huh? Alla fine è tornato utile.

V , 2 byte

¬U

Provalo online!

La risposta ovvia è:

év~

Provalo online!

Che è "Inserisci la lettera 'v' e attiva / disattiva caso". Tuttavia, poiché si consente l'output indesiderato prima / dopo il nome della lingua, anche questo funziona.

Il ¬comando accetta due caratteri per l'input e inserisce ogni carattere ASCII tra di essi. Se non forniamo il secondo carattere, viene automaticamente impostato su ÿ(ASCII 0xff), quindi questo programma inserisce tutti i caratteri nella codifica latin1 tra Ue ÿ.

Brainfuck , 54 byte

+[[-<]-[->]<-]<.<<<<.>>>>-.<<-.<.>>.<<<+++.>>>---.<++.

Emette brainfuck, presupponendo un nastro a 8 bit aperto a sinistra. Provalo online!

Come sempre, i crediti parziali vanno a Hello, World di @ primo! rispondere .

Alternative con involucro diverso

Brainfuck (62 byte):

+[<-[-<]-[->]<<]<---.<<<<<<--.>>>-.<+.<.>---.<<+++.>>---.<---.

BrainFuck (68 byte):

-[[-<]->+[->]<-]<<.<<<<<--.>>+.<-.+++++.>>>------.<<<<+++.>>++.<---.

MATLAB, 3 byte

ver

L'output è il seguente. Le informazioni irrilevanti sono state sostituite da [...]). Alcune parti dell'output possono cambiare in base alla versione, alle cassette degli strumenti installate ecc.

-----------------------------------------------------------------------------------------
MATLAB Version: 8.6.0.267246 (R2015b)
MATLAB License Number: [...]
Operating System: [...]
Java Version: Java 1.7.0_60-b19 with [...]
-----------------------------------------------------------------------------------------
MATLAB                                                Version 8.6         (R2015b)
Communications System Toolbox                         Version 6.1         (R2015b)
Curve Fitting Toolbox                                 Version 3.5.2       (R2015b)
[...]
Wavelet Toolbox                                       Version 4.15        (R2015b)

Python, 27 53 49 48 45 byte

-3 byte da @ wizzwizz4

exec eval('"IMpORT THIS".LOWER()'.swapcase())

Stampa il seguente testo, che ha "Python" sulla prima riga.

The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

Python 2 (1 byte)

è

produzione...:

> <> , 12 10 byte

"2,:o:2-o|

Questo stampa continuamente> <> fino a quando l'interprete non esaurisce lo spazio.

Provalo online!

Versione a 12 byte di seguito per coloro a cui piace un output pulito. Consigliato da Aaron (nessun errore, 1 uscita)

":3+:o$1+oo;

JAVA, 1 byte

1

L'output di stderr è:

Main.java:1: error: class, interface, or enum expected
1
^
1 error
Error: Could not find or load main class Main
Command exited with non-zero status 1
    Command being timed: "/srv/wrappers/java-openjdk"
    User time (seconds): 1.40
    System time (seconds): 0.80
    Percent of CPU this job got: 40%
    Elapsed (wall clock) time (h:mm:ss or m:ss): 0:05.40
    Average shared text size (kbytes): 0
    Average unshared data size (kbytes): 0
    Average stack size (kbytes): 0
    Average total size (kbytes): 0
    Maximum resident set size (kbytes): 44564
    Average resident set size (kbytes): 0
    Major (requiring I/O) page faults: 205
    Minor (reclaiming a frame) page faults: 11301
    Voluntary context switches: 2666
    Involuntary context switches: 1677
    Swaps: 0
    File system inputs: 78312
    File system outputs: 0
    Socket messages sent: 0
    Socket messages received: 0
    Signals delivered: 0
    Page size (bytes): 4096
    Exit status: 1 

CSS, 25 byte

:after{content:'\43\53\53

Tieni presente che un ulteriore markup viene aggiunto agli snippet Stack Overflow, causando la visualizzazione di "CSS" più di una volta. Apri un .htmlfile con i contenuti

<style>:after{content:'\43\53\53

per vedere il risultato come previsto.

bash CLI, 9

printf $0

Se vuoi uno script reale e non solo un comando nella riga di comando interattiva, puoi farlo:

bash, 13

printf $SHELL

Uscite /bin/bash

C, 15 byte

Compilato C su una macchina Linux con una localizzazione tedesca:

main(){main();}

Verrà eseguito su un overflow dello stack e verrà stampato Speicherzugriffsfehler(tedesco per errore di segmentazione) su stderr.

dc, 6

25699P

Uscite dc.

Provalo online .

Pip , 8 byte

'IWR C80

Prende il personaggio Ie WRlo assume in Chr ( 80), risultando in PIP. Provalo online!

Usare il Ifeeling è un po 'come imbrogliare, quindi ecco due soluzioni a 9 byte che non usano nessuno dei PpIi:

z@8WRz@15
(z8+^707)

Entrambi in uscita pip. Sono particolarmente soddisfatto del secondo:

    ^707   Split 707 into a list of characters        [7;0;7]
  8+       Add 8 to each one                          [15;8;15]
(z      )  Use list to index into lowercase alphabet  ["p";"i";"p"]
           By default, lists are printed without a separator

Per una corretta capitalizzazione, abbiamo bisogno di una soluzione a 10 byte :

'IWR C80Vx

Il modo in cui funziona è lasciato come esercizio per il lettore. ; ^)

C #, 60 67 byte

class P{static void Main(){System.\u0043onsole.Write("\x43\x23");}}

brainfuck, 105 byte

--[----->+<]>----.[--->+<]>----.+++[->+++<]>++.++++++++.+++++.--------.-[--->+<]>--.+[->+++<]>+.++++++++.

Provalo online qui

R , 11 byte

cat("\x52")

Provalo online!

Avanti, 5 byte

WORDS

Provalo online

Stampa un elenco di ogni parola nella lingua. Forthsembra essere nella lista (prima parola nella riga 125), anche se non so cosa faccia.

Esagonia , 19 byte

Fondamentalmente un flusso lineare diretto avvolto all'interno dell'esagono.

h;E;N;Y;X;A;;@/OG;/

Prova online questa soluzione poco interessante di 19 byte!

28 byte più interessanti:

. I] f @] z;. (;. [$>] Z (] b] \ (] p] h <

Provalo online!

Questo utilizza il piccolo h, che è consentito. Utilizza IP1 (iniziale è 0) come "funzione" che fa "Decrementa e stampa come carattere".

Vista espansa

   I ] f .
  @ ] z ; .
 ( ; [ . $ >
] z ( ] b ] \
 ( ] p ] h <
  . . . . .
   . . . .

Salva Iin memoria, vai al puntatore dell'istruzione successivo con ], quindi IP1 scorre dall'angolo NE in direzione SE e colpisce ..>che dirige verso E, avvolto verso il basso 5 no-op .e quindi su ((decrementa), ;(stampa come carattere) e quindi [che ritorna a IP0.

IP0 inizia a leggere da dove si è fermato f, passa attraverso la no-op .e al centro ]che esegue di nuovo la "funzione": IP1 inizia da dove si è fermata e colpisce no-op, .quindi $salta >e scorre di nuovo nella parte inferiore. per stampare e.

Il programma continua a fare cose del genere. Ho scoperto che avrei appena potuto stampare nchiamando nuovamente la funzione dopo la stampa o. Mm .. non riesco a pensare a come accorciarlo ulteriormente anche se sostituisco 1 byte con nessuna operazione con questa scoperta.

Lasciami un commento se vuoi vedere i diagrammi in questa spiegazione!

J, 2 byte

   a.


┌┬┐├┼┤└┴┘│─ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~��������������������������������������������������������������������������������������������������������������������������������

a. restituisce l'alfabeto della lingua J - un elenco incorporato di tutti i byte.

Il mio originale: 4 byte

   %:_1
0j1

Questo mi sembra davvero interessante. La radice quadrata ( %:) di 1 ( _1) negativa è i ( 0j1).

BASIC (spettro ZX), 4 2 byte

barrato 4 è ancora regolare 4

Salvato 2 byte grazie a @ShaunBebbers.

0õ

Nota: nel set di caratteri ZX Spectrum, questi byte vengono visualizzati come

0 PRINT

Quando lo inserisci, lo Spettro inizia analizzando un numero opzionale seguito da una riga di codice. Normalmente è il numero di riga 1..9999che causa l'aggiunta del codice al programma memorizzato. Tuttavia, se non viene fornito alcun numero di riga, il codice viene eseguito immediatamente. Sfortunatamente un bug nello Spettro significa che sbaglia un numero di riga pari a zero per nessun numero di riga, ma tenta comunque di eseguire lo zero come parte della riga di codice, il che è illegale, causando così l'errore.

La precedente versione a 4 byte genera un errore vero anziché basarsi su un bug dell'interprete:

õ°""

Nota: nel set di caratteri ZX Spectrum, questi byte vengono visualizzati come

PRINT VAL ""

quali uscite

C Nonsense in BASIC, 0:1

perché la stringa vuota non è un'espressione numerica valida. (Ovviamente avrei potuto usare qualsiasi istruzione che accetta un singolo numero intero.) Se questa risposta è inaccettabile, quindi per 6 byte puoi scrivere un programma composto da una singola riga con una delle parole chiave che non accetta argomenti, quindi usa POKEper sostituire con una parola chiave illegale, quindi provare al RUNprogramma.

C 24 20 byte (Clang 3.8.1)

Grazie a @squeamish ossifrage per avermi aiutato a salvare 4 byte.

main(){putchar(67);}

Vim, 3 byte

:h<CR>

Provalo online!

Questo apre il file della guida predefinito e genera:

*help.txt*  For Vim version 7.4.  Last change: 2016 Mar 31

                        VIM - main help file
                                                                         k
      Move around:  Use the cursor keys, or "h" to go left,        h   l
                    "j" to go down, "k" to go up, "l" to go right.   j
Close this window:  Use ":q<Enter>".
   Get out of Vim:  Use ":qa!<Enter>" (careful, all changes are lost!).

Jump to a subject:  Position the cursor on a tag (e.g. |bars|) and hit CTRL-].
   With the mouse:  Double-click the left mouse button on a tag, e.g. |bars|.
        Jump back:  Type CTRL-T or CTRL-O.  Repeat to go further back.

Get specific help:  It is possible to go directly to whatever you want help
                    on, by giving an argument to the |:help| command.
                    Prepend something to specify the context:  *help-context*

                          WHAT          PREPEND    EXAMPLE  ~
                      Normal mode command          :help x
                      Visual mode command     v_       :help v_u
                      Insert mode command     i_       :help i_<Esc>
                      Command-line command    :    :help :quit
                      Command-line editing    c_       :help c_<Del>
                      Vim command argument    -    :help -r
                      Option              '    :help 'textwidth'
                      Regular expression      /    :help /[
                    See |help-summary| for more contexts and an explanation.

  Search for help:  Type ":help word", then hit CTRL-D to see matching
                    help entries for "word".
                    Or use ":helpgrep word". |:helpgrep|

VIM stands for Vi IMproved.  Most of VIM was made by Bram Moolenaar, but only
through the help of many others.  See |credits|.
------------------------------------------------------------------------------
                                                *doc-file-list* *Q_ct*
BASIC:
|quickref|  Overview of the most common commands you will use
|tutor|     30 minutes training course for beginners
|copying|   About copyrights
|iccf|      Helping poor children in Uganda
|sponsor|   Sponsor Vim development, become a registered Vim user
|www|       Vim on the World Wide Web
|bugs|      Where to send bug reports

USER MANUAL: These files explain how to accomplish an editing task.

|usr_toc.txt|   Table Of Contents

Getting Started ~
|usr_01.txt|  About the manuals
|usr_02.txt|  The first steps in Vim
|usr_03.txt|  Moving around
|usr_04.txt|  Making small changes
|usr_05.txt|  Set your settings
|usr_06.txt|  Using syntax highlighting
|usr_07.txt|  Editing more than one file
|usr_08.txt|  Splitting windows
|usr_09.txt|  Using the GUI
|usr_10.txt|  Making big changes
|usr_11.txt|  Recovering from a crash
|usr_12.txt|  Clever tricks

Editing Effectively ~
|usr_20.txt|  Typing command-line commands quickly
|usr_21.txt|  Go away and come back
|usr_22.txt|  Finding the file to edit
|usr_23.txt|  Editing other files
|usr_24.txt|  Inserting quickly
|usr_25.txt|  Editing formatted text
|usr_26.txt|  Repeating
|usr_27.txt|  Search commands and patterns
|usr_28.txt|  Folding
|usr_29.txt|  Moving through programs
|usr_30.txt|  Editing programs
|usr_31.txt|  Exploiting the GUI
|usr_32.txt|  The undo tree

Tuning Vim ~
|usr_40.txt|  Make new commands
|usr_41.txt|  Write a Vim script
|usr_42.txt|  Add new menus
|usr_43.txt|  Using filetypes
|usr_44.txt|  Your own syntax highlighted
|usr_45.txt|  Select your language


REFERENCE MANUAL: These files explain every detail of Vim.  *reference_toc*

General subjects ~
|intro.txt| general introduction to Vim; notation used in help files
|help.txt|  overview and quick reference (this file)
|helphelp.txt|  about using the help files
|index.txt| alphabetical index of all commands
|help-tags| all the tags you can jump to (index of tags)
|howto.txt| how to do the most common editing tasks
|tips.txt|  various tips on using Vim
|message.txt|   (error) messages and explanations
|quotes.txt|    remarks from users of Vim
|develop.txt|   development of Vim
|debug.txt| debugging Vim itself
|uganda.txt|    Vim distribution conditions and what to do with your money

Basic editing ~
|starting.txt|  starting Vim, Vim command arguments, initialisation
|editing.txt|   editing and writing files
|motion.txt|    commands for moving around
|scroll.txt|    scrolling the text in the window
|insert.txt|    Insert and Replace mode
|change.txt|    deleting and replacing text
|indent.txt|    automatic indenting for C and other languages
|undo.txt|  Undo and Redo
|repeat.txt|    repeating commands, Vim scripts and debugging
|visual.txt|    using the Visual mode (selecting a text area)
|various.txt|   various remaining commands
|recover.txt|   recovering from a crash

Advanced editing ~
|cmdline.txt|   Command-line editing
|options.txt|   description of all options
|pattern.txt|   regexp patterns and search commands
|map.txt|   key mapping and abbreviations
|tagsrch.txt|   tags and special searches
|quickfix.txt|  commands for a quick edit-compile-fix cycle
|windows.txt|   commands for using multiple windows and buffers
|tabpage.txt|   commands for using multiple tab pages
|syntax.txt|    syntax highlighting
|spell.txt| spell checking
|diff.txt|  working with two to four versions of the same file
|autocmd.txt|   automatically executing commands on an event
|filetype.txt|  settings done specifically for a type of file
|eval.txt|  expression evaluation, conditional commands
|fold.txt|  hide (fold) ranges of lines

Special issues ~
|print.txt| printing
|remote.txt|    using Vim as a server or client
|term.txt|  using different terminals and mice
|digraph.txt|   list of available digraphs
|mbyte.txt| multi-byte text support
|mlang.txt| non-English language support
|arabic.txt|    Arabic language support and editing
|farsi.txt| Farsi (Persian) editing
|hebrew.txt|    Hebrew language support and editing
|russian.txt|   Russian language support and editing
|ft_ada.txt|    Ada (the programming language) support
|ft_sql.txt|    about the SQL filetype plugin
|rileft.txt|    right-to-left editing mode

GUI ~
|gui.txt|   Graphical User Interface (GUI)
|gui_w32.txt|   Win32 GUI

Interfaces ~
|if_cscop.txt|  using Cscope with Vim
|if_pyth.txt|   Python interface
|if_ruby.txt|   Ruby interface
|debugger.txt|  Interface with a debugger
|sign.txt|  debugging signs

Versions ~
|vim_diff.txt|  Main differences between Nvim and Vim
|vi_diff.txt|   Main differences between Vim and Vi
                                                *sys-file-list*
Remarks about specific systems ~
|os_win32.txt|  MS-Windows
                                                *standard-plugin-list*
Standard plugins ~
|pi_gzip.txt|      Reading and writing compressed files
|pi_netrw.txt|     Reading and writing files over a network
|pi_paren.txt|     Highlight matching parens
|pi_tar.txt|       Tar file explorer
|pi_vimball.txt|   Create a self-installing Vim script
|pi_zip.txt|       Zip archive explorer

LOCAL ADDITIONS:                *local-additions*

------------------------------------------------------------------------------
*bars*      Bars example

Now that you've jumped here with CTRL-] or a double mouse click, you can use
CTRL-T, CTRL-O, g<RightMouse>, or <C-RightMouse> to go back to where you were.

Note that tags are within | characters, but when highlighting is enabled these
characters are hidden.  That makes it easier to read a command.

Anyway, you can use CTRL-] on any word, also when it is not within |, and Vim
will try to find help for it.  Especially for options in single quotes, e.g.
'hlsearch'.

------------------------------------------------------------------------------
 vim:tw=78:fo=tcq2:isk=!-~,^*,^\|,^\":ts=8:ft=help:norl: