Returns the standard output of executingcommand in a subshell. Standard input, and error are inherited. The special$? variable is set to aProcess::Status associated with this execution.

It is impossible to call this method with any regular call syntax. There is an associated literal type which calls the method with the literal content as command:

`echo hi`   # => "hi\n"
$?.success? # => true

SeeCommand literals in the language reference.

Terminates execution immediately, printingmessage toSTDERR and then callingexit(status).

Returns the alignment of the given type as number of bytes.

type must be a constant ortypeof() expression. It cannot be evaluated at runtime.

alignof(Int32)        # => 4
alignof(Float64)      # usually 4 or 8
alignof(typeof(true)) # => 1

ForReference types, the alignment is the same as the alignment of a pointer:

# On a 64 bits machine
alignof(Pointer(Int32)) # => 8
alignof(String)         # => 8

This is because aReference's memory is allocated on the heap and a pointer to it is passed around. The alignment of a class on the heap can be determined using#instance_alignof.

• Seealignof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Registers the givenProc for execution when the program exits regularly.

A regular exit happens when either

• the main fiber reaches the end of the program,
• the main fiber rescues an unhandled exception, or
• ::exit is called.

Process.exit doesnot triggerat_exit handlers, nor does external process termination (seeProcess.on_terminate for handling that).

If multiple handlers are registered, they are executed in reverse order of registration.

def do_at_exit(str1)
  at_exit { print str1 }
end

at_exit { puts "cruel world" }
do_at_exit("goodbye ")
exit

Produces:

goodbye cruel world

The exit status code that will be returned by this program is passed to the block as its first argument. In case of any unhandled exception, it is passed as the second argument to the block, if the program terminates normally orexit(status) is called explicitly, then the second argument will benil.

NOTE Ifat_exit is called inside anat_exit handler, it will be called right after the currentat_exit handler ends, and then other handlers will be invoked.

Returns the current execution stack as an array containing strings usually in the form file:line:column or file:line:column in'method'.

Terminates execution immediately, returning the given status code to the invoking environment.

Registeredat_exit procs are executed.

Reads a line fromSTDIN.

See also:IO#gets.

Returns the instance alignment of the given class as number of bytes.

type must be a constant ortypeof() expression. It cannot be evaluated at runtime.

instance_alignof(String)    # => 4
instance_alignof(Exception) # => 8

Seealignof for determining the size of value types.

• Seeinstance_alignof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Returns the instance size of the given class as number of bytes.

type must be a constant ortypeof() expression. It cannot be evaluated at runtime.

instance_sizeof(String)    # => 16
instance_sizeof(Exception) # => 48

Seesizeof for determining the size of value types.

• Seeinstance_sizeof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Repeatedly executes the block.

loop do
  line = gets
  break unless line
  # ...
end

Main function that acts as C's main function. InvokesCrystal.main.

Can be redefined. SeeCrystal.main for examples.

On Windows the actual entry point iswmain, but there is no need to redefine that. See the file required below for details.

Returns the byte offset of an instance variable in a struct or class type.

type must be a constant ortypeof() expression. It cannot be evaluated at runtime. offset must be the name of an instance variable oftype, prefixed by@, or the index of an element in a Tuple, starting from 0, iftype is aTuple.

offsetof(String, @bytesize)       # => 4
offsetof(Exception, @message)     # => 8
offsetof(Time, @location)         # => 16
offsetof({Int32, Int8, Int32}, 0) # => 0
offsetof({Int32, Int8, Int32}, 1) # => 4
offsetof({Int32, Int8, Int32}, 2) # => 8

• Seeoffsetof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Inspectsobject toSTDOUT followed by a newline. Returnsobject.

See also:Object#inspect(io).

Inspects each object inobjects toSTDOUT, followed by a newline. Returnsobjects.

See also:Object#inspect(io).

Inspectsobjects toSTDOUT, followed by a newline. Returnsobjects.

p foo: 23, bar: 42 # => {foo: 23, bar: 42}

SeeObject#inspect(io)

Returns aPointer to the contents of a variable.

variable must be a variable (local, instance, class or library).

a = 1
ptr = pointerof(a)
ptr.value = 2

a # => 2

