actor Main
    new create(env: Env) =>
        env.out.print("placeholder value")

// Single quotes for character literals
// You can use unnecessarily long ints to store characters, even
// though they only require a U8
// You need to specify the type, though. Pony cannot infer it
let big_a: U8 = 'A'
let concrete_type_specified_a: U8 = 'A'
let unnecessarily_long_type: U64 = '\n'

// Pony needs to be told what type to use to store most literals
// You can do it like this:
let hundred: U8 = 100
// Or like this (with a constructor):
let a_lot = U16(999)

// Double quotes or triplicate double quotes for strings
// There's only the one string type, so you can let Pony
// infer the type of strings
let some_string = "p\xF6n\xFF"

// All string literals support multiline strings:
let long_string = "
hello
there
!
"

// Note: String literals contain the actual bytes that were read from
// the relevant source file, so their value depends on the encoding
// of the source file.

// Another note! If you use the same String literal lots of times in one
// Pony program, they will be stored as the same entry in memory, so
// they will always be equal based on identity.

// Array literals are enclosed by square brackets
let my_literal_array =
    [
        "an item"
        "another item"; "yet another (this is like a new line)"
    ]

// If the type of the array is not specified, the resulting type of the
// literal array expresion is Array[T] ref, where T (the type of the
// elements) is inferred as the union of all the element types

// If the variable or call argument the array literal is assigned to
// has a type, the literal will be coerced to that type.
// Thus this array is coereced to Array[Stringable] ref, which is
// possible because Stringable is a trait implemented by both
// String and U64.
let my_stringable_array: Array[Stringable] ref =
    [
        U64(0xA)
        "0xA"
    ]

// You can also get a different reference capability than ref for
// a literal array just by specifiying it. For example, an array with
// reference capability `val` follows
let my_val_array: Array[Stringable] val =
    [
        U64(0xABAD)
        "0x1DEA"
    ]

// You can use an `as` expression to give the compiler a hint as to
// what type to coerce the array's elements to
// This array gets coerced to Array[Stringable] ref
// The `as` expression must follow directly after the opening bracket
// of the array literal and be followed by a colon as shown
let an_array_with_as =
    [ as Stringable:
            U64(0xDEAD)
            "0xBEEF"
            U64(1 + 1)
    ]