You are encouraged to solve this task according to the task description, using any language you may know.

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

•   Wikipedia
•   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 }


\ This is a Rapira comment.

## Raven

 # this is a comment

## REBOL

; This is a line comment.

{ Multi-line strings can
if you like }


Functions have special commenting options which make them self documenting:

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


If you say "help plus2" at REBOL's REPL, you'll get this help information:

   USAGE:
PLUS2 n

DESCRIPTION:
PLUS2 is a function value.

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


## Relation

// This is a valid comment
// A space is needed after the double slash

## Retro

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

## REXX

It should be noted that comments in the REXX language support nested comments, so comments aren't totally ignored by the REXX interpreter (and compiler).

REXX comments are scanned and preserved for use by the   sourceline   BIF.   [The   sourceline   BIF allows the retrieval of any or all lines of source (of the REXX program).]

Also, redundant blanks are removed and processed/shown for various   trace   options   (trace   is a REXX statement that may show various interpretation/execution stages of REXX statements (clauses, values, etc.),   including comments and also blank lines).   The   trace   statement is also used for interactive debugging.

Nested comments must have matching delimiters, so the contents of the comments can't just be willy-nilly characters.

Also, some REXX interpreters show the comment (if part of a REXX statement) as part of the information displayed when (if) a   syntax   error occurs and an informative error message is generated.   For instance, in the program   (named c:\COMMENTD.REX):

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


output   when using the Regina REXX interpreter:'

     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


output   when using the R4 REXX interpreter:'

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


output   when using the Personal REXX interpreter:'

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


The REXX language was heavily modeled after PL/I, both languages have the same comment construct, but PL/I doesn't support nested comments.

Nested comments allow an easy way to comment large chunks of code where the commented-out code has its own comments.

/*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 Classic REXX implementation (e.g. Regina) also allow line comments which start with a   --   sequence and extend to the end of the line:

[Note:   Regina REXX releases since 3.4 allow this type of single-line comment only if the option Single_Line_comments isn't present in the REGINA_OPTIONS environmental variable.   So, Regina may allow the use of single-line comments,   depending upon which release is being used.   That is to say, one can't depend (or assume) that the Regina extension (of single-line comments) for the aforementioned option will be or not be present (supported and/or allowed) in the environment being used].   Which means one could set this option to their preference if using Regina REXX later than version 3.3.

Since Single-Line comments aren't part of the ANSI standard nor a part of the Classic REXX language, the use of which would make the REXX code non-portable.]

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


It should be noted that the above type of comments are not part of Classic REXX, nor are they described nor sanctioned in the REXX ANSI standard.

## Ring

in Ring language we can use // or # for one line comments:

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

and for multi-line comments we use /* */:

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

## RLaB

RLaB only has single line comment indicator, as in following examples

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

## Robotic

Comments can only be created in one way:

. "This is a comment line"

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

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

Although these are comments, the interpreter doesn't completely ignore it. For one, the code speed can be affected if they are ever encountered. Also, if an @ character exists at the beginning of the comment line, then the rest of the string after it is now the Robot's new name (there is a 14 character limit).

Example of changing the robot's name:

. "@NewRobotName"

This would then change the robot's name from whatever it was before to "NewRobotName" instead.

## Ruby

x = "code" # I am a comment

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


## Run BASIC

Comments have a ' (single quote) or REM for remarks

'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

## Rust

// 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.

/**

*  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.

/*!
*/
}

#[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)
}


## SAS

/* comment */

*another comment;

* both
may
be
multiline;


## Sather

-- a single line comment

## Scala

// A single line comment

/* A multi-line
comment */


## 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


## Scilab

Specify a comment starting with // to the end of line

// this is a comment
i=i+1 // this is a comment


## sed

# a single line comment


## Seed7

# A single line comment

(* A multi-line
comment *)

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

## SenseTalk

#   Hashtag is a comment
--  Dash dash is another comment
//  Slash slash is yet another comment
—   Alt/Option + Underscore creates an m-dash comment
(*  Parentheses and star is used for commenting
blocks of code (* and can be nested *) *)
set foo to true // all comments can append to statements

## Set lang

> Comments start where a > (greater than symbol) starts
set a 0 > Comments may start after a Set command

## SETL