• Seepointerof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Pretty printsobject toSTDOUT followed by a newline. Returnsobject.

See also:Object#pretty_print(pp).

Pretty prints each object inobjects toSTDOUT, followed by a newline. Returnsobjects.

See also:Object#pretty_print(pp).

Pretty printsobjects toSTDOUT, followed by a newline. Returnsobjects.

p foo: 23, bar: 42 # => {foo: 23, bar: 42}

SeeObject#pretty_print(pp)

Prints objects toSTDOUT and then invokesSTDOUT.flush.

See also:IO#print.

Prints a formatted string toSTDOUT.

For details on the format string, seesprintf.

Prints a formatted string toSTDOUT.

For details on the format string, seesprintf.

Printsobjects toSTDOUT, each followed by a newline character unless the object is aString and already ends with a newline.

See also:IO#puts.

Raises theexception.

This will set the exception's callstack if it hasn't been already. Re-raising a previously caught exception won't replace the callstack.

Raises an Exception with themessage.

SeeRandom#rand(x).

SeeRandom#rand.

Reads a line fromSTDIN.

See also:IO#read_line.

Returns the size of the given type as number of bytes.

type must be a constant ortypeof() expression. It cannot be evaluated at runtime.

sizeof(Int32)        # => 4
sizeof(Int64)        # => 8
sizeof(typeof(true)) # => 1

ForReference types, the size is the same as the size of a pointer:

# On a 64 bits machine
sizeof(Pointer(Int32)) # => 8
sizeof(String)         # => 8

This is because aReference's memory is allocated on the heap and a pointer to it is passed around. The size of a class on the heap can be determined using#instance_sizeof.

• Seesizeof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Blocks the current fiber for the specified number of seconds.

While this fiber is waiting this time, other ready-to-execute fibers might start their execution.

DEPRECATED Use::sleep(Time::Span) instead

Blocks the current Fiber for the specified time span.

While this fiber is waiting this time, other ready-to-execute fibers might start their execution.

Blocks the current fiber forever.

Meanwhile, other ready-to-execute fibers might start their execution.

Spawns a new fiber.

When using execution contexts, the fiber spawns into the current execution context (Fiber::ExecutionContext.current).

NOTE The newly created fiber doesn't run as soon as spawned.

Example:

# Write "1" every 1 second and "2" every 2 seconds for 6 seconds.

require "wait_group"

wg = WaitGroup.new 2

spawn do
  6.times do
    sleep 1.second
    puts 1
  end
ensure
  wg.done
end

spawn do
  3.times do
    sleep 2.seconds
    puts 2
  end
ensure
  wg.done
end

wg.wait

Returns a formatted string. The string is produced according to theformat_string with format specifiers being replaced by values fromargs formatted according to the specifier.

Within the format string, any characters other than format specifiers (specifiers beginning with%) are copied to the result. The formatter supports the following kinds of format specifiers:

• Sequential (%.1f). The first% consumes the first argument, the second consumes the second argument, and so on.
• Positional (%3$.1f). The one-based argument index is specified as part of the flags.
• Named substitution (%<name>.1f,%{name}). The angle bracket form accepts flags and the curly bracket form doesn't. Exactly oneHash orNamedTuple must be passed as the argument.

Mixing of different kinds of format specifiers is disallowed, except that the two named forms may be used together.

A simple format specifier consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character.

%[flags][width][.precision]type

A formatted substitution is similar but after the percent sign follows the mandatory name of the substitution wrapped in angle brackets.

%<name>[flags][width][.precision]type

The percent sign itself is escaped by%%. No format modifiers are allowed, and no arguments are consumed.

The field type controls how the corresponding argument value is to be interpreted, while the flags modify that interpretation.

The field type characters are:

Field | Integer Format
------+------------------------------------------------------------------
  b   | Formats argument as a binary number.
  d   | Formats argument as a decimal number.
  i   | Same as d.
  o   | Formats argument as an octal number.
  x   | Formats argument as a hexadecimal number using lowercase letters.
  X   | Same as x, but uses uppercase letters.

