Strings

main:
  print "String with \"quotes\"."  // >> String with "quotes".
  print "Zig zag string /\\/\\."   // >> Zig zag string /\/\.

main:
  print """String with "quotes"."""  // >> String with "quotes".

  // For two-digit code points (runes).
  // using \x, the curly braces are optional.
  s1 /string := "S\xf8en s\x{e5} s\u{00e6}r ud."
  print s1  // >> Søen så sær ud.

  // For four-digit values you can either use \x with curly
  // braces or \u.
  s2 /string := "\u{20ac} \u20ac \x{20ac}"
  print s2  // Prints "€ € €", which is Unicode 0x20ac.

  // The \u version can also be used with curly braces.
  // It is in fact necessary for 5-digit Unicode runes.
  s3 /string := "\u{1f648}"
  print s3  // Prints the see-no-evil-monkey emoji.

  // \x{} is recommended for one or two digits, and \u{} is
  // recommended for three to five digits.

  // The same escapes work in character literals.
  c /int := '\x2a'
  print c  // Prints "42", which is the decimal from of 0x2a.

  c2 /int := '\''
  print c2 // Prints "39", the ASCII code for a single quote.

  print "Hello!".size  // Prints "6", the number of bytes.
  print "Hellö!".size  // Prints "7", the number of bytes.

  print "Hello!"[0]  // Prints "72", the ASCII code for 'H'.
  print "Hellö!"[4]  // Prints "246", the Unicode code point for 'ö'.

  print "€2".size  // Prints "4", the number of bytes in the string.
  print "€2"[0]    // Prints "8364", the Unicode code for '€'.
  print "€2"[1]    // Prints "null", no character starts at byte index 1.
  print "€2"[2]    // Prints "null", no character starts at byte index 2.
  print "€2"[3]    // Prints "50", the ASCII code for '2'.

  STR ::= "£2.24"
  for i := 0; i < STR.size; i++:
    ch := STR[i]
    if ch:  // Only handle non-null.
      print ch

  STR ::= "£2.24"
  STR.do --runes:
    print it

  // The following examples use the #[...] syntax for
  // byte array literals.
  // Create a single-character string containing an 'A':
  s1/string := #[65].to-string
  // Create a string with the word "Hello":
  s2/string := #[72, 101, 108, 108, 111].to-string
  // Null characters are allowed in strings:
  s3/string := #[0].to-string
  // Bytes above 127 are part of multi-byte UTF-8 sequences
  // and cannot stand alone:
  s4/string := #[128].to-string // Error: Not legal UTF-8!
  s5/string := #[0xc0, 0xbb].to-string // Error: Overlong encoding!

  // Print all 10 UTF-8 bytes in the 8-character string.
  s6 := "RöckDöts"
  list := []  // Empty list.
  s6.size.repeat: | index |  // Index ranges from 0 to 10.
    list.add (s6.at --raw index)
  print list  // >> [82, 195, 182, 99, 107, 68, 195, 182, 116, 115]

  hello ::= "Hello"
  print hello[2..4] // Prints "ll", characters 2 to 4 of "Hello".
  two-euro := "€2"
  print two-euro[0..2] // Error, this 2-byte slice cuts the '€' character!
  print two-euro[0..3] // Prints "€", these 3 bytes make up the '€' character.

  hello-world := "Hello, World!"
  print hello-world[..5] // >> Hello
  print hello-world[7..] // >> World!

help-message := """
  My CLI command
      -h help
      -d device name
      -p prefix
  """
main:
  print help-message

My CLI command
    -h help
    -d device name
    -p prefix

main:
  str1 := """
    foo"""
  str2 := """
    \sfoo"""
  print "[" + str1 + "]"  // >> [foo]
  print "[" + str2 + "]"  // >> [ foo]

main:
  print """
    foo
    bar
  """ // <== indented less than the previous lines. As such
      // it gives the indentation for the other lines.

  print """
    foo
    bar
    """

  foo
  bar
foo
bar

main:
  print """
    This is a very long line that goes on \
    and on for a very long time. It's easier \
    to put any spaces at the end of the line, \
    but you can put them at the start,\
     making use of the usual\
     indentation-removing rules \
    for triple-quoted strings."""

This is a very long line that goes on and on for a very long time. It's easier to put any spaces at the end of the line, but you can put them at the start, making use of the usual indentation-removing rules for triple-quoted strings.

// Print:
//   Little pig 1
//   Little pig 2
//   Little pig 3
main:
  for i := 1; i <= 3; i++:
    print "  Little pig $i"

main:
  i := 42
  print "Level $i, the band."        // >> Level 42, the band.
  j := -42
  print "Level $j.abs, the band."    // >> Level 42, the band.
  list := [0, 42, 103]
  print "Level $list[1], the band."  // >> Level 42, the band.

main:
  print "Level $(6 * 7), the band." // >> Level 42, the band.
  j := -42
  print "Level $(-j), the band."    // >> Level 42, the band.
  i := 42
  print "Almost $(i)mm."            // >> Almost 42mm.

import math show PI

main:
  // %f can be used to specify the number of decimals for
  // floating point numbers:
  print "PI $(%.2f PI)"         // >> 3.14
  // %x is for hexadecimal numbers:
  print "In hex 0x$(%x 42)."    // >> In hex 0x2a.
  // %02x pads a hex number with zeros:
  print "CR is 0x$(%02x 0xd)."  // >> CR is 0x0d.
  // %4d pads a decimal number with spaces:
  // Prints:
  // >   0<
  // >   1<
  // >   8<
  // >  27<
  // >  64<
  // > 125<
  6.repeat:
    print ">$(%4d it * it * it)<"
  // %c inserts a character by its Unicode code point (rune):
  // Prints: Life, the Universe and *.
  print "Life, the Universe and $(%c 42)."
  // %o writes in octal:
  print "The VAX answer: $(%03o 42)." // >> The VAX answer: 052.
  // %b writes in binary:
  print "The year $(%b 2010)." // >> The year 11111011010.