print("This is not a comment"); -- This is a comment
$For nostalgic reasons, this is also a comment. ## Sidef Single line comment # this is commented  These may also be at the end of a line var i = 1; # this is the comment part  Embedded comments var distance #{in meters} = (30 #{meters} * 100 #{seconds}); say distance; # prints: 3000  Multi-line comments /* This is a multi-line comment */  ## Simula The same as Algol 60: COMMENT This is a comment for Simula 67;  And an new form: !This is a comment for Simula 67;  Pitfall: it's not easy to comment-out parts of code: !OutText("Dying."); !Outimage; !terminate_program; ## Slate "basically the same as smalltalk" ## 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."  ## smart BASIC 'Single line comments are preceded by a single quote or the command REM PRINT "Hello" 'Single line comments may follow code PRINT "Hello" REM You can also use the command REM following code /* Multi-line comments are surrounded by mirrored slash and asterisk */ /*Multi-line comments do not have to actually have multiple lines*/ /* Spaces before or after comment bounds are optional.*/ /* A comment can also follow another comment */ 'Like this Some programmers like to do this to allow for /* Procedural comments */ followed by 'Programmer's notes.  ## 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. ## SNUSP As with Brainf*** and Befunge, any character that is not part of the language is ignored and can be used as commentary, and you can add comments anywhere the instruction pointer is not expected to traverse. Reserved characters are: • Core: + - > < , . ? ! / \$ #
• Modular: @ #
• Bloated: : ; & %

As a matter of convention, the characters '=' and '|' are used for spacing to indicate horizontal and vertical flow of control, respectively.

## SPL

'This is single-line comment

''This is
multiline comment''

## SQL

The double hyphen ( -- ) is used to include a comment on an SQL statement.

The comment appears on the same line as the statement:

SELECT * FROM mytable -- Selects all columns and rows


or before:

-- Selects all columns and rows
SELECT * FROM mytable


or after:

SELECT * FROM mytable
-- Selects all columns and rows


## SQL PL

Works with: Db2 LUW

Single line comment:

--This is a single line comment.

Multiline comment:

/* This is
a multiline
comment */

Another way to do multiline comments

(= This is
a multiline
comment =)

End of line comment:

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

Comments work the same as in SQL.

## Squirrel

//this is a single line comment

#this is also a single line comment

/*
this is a multi-line comment
*/

## SSEM

The SSEM can only be programmed in pure binary, by setting front panel switches: the concepts of "text" and "source file" (both mentioned in the specification) are therefore not directly applicable to it. If binary numbers have any mnemonic or explanatory value for you, however, there is a way of including information in your program that the computer will ignore. This is a direct result of the machine's rather poor code density. Each 32-bit instruction word consists of (a) a five-bit address field giving the operand, (b) eight unused bits, (c) a three-bit instruction field giving the operation to be performed, and (d) sixteen more unused bits. If the instruction field is set to 011 Test or 111 Stop, even the address field is unused. In the case of a Sub. instruction, finally, the leftmost bit of the instruction field is disregarded: 001 and 101 both mean "subtract". We therefore have at least 24 and sometimes 25 or 29 bits in each instruction that we can, if we like, use for comments. The word

00101010010001000100100100001100

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

00101 -- address field = 20

01001 -- "comment" field = 18

000 -- three unused bits

100 -- instruction field = Add to CI

01001 -- "comment" field = 18

00100 -- "comment" field = 4

01100 -- "comment" field = 12

0 -- 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

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


## Stata

* 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

*/


## SuperTalk

-- This is a comment

## Swift

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

///This is a documentation comment

/**
This is a documentation block comment
*/


## Symsyn

| This is a comment

## Tcl

Tcl follows the usual scripting language rules: a comment starts at a "#" symbol, which can be placed after a command if that is terminated by a semicolon:

# 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


The reason for the need for a semi-colon on a trailing comment is this:

"If a hash character (“#”) appears at a point where Tcl is expecting the first character of the first word of a command, then the hash character and the characters that follow it, up through the next newline, are treated as a comment and ignored. The comment character only has significance when it appears at the beginning of a command." (from the Tcl man page -- emphasis mine)

The "#" symbol has no special meaning if it is not where a command would appear -- it's just data. (Syntax highlighters often get this wrong.)

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


TCL has no native multi-line comment format. However, in most circumstances, a multi-line comment can be faked by wrapping it within a block that will never be executed:

if 0 {
}


See Java

## TI-83 BASIC

There is no 'proper' way of adding comments in TI-BASIC, however there are ways to add text to a program that will be ignored by the calculator.

One common approach is to put the comment in a string which is not stored anywhere:

:"THIS IS A COMMENT

However this will change the Ans variable.

This approach, while messier, does not affect the Ans variable:

:If 0
:THIS IS A COMMENT

## TI-89 BASIC

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

## Tiny BASIC

10 REM this is a comment
20

40 REM from above you can see that line numbers with no statement
50 REM and blank lines also are ignored

## Toka

There are two ways to add comments in Toka. For full lines, or at the end of a line, the shebang is normally used:

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

The shebang comments can not be used inside of functions.

In addition, Toka also accepts parenthetical comments. These are enclosed in parenthesis, and are often used for stack comments or comments inside functions.

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

( This is a
simple, multi-line
comment )

Since comments are provided by actual functions, the comment function must be whitespace delimited, just as with all other functions in Toka.

A final way to include text in a file is to mark a false ending with end.

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

## TorqueScript

//This is a one line comment. There are no other commenting options in TorqueScript.

## TPP

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

## Transd

// This is a line comment.
/* This is a single line block comment.*/
/* This is
a multi-line
block comment.*/