Field | Float Format
------+---------------------------------------------------------------
  e   | Formats floating point argument into exponential notation
      | with one digit before the decimal point as [-]d.dddddde[+-]dd.
      | The precision specifies the number of digits after the decimal
      | point (defaulting to six).
  E   | Equivalent to e, but uses an uppercase E to indicate
      | the exponent.
  f   | Formats floating point argument as [-]ddd.dddddd,
      | where the precision specifies the number of digits after
      | the decimal point.
  g   | Formats a floating point number using exponential form
      | if the exponent is less than -4 or greater than or
      | equal to the precision, or in dd.dddd form otherwise.
      | The precision specifies the number of significant digits.
  G   | Equivalent to g, but use an uppercase E in exponent form.
  a   | Formats floating point argument as [-]0xh.hhhhp[+-]dd,
      | which consists of an optional sign, "0x", fraction part
      | as hexadecimal, "p", and exponential part as decimal.
  A   | Equivalent to a, but uses uppercase X and P.

Field | Other Format
------+------------------------------------------------------------
  c   | Argument is a single character itself.
  s   | Argument is a string to be substituted. If the format
      | sequence contains a precision, at most that many characters
      | will be copied.

Flags modify the behavior of the format specifiers:

Flag     | Applies to    | Meaning
---------+---------------+----------------------------------------------------
space    | bdiouxX       | Add a leading space character to
         | aAeEfgG       | non-negative numbers. Has no effect if the plus
         | (numeric fmt) | flag is also given.
---------+---------------+----------------------------------------------------
#        | boxX          | Use an alternative format.
         | aAeEfgG       | For x, X, b, prefix any non-zero result with
         |               | 0x, 0X, or 0b respectively.
         |               | For o, prefix any non-zero result with 0o. Note
         |               | that this prefix is different from C and Ruby.
         |               | For a, A, e, E, f, g, G,
         |               | force a decimal point to be added,
         |               | even if no digits follow.
         |               | For g and G, do not remove trailing zeros.
---------+---------------+----------------------------------------------------
+        | bdiouxX       | Add a leading plus sign to non-negative
         | aAeEfgG       | numbers.
         | (numeric fmt) |
---------+---------------+----------------------------------------------------
-        | all           | Left-justify the result of this conversion.
---------+---------------+----------------------------------------------------
0 (zero) | bdiouxX       | Pad with zeros, not spaces. Has no effect if the
         | aAeEfgG       | number is left-justified, or a precision is given
         | (numeric fmt) | to an integer field type.
---------+---------------+----------------------------------------------------
*        | all           | Use the next argument as the field width or
         |               | precision. If width is negative, set the minus flag
         |               | and use the argument's absolute value as field
         |               | width. If precision is negative, it is ignored.
---------+---------------+----------------------------------------------------
1$ 2$ 3$ | all           | As a flag, specifies the one-based argument index
...      |               | for a positional format specifier.
         |               | Immediately after *, use the argument at the given
         |               | one-based index as the width or precision, instead
         |               | of the next argument. The entire format string must
         |               | also use positional format specifiers throughout.

Examples of flags:

Decimal number conversion:

sprintf "%d", 123  # => "123"
sprintf "%+d", 123 # => "+123"
sprintf "% d", 123 # => " 123"

Octal number conversion:

sprintf "%o", 123   # => "173"
sprintf "%+o", 123  # => "+173"
sprintf "%o", -123  # => "-173"
sprintf "%+o", -123 # => "-173"

Hexadecimal number conversion:

sprintf "%x", 123   # => "7b"
sprintf "%+x", 123  # => "+7b"
sprintf "%x", -123  # => "-7b"
sprintf "%+x", -123 # => "-7b"
sprintf "%#x", 0    # => "0"
sprintf "% x", 123  # => " 7b"
sprintf "% x", -123 # => "-7b"
sprintf "%X", 123   # => "7B"
sprintf "%#X", -123 # => "-0X7B"

Binary number conversion:

sprintf "%b", 123    # => "1111011"
sprintf "%+b", 123   # => "+1111011"
sprintf "%+b", -123  # => "-1111011"
sprintf "%b", -123   # => "-1111011"
sprintf "%#b", 0     # => "0"
sprintf "% b", 123   # => " 1111011"
sprintf "%+ b", 123  # => "+1111011"
sprintf "% b", -123  # => "-1111011"
sprintf "%+ b", -123 # => "-1111011"
sprintf "%#b", 123   # => "0b1111011"

Floating point conversion:

sprintf "%a", 123 # => "0x1.ecp+6"
sprintf "%A", 123 # => "0X1.ECP+6"

Exponential form conversion:

sprintf "%g", 123.4          # => "123.4"
sprintf "%g", 123.4567       # => "123.457"
sprintf "%20.8g", 1234.56789 # => "           1234.5679"
sprintf "%20.8g", 123456789  # => "       1.2345679e+08"
sprintf "%20.8G", 123456789  # => "       1.2345679E+08"
sprintf "%20.8g", -123456789 # => "      -1.2345679e+08"
sprintf "%20.8G", -123456789 # => "      -1.2345679E+08"

The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field.

Examples of width:

sprintf "%20d", 123   # => "                 123"
sprintf "%+20d", 123  # => "                +123"
sprintf "%020d", 123  # => "00000000000000000123"
sprintf "%+020d", 123 # => "+0000000000000000123"
sprintf "% 020d", 123 # => " 0000000000000000123"
sprintf "%-20d", 123  # => "123                 "
sprintf "%-+20d", 123 # => "+123                "
sprintf "%- 20d", 123 # => " 123                "
sprintf "%020x", -123 # => "-000000000000000007b"
sprintf "%020X", -123 # => "-000000000000000007B"

For numeric fields, the precision controls the number of decimal places displayed.

For string fields, the precision determines the maximum number of characters to be copied from the string.

Examples of precisions:

Precision ford,o,x andb is minimum number of digits:

sprintf "%20.8d", 123   # => "            00000123"
sprintf "%020.8d", 123  # => "            00000123"
sprintf "%20.8o", 123   # => "            00000173"
sprintf "%020.8o", 123  # => "            00000173"
sprintf "%20.8x", 123   # => "            0000007b"
sprintf "%020.8x", 123  # => "            0000007b"
sprintf "%20.8b", 123   # => "            01111011"
sprintf "%20.8d", -123  # => "           -00000123"
sprintf "%020.8d", -123 # => "           -00000123"
sprintf "%20.8o", -123  # => "           -00000173"
sprintf "%20.8x", -123  # => "           -0000007b"
sprintf "%20.8b", -11   # => "           -00001011"

Precision fore is number of digits after the decimal point:

sprintf "%20.8e", 1234.56789 # => "      1.23456789e+03"

Precision forf is number of digits after the decimal point:

sprintf "%20.8f", 1234.56789 # => "       1234.56789000"

Precision forg is number of significant digits:

sprintf "%20.8g", 1234.56789 # => "           1234.5679"
sprintf "%20.8g", 123456789  # => "       1.2345679e+08"
sprintf "%-20.8g", 123456789 # => "1.2345679e+08       "

Precision fors is maximum number of characters:

sprintf "%20.8s", "string test" # => "            string t"

Additional examples:

sprintf "%d %04x", 123, 123                 # => "123 007b"
sprintf "%08b '%4s'", 123, 123              # => "01111011 ' 123'"
sprintf "%+g:% g:%-g", 1.23, 1.23, 1.23     # => "+1.23: 1.23:1.23"
sprintf "%-3$*1$.*2$s", 10, 5, "abcdefghij" # => "abcde     "

Returns a formatted string. The string is produced according to theformat_string with format specifiers being replaced by values fromargs formatted according to the specifier.

Within the format string, any characters other than format specifiers (specifiers beginning with%) are copied to the result. The formatter supports the following kinds of format specifiers:

• Sequential (%.1f). The first% consumes the first argument, the second consumes the second argument, and so on.
• Positional (%3$.1f). The one-based argument index is specified as part of the flags.
• Named substitution (%<name>.1f,%{name}). The angle bracket form accepts flags and the curly bracket form doesn't. Exactly oneHash orNamedTuple must be passed as the argument.

Mixing of different kinds of format specifiers is disallowed, except that the two named forms may be used together.

A simple format specifier consists of a percent sign, followed by optional flags, width, and precision indicators, then terminated with a field type character.

%[flags][width][.precision]type

A formatted substitution is similar but after the percent sign follows the mandatory name of the substitution wrapped in angle brackets.

%<name>[flags][width][.precision]type

The percent sign itself is escaped by%%. No format modifiers are allowed, and no arguments are consumed.

The field type controls how the corresponding argument value is to be interpreted, while the flags modify that interpretation.

The field type characters are:

Field | Integer Format
------+------------------------------------------------------------------
  b   | Formats argument as a binary number.
  d   | Formats argument as a decimal number.
  i   | Same as d.
  o   | Formats argument as an octal number.
  x   | Formats argument as a hexadecimal number using lowercase letters.
  X   | Same as x, but uses uppercase letters.

Field | Float Format
------+---------------------------------------------------------------
  e   | Formats floating point argument into exponential notation
      | with one digit before the decimal point as [-]d.dddddde[+-]dd.
      | The precision specifies the number of digits after the decimal
      | point (defaulting to six).
  E   | Equivalent to e, but uses an uppercase E to indicate
      | the exponent.
  f   | Formats floating point argument as [-]ddd.dddddd,
      | where the precision specifies the number of digits after
      | the decimal point.
  g   | Formats a floating point number using exponential form
      | if the exponent is less than -4 or greater than or
      | equal to the precision, or in dd.dddd form otherwise.
      | The precision specifies the number of significant digits.
  G   | Equivalent to g, but use an uppercase E in exponent form.
  a   | Formats floating point argument as [-]0xh.hhhhp[+-]dd,
      | which consists of an optional sign, "0x", fraction part
      | as hexadecimal, "p", and exponential part as decimal.
  A   | Equivalent to a, but uses uppercase X and P.

Field | Other Format
------+------------------------------------------------------------
  c   | Argument is a single character itself.
  s   | Argument is a string to be substituted. If the format
      | sequence contains a precision, at most that many characters
      | will be copied.

Flags modify the behavior of the format specifiers:

Flag     | Applies to    | Meaning
---------+---------------+----------------------------------------------------
space    | bdiouxX       | Add a leading space character to
         | aAeEfgG       | non-negative numbers. Has no effect if the plus
         | (numeric fmt) | flag is also given.
---------+---------------+----------------------------------------------------
#        | boxX          | Use an alternative format.
         | aAeEfgG       | For x, X, b, prefix any non-zero result with
         |               | 0x, 0X, or 0b respectively.
         |               | For o, prefix any non-zero result with 0o. Note
         |               | that this prefix is different from C and Ruby.
         |               | For a, A, e, E, f, g, G,
         |               | force a decimal point to be added,
         |               | even if no digits follow.
         |               | For g and G, do not remove trailing zeros.
---------+---------------+----------------------------------------------------
+        | bdiouxX       | Add a leading plus sign to non-negative
         | aAeEfgG       | numbers.
         | (numeric fmt) |
---------+---------------+----------------------------------------------------
-        | all           | Left-justify the result of this conversion.
---------+---------------+----------------------------------------------------
0 (zero) | bdiouxX       | Pad with zeros, not spaces. Has no effect if the
         | aAeEfgG       | number is left-justified, or a precision is given
         | (numeric fmt) | to an integer field type.
---------+---------------+----------------------------------------------------
*        | all           | Use the next argument as the field width or
         |               | precision. If width is negative, set the minus flag
         |               | and use the argument's absolute value as field
         |               | width. If precision is negative, it is ignored.
---------+---------------+----------------------------------------------------
1$ 2$ 3$ | all           | As a flag, specifies the one-based argument index
...      |               | for a positional format specifier.
         |               | Immediately after *, use the argument at the given
         |               | one-based index as the width or precision, instead
         |               | of the next argument. The entire format string must
         |               | also use positional format specifiers throughout.

Examples of flags:

Decimal number conversion:

sprintf "%d", 123  # => "123"
sprintf "%+d", 123 # => "+123"
sprintf "% d", 123 # => " 123"

Octal number conversion:

sprintf "%o", 123   # => "173"
sprintf "%+o", 123  # => "+173"
sprintf "%o", -123  # => "-173"
sprintf "%+o", -123 # => "-173"

Hexadecimal number conversion:

sprintf "%x", 123   # => "7b"
sprintf "%+x", 123  # => "+7b"
sprintf "%x", -123  # => "-7b"
sprintf "%+x", -123 # => "-7b"
sprintf "%#x", 0    # => "0"
sprintf "% x", 123  # => " 7b"
sprintf "% x", -123 # => "-7b"
sprintf "%X", 123   # => "7B"
sprintf "%#X", -123 # => "-0X7B"

Binary number conversion:

sprintf "%b", 123    # => "1111011"
sprintf "%+b", 123   # => "+1111011"
sprintf "%+b", -123  # => "-1111011"
sprintf "%b", -123   # => "-1111011"
sprintf "%#b", 0     # => "0"
sprintf "% b", 123   # => " 1111011"
sprintf "%+ b", 123  # => "+1111011"
sprintf "% b", -123  # => "-1111011"
sprintf "%+ b", -123 # => "-1111011"
sprintf "%#b", 123   # => "0b1111011"

Floating point conversion:

sprintf "%a", 123 # => "0x1.ecp+6"
sprintf "%A", 123 # => "0X1.ECP+6"

Exponential form conversion:

sprintf "%g", 123.4          # => "123.4"
sprintf "%g", 123.4567       # => "123.457"
sprintf "%20.8g", 1234.56789 # => "           1234.5679"
sprintf "%20.8g", 123456789  # => "       1.2345679e+08"
sprintf "%20.8G", 123456789  # => "       1.2345679E+08"
sprintf "%20.8g", -123456789 # => "      -1.2345679e+08"
sprintf "%20.8G", -123456789 # => "      -1.2345679E+08"

The field width is an optional integer, followed optionally by a period and a precision. The width specifies the minimum number of characters that will be written to the result for this field.

Examples of width:

sprintf "%20d", 123   # => "                 123"
sprintf "%+20d", 123  # => "                +123"
sprintf "%020d", 123  # => "00000000000000000123"
sprintf "%+020d", 123 # => "+0000000000000000123"
sprintf "% 020d", 123 # => " 0000000000000000123"
sprintf "%-20d", 123  # => "123                 "
sprintf "%-+20d", 123 # => "+123                "
sprintf "%- 20d", 123 # => " 123                "
sprintf "%020x", -123 # => "-000000000000000007b"
sprintf "%020X", -123 # => "-000000000000000007B"

For numeric fields, the precision controls the number of decimal places displayed.

For string fields, the precision determines the maximum number of characters to be copied from the string.

Examples of precisions:

Precision ford,o,x andb is minimum number of digits:

sprintf "%20.8d", 123   # => "            00000123"
sprintf "%020.8d", 123  # => "            00000123"
sprintf "%20.8o", 123   # => "            00000173"
sprintf "%020.8o", 123  # => "            00000173"
sprintf "%20.8x", 123   # => "            0000007b"
sprintf "%020.8x", 123  # => "            0000007b"
sprintf "%20.8b", 123   # => "            01111011"
sprintf "%20.8d", -123  # => "           -00000123"
sprintf "%020.8d", -123 # => "           -00000123"
sprintf "%20.8o", -123  # => "           -00000173"
sprintf "%20.8x", -123  # => "           -0000007b"
sprintf "%20.8b", -11   # => "           -00001011"

Precision fore is number of digits after the decimal point:

sprintf "%20.8e", 1234.56789 # => "      1.23456789e+03"

Precision forf is number of digits after the decimal point:

sprintf "%20.8f", 1234.56789 # => "       1234.56789000"

Precision forg is number of significant digits:

sprintf "%20.8g", 1234.56789 # => "           1234.5679"
sprintf "%20.8g", 123456789  # => "       1.2345679e+08"
sprintf "%-20.8g", 123456789 # => "1.2345679e+08       "

Precision fors is maximum number of characters:

sprintf "%20.8s", "string test" # => "            string t"

Additional examples:

sprintf "%d %04x", 123, 123                 # => "123 007b"
sprintf "%08b '%4s'", 123, 123              # => "01111011 ' 123'"
sprintf "%+g:% g:%-g", 1.23, 1.23, 1.23     # => "+1.23: 1.23:1.23"
sprintf "%-3$*1$.*2$s", 10, 5, "abcdefghij" # => "abcde     "

Executes the given command in a subshell. Standard input, output and error are inherited. Returnstrue if the command gives zero exit code,false otherwise. The special$? variable is set to aProcess::Status associated with this execution.

Ifcommand contains no spaces andargs is given, it will become its argument list.

Ifcommand contains spaces andargs is given,command must include "${@}" (including the quotes) to receive the argument list.

No shell interpretation is done inargs.

Example:

system("echo *")

Produces:

LICENSE shard.yml Readme.md spec src

Timeout keyword for use inselect.

select
when x = ch.receive
  puts "got #{x}"
when timeout(1.seconds)
  puts "timeout"
end

NOTE It won't trigger if theselect has anelse case (i.e.: a non-blocking select).

Returns the type of an expression.

typeof(1) # => Int32

It accepts multiple arguments, and the result is the union of the expression types:

typeof(1, "a", 'a') # => (Int32 | String | Char)

The expressions passed as arguments totypeof do not evaluate. The compiler only analyzes their return type.

• Seetypeof in the language specification.

NOTE This is a pseudo-method provided directly by the Crystal compiler. It cannot be redefined nor overridden.

Invokes an execution trap to catch the attention of a debugger. This has the same effect as placing a breakpoint in debuggers or IDEs supporting them.

Execution is allowed to continue if the debugger instructs so. If no debugger is attached, usually the current process terminates with a status that corresponds toProcess::ExitReason::Breakpoint.

Inside an interpreter session, this drops into the REPL's pry mode instead of a system debugger.

Prints a series of expressions together with their inspected values. Useful for print style debugging.

a = 1
p! a # => "a # => 1"

p! [1, 2, 3].map(&.to_s) # => "[1, 2, 3].map(&.to_s) # => ["1", "2", "3"]"

See also:p,Object#inspect.

Prints a series of expressions together with their pretty printed values. Useful for print style debugging.

a = 1
pp! a # => "a # => 1"

pp! [1, 2, 3].map(&.to_s) # => "[1, 2, 3].map(&.to_s) # => ["1", "2", "3"]"

See also:pp,Object#pretty_inspect.

Defines aStruct type calledname with the givenproperties.

The generated struct has a constructor with the given properties in the same order as declared. The struct only provides getters, not setters, making it immutable by default.

record Point, x : Int32, y : Int32

p = Point.new 1, 2 # => #<Point(@x=1, @y=2)>
p.x                # => 1
p.y                # => 2

Theproperties are a sequence of type declarations (x : Int32,x : Int32 = 0) or assigns (x = 0). They declare instance variables and respective getter methods of their name with optional type restrictions and default value.

When passing a block to this macro its body is inserted inside the struct definition. This allows to define additional methods or include modules into the record type (reopening the type would work as well).

record Person, first_name : String, last_name : String do
  def full_name
    "#{first_name} #{last_name}"
  end
end

person = Person.new "John", "Doe"
person.full_name # => "John Doe"

An example with type declarations and default values:

record Point, x : Int32 = 0, y : Int32 = 0

Point.new      # => #<Point(@x=0, @y=0)>
Point.new y: 2 # => #<Point(@x=0, @y=2)>

An example with assignments (in this case the compiler must be able to infer the types from the default values):

record Point, x = 0, y = 0

Point.new      # => #<Point(@x=0, @y=0)>
Point.new y: 2 # => #<Point(@x=0, @y=2)>

This macro also provides a#copy_with method which returns a copy of the record with the provided properties altered.

record Point, x = 0, y = 0

p = Point.new y: 2 # => #<Point(@x=0, @y=2)>
p.copy_with x: 3   # => #<Point(@x=3, @y=2)>
p                  # => #<Point(@x=0, @y=2)>

Spawns a fiber by first creating aProc, passing thecall's expressions to it, and letting theProc finally invoke thecall.

When using execution contexts, the fiber spawns into the current execution context (Fiber::ExecutionContext.current).

Compare this:

i = 0
while i < 5
  spawn { print(i) }
  i += 1
end
Fiber.yield
# Output: 55555

To this:

i = 0
while i < 5
  spawn print(i)
  i += 1
end
Fiber.yield
# Output: 01234

This is because in the first case all spawned fibers refer to the same local variable, while in the second example copies of i are passed to aProc that eventually invokes the call.