Hello world/Text: Difference between revisions
This version technically worked in the Waduzitdo web interpreter, but I'm sure some implementations require the stop run command S: so I finally gave the program a proper end
(This version technically worked in the Waduzitdo web interpreter, but I'm sure some implementations require the stop run command S: so I finally gave the program a proper end) |
|||
| (90 intermediate revisions by 51 users not shown) | |||
Line 44:
BR 14 Return
END
</syntaxhighlight>
=={{header|IBM Z HL/ASM}}==
Using Modern IBM Z High Level assembler to write 'Hello World' to the Unix System Services 'stdout' file descriptor
<syntaxhighlight lang="360 assembly">
PRINT ON,GEN,DATA
HELLO CSECT
HELLO RMODE ANY
HELLO AMODE 31
*
* Prolog
*
SAVE (14,12)
BASR R12,0
USING *,R12
STORAGE OBTAIN,LENGTH=DYNL,ADDR=(R11)
USING DYNAREA,R11
LA R2,DSA
ST R2,8(,R13)
ST R13,DSA+4
LR R13,R2
*
* Body
* Write Hello World to STDOUT
*
*
* Store values into parameter list
*
MVC REC(HWL),HW
LA R1,REC
ST R1,RECA
LA R1,HWL
ST R1,RECL
L R1,STDOUT
ST R1,FD
L R1,BPXALET
ST R1,ALET
CALL BPX1WRT,(FD, x
RECA, x
ALET, x
RECL, x
RV, x
RC, x
RN),MF=(E,BPXWRTD)
L R8,RV
L R9,RC
L R10,RN
*
* Epilog
*
L R13,DSA+4
STORAGE RELEASE,LENGTH=DYNL,ADDR=(R11)
RETURN (14,12),RC=0
*
* Statics, Dynamic Storage, Equates follows
*
* Naming convention:
* Suffixes:
* L : length
* S : static
* D : dynamic
* A : address
LTORG
*
* Statics (constants)
*
STDIN DC F'0'
STDOUT DC F'1'
STDERR DC F'2'
BPXALET DC F'0'
BPX1WRT DC V(BPX1WRT)
BPXWRTS CALL ,(0,0,0,0,0,0,0),MF=L
BPXWRTL EQU *-BPXWRTS
HW DC C'Hello World'
NEWLINE DC X'15'
HWL EQU *-HW
*
* Dynamic (storage obtain'ed) area
*
DYNAREA DSECT
*
* Dynamic Save Area regs always first
*
DSA DS 18F
*
* Working storage
*
FD DS F
RECSIZE EQU RECEND-*
REC DS CL80
RECEND EQU *
RECA DS A
BPXWRTD DS CL(BPXWRTL)
ALET DS F
RECL DS F
RV DS F
RC DS F
RN DS F
DYNL EQU *-DYNAREA
*
*
* End of working storage
*
*
* Equates
*
R0 EQU 0
R1 EQU 1
R2 EQU 2
R3 EQU 3
R4 EQU 4
R5 EQU 5
R6 EQU 6
R7 EQU 7
R8 EQU 8
R9 EQU 9
R10 EQU 10
R11 EQU 11
R12 EQU 12
R13 EQU 13
R14 EQU 14
R15 EQU 15
END
</syntaxhighlight>
Line 186 ⟶ 322:
<syntaxhighlight lang="lisp">(cw "Hello world!~%")</syntaxhighlight>
=={{header|Acornsoft Lisp}}==
Since there is no string data type in the language, a symbol (an identifier or 'character atom') must be used instead. When writing a symbol in source code, exclamation mark is an escape character that allows characters such as spaces and exclamation marks to be treated as part of the symbol's name. Some output functions will include exclamation mark escapes when outputting such symbols, and others, such as <code>printc</code>, will not.
<syntaxhighlight lang="lisp">(printc 'Hello! world!!)</syntaxhighlight>
The single quote in front of <code>Hello! world!!</code> makes it an expression that evaluates to the symbol itself; otherwise, it would be treated as a variable and its value (if it had one) would be printed instead.
=={{header|Action!}}==
Line 204 ⟶ 347:
=={{header|Agda}}==
For Agda 2.6.
<syntaxhighlight lang="agda">module
open import Agda.Builtin.IO using (IO)
Line 351 ⟶ 494:
mov r7, #1
swi 0</syntaxhighlight>
Alternative versions
<pre>
Developed on an Acorn A5000 with RISC OS 3.10 (30 Apr 1992)
Using the assembler contained in ARM BBC BASIC V version 1.05 (c) Acorn 1989
The Acorn A5000 is the individual computer used to develop the code,
the code is applicable to all the Acorn Risc Machines (ARM)
produced by Acorn and the StrongARM produced by digital.
In the BBC BASIC part of the program I have included:
OS_WriteC = &00
OS_WriteO = &02
OS_NewLine = &03
this is so I can write SWI OS_WriteC etc instead of SWI &0 to make the assembler more legible
(a) method1 - output the text character by character until the terminating null (0) is seen
.method1_vn00
ADR R8 , method1_string \ the ARM does not have an ADR instruction
\ the assembler will work out how far the data item
\ is from here (in this case a +ve relative offset)
\ and so will produce an ADD R8 , PC, offset to method1_string
\ a magic trick by the ARM assembler
.method1_loop
LDRB R0 , [R8], #1 \ load the byte found at address in R8 into R0
\ then post increment the address in R8 in preparation
\ for the next byte (the #1 is my choice for the increment)
CMP R0 , #0 \ has the terminating null (0) been reached
SWINE OS_WriteC \ when not the null output the character in R0
\ (every opportunity to have a SWINE in your program should be taken)
BNE method1_loop \ go around the loop for the next character if not reached the null
SWI OS_NewLine \ up to you if you want a newline
MOVS PC , R14 \ return
\ when I call an operating system function it no longer operates
\ in 'user mode' and it has its own R14, and anyway the operating system
\ is too polite to write rubbish into this return address
.method1_string
EQUS "Hello world!" \ the string to be output
EQUB &00 \ a terminating null (0)
ALIGN \ tell the assembler to ensure that the next item is on a word boundary
(b) method2 - get the supplied operating system to do the work
.method2_vn00
ADR R0 , method2_string \ the ARM does not have an ADR instruction
\ the assembler will work out how far the data item
\ is from here (in this case a +ve relative offset)
\ and so will produce an ADD R0 , PC, offset to method2_string
\ a magic trick by the ARM assembler
SWI OS_WriteO \ R0 = pointer to null-terminated string to write
SWI OS_NewLine \ up to you if you want a newline
MOVS PC , R14 \ return
.method2_string
EQUS "hELLO WORLD!" \ the string to be output
EQUB &00 \ a terminating null (0)
ALIGN \ tell the assembler to ensure that the next item is on a word boundary
</pre>
=={{header|ArnoldC}}==
Line 374 ⟶ 588:
=={{header|Asymptote}}==
<syntaxhighlight lang="asymptote">write('Hello world!');</syntaxhighlight>
=={{header|Atari BASIC}}==
<syntaxhighlight lang="Atari BASIC">10 PRINT "Hello World"</syntaxhighlight>
=={{header|ATS}}==
Line 450 ⟶ 666:
<syntaxhighlight lang="babel">"Hello world!" <<</syntaxhighlight>
=={{header|BabyCobol}}==
<syntaxhighlight lang="cobol">
* Since no quotes are used, two undeclared fields (variables) are printed.
* Their default values are their own names in uppercase.
IDENTIFICATION DIVISION.
PROGRAM-ID. USER OUTPUT.
PROCEDURE DIVISION.
DISPLAY HELLO WORLD.
</syntaxhighlight>
=={{header|Bait}}==
<syntaxhighlight lang="bait">fun main() {
println('Hello World!')
}</syntaxhighlight>
=={{header|Ballerina}}==
Line 463 ⟶ 694:
=={{header|BASIC}}==
{{works with|BASICA}}
{{works with|Chipmunk Basic}}
{{works with|Commodore BASIC}}
{{works with|GW-BASIC}}
{{works with|IS-BASIC}}
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
{{works with|Locomotive Basic}}
{{works with|M2000 Interpreter}}
{{works with|MSX BASIC}}
{{works with|QBasic}}
{{works with|Quite BASIC}}
{{works with|Run BASIC}}
{{works with|Tiny BASIC}}
{{works with|ZX Spectrum Basic}}
<syntaxhighlight lang="qbasic">10 print "Hello world!"</syntaxhighlight>
{{works with|7Basic}}
{{works with|Applesoft BASIC}}
{{works with|BaCon}} [[Category:BaCon]]
{{works with|
{{works with|FreeBASIC}}
{{works with|IS-BASIC}}
{{works with|M2000 Interpreter}}
{{works with|QBasic}}
{{works with|QB64}}
{{works with|Script Basic}}
{{works with|SmallBASIC}}
{{works with|Yabasic}}
<syntaxhighlight lang="qbasic">PRINT "Hello world!"</syntaxhighlight>
Line 552 ⟶ 800:
=={{header|Binary Lambda Calculus}}==
As explained at https://www.ioccc.org/2012/tromp/hint.html
<
=={{header|Bird}}==
Line 612 ⟶ 860:
=={{header|bootBASIC}}==
<syntaxhighlight lang="
=={{header|BQN}}==
Line 723 ⟶ 971:
<syntaxhighlight lang="brlcad">
echo Hello world!
</syntaxhighlight>
=={{header|Bruijn}}==
Ignore stdin by not referring to the abstraction:
<syntaxhighlight lang="bruijn">
main ["Hello world!"]
</syntaxhighlight>
Line 796 ⟶ 1,052:
<syntaxhighlight lang="cpp">#include <iostream>
int main
std::cout << "Hello world!\n"
}</syntaxhighlight>
Since C++23’s addition of the <code><print></code> header and the standard library module <code>std</code> we could now write this:
<syntaxhighlight lang="cpp">import module std; // here does the same thing as #include <print>
int main() {
std::print("Hello world!\n");
}</syntaxhighlight>
Line 829 ⟶ 1,091:
<syntaxhighlight lang="c3">import std::io;
fn
{
io::
}</syntaxhighlight>
Line 899 ⟶ 1,160:
Serves 1.</syntaxhighlight>
=={{header|Chipmunk Basic}}==
<syntaxhighlight lang="qbasic">10 print "Hello world!"</syntaxhighlight>
=={{header|ChucK}}==
Line 1,054 ⟶ 1,318:
=={{header|Craft Basic}}==
<syntaxhighlight lang="basic">print "Hello
=={{header|Creative Basic}}==
Line 1,075 ⟶ 1,339:
=={{header|Crystal}}==
<syntaxhighlight lang="ruby">puts "Hello world!"</syntaxhighlight>
=={{header|Curto}}==
<syntaxhighlight lang="curto">." Hola, mundo!"</syntaxhighlight>
=={{header|D}}==
Line 1,243 ⟶ 1,510:
showln "Hello world!"
</syntaxhighlight>
=={{header|DreamBerd}}==
<syntaxhighlight lang="text">
print "Hello world!"!
</syntaxhighlight>
=={{header|dt}}==
<syntaxhighlight lang="dt">"Hello world!" pl</syntaxhighlight>
=={{header|DWScript}}==
Line 1,299 ⟶ 1,574:
=={{header|EasyLang}}==
<syntaxhighlight lang="text"
print "Hello world!"
</syntaxhighlight>
=={{header|eC}}==
Line 1,321 ⟶ 1,598:
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module HelloWorld {
void run() {
@Inject Console console;
console.print("Hello, World!");
}
</syntaxhighlight>
=={{header|EDSAC order code}}==
Line 1,447 ⟶ 1,724:
=={{header|Elena}}==
ELENA
<syntaxhighlight lang="elena">public program()
{
console.writeLine
}</syntaxhighlight>
Line 1,479 ⟶ 1,756:
😀 🔤Hello world!🔤
🍉</syntaxhighlight>
=={{header|Enguage}}==
This shows "hello world", and shows how Enguage can generate this program on-the-fly.
<pre>
On "say hello world", reply "hello world".
## This can be tested:
#] say hello world: hello world.
## This can also be created within Enguage:
#] to the phrase hello reply hello to you too: ok.
#] hello: hello to you too.
</pre>
Output:
<pre>
TEST: hello
===========
user> say hello world.
enguage> hello world.
user> to the phrase hello reply hello to you too.
enguage> ok.
user> hello.
enguage> hello to you too.
1 test group(s) found
+++ PASSED 3 tests in 53ms +++
</pre>
=={{header|Erlang}}==
Line 1,723 ⟶ 2,030:
=={{header|GLBasic}}==
<syntaxhighlight lang="glbasic">STDOUT "Hello world!"</syntaxhighlight>
=={{header|Gleam}}==
<syntaxhighlight lang="gleam">
import gleam/io
pub fn main() {
io.println("Hello world!")
}
</syntaxhighlight>
=={{header|Glee}}==
Line 1,820 ⟶ 2,136:
=={{header|Hoon}}==
<syntaxhighlight lang="hoon">~& "Hello world!" ~</syntaxhighlight>
=={{header|Hopper}}==
<syntaxhighlight lang="csharp">program Hello
{
uses "/Source/Library/Boards/PiPico"
Hopper()
{
WriteLn("Hello world!");
loop
{
LED = !LED;
Delay(500);
}
}
}</syntaxhighlight>
{{out}}
In IDE, build hello.hs into hello.hexe, (press F7) and start debug (F5) or hm console monitor.
<pre>!> hello
Hello world!
</pre>
The language and runtime install verification message shows up on the monitor console. In keeping with most MCU introductions, the onboard Light Emitting Diode (LED) will then blink on and off at 1/2 second intervals, forever; ''(until power runs out, or explicit operator intervention)''.
=={{header|HPPPL}}==
Line 1,884 ⟶ 2,223:
stdout.print('Hello, world!')</syntaxhighlight>
=={{header|Insitux}}==
<syntaxhighlight lang="insitux">(print "Hello, world!")</syntaxhighlight>
=={{header|Intercal}}==
Line 2,083 ⟶ 2,424:
| |
+---------------+</syntaxhighlight>
=={{header|Jai}}==
<syntaxhighlight lang="jai">
#import "Basic";
main :: () {
print("Hello, World!\n");
}
</syntaxhighlight>
=={{header|Jakt}}==
<syntaxhighlight lang="jakt">
fn main() {
println("Hello world!")
}
</syntaxhighlight>
=={{header|Janet}}==
Line 2,193 ⟶ 2,550:
<syntaxhighlight lang="kitten">"Hello world!" say</syntaxhighlight>
=={{header|KL1}}==
<syntaxhighlight lang="prolog>
:- module main.
main :-
unix:unix([stdio(normal(S))]),
S = [fwrite("Hello world\n")].
</syntaxhighlight>
=={{header|Koka}}==
Line 2,198 ⟶ 2,564:
println("Hello world!")
}</syntaxhighlight>
Alternatively:
- indentation instead of braces
- uniform function call syntax
- omitted parentheses for function calls with no parameters
<syntaxhighlight lang="koka">fun main()
"Hello world!".println
</syntaxhighlight>
=={{header|KonsolScript}}==
Line 2,235 ⟶ 2,613:
=={{header|langur}}==
<syntaxhighlight lang="langur">writeln "
=={{header|Lasso}}==
Line 2,279 ⟶ 2,657:
<syntaxhighlight lang="lean">
#eval "Hello world!"
</syntaxhighlight>
Slightly longer version:
<syntaxhighlight lang="lean">
def main : IO Unit :=
IO.println ("Hello world!")
#eval main
</syntaxhighlight>
Line 2,550 ⟶ 2,936:
=={{header|Malbolge}}==
'''Long version:'''
<syntaxhighlight lang="malbolge">('&%:9]!~}|z2Vxwv-,POqponl$Hjig%eB@@>}=<M:9wv6WsU2T|nm-,jcL(I&%$#"
Line 2,579 ⟶ 2,964:
Hello world!
</syntaxhighlight>
=={{header|Mastermind}}==
<syntaxhighlight lang="mastermind">output "Hello world!\n";</syntaxhighlight>
=={{header|Mathcad}}==
Line 2,647 ⟶ 3,035:
=={{header|min}}==
<syntaxhighlight lang="min">"Hello world!" puts</syntaxhighlight>
=={{header|Minimal BASIC}}==
<syntaxhighlight lang="qbasic">10 PRINT "Hello world!"
20 END</syntaxhighlight>
=={{header|MiniScript}}==
Line 2,656 ⟶ 3,048:
</syntaxhighlight>
{{out}}
<pre>Hello World
----------</pre>
=={{header|MIPS Assembly}}==
Line 2,739 ⟶ 3,129:
Or just:
<syntaxhighlight lang="mosaic">
println "Hello, world"</syntaxhighlight>
=={{header|MSX Basic}}==
<syntaxhighlight lang="qbasic">10 PRINT "Hello world!"</syntaxhighlight>
=={{header|MUF}}==
Line 2,873 ⟶ 3,265:
Using <code>PRINT</code>:
<syntaxhighlight lang="ns-hubasic">10 PRINT "HELLO WORLD!"</syntaxhighlight>
=={{header|Nu}}==
<syntaxhighlight lang="nu">
print "Hello world!"
</syntaxhighlight>
=={{header|Nutt}}==
<syntaxhighlight lang="Nutt">
module hello_world
imports native.io.output.say
say("Hello, world!")
end
</syntaxhighlight>
=={{header|Nyquist}}==
Line 2,911 ⟶ 3,318:
}
}</syntaxhighlight>
=={{header|ObjectIcon}}==
<syntaxhighlight lang="objecticon">
import io
procedure main ()
io.write ("Hello world!")
end
</syntaxhighlight>
{{out}}
<pre>$ oiscript hello-OI.icn
Hello world!</pre>
=={{header|Objective-C}}==
Line 2,989 ⟶ 3,409:
=={{header|Onyx}}==
<syntaxhighlight lang="onyx">`Hello world!\n' print flush</syntaxhighlight>
=={{header|Onyx (wasm)}}==
<syntaxhighlight lang="TS">
use core {printf}
main :: () {
printf("Hello world!");
}
</syntaxhighlight>
{{out}}
<pre>
Hello world!
</pre>
=={{header|OOC}}==
Line 3,024 ⟶ 3,456:
linear_extrude(height=10) text("Hello world!"); // creates 3D text in the object space
</syntaxhighlight>
=={{header|Owl Lisp}}==
<syntaxhighlight lang="scheme">
(print "Hello world!")
</syntaxhighlight>
{{out}}
<pre>$ ol hello-Owl.scm
Hello world!</pre>
=={{header|Oxygene}}==
From [[wp:Oxygene (programming language)]]
<syntaxhighlight lang="
namespace HelloWorld;
Line 3,047 ⟶ 3,489:
end.
</syntaxhighlight>
{{out}}
<pre>
Hello world!
</pre>
Line 3,328 ⟶ 3,770:
#FINISH
#STOP</syntaxhighlight>
=={{header|Pointless}}==
<syntaxhighlight lang="pointless">
output = println("Hello world!")
</syntaxhighlight>
=={{header|Pony}}==
Line 3,543 ⟶ 3,990:
=={{header|RED}}==
<syntaxhighlight lang="red">print "Hello world!"</syntaxhighlight>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <Prout 'Hello, world!'>;
};</syntaxhighlight>
=={{header|Relation}}==
Line 3,580 ⟶ 4,032:
call lineout ,"Hello world!"</syntaxhighlight>
=={{header|Rhovas}}==
<syntaxhighlight lang="360 assembly">
print("Hello world!");
</syntaxhighlight>
=={{header|Ring}}==
Line 3,609 ⟶ 4,067:
=={{header|Rockstar}}==
<syntaxhighlight lang="rockstar">Shout "Hello world!"</syntaxhighlight>
=={{header|RPG}}==
<nowiki>**</nowiki>free<br>
dsply 'Hello World!';
=={{header|RPL}}==
≪ "Hello world!" 1 DISP
1 FREEZE <span style="color:grey">@ remove this line on HP-28 models</span>
≫ '<span style="color:blue">TASK</span>' STO
=={{header|RTL/2}}==
Line 3,822 ⟶ 4,289:
"Hello world!"
end function</syntaxhighlight>
=={{header|Skew}}==
{{works with|skewc|0.9.19}}
<syntaxhighlight lang="skew">
@entry
def main {
dynamic.console.log("Hello world!")
}
</syntaxhighlight>
=={{header|SkookumScript}}==
Line 3,833 ⟶ 4,310:
=={{header|Slope}}==
<syntaxhighlight lang="slope">(write "Hello, world!")</syntaxhighlight>
=={{header|SmallBASIC}}==
<syntaxhighlight lang="smallbasic">PRINT "Hello world!"</syntaxhighlight>
=={{header|Smalltalk}}==
Line 3,863 ⟶ 4,343:
| \@@@@=+++++# | \===--------!\===!\-----|-------#-------/
\@@+@@@+++++# \!#+++++++++++++++++++++++#!/</syntaxhighlight>
=={{header|Soda}}==
<syntaxhighlight lang="soda">
class Main
main (arguments : Array [String] ) : Unit =
println ("Hello world!")
end
</syntaxhighlight>
=={{header|SoneKing Assembly}}==
Line 3,975 ⟶ 4,465:
'hello world' []
</syntaxhighlight>
=={{header|TailDot}}==
<syntaxhighlight lang=taildot>c,x,Hello World!,v,x</syntaxhighlight>
=={{header|Tailspin}}==
<syntaxhighlight lang="tailspin">'Hello World' -> !OUT::write</syntaxhighlight>
Line 4,020 ⟶ 4,511:
<syntaxhighlight lang="testml">%TestML 0.1.0
Print("Hello world!")</syntaxhighlight>
=={{header|TI-57}}==
0.7745
You must then turn the calculator upside down to read the text: [https://aerobarfilms.files.wordpress.com/2023/04/ti-57-hello-world-1.jpg screenshot]
=={{header|TI-83 BASIC}}==
Line 4,034 ⟶ 4,529:
20 END
</syntaxhighlight>
=={{header|TMG}}==
Line 4,121 ⟶ 4,611:
main = <file[contents: -[Hello world!]-]>!</syntaxhighlight>
=={{header|Ursalang}}==
<syntaxhighlight lang="ursa">print("hello woods!")</syntaxhighlight>
=={{header|உயிர்/Uyir}}==
Line 4,128 ⟶ 4,621:
முதன்மை = 0;
}};</syntaxhighlight>
=={{header|Uxntal}}==
<syntaxhighlight lang="Uxntal">
( hello-world.tal )
|00 @System [ &vector $2 &wst $1 &rst $1 &eaddr $2 &ecode $1 &pad $1 &r $2 &g $2 &b $2 &debug $1 &halt $1 ]
|10 @Console [ &vector $2 &read $1 &pad $5 &write $1 &error $1 ]
( program )
|0100 @on-reset ( -> )
;hello print-str
HALT
BRK
@print-str ( str* -- )
&while
LDAk .Console/write DEO
INC2 LDAk ?&while
POP2
JMP2r
@HALT ( -- )
#01 .System/halt DEO
JMP2r
@hello "Hello 20 "world! 0a 00
</syntaxhighlight>
=={{header|V}}==
Line 4,136 ⟶ 4,655:
stdout.printf("Hello world!\n");
}</syntaxhighlight>
=={{header|Vale}}==
{{works with|Vale|0.2.0}}
<syntaxhighlight lang="vale">
import stdlib.*;
exported func main() {
println("Hello world!");
}
</syntaxhighlight>
=={{header|VAX Assembly}}==
Line 4,147 ⟶ 4,676:
.end hello ;transfer address for linker
</syntaxhighlight>
=={{header|VBA}}==
Line 4,247 ⟶ 4,775:
=={{header|VTL-2}}==
<syntaxhighlight lang="vtl-2">10 ?="Hello world!"</syntaxhighlight>
=={{header|Waduzitdo}}==
<syntaxhighlight lang="waduzitdo">T:Hello world!
S:</syntaxhighlight>
=={{header|Wart}}==
Line 4,327 ⟶ 4,858:
=={{header|Wren}}==
<syntaxhighlight lang="
=={{header|X10}}==
Line 4,470 ⟶ 5,001:
<syntaxhighlight lang="yabasic">
print "Hello world!"
</syntaxhighlight>
=={{header|YAMLScript}}==
All the following examples are valid YAML and valid YAMLScript.
This is a good example of various ways to write function calls in YAMLScript.
Since function calls must fit into their YAML context, which may be mappings or scalars;
it is actually useful to support these variants.
<syntaxhighlight lang="yaml">
!yamlscript/v0
say: "Hello, world!"
=>: (say "Hello, world!")
=>: say("Hello, world!")
say:
=>: "Hello, world!"
say: ("Hello, " + "world!")
say: ."Hello," "world!"
say "Hello,": "world!"
say "Hello," "world!":
</syntaxhighlight>
Line 4,503 ⟶ 5,064:
=={{header|Zig}}==
'''Works with:''' 0.10.x, 0.11.x, 0.12.0-dev.1389+42d4d07ef
<syntaxhighlight lang="zig">const std = @import("std");
pub fn main() std.fs.File.WriteError!void {
const stdout = std.io.getStdOut();
try stdout.writeAll("Hello world!\n");
}</syntaxhighlight>
| |||