{{task|Basic language learning}} [[Category:Initialization]]

;Task: Show all ways to include text in a language source file that's completely ignored by the compiler or interpreter.

;Related tasks:

• [[Documentation]]
• [[Here_document]]

;See also:

• [https://en.wikipedia.org/wiki/Comment_(computer_programming) Wikipedia]
• [http://xkcd.com/156 xkcd] (Humor: hand gesture denoting // for "commenting out" people.)

11l

// Single line comment
\\ Also single line comment (continuation of the comment in previous line)

\[ This is
a multi line
comment ]

\{ And
this }

\( And
this )

\‘ And
this ’

360 Assembly

* An asterisk in column one denotes a comment line
* Comments may also follow any syntactically complete instruction:
         LA    1,0           Comment
         NOP                 Comment (after a NOP instruction)
* Comments after instructions with omitted operands require a comma ","
         END   ,             Comment (without comma, "Comment" assumed an operand of "END")

4D

`Comments in 4th Dimension begin with the accent character and extend to the end of the line (until 4D version 2004).
// This is a comment starting from 4D v11 and newer. Accent character is replaced by //

6502 Assembly

Note: syntax depends on the assembler software but use of a semicolon is fairly standard

## 8086 Assembly

Note: syntax depends on the assembler software but use of a semicolon is fairly standard

```asm
	MOV AX, 4C00h 		; go back to DOS
	INT 21h                 ; BIOS interrupt 21 base 16

ACL2

Just like Common Lisp:

; Single line comment
#| Multi-line
comment |#

ActionScript

:''See [[Comments#Java|Java]]''

Ada

-- All Ada comments begin with "--" and extend to the end of the line

Agena

Agena has single line comments and two styles of multi-line comments.

# single line comment

#/ multi-line comment
   - ends with the "/ followed by #" terminator on the next line
/#

/* multi-line comment - C-style
   - ends with the "* followed by /" terminator on the next line
*/

ALGOL 60

A comment in ALGOL 60 takes the place of a single instruction. 'COMMENT' this is a first comment; 'COMMENT' ****** this is a second comment ****** ;

## ALGOL 68


### With Standard

Comments can be inserted in variety of ways:
{|border="1" style="border-collapse: collapse; border: 5px double grey;"
|align=center|Algol68 as typically published,
includes '''bold''' typeface.
|align=center|''Quote'' stropping,
like to [[wp:Wiki markup|Wiki markup]].
|align=center|''Case'' stropping,
7-bit/ascii implementations.
|align=center|''Res'' stropping,
detecting reserved words.
|align=center|''Point'' stropping,
6-bits/byte implementations.
|-
|colspan=4 align=center|¢ The original way of adding your 2 cents worth to a program with the "cent" character ¢||¢ TEXT ¢
|-
|'''co''' Style i comment '''co'''
'''comment''' text '''comment'''
||'co' text 'co'
'comment' text 'comment'
||CO text CO
COMMENT text COMMENT
||co text co
comment text comment
||.CO TEXT .CO
.COMMENT TEXT .COMMENT
|-
|colspan=4 align=center|# Style ii comment with the hash character #||# TEXT #
|}
Notes:
* The <tt># test #</tt> and <tt>¢ text ¢</tt> comment tends to be used for inline comments.  And the <tt>COMMENT text COMMENT</tt> style tends to be used to comment out entire blocks.
* The script [http://www.vim.org/scripts//script.php?script_id=1927 '''algol68.vim'''] can be used to highlight commented blocks while editing source code.


### With Extensions

 &pound; This is a hash/pound comment for a UK keyboard &pound;


## ALGOL W

Comments in Algol W can appear anywhere whitespace is allowed. A comment starts with the reserved word 'comment' and ends with the next semi-colon. Alternatively a comment can start with a percent sign and end with the next percent sign or semi-colon.

A single word in the form of an identifier following the reserved word 'end' is also a comment.


```algolw
begin
    comment a comment;
    % another comment
    ;
    % and
      another
    %
end this_word_is_also_a_comment.

AmigaE

/* multiline comment
are like C ... */
-> this is a end of line comment

AntLang

## Apex


```apex

System.debug ('I will execute');   // This comment is ignored.
/*
 I am a large comment, completely ignored as well.
*/

APL

⍝ This is a comment

AppleScript

--This is a single line comment

display dialog "ok" --it can go at the end of a line

# Hash style comments are also supported

(* This is a multi
line comment*)

(* This is a comment. --comments can be nested
  (* Nested block comment *)
*)

{{works with|AppleScript|2.0}}

display dialog "ok" #Starting in version 2.0, end-line comments can begin with a hash

ARM Assembly

{{works with|as|Raspberry Pi}}

/* ARM assembly Raspberry PI comment one line */
/*  comment line 1
    comment line 2
*/

	mov r0,#0    @ this comment on end of line
	mov r1,#0    //  authorized comment

Arendelle

Arendelle uses C style comments

Arturo

// This is a simple single-line comment

a 10 // another single-line comment

/* Now, this is a
   multi-line comment
*/

Asymptote

See [http://asymptote.sourceforge.net/doc/Programming.html programming introduction in the Asymptote manual].

When reading data files a comment character in them can be specified as <code>comment="#"</code> etc.  See [http://asymptote.sourceforge.net/doc/Files.html Files in the Asymptote manual].


## AutoHotkey


```AutoHotkey
Msgbox, comments demo ; end of line comment
/*
multiline comment1
multiline comment2
*/

For multi-line comments, the '''/''' and '''/''' '''must''' be on their own separate lines. Nothing else can be on the same line.

AutoIt

#cs
Everything between the cs and and the ce is commented.
Commented code is not used by the computer.
#ce
;individual lines after a semicolon are commented.

AWK

The ''hash'' symbol # start a comment; it ends at the end of line.

BEGIN { # this code does something
  # do something
}

Axe

.This is a single-line comment

...
This is a multi-line comment
...

...If 0
This is a comment only if the condition evaluates to zero
...

...!If 1
This is a comment only if the condition evaluates to nonzero
...

...Else
This is a comment only if the previous conditional comment was executed (and vice versa)
...

Babel

-- This is a line-comment

#
    This is a block-comment
    It goes until de-dent

dedent: 0x42 -- The comment block above is now closed

BASIC

{{works with|Applesoft BASIC}} {{works with|Commodore BASIC}} {{works with|GW-BASIC}} {{works with|ZX Spectrum Basic}} The only truly standard method of marking a comment in BASIC is using the REM keyword. This dates back to (at least) the late 1970's, and ''should'' work with most BASICs available today:

100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line
110 PRINT "this is code": REM comment after statement

{{works with|Applesoft BASIC}} This may not be well known, but you may include text after the line number of GOTO and GOSUB statements. This is kind of a comment in absence of labels.

100 GOTO 200HERE 110 GOSUB 300THERE 120 GOTO 400THEOTHERPLACE 130 GOTO 500MOM AND POP

Spaces are removed from non-keyword text. BASIC keywords can be used. List outputs spaces around keywords.

{{works with|QuickBASIC|4.5}} Most BASICs also support alternate comment characters, commonly an apostrophe (single quote):

 'this is a comment
 PRINT "this is code"  'comment after statement

{{works with|DarkBASIC}} Characters other than apostrophe are used in some BASICs. For example, DarkBASIC uses a back-tick character ('''`''', a.k.a. [[wp:grave accent|grave accent]]):

this is a comment PRINT "this is code" comment after statement 'this is NOT a comment!

{{works with|FreeBASIC|0.16 or later}} In addition to single-line comments, a few BASICs support block comments. FreeBASIC was influenced by [[Comments#C|the C family's]] block comment characters:

/' This is a multi line comment. Requires FreeBASIC 0.16 or later. Last line of the comment block. '/

DIM a AS /' Comment in the middle of statement '/ Integer

=

BaCon

= BaCon accepts '''REM''' (or single quote apostrophe) for line comments.

C-style block comments can be used with /* and */ pairs; these comment blocks may cross line boundaries.

Inside ''USEC'' sections, all comment styles accepted by the configured C compiler will also be ignored.

==={{header|IS-BASIC}}=== 100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line 110 PRINT "this is code" ! comment after statement

## Batch File


```dos
rem Single-line comment.

There is another (unsupported) option, using a double-colon ::. However, this has issues with some syntactic constructs and therefore may raise syntax errors.

:: Another option, though unsupported and known
:: to fail in some cases. Best avoided.

Since comment lines are skipped entirely by the parser multi-line comments aren't possible even with line continuation.

BBC BASIC

      REM This is a comment which is ignored by the compiler
      *| This is a comment which is compiled but ignored at run time

bc

/* This is a comment. */

2 + /* Comment between tokens. */ 3

"This is a string, /* NOT a comment */."

/*
 * A comment can have multiple lines. These asterisks in the middle
 * of the comment are only for style. You must not nest a comment
 * inside another comment; the first asterisk-slash ends the comment.
 */

{{works with|GNU bc}} {{works with|OpenBSD bc}}

#!/usr/bin/bc

# This form of comment is an extension, not part of standard bc.

# Your program must not have a #! shebang line
# unless your bc supports this form of comment.

2 + 3  # It can be after a statement.

a = 1  # The newline is not part of the comment.
b = 2  # So this line is a different statement.

Befunge

Like Brainfuck, all characters and whitespace which are not commands are ignored. Also, since the code/data-space is two-dimensional, comments can be placed anywhere that will be untouched by the instruction pointer and data access commands. Finally, in Funge-98, the ; instruction immediately skips to the next ; instruction, which allows to isolate comments from code.

{{works with|Befunge|93}}

& read a number 2+ add two .@ display result and exit
  ^- inline comments -^     <-^- other comments

{{works with|Befunge|98}}

&;read a number;2+;add two;.@;display result and exit;
  ^- inline comments -^     <-^- other comments
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;completely isolated comment block for the paranoid;
;(almost - you can still skip into it.)            ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

Blast

# A hash symbol at the beginning of a line marks the line as a comment

Bracmat

Bracmat uses curly braces as comment delimiters. Curly braces inside comments must be balanced. Comments are so much ignored when source code is read, that they do not reappear in listings created by the built-in lst$ function, an otherwise very useful function to autoindent your code.

=={{header|Brainfuck}}==

Most ASCII characters may be used for comments; only the eight characters "+-<>[],." are Brainfuck commands. Extra care must be used when using punctuation, particularly the comma or period. These are I/O operators and are actually commands rather than comments, and are instead compiled into the program if used and may have to be "debugged" and removed if you forget this issue.


## Brat


```brat
# Single line comment

#* Multi
   Line
   Comment *#

Brlcad

 # Comments in mget scripts are prefixed with a hash symbol
 ls   # comments may appear at the end of a line

Burlesque

Burlesque does NOT have comments. However, you can comment code by pushing a string and popping it immediately.

"I'm sort of a comment"vv

Since strings are multi-line strings:

"I'm a
very long comment spanning
over several lines"vv

C

/* This is a comment. */
/* So is this
   multiline comment.
 */

The comment starts at the /, and ends at the /. A comment may be used between any tokens. It cannot be used inside tokens, that is, given the code

struct charisma {};
void f(char/* comment */isma) {}

the function takes an argument of type char, named isma, not an unnamed argument of type charisma.

Comments cannot be nested; that is, if you write

/* some comment /* trying to nest some other comment */ inside */

the comment ends at the first */, and inside */ is again interpreted as source code (almost certainly causing a compile error). Some compilers have the option to allow nested comments, but this is not a standard feature.

Conditional compilation also can be used to make the compiler ignore some text:

#if 0
While technically not a comment, this is also ignored by the compiler
#endif

The trick is that 0 is always false, therefore the text between #if 0 and #endif is never compiled. While this should never be used for actual comments, it's an easy way to comment out some code, especially because it doesn't interfere with normal (documentation) comments.

Conditional compile "comments" can be nested:

#ifdef UNDEFINED
This is not compiled.
#if 0
Nor is this.
#endif
And this still is not compiled.
#endif

{{works with|ANSI}}

Even though the compiler doesn't see '''#if 0''' text, the preprocessor does. Therefore some minimal rules still have to be followed. For example, the following code is ''not'' valid:

#if 0
This isn't valid.
#endif

That's because the preprocessor will interpret the apostrophe as beginning of a character constant, and will complain because that character constant isn't terminated with another apostrophe.

Note that the problem mentioned above cannot occur if there's valid code between the #if 0 and #endif.

{{works with|C99}}

// C++ single-line comments were adopted in the C99 standard.

ChucK

<-- Not common
// Usual comment

C++

:''See also [[Comments#C|C]]''

Single line C++-style comments

// This is a comment

C++-style comments start with // and reach up to, but not including, the end of line (more exactly, up to the next unescaped newline). While formally, C++-style comments cannot be nested either, in practice they can:

// This is a valid comment // with a "nested" comment

That's because starting with the first // everything in the line is ignored, including the second //. The fact that the newline is ''not'' part of the comment is important for multi-line macro definitions. It means that in the code

#define FOO \
  (macro text) // comment
  (no more macro text)

the line (no more macro text) is ''not'' part of the macro definition. Also escaping the line break at the end of the comment with '' doesn't help, because that would make the third line part of the ''comment'' instead. Comments inside macros therefore have to be C-style.

C#

//This is a comment.
//This is other comment.

/* This is a comment too. */

/* This is a
multi-line
comment */

Chapel

// single line

/* multi
line */

Chef

Comment Stew.

This is a comment.
The other comment is a loop, but you can name it anything (single word only).
You can also name ingredients as comments
This is pseudocode.

Ingredients.
Ingredient list

Method.
Methods.
SingleWordCommentOne the Ingredient.
Methods.
SingleWordCommentTwo until SingleWordCommentOned.
Methods.

Clean

Clean comments are similar to C++.

Start = /* This is a multi-
           line comment     */ 17 // This is a single-line comment

In contrast to C++ comments can be nested.

Start = /* This is a comment /* Nested comment */ still a comment */ 17

Clojure

Anything from a semicolon to the end of a line is a comment.

;; This is a comment
(defn foo []
  123) ; also a comment

The (comment) macro will prevent a form from being evaluated, returning nil no matter what is contained in the comment. However the forms inside the comment form must be properly parseable (parentheses balanced, etc.) or an exception will be thrown.

(comment (println (foo)) "bar" :baz 123 (System/exit 0))  ;; does nothing, returns nil

Finally, the #_ reader macro will cause a form to be ignored by the reader. Unlike (comment), this does not return nil; the surrounding code is evaluated as though the ignored form isn't even there.

(+ 1 (comment "foo") 3)  ;; Throws an exception, because it tries to add nil to an integer
(+ 1 #_"foo" 3)          ;; Returns 4

COBOL

Fixed format

      * an asterisk in 7th column comments the line out

A D in the 7th column indicates a debugging line which is treated like a comment unless a compiler flag is set.

      D    DISPLAY "Debug"

Free format

*> This comment syntax was defined (with free format code) in COBOL 2002.

{{works with|GnuCOBOL}} This indicates a debugging line like above, but if it is used in fixed format files, it must be in the 8th column or beyond. ''Not necessarily.'' GnuCOBOL also supports D as an indicator in column 7, the >>D format works (more by trickery than spec) if the angle brackets start in column 5, the D ending up in column 7. The >>D debug marker can then be both fixed and free form compatible.

D DISPLAY "Debug"

NOTE statement

{{works with|OS/VS COBOL}} This statement causes everything following it up to the next separator period to be treated as a comment. This statement was deleted in COBOL-74.

           NOTE this paragraph is
               commented out and ignored
           .

REMARKS and other statements

{{works with|GnuCOBOL}} There are quite a few IDENTIFICATION DIVISION obsolete and extension reserved words that will work in GnuCOBOL 2.

        IDENTIFICATION DIVISION.
        PROGRAM-ID. program.

        AUTHOR. Rest of line ignored.
        REMARKS. Rest of line ignored.
        REMARKS. More remarks.
        SECURITY. line ignored.
        INSTALLATION. line ignored.
        DATE-WRITTEN. same, human readable dates are allowed for instance
        DATE-COMPILED. same.
        DATE-MODIFIED. this one is handy when auto-stamped by an editor.

Those lines can occur multiple times each within the IDENTIFICATION DIVISION. There can be many AUTHORs, SECURITY notes, etc. These words are also supported by other COBOL dialects, but may have different rules on order, multiples allowed of if full stop periods are required (or allowed) before the end of line.

CoffeeScript

# one line comment

### multi
line
comment ###

ColdFusion

In tags:

As ColdFusion's grammar is based around HTML syntax, commenting is similar to HTML.
<!--- This is a comment.  Nothing in this tag can be seen by the end user.
       Note the three-or-greater dashes to open and close the tag. --->
<!--  This is an HTML comment.  Any HTML between the opening and closing of the tag will be ignored, but any ColdFusion code will still run.
       Note that in the popular FuseBox framework for ColdFusion, the circuit.xml files require that you use this style of comment. -->

In script:

/* This is a comment */
// This is also a comment

Common Lisp

Common Lisp provides [http://www.lispworks.com/documentation/HyperSpec/Body/02_dd.htm line comments (;)] and [http://www.lispworks.com/documentation/HyperSpec/Body/02_dhs.htm block comments (#|...|#)].

Block comments can nest (#|...#|...|#...|#), unlike block comments in e.g. [[C]].

In a common convention, header comments are prefaced with four semicolons, top-level (function level) comments use three, comments for sections of code use two, and margin comments use one.

;;;; This code implements the foo and bar functions

;;; The foo function calls bar on the first argument and multiplies the result by the second.
;;; The arguments are two integers
(defun foo (a b)
   ;; Call bar and multiply
   (* (bar a) ; Calling bar
      b))

;;; The bar function simply adds 3 to the argument
(defun bar (n)
   (+ n 3))

However, comments should not be used for inline documentation, as most defining constructs permit a documentation string (which is then available at runtime).

(defun bar (n)
  "Add 3 to the argument."
  (+ n 3))

(defclass button (widget)
  (label action)
  (:documentation "This is a push-button widget."))

Component Pascal

(* Comments (* can nest *)
   and they can span multiple lines.
 *)

D

void main() {
    // A single line comment.

    /* This is a simple C-style comment that can't be nested.
    Comments mostly work similar to C, newlines are irrelevant.
    */

    /+ This is a nestable comment
      /+ See?
      +/
    +/

    /// Documentation single line comment.

    /**
    Simple C-style documentation comment.
    */

    /++
    Nestable documenttion comment.
    +/
}

Dart

// This is a single line comment, which lasts until the end of the line. The Dart linter prefers this one.

/* This is also a valid single line comment. Unlike the first one, this one terminates after one of these -> */

/*
  You can use the syntax above to make multi line comments as well.
  Like this!
*/

/// These are doc comments. You can use dartdoc to generate doc pages for your classes with these.
///
/// Formatting [variable] and [function] names like so allows dartdoc to link to the documentation for those entities.

dc

There is no comment syntax in POSIX dc. The convention is to make a string on the stack and move it to an unused register; a no-op.

[Making and discarding a string acts like a comment] sz

GNU dc added the comment syntax of many other scripting languages.

## Deluge


Comments are only allowed in places such as "on load" scripts. You cannot put them in form or view definitions.


```deluge>// single line comment</lang



## Delphi

:''See also [[Comments#Pascal|Pascal]]''

In addition to Pascal, Delphi also allows C++ style single line comments:

```delphi>// single line comment</lang


=={{header|Déjà Vu}}==

```dejavu
#this is a comment
!print "this is not a comment, obviously" #this is a comment as well

Dragon

```dragon
/*
  This is
  a multiple
  line comment.
 */

showln "Hello " /* This is an inline comment */ "world"

DWScript

(* This is a comment.
   It may extend across multiple lines. *)

{ Alternatively curly braces
  can be used. }

/* C-style multi-line comments
   are supported  */

// and single-line C++ style comments too

Dyalect

/* This is a
multi-line comment */

//This is a single-line comment

Dylan

// This is a comment

/*
   This is a comment
   that spans multiple
   lines
*/

E

# This is a regular comment.

? "This is an Updoc comment, which
> is an executable example or test case.".split(" ")
# value: ["This", "is", "an", "Updoc", "comment,", "which
#        is", "an", "executable", "example", "or", "test", "case."]

All comments span to the end of the line; there are no paired-delimiter comment syntaxes. “#” begins a comment anywhere outside of quotes; “?” and “>” begin comments only if they are at the beginning of a line (except for whitespace), because those characters are also used for infix operators.

In Updoc, “?” indicates the beginning of a program fragment, “>” the continuation of one, and “#” begins the expected output from its evaluation; “??” indicates special directives.

EasyLang

# This is a comment

## EchoLisp


```lisp

666 ; this is an end-of-line comment

#|
 This is a multi-line comment
 Nesting is not allowed
|#

;; The (info <name> [<string>)] function associates a symbol and a comment
;; These info strings are saved in permanent memory (local storage)
;; Unicode characters may be used, as everywhere in the language

(define mynumber 666) → mynumber
(info 'mynumber "👀 Symbols may be commented with an information string 👺")
(info 'mynumber) → displays the above inside the 'info' field.

ECL

Single-line comments must begin with //

// this is a one-line comment

Block comments must be delimited with /* and */

 /* this is a block comment - the terminator can be on the same line
or any succeeding line – everything in between is ignored */

EDSAC order code

EDSAC programs were handwritten on "programme sheets" designed for the purpose. The programmer, or a computer operator, then copied the "orders" (instructions) to punched tape for input to the machine. Programme sheets had a column for "notes" (comments), but these were not copied to the tape. Modern simulators, however, accept square brackets as comment delimiters.

[This is a comment]
[
And so
is
this
]
[But in 1949 they wouldn't have been]

EGL

:''See [[Comments#Java|Java]]''

Eiffel

-- inline comment, continues until new line

Ela

//single line comment

/*multiple line
comment*/

Elena

//single line comment

/*multiple line
comment*/

Elixir

Elixir does not have multiple line comments.

# single line comment

Elm

-- a single line comment

{- a multiline comment
   {- can be nested -}
-}

Emacs Lisp

A comment is started by ; and reaches to the end of the line.

There are some coding conventions for <code>;;</code> align to indentation, <code>;;;</code> sections, etc,

: [http://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html http://www.gnu.org/software/emacs/manual/html_node/elisp/Comment-Tips.html]

Another way to add comments is to use strings at places where the result of an expression is ignored, since they simply evaluate to themselves without any effect. Note that strings can be multi-line:

```lisp
"This is effectively a comment,
if used at a place where the result is ignored"

Note that strings at the beginning of function definitions are interpreted as documentation strings for the function (i.e. Emacs will display them if asked for help about the function), e.g.

(defun subtract-second-from-first (x y)
  "This function subtracts its second argument from its first argument."
  (- y x))

Due to this, it's debatable if the string at that place can be considered as comment.

Erlang

% Erlang comments begin with "%" and extend to the end of the line.

ERRE

! Standard ERRE comments begin with ! and extend to the end of the line

PRINT("this is code") ! comment after statement

Euphoria

Single line comment:

-- This is a comment

Multiline C-style comment:

/*
This is a comment
*/

{{works with|Euphoria|4.0.0}}

FreeBASIC

' FB 1.05.0 Win64

' This a single line comment

REM This is another way of writing a single line comment

/' This is a multi-line comment '/

/' Multi-line comments /' can also be nested '/ like this '/

=={{header|F_Sharp|F#}}==
F# accepts C++ type line comments and OCaml type block comments

```fsharp
// this comments to the end of the line
(* this comments a region
   which can be multi-line *)

Factor

! Comments starts with "! "
#! Or with "#! "
! and last until the end of the line

Fancy

# Comments starts with "#"
# and last until the end of the line

Falcon

Falcon supports C-language style single line and block comments. A single line comment begins with two slashes (//) and ends at the end of the line. A block comment begins with a slash followed by an asterisk, and terminates when an asterisk followed by a slash is met (/.../).

/* Start comment block
 My Life Story
 */

// set up my bank account total
bank_account_total = 1000000 // Wish this was the case

FALSE

{comments are in curly braces}

Fish

Since ><> is a funge-like language, all characters not touched by the command pointer or modified by the p and g commands can be comments. Unlike Brainfuck, unknown commands are not ignored by the compiler, they just raise an error.

v This is the Fish version of the Integer sequence task
>0>:n1+v all comments here
  ^o" "< still here
And of course here :)

Forth

Standard Forth includes a number of ways to add comment text. As with everything in Forth, comment characters are actually words that control the compiler.

\ The backslash skips everything else on the line
( The left paren skips everything up to the next right paren on the same line)

Traditionally, the paren comments are used for "stack effect" notation:

: myword ( a b -- c )  ...

This comment means "myword takes two cells on the stack and leaves one". Sometimes, stack effect comment names give clues about the word's function:

: add'em ( a b -- a+b )   + ;
: strlen ( addr -- len )   count nip ;

Some Forth systems implement other commenting words, such as these words from Win32Forth:

\s skips all remaining text in the file
(( skips until the next double-paren,
   stretching across multiple lines ))
comment:
   Ignore all text in this section
comment;
doc
   Another comment block
enddoc
/* C-style comment */
(* Pascal-style comment *)

Fortran

Compiler: ANSI FORTRAN 77 or compatible (like [[g77]] -strict)

The first six columns in Fortran are traditionally reserved for labels and certain special characters. In particular the letter "C" in the first column indicates a comment:

C     This would be some kind of comment
C     Usually one would avoid columns 2-6 even in a comment.

Some Fortran compilers have the extension that comments starting with D are treated as non-comments if a special debugging flag is given at the compiler invocation. For example:

C     If compiled in debugging mode, print the current value of I
D     PRINT *, I

ISO Fortran 90 or later have an inline comment (!) syntax:

real :: a = 0.0   ! initialize A to be zero

In ISO Fortran 90 or later, "C in first column" comments are only allowed in the "fixed" source form familiar to FORTRAN 77 programmers. The "free" source form only has inline comments (!).

ISO Fortran 95 or later has an optional conditional compilation syntax. If present, it can be used (abused?) to (in effect) comment out blocks of code:

?? if (.false.) then
do while (oh_no)
   a = bad_news()
   b = big_mistake()
   c = gigo()
end do
?? end if

Frink

// This is a single-line comment
/*  This is a comment
    that spans multiple lines
    and so on.
*/

Futhark

-- Single-line comment

-- Multi-line
-- comment (yes, just several single-line comments).

FUZE BASIC

//Comment (No space required)
# Comment (Space required)
REM Comment (Space require)
PRINT "This is an inline comment."//Comment (No space required)
END

Gambas

In gambas, comments can be inserted by prefixing them with an apostrophe. The gambas interpreter will ignore the apostrophe and any other characters that follow it until the end of the line:

 ' This whole line is a comment and is ignored by the gambas interpreter
 print "Hello" ' Comments after an apostrophe are ignored
 '' A bold-style comment
 ' TODO:  To Do  comment will appear in Task Bar
 ' FIXME: Fix Me comment will appear in Task Bar
 ' NOTE:  Note   commnet will appear in Task Bar

GAP

# Comment (till end of line)

Gema

! comment starts with "!" and continues to end of line

A shebang (#!) may be used as a comment in the first line of a file.

Genie

Genie allows comments in code in two different ways.

// Comment continues until end of line

/* Comment lasts between delimiters */

Delimited comments cannot be nested.

GML

single-line comment:

 // comment starts with "//" and continues to the end of the line

multi-line comment:

 /* a multi-line comment starts with slash-asterisk and,
ends with asterisk-slash.
also note:
 * A multi-line comment is ignored inside a string
 * A multi-line comment can be ended inside a line
*/

gnuplot

# this is a comment

# backslash continues \
a comment to the next \
line or lines

The way backslash continues a comment means that comments can't usefully be put within a multi-line function definition,

# this doesn't work
foo(n) = (n                \
          + 2    # no good \
          + 3)

# behaves as if you wrote merely
foo(n) = (n+2

Go

// this is a single line comment
/* this is
   a multi-line
   block comment.
/* It does not nest */

Golfscript

## Gri

<code>#</code> through to newline.


```Gri
# this is a comment
show 123        # this too is a comment

// works similarly but is reckoned the "old way" (as of Gri 2.12.23)

// this is a comment show 123 // this too is a comment

Both forms can be used in input data files too.


## Groovy

:''See [[Comments#Java|Java]]''

=={{header|GW-BASIC}}==
{{works with|GW-BASIC}}


```gwbasic
100 REM Standard BASIC comments begin with "REM" (remark) and extend to the end of the line
110 PRINT "this is code": REM comment after statement

Haskell

i code = True -- I am a comment.

{- I am also
   a comment. {-comments can be nested-}
   let u x = x x (this code not compiled)
   Are you? -}

-- |This is a Haddock documentation comment for the following code
i code = True
-- ^This is a Haddock documentation comment for the preceding code

{-|
  This is a Haddock documentation block comment
-}
i code = True

Haxe

// Single line commment.

/*
   Multiple
   line
   comment.
*/

HicEst

! a comment starts with a "!" and ends at the end of the line

HTML

<!-- Anything within these bracket tags is commented, single or multi-line. -->

=={{header|Icon}} and {{header|Unicon}}== Any text after "#" is a comment.

# This is a comment

procedure x(y,z)    #: This is a comment and an IPL meta-comment for a procedure

The [[:Category:Icon_Programming_Library|The Icon Programming Library]] established conventions for commenting library additions and functions. This included both header block comments and meta comments on procedures within library files.

IDL

The comment character in IDL is the semicolon - everything starting with it and to the end of the line is a comment. Like this:

; The following computes the factorial of a number "n"
fact = product(indgen( n )+1) ; where n should be an integer

Inform 7

[This is a single-line comment.]

[This is a
multi-line comment.]

[Comments can [be nested].]

Io

# Single-line comment

// Single-line comment

/* Multi-line
   comment */

J

NB. Text that follows 'NB.' has no effect on execution.

0 : 0
Multi-line comments may be placed in strings,
like this.
)

Note 'example'
Another way to record multi-line comments as text is to use 'Note', which is actually
a simple program that makes it clearer when defined text is used only to provide comment.
)

'A simple string which is not used is legal, and will be discarded'

Java

Java has two ways to enter normal comments, plus a third type of comment that doubles as a way to generate HTML documentation.

C Style

/* This is a comment */

/*
 * This is
 * a multiple
 * line comment.
 */

This ''C-style'' comment starts with / and ends with /. The two delimiters may be on the same or separate lines. This style comment may be used anywhere white space is permitted. ===C++ Style (inline)===

This ''C++-style'' comment starts with <tt>//</tt> and extends to the end of line.

===Java Documentation (Javadoc)===

```java
/** This is a Javadoc comment */

/**
 * This is
 * a multiple
 * line Javadoc comment
 */

[http://en.wikipedia.org/wiki/Javadoc Javadoc] is a standardized documentation code for Java. Its comments begin with a forward slash and two stars. Javadoc comments have different tags that signify different things in the methods and classes that they precede.

Sneaky

Your editor will probably colour this as great big comment, but it compiles and prints "Hello World!". Once you've figured out how this works, try this [http://stackoverflow.com/questions/4448180/why-does-java-permit-escaped-unicode-characters-in-the-source-code discussion on why it's allowed].

public class JustComments {
    /*
    \u002A\u002F\u0070\u0075\u0062\u006C\u0069\u0063\u0020\u0073\u0074\u0061\u0074\u0069\u0063
    \u0020\u0076\u006F\u0069\u0064\u0020\u006D\u0061\u0069\u006E\u0028
    \u0053\u0074\u0072\u0069\u006E\u0067\u005B\u005D\u0061\u0072\u0067\u0073\u0029
    \u007B\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006F\u0075\u0074\u002E
    \u0070\u0072\u0069\u006E\u0074\u006C\u006E\u0028\u0022\u0048\u0065\u006C\u006C\u006F\u0022
    \u002B\u0022\u0020\u0057\u006F\u0072\u006C\u0064\u0021\u0022\u0029\u003B\u007D\u002F\u002A
    */
}

JavaScript

```javascript
// This is a valid comment // with a "nested" comment

/* This is
a multi line
comment
// with a "nested" comment
and another line in the comment
*/

JCL

first form

//* This is a comment line (//* in columns 1-3)

second form

/* This is also a comment line (/*  in columns 1-3)

Joy

# this is a single line comment

(* this is a
multi-line comment *)

Multi-line comments cannot be nested.

jq

Except when a hash symbol (#) appears within a string, it begins a comment that continues to the end of the line:

# this is a single line comment
"Hello #world" # the first # on this line is part of the jq program

Jsish

#!/usr/bin/env/jsish
/* Comments, in Jsish */

// to end of line comment, double slash

/*
 Enclosed comment, slash star, ending with star slash
 Cannot be nested, but can cross line boundaries and occur
 pretty much anywhere whitespace is allowed
*/

var x = 'X'; /* A var called X */
/* active code on this line */ printf("Result %q %d\n", /* comment code mix */ x, /**/42);

;x;
// jsish also handles double slash commented
// unit test echo lines as a special case of "expect failure"

;//noname(x);

/*
=!EXPECTSTART!=
Result X 42
x ==> X
noname(x) ==>
PASS!: err = can not execute expression: 'noname' not a function
=!EXPECTEND!=
*/

{{out}}

prompt$ jsish comments.jsi
Result X 42
prompt$ jsish --U comments.jsi
Result X 42
x ==> X
noname(x) ==>
PASS!: err = can not execute expression: 'noname' not a function
prompt$ jsish -u comments.jsi
[PASS] comments.jsi

Julia

# single line

#=
Multi-
line
comment
=#

K

  / this is a comment
  2+2  / as is this

KonsolScript

//This is a comment.
//This is another comment.

/* This is a comment too. */

/* This is a
multi-line
comment */

Kotlin

// This is a single line comment

/*
    This is a
    multi-line
    comment
*/

/*
    Multi-line comments
    /*
        can also be nested
    */
    like so
*/

const val CURRENT_VERSION = "1.0.5-2"  // A comment can also be added at the end of a line
const val /* or even in the middle of a line */ NEXT_MAJOR_VERSION = "1.1"

/**
 * This is a documentation comment used by KDoc.
 *
 * It's documenting the main function which is the entry-point to a Kotlin executable.
 *
 * @param [args] A string array containing the command line arguments (if any) passed to the executable
 * @return Implicit return value is Unit which signifies no meaningful return value (like 'void' in java)
 */
fun main(args: Array<String>) {
    println("Current stable version is $CURRENT_VERSION")
    println("Next major version is $NEXT_MAJOR_VERSION")
}

LabVIEW

{{VI solution|LabVIEW_Comments.png}}

Lang5

## Lasso



```Lasso
//This is a comment.

/* This is also a comment. */

/* A multi-line
comment */

/*
### ====================

A multi-line
comment

### =====================
 */

LaTeX

In LaTeX, comments look like this:

% This is a comment

LaTeX comments start with % and continue up to ''and including'' the line break. The fact that the line break itself is commented out as well makes it useful for adding line breaks in the source code of complex macros without LaTeX interpreting them (which may cause extra space or even a paragraph break in the resulting typeset text). For example, the following results in the ''one'' word "understandable":

\newcommand{\firstpart}[1]{under#1}
\newcommand{\secondpart}{able}
\newcommand{\complete}{%
\firstpart{stand}%
\secondpart}

\complete

Without the percent sign after \firstpart{stand}, it would have been the ''two'' words "understand able".

Liberty BASIC

'This is a comment
REM This is a comment

print "This has a comment on the end of the line." 'This is a comment
print "This also has a comment on the end of the line." : REM This is a comment

Lily

There are two kinds of comments:

# This is a single-line comment

and

#[ This
is
a
block
comment ]#

Like with C, block comments don't nest.

Lilypond

% This is a comment

%{ This is a comment
spanning several lines %}

Lingo

In Lingo any line starting with "--" is a comment and ignored by the interpreter.

-- This is a comment.
-- This is another comment

LiveCode

-- comment may appear anywhere on line
// comment may appear anywhere on line
# comment may appear anywhere on line
/*  this is a
block comment that
may span any number of lines */

Logo

; comments come after a semicolon, and last until the end of the line

Logtalk

% single-line comment; extends to the end of the line

/* multi-line
comment */

LotusScript

LotusScript has two ways to enter comments.

' This is a comment

Wherever the single quote (') is used, the rest of the line is treated as a comment and ignored. Multi-line comments would each need a single quote mark. This style of comment is usually used for making small in-line or single line comments.

%REM
This is a multi-
line comment.
%END REM

A %REM marker begins a comment block, and a %END REM marker ends the comment block. This style of comment is used for making longer multi-line comments, often at the beginning of a class, sub or function.

LSE64

# single line comment (space after # is required)

The author of LSE comments the stack effect of words with header comments as follows:

# arg1 arg2 '''yields''' result|''nothing''

Lua

-- A single line comment

--[[A multi-line
    comment --]]

{{works with|Lua|5.1 and above}}

--[====[ A multi-line comment that can contain [[ many square brackets ]]
]====]

M2000 Interpreter

There is no multi line comment. We have to use ' or

There are three types of remarks. After statement with a dark color, in a line, with no statements, with the current pen color, and the Rem statement. Rem statement skip statements in current line, but m2000 editor render these using syntax highlight.

Module Comments {
      Print "ok" ' comment at the end of line
      Print "ok"  \ comment at the end of line
      \ comment  in one line - different color with previous two
      'comment in one line
      Rem : Print "ok"   ' statements after Rem skipped, but stay with syntax highlight
}
Comments

M4

eval(2*3)  # eval(2*3)  "#" and text after it aren't processed but passed along

dnl  this text completely disappears, including the new line

divert(-1)
Everything diverted to -1 is processed but the output is discarded.
A comment could take this form as long as no macro names are used.
divert

{{out}}

6  # eval(2*3)  "#" and text after it aren't processed but passed along

dnl must be a separate word. An empty pair of quotes can separate it from preceding text if necessary

some text`'dnl then a deleted comment

changecom() can set a different character for #,

changecom(%)
% now percent prevents macro expansion

In GNU m4 an empty changecom() string means no such commenting char at all (but in BSD m4 means reset to the default #)

changecom()
GNU m4 now no macro expansion suppression character at all

In GNU m4 changecom() also takes separate start and end strings and they can be multi-character sequences, allowing for example C style,

changecom(/*,*/)
/* GNU m4 now no macro expansion in C style comments */

Maple

x := 4: x; # Everything on this line, after this, is a comment.

17; (* This
   is
   a multiline comment *) 23.4;

{{out}}

                               4
                               17
                              23.4

=={{header|Mathematica}} / {{header|Wolfram Language}}==

(*this is a comment*)

It can be used everywhere and nested if necessary:

If[a(*number 1*)<(* is smaller than number 2*) b, True (*return value (*bool true*)*), False (*return bool false*)]

evaluates to:

If[a < b, True, False]

MATLAB

%This is a comment
%% Two percent signs and a space are called a cell divider

Maxima

/* Comment
  /* Nested comment */
*/

MAXScript

-- Two dashes precede a single line comment

/* This is a
   multi-line comment */

MBS

! A pling in a line starts a comment

INT   n:=5   ! Comments can appear at the end of a line

/* A comment block can also be defined using climbstar and starclimb symbols.
  This allows comments to be stretched across several lines */

Metafont

% this is "to-end-of-line" comment

Microsoft Small Basic

Microsoft Small Basic uses the quote symbol to mark it's comments. After placing a quote everything in that line will be ignored.

' This is a comment
i = i + 1  ' You can also append comments to statements

min

{{works with|min|0.19.3}}

; this is a comment
1 1 + ; add one and one together

Mirah

puts 'code' # I am a comment
/* This is
 * a multiple
 * line comment */

mIRC Scripting Language

;Single Line Comment
/*
Multiple
Line
Comment
*/

=={{header|Modula-2}}== (* Comments (* can nest *) and they can span multiple lines. *)

=={{header|Modula-3}}==

```modula3
(* Comments (* can nest *)
   and they can span multiple lines.
 *)

Monte

# This comment goes to the end of the line
/** This comment is multi-line.
    Yes, it starts with a two stars
    and ends with only one.
    These should only be used for docstrings. */

MontiLang

/# This is a comment #/
/#
comments can span multiple lines
nested comments are not supported #/

MOO

"String literals are technically the only long-term comment format";
// Some compilers will, however, compile // one-liners to string literals as well (and vice-versa)
/* Classical C-style comments are removed entirely during compile */

Neko

// Single line comment, of course!

/*
Multi line comment!
*/

/**
Documentation block
<doc>can include XML parsed nodes between doc tags</doc>
**/

Nemerle

// This comment goes up to the end of the line
/* This
is
a
multiline
comment */

NESL

% This is a comment. %

NetRexx

NetRexx supports block-comments and line comments. Block comments are started with a '''/''' and terminated with a '''/'''. Line comments follow a '''--''' sequence anywhere on a line. NetRexx supports nested comments (see [[#REXX|REXX]]).

/*

 NetRexx comment block

*/

-- NetRexx line comment

NewLISP

A comment is started by ; and reaches to the end of the line.

## Nim


```Python
# Nim supports single-line comments

var x = 0 ## Documentation comments start with double hash characters.

var y = 0 ## Documentation comments are a proper part of the syntax (they're not discarded by parser, and a real part of AST).

#[
There are also multi-line comments
Everything inside of #[]# is commented.
]#

# You can also discard multiline statements:

discard """This can be considered as a "comment" too
This is multi-line"""

NSIS

# This is a comment that goes from the # to the end of the line.
; This is a comment that goes from the ; to the end of the

/* This is a
multi-line
comment */

=={{header|Oberon-2}}==

(* this is a comment *)
(*
   and this is a
   multiline comment
   (* with a nested comment *)
*)

Objeck

#This is a comment.
# This is other comment.

#~ This is a comment too. ~#

#~ This is a
multi-line
comment ~#

=={{header|Objective-C}}== :''See [[Comments#C|C]]''

OCaml

(* This a comment
   (* containing nested comment *)
 *)

(** This an OCamldoc documentation comment *)

Oforth

Oforth has only single line comment (inside or outside definition)

## Octave


```octave
# I am a comment till the end of line
% I am a comment till the end of line

%{
  This comment spans
  multiple lines
%}

ooRexx

Comments in ooRexx follow the same rules as [[#REXX|REXX]] and [[#NetRexx|NetRexx]]

/*
  Multi-line comment block
 */

-- this type of comment works in ooRexx, NetRexx and some of the more popular REXX implementations like Regina

hour = 0  -- which is, like midnight, dude.

hour = 12 /* time for lunch! works as well (and really everywhere) */

Openscad

The openscad geometry compiler supports C++ style comments:

// This is a single line comment

/*
  This comment spans
  multiple lines
*/

OxygenBasic

'  Basic line comment
;  Assembly code line comment
// C line comment
/* C block comment */

Oz

% one line comment

%% often with double "%" because then the indentation is correct in Emacs

/* multi line
   comment
*/

PARI/GP

Comments are similar to C. The block comment is identical: /* comment */. The line comment uses backslashes instead of slashes: \ comment.

Pascal

(* This is a comment.
   It may extend across multiple lines. *)

{ Alternatively curly braces
  can be used. }

(* This is a valid comment in Standard Pascal,
   but not valid in [[Turbo Pascal]]. }

{ The same is true in this case *)

In Pascal, comments cannot be nested.

PASM

# This is a comment
print "Hello\n"    # This is also a comment
end

Peloton

Peloton encloses all comments inside <@ OMT></@> (fixed length opcode) or <# OMIT></#> (variable length opcode) whether single- or multi- line.

<@ OMT>This is a
multiline
comment</@>

OMT suppresses evaluation of everything contained. There are a variety of extra opcodes which can be used to control how OMT functions at run time.

Perl

{{works with|Perl|5.x}} Single line comment

These may also be at the end of a line


```perl
my $var = 1; # this is the comment part

Multi-line comments for inline documentation (Plain Old Documentation, or POD in Perl parlance) follow the format:

=pod

Here are my comments
this is multi-line

=cut

Note that technically, both of the lines beginning with the equals sign must be surrounded on either side for compatibility with all "POD" parsers.

Note also that any string beginning with an equals sign, and that appears in the initial column of a line, begins a multi-line comment. It does not have to be a POD "command:" the following are all valid:

=head1
=head4
=over 4
=Any Old String

Such blocks always end in =cut.

For more info, type at a command prompt (or into a search engine): "perldoc perlpod"

Perl 6

'''Single-line comments'''

A single-line comment starts with # and extends to the end of the line.

# the answer to everything
my $x = 42;

'''Multi-line comments'''

A multi-line comment starts with #` and followed by the commented text enclosed by bracketing characters (e.g., (), [], {}, 「」, etc.).

#`(
    Comments beginning with a backtick and one or more opening bracketing characters are embedded comments.
    They can span more than one line…
)

my $y = #`{ …or only part of a line. } 3;

Multi-line comments can also be embedded into code.

for #`(each element in) @array {
    say #`(or print element) $_ #`(with a newline);
}

Using more than one bracketing character lets you include an unmatched close bracket, as shown below.

#`{{
  This close curly brace } won't terminate the comment early.
}}

'''Pod comments'''

=begin comment

Pod is the successor to Perl 5's POD. This is the simplest way to use it for multi-line comments.
For more about Pod, see Pod: https://docs.perl6.org/language/pod

=end comment

Pod also provides declarator blocks which are special comments that attach to some source code and can be extracted as documentation. They are either #| or #= and must be immediately followed by either a space or an opening curly brace. In short, blocks starting with #| are attached to the code after them, and blocks starting with #= are attached to the code before them.

#| Compute the distance between two points in the plane.
sub distance(
    Rat \x1, #= First point's abscissa,
    Rat \y1, #= First point's ordinate,
    Rat \x2, #= Second point's abscissa,
    Rat \y2, #= Second point's ordinate,
){
    return sqrt((x2 - x1)**2 + (y2 - y1)**2)
}

Phix

Single line comment:

-- This is a comment

Nestable multiline comments:

/*
This is a comment
procedure oldproc()
   /*
     This is also a comment
   */
   puts(1,"kill me now")
end procedure
*/
puts(1,"this is not a comment")

{{out}}

this is not a comment

PHP

Single line comment:

# this is commented
// this is commented

These may also be at the end of a line:

$var = 1; # this is the comment part
$var = 1; // this is the comment part

Basic syntax for multi-line comments:

/*
Here are my comments
this is multi-line
*/

Note that; it is more common to see phpDocumentor styled multi-lined comments:

/**
 * phpdoc Comments
 * @todo this is a todo stub
 */

PicoLisp

# The rest of the line is ignored
#{
   This is a
   multiline comment
}#
NIL
Immediately stop reading this file. Because all text in the input file following
a top-level 'NIL' is ignored.

This is typically used conditionally, with a read-macro expression like
`*Dbg
so that this text is only read if in debugging mode.

Pike

// This is a comment.
/* This is a
   multi
   line
   comment */

int e = 3; // end-of-statement comment.

plainTeX

The default raw/bare [[TeX]] assigns the category code 14 (comment character) to the character %, and [[plainTeX]], as also [[LaTeX]] (see here [[Comments#LaTeX|Comments in LaTeX]], does not change it; so the % starts a to-end-of-line comment in many TeX macro packages.

% this is a comment
This is not.

The final newline character is eaten and since it normally behaves like a space, the comment can be used to hide the newline:

\def\firstpart#1{under#1}
\def\secondpart{able}
\def\complete{\firstpart{stand}%
\secondpart}

\complete

Outputs understandable; without % it would output understand able.

PL/I

/* This is a comment. */

/*
This is a multiline comment.
*/

Note: In PL/I, comments cannot be nested.

PL/SQL

Single line comment:

--this is a single line comment

Multiline comment:

/*
this is a multiline
comment
*/

End of line comment:

v_var number; --this is an end of line comment

Pop11

Pop11 has two kinds of comments: endline and C-like. Endline comment begins with tree consecutive semicolons and ends at the end of line:

C-like comments may be multiline:


```pop11
/* First line
   Second line */

C-like comments (unlike C) may be nested:

/* This is a comment /* containing nested comment */ */

One can also use conditional compilation to comment out sections of code

#_IF false
some code
#_ENDIF

however, commented out part must consist of valid Pop11 tokens. In particular, C-like comments must balance and strings must be terminated. The following is an error:

#_IF false
This w'ont work
#_ENDIF

because apostrophe starts an unterminated string.

PostScript

## PowerShell


```powershell
# single-line comment

<# multi-line
   comment #>

// a single-line comment

/* a multi-line
   comment
*/

/*
 * a multi-line comment
 * with some decorative stars
 */

## Prolog


```prolog
% this is a single-line comment that extends to the end of the line

/* This is a
multi-line comment */

;comments come after an unquoted semicolon and last until the end of the line
foo = 5 ;This is a comment
c$ = ";This is not a comment"  ;This is also a comment

# This is a comment
foo = 5 # You can also append comments to statements

"""Un-assigned strings in triple-quotes might be used
   as multi-line comments
"""

'''
   "triple quoted strings" can be delimited by either 'single' or "double" quote marks; and they can contain mixtures
   of other quote marks without any need to \escape\ them using any special characters.  They also may span multiple
   lines without special escape characters.
'''

#!/usr/bin/env python
# Example of using doc strings
"""My Doc-string example"""

class Foo:
     '''Some documentation for the Foo class'''
     def __init__(self):
        "Foo's initialization method's documentation"

def bar():
    """documentation for the bar function"""

if __name__ == "__main__":
    print (__doc__)
    print (Foo.__doc__)
    print (Foo.__init__.__doc__)
    print (bar.__doc__)

## Racket


```racket

; this is a to-end-of-line coment

#| balanced comment, #| can be nested |# |#

#;(this expression is ignored)

#; ; the following expression is commented because of the #; in the beginning
(ignored)

## REBOL



```REBOL

; This is a line comment.

{ Multi-line strings can
  be used as comments
  if you like }

plus2: func [
    "Adds two to a number."
    n [number!] "The number to increase."
][
    n + 2
]

USAGE:
    PLUS2 n

DESCRIPTION:
     Adds two to a number.
     PLUS2 is a function value.

ARGUMENTS:
     n -- The number to increase. (Type: number)

( comments are placed between parentheses. A space must follow the opening parenthesis. )

/*REXX program that demonstrates what happens when dividing by zero.  */
y=7
say 44 / (7-y)      /* divide by some strange thingy.*/

     3 +++ say 44 / (7-y)      /* divide by some strange thingy.*/
Error 42 running "c:\COMMENTD.REX", line 3: Arithmetic overflow/underflow
Error 42.3: Arithmetic overflow; divisor must not be zero

Error 42 : Arithmetic overflow/underflow (SYNTAX)
Information: Divide by zero
Error occurred in statement# 3
Statement source: say 44/(7-y)
Statement context: c:\commentdv.rex, procedure: commentdv

     3 +++ say 44 / (7-y)      /* divide by some strange thingy.*/
Error 42 on line 3 of C:\COMMENTD.REX: Arithmetic overflow/underflow

/*REXX program to demonstrate various uses and types of comments. */

/* everything between a "climbstar" and a "starclimb" (exclusive of literals) is
   a comment.
                         climbstar =  /*   [slash-asterisk]
                         starclimb =  */   [asterisk-slash]

            /* this is a nested comment, by gum! */
            /*so is this*/

Also, REXX comments can span multiple records.

There can be no intervening character between the slash and asterisk  (or
the asterisk and slash).  These two joined characters cannot be separated
via a continued line, as in the manner of:

       say 'If I were two─faced,' ,
           'would I be wearing this one?' ,
           '      --- Abraham Lincoln'

 Here comes the thingy that ends this REXX comment. ───┐
                                                       │
                                                       │
                                                       ↓

                                                       */

    hour = 12       /*high noon                   */
midnight = 00       /*first hour of the day       */
   suits = 1234     /*card suits:   ♥  ♦  ♣  ♠    */

hutchHdr = '/*'
hutchEnd = "*/"

    /* the previous two "hutch" assignments aren't
       the start  nor  the end of a REXX comment. */

  x=1000000 **   /*¡big power!*/   1000

/*not a real good place for a comment (above),
  but essentially, a REXX comment can be
  anywhere whitespace is allowed.            */

-- A REXX line comment (maybe)
say "something" -- another line comment (maybe)

//this is a single line comment
#this also a single line comment!

/*This is a multi-line
comment that will be completely
ignored by the compiler/interpreter
*/

x = "code" # I am a comment
x = "code" // Here I comment thee
#  matlab-like document line
// C++ like document line

. "This is a comment line"

. "Print Hello world"
* "Hello world."

. "This is the only way to comment a line in Robotic"

. "@NewRobotName"

x = "code" # I am a comment

=begin hello
I a POD documentation comment like Perl
=end puts "code"

'This is a comment
REM This is a comment

print "Notice comment at  the end of the line."          'This is a comment
print "Also notice this comment at the end of the line." : REM This is a comment

// A single line comment

/*
    This is a multi-line (aka block) comment

    /*
        containing nested multi-line comment
        (nesting supported since 0.9-pre https://github.com/mozilla/rust/issues/9468)
    */
*/


/// Outer single line Rustdoc comments apply to the next item.

/**
    Outer multi-line Rustdoc comments.

 *  Leading asterisk (*) in multi-line Rustdoc comments
 *  is not considered to be part of the comment text,
 *  blanks and tabs preceding the initial asterisk (*) are also stripped.
*/

fn example() {

    //! Inner single line Rustdoc comments apply to their enclosing item.

    /*!
        Inner multi-line Rustdoc comments.
        See also https://github.com/mozilla/rust/wiki/Doc-using-rustdoc
    */
}

#[doc = "Unsugared outer Rustdoc comments.
        (outer attributes are not terminated by a semi-colon)"]
fn example() {
    #[doc = "Unsugared inner Rustdoc comments.
            (inner attributes are terminated by a semi-colon)
            See also https://github.com/mozilla/rust/blob/master/doc/rust.md#attributes"];
}

/* comment */

*another comment;

* both
  may
  be
  multiline;

-- a single line comment

// A single line comment

/* A multi-line
   comment */

## Scheme


```scheme
; Basically the same as Common Lisp
; While R5RS does not provide block comments, they are defined in SRFI-30, as in Common Lisp :

#| comment
... #| nested comment
... |#
|#

; See http://srfi.schemers.org/srfi-30/srfi-30.html

## Seed7



```seed7
# A single line comment

(* A multi-line
    comment *)

(* In Seed7,
(* comments can be nested. *) *)

## SETL


```setl
print("This is not a comment"); -- This is a comment
$ For nostalgic reasons, this is also a comment.

These may also be at the end of a line

```ruby>var i = 1; # this is the comment part</lang


Embedded comments

```ruby
var distance #`{in meters} = (30 #`{meters} * 100 #`{seconds});
say distance; # prints: 3000

/*
    This is a multi-line comment
*/

And an new form:
<lang>!This is a comment for Simula 67;

!OutText("Dying."); !Outimage; !terminate_program;

"basically the same as smalltalk"

"Comments traditionally are in double quotes."
"Multiline comments are also supported.
 Comments are saved as metadata along with the source to a method.
 A comment just after a method signature is often given to explain the
 usage of the method. The class browser may display such comments
 specially."

## SNOBOL4



```SNOBOL4

* An asterisk in column 1 is the standard Snobol comment
* mechanism, marking the entire line as a comment. There
* are no block or multiline comments.

*               Comments may begin at
*               any position on the line.

- A hyphen in column 1 begins a control statement.
- Unrecognized control statements are ignored and
- may also mark comment lines. Not recommended.

                   ;* The semicolon statement separator
    output = 'FOO' ;* begins a new statement. This idiom
    output = 'BAR' ;* simulates an asterisk in the first
                   ;* column, allowing end of line comments.

END

Any text after the required END label is ignored.

'This is single-line comment

''This is
multiline comment''

SELECT * FROM mytable -- Selects all columns and rows

-- Selects all columns and rows
SELECT * FROM mytable

SELECT * FROM mytable
-- Selects all columns and rows

--This is a single line comment.

/* This is
a multiline
comment */

(= This is
a multiline
comment =)

declare myvar number; --This is an end of line comment.

will be understood by the machine as <tt>Add 20 to CI</tt>, a normal instruction. But it also fits four comment characters into the unused bits, employing a simple five-bit encoding where <tt>A</tt>=0 and <tt>Z</tt>=25. The instruction breaks down as follows:

<tt>00101 -- </tt>address field = 20

<tt>01001 -- </tt>"comment" field = 18

<tt>000 -- </tt>three unused bits

<tt>100 -- </tt>instruction field = <tt>Add to CI</tt>

<tt>01001 -- </tt>"comment" field = 18

<tt>00100 -- </tt>"comment" field = 4

<tt>01100 -- </tt>"comment" field = 12

<tt>0 -- </tt>unused bit

Applying our simple alphabetic encoding, we see that the "spare" bits spell out 18, 18, 4, 12 = S, S, E, M.

More realistically, you can include comments when you are drafting your program using mnemonic notation and then simply leave the comments out when it comes time to toggle the program in.


## Standard ML



```sml
(* This a comment
   (* containing nested comment *)
 *)

//this is a single line comment

#this is also a single line comment

/*
    this is a multi-line comment
*/

* Line comment: must be used at the beginning of a line (does not work in Mata)

// Line comment until the end of the line

/* Multiline comment

*/

// this is a single line comment
/* This a block comment
   /* containing nested comment */
 */

///This is a documentation comment

/**
  This is a documentation block comment
*/

# comment on a line by itself. The next is a command by itself:
set var1 $value1
set var2 $value2 ; # comment that follows a line of code

set aList {foo}
lappend aList # bar
puts $aList           ;# ==> prints "foo # bar"
puts [llength $aList] ;# ==> 3

if 0 {
   Comments...
}

:"THIS IS A COMMENT

:If 0
:THIS IS A COMMENT

© This is a comment. Everything from © to the end of the line is ignored.

#! Everything on this line (after the shebang to the left) will be ignored.

[ ( a b -- c )
  ... ] is myword

( This is a
  simple, multi-line
  comment )

... code ....
end.
Nothing following the end. will be evaluated by Toka.

## TPP



```tpp
--## comments are prefixed with a long handed double paintbrush

$$ MODE TUSCRIPT
- This is a comment

@# old-style comment to end of line
@; new-style comment to end of line
@(bind a ; comment within expression
       "foo")

#!/bin/sh
# A leading hash symbol begins a comment.
echo "Hello"      # Comments can appear after a statement.

# The hash symbol must be at the beginning of a word.
echo This_Is#Not_A_Comment
#Comment

#!/bin/csh -f

# C Shell has a similar comment syntax, but only allows comments in a
# script file, not in terminal input.

echo Hello#With C Shell, the hash can also be in the middle of a word.

# Comments in es (extensible shell) look like those of other shells.

echo Hello#With es, the hash can also be in the middle of a word.

# this is a comment.

`  # apply
.a # output "a"
i  # identity

`.ai

# this is a comment
# this is another comment

# this is single line a comment

# this is a\
continued comment

(# this is a
multi-line comment #)

(# comments in (# this form #) can (#
be (# arbitrarily #) #) nested #)

---- this is also a comment\
and can be continued

###
The whole rest of the file after three hashes
is a comment.

x = <1,## 2,3>

a =

<
   'to',
   ## <
      'be',
      'or'>,
   'not',
   'to',
   ## 'be'>

foo = 1

##

bar = 2

baz = 3

#comment -[
I document the source text but will also be embedded in
the output library or executable file.]-

#comment gpl'3'

my_input_type%C f

my_input_type%Ck f

#depend <this,expression> is (parsed)* but {
   otherwise,
   ignored}

' This is a VBA comment

' This is a VBScript comment

//////////////////////////////////////////////////////////////////////////////////////////////
//
// Line Comments:
//
### =======

//
@VAR v1 = 10; // Line comments start from the "//" and continue to end of the line.
//               (normal code can appear on the same line, before the //)
//
//   Line comments can span a complete line, or start in the middle of a line.
///
//// Additional // chars and /* /*  /[  ]/ and  /] are ignored
//// Line comments can be appear to be nested, since any additional // is ignored.
///
//   Note: // can appear in strings without triggering a line comment
//         // cannot appear inside an operator (or verbname), since a line comment
//            would start
//
/////////////////////////////////////////////////////////////////////////////////////////////

/********************************************************************************************
 *
 *  Block Comments:
 *
### ========

 *
 ********************************************************************************************/
//*
//*  These start with /* and end with the next */ .  They cannot be nested, since the first */
//*  will end the block comment.  For example, the comment, /* /* */ */ would end after the
//*  first */. Note that /* is ignored inside a block comment, as are   //   /[   /] and  /].
//*
//*  Also note that something like the following will cause trouble in a block comment:
//*
//*    /* comments                          //
//*     * more comments                     //   */  (the // does not prevent the */ from ending
//*     * (no longer part of the comment)   //        block comment)
//*     */
//*
//*    Note: /* can appear in strings without triggering the start of a block comment
//*          /* cannot appear inside an operator (or verbname), since a line comment will
//*             start, although */ is allowed inside an operator (verbname).  Commenting
//*             out such a verbname may cause problems.
//*
//*    Note: Since string literals are not recognized in block comments, */ appearing
//*          in a string literal inside a block comment (perhaps commented-out code)
//*          will cause the block comment to end.
//*
//*    Note: It is an error to start a block comment and not end it, so that it is still
//*          in progresss when the end-of-file is reached.
//*
//*    Block comments can appear inside lines of code:
//*
/*1*/@VAR/*2*/v2/*3*/=/*4*/20/*5*/;/*6*/  // a line comment can follow block comments on the
                                           // same line

/[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
/[]                                                                                          []
/[]     Nestable Block Comments:                                                             []
 []
### ==================
                                                             []/
 []                                                                                          []/
 [][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]/

//[]
//[]  These start with /[ and end with the next matching ]/ .  Additional occurrences
//[]  of /[ ... ]/ can appear inside a nestable block comment.  The nestable block comment
//[]  will end only when the nest level reaches 0.  Note that /* is ignored inside a nestable
//[]  block comment, as are  */   //  and  /].
//[]
//[]  Nestable block comments can be used to comment out blocks of code containing line
//[]  comments or regular comments, and even balanced and well-formed nestable block comments.
//[]
//[]    Note: /[ can appear in strings without triggering the start of a block comment.
//[]          However, strings literals are not recognized inside a nestable block comment, so
//[]          any appearances of /[ and /] inside a string literal in a nestable block commment
//[]          will affect the nest level, and may cause problems.
//[]
//[]    Note: It is an error to start a nestable block comment and not end it, so that it is
//[]          still in progresss when the end of file is reached.
//[]
//[]    Nestable block comments can appear inside lines of code:
//[]
/[1]/@VAR/[2]/v3/[3]/=/[4]/30/[5]/;/[6]/  // a line comment can follow nestable block comments
                                          // on the same line

@SAY v1 v2 v3;                            // should see:   10 20 30

/]
/
### ===========================================================================================
\
|                                                                                                 |
|   /] starts a block comment that lasts until the end of the current file.  Everything after     |
|   the /] is ignored.                                                                            |
|                                                                                                 |
\
### ===========================================================================================
/

// Single line commment.

/*
   Multiple
   line
   comment.
*/

-- Single line commment in VHDL

let a = 4 " A valid comment
echo "foo" " Not a comment but an argument that misses the closing quote

'comment
Rem comment
#If 0
  Technically not a comment; the compiler may or may not ignore this, but the
  IDE won't. Note the somewhat odd formatting seen here; the IDE will likely
  just mark the entire line(s) as errors.
#End If

' This is a comment
REM This is also a comment
Dim comment as string ' You can also append comments to statements
Dim comment2 as string REM You can append comments to statements

// This is a comment
/* This is a comment */
* This is a comment
&& This is a comment
NOTE This is a commen

## Wart



```wart
# single-line comment

## Xojo



```VB

// Comments are denoted by a preceding double slash or or single quote
' and continue to the end of the line. There are no multi-line comment blocks
Dim foo As Integer // Comments can also occupy the ends of code lines

Text(0, \comment\ "Hello \not a comment\ World!"); \comment

 Text(0, "Hello World");  \comment
\Text(0, "Hello World"); \\comment

\\Text(0, \comment\ "Hello \not a comment\ World"); \comment

cond false;
Text(0, "Hello World"); \comment
CrLf(0);
cond true;

(: This is a XQuery comment :)

<!-- Comment syntax is borrowed from XML and HTML. -->

<!-- Comment syntax is borrowed from XML and HTML. -->

(* this is a comment *)
(*
   and this is a
   multiline comment
   (* with a nested comment *)
*)

// This is a normal comment in Zig
/// This is a documentation comment in Zig (for the following line)

x=1; // comment ala C++
x=2; # ala scripts
/* ala C, these comments are parsed (also ala C) */
/* can /* be */ nested */
#if 0
  also ala C (and parsed)
#endif
#<<<#
  "here" comment, unparsed
#<<<#