## TUSCRIPT

 MODE TUSCRIPT
- This is a comment

## TXR

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

## UNIX Shell

Works with: Bourne Shell
Works with: Korn Shell
#!/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


### C Shell

#!/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.


### es

# 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.

## Unlambda

Unlambda comments start with # and extend to the end of the line:

# this is a comment.


Note that comments don't need to start at the beginning of a line, e.g.

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


is equivalent to

.ai


## Ursa

Comments in Ursa must be on a single line, and are denoted by a #

# this is a comment
# this is another comment

## Ursala

There are lots of ways to have comments in Ursala. Here are the conventional ones.

# 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.

### Commenting out code

There are also ways to comment out sections of code during testing. An individual item of a syntactically correct list or aggregate is commented out like this.

x = <1,## 2,3>

The 2 is ignored but 1 and 3 aren't. This also works with nested aggregates and multiple lines.

a =

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

A syntactically correct declaration can be commented out like this.

foo = 1

##

bar = 2

baz = 3

As far as the compiler is concerned, bar is not defined, but foo and baz are. It wouldn't matter if bar took multiple lines.

The compiler can be directed to embed comments in executable files and libraries it generates without affecting their semantics.

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

#comment gpl'3'

The latter comment puts the standard GPL license notification in the output file.

A function f annotated with a crash dump wrapper expressed like this during debugging

my_input_type%C f

is equivalent to just f when changed to this in the production code.

my_input_type%Ck f

Compiling with the --depend command line option makes the compiler only scan for the #depend'ed expressions and send them to standard output.

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

This way, scripts and source management tools can have information passed to them from the programmer by running the compiler instead of re-implementing their own parsers.

## VBA

A comment starts with a quote (') and it ends at end of line

' This is a VBA comment


## VBScript

A comment starts with a quote (') and it ends at end of line

' This is a VBScript comment


## Verbexx

//////////////////////////////////////////////////////////////////////////////////////////////
//
// =============
//
@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
//
/////////////////////////////////////////////////////////////////////////////////////////////

/********************************************************************************************
*
*  ==============
*
********************************************************************************************/
//*
//*  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:
//*
//*     * 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:
//*
// same line

/[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
/[]                                                                                          []
[]     ========================                                                             []/
[]                                                                                          []/
[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]/

//[]
//[]  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
//[]
//[]    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:
//[]
// 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.                                                                            |
|                                                                                                 |
\=================================================================================================/

## Verilog

// Single line commment.

/*
Multiple
line
comment.
*/


## VHDL

-- Single line commment in VHDL


## Vim Script

All lines starting with " are comments and will be ignored.

In most cases, " will also work after a command (i.e. the rest of the line will be ignored). But some commands like echo treat the whole line as their argument and thus will raise an error (Missing quote).

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


## Visual Basic

In addition to the methods mentioned in BASIC above, it is also somewhat common to effectively comment out code by including the unwanted code inside an #If 0 ... #End If block. (This works because 0 evaluates to False in VB.) Note, however, that the IDE will complain about actual comments inside an #If 0 block unless it's also commented normally (i.e., using Rem or ').

'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


## Visual Basic .NET

Visual Basic .NET uses the "'" symbol or "REM" to mark it's comments. After placing a "'", or "REM", everything in that line will be ignored.

' 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


## Visual Objects

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


## Vlang

// This is a single line comment.
/*
This is a multiline comment.
/* It can be nested. */
*/


## Vorpal

# single line comment

## Wart

# single-line comment

## Wren

// This is a line comment.
/* This is a single line block comment.*/
/* This is
a multi-line
block comment.*/
/* This is/* a nested */block comment.*/


## X10

All text included within the ASCII characters “/*” and “*/” is considered a comment and ignored; nested comments are not allowed.

All text from the ASCII characters “//” to the end of line is considered a comment and is ignored.

// This is a single line comment

/*
This comment spans
multiple lines
*/


## XLISP

; this is a comment

## Xojo

// 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


## XPL0

Comments are enclosed in backslash characters, but the end of a line always terminates a comment. Consequently there is no multi-line comment. For example:

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

Since backslashes toggle comments on and off, it could be inconvenient to comment out a line of code that contains a comment. For example, two additional backslashes could be used to comment out this line, as shown here:

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

However, two backslashes together comment out everything to the end of the line regardless of any backslashes the line might contain. So the first example could be commented out like this:

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

Conditional compilation can be used to effectively comment out multiple lines of code. For example:

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

## XQuery

(: This is a XQuery comment :)


## XSLT

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


## XUL

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

## Yacas

// This is a single line comment
/*
This comment spans
multiple lines
*/

## Z80 Assembly

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

 ld hl,&8000  ;This is a comment


## zig

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


## zkl

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
#<<<#

## Zoea

program comments        # this program does nothing

# zoea supports single line comments starting with a '#' char

/*
zoea also supports
multi line
*/
(* this is a comment *)
*)