#lang racket

(struct point (x y))

(define (main)
  ; Racket offers several printing functions for formatting values.
  ; For example, this prints an instance of our `point` struct.
  (let ([p (point 1 2)])
    (printf "struct1: ~a\n" p)

    ; To include the struct's field names, we can use `~v`.
    (printf "struct2: ~v\n" p)

    ; The `~s` format specifier prints a Racket syntax representation
    ; of the value, i.e. the source code snippet that would produce that value.
    (printf "struct3: ~s\n" p)

    ; To print the type of a value, we can use `object-name`.
    (printf "type: ~a\n" (object-name (point-x p)))

    ; Formatting booleans is straightforward.
    (printf "bool: ~a\n" #t)

    ; There are many options for formatting integers.
    ; Use `~a` for standard formatting.
    (printf "int: ~a\n" 123)

    ; This prints a binary representation.
    (printf "bin: ~b\n" 14)

    ; This prints the character corresponding to the given integer.
    (printf "char: ~a\n" (integer->char 33))

    ; `~x` provides hex encoding.
    (printf "hex: ~x\n" 456)

    ; For basic decimal formatting of floats, use `~f`.
    (printf "float1: ~f\n" 78.9)

    ; `~e` formats the float in scientific notation.
    (printf "float2: ~e\n" 123400000.0)

    ; For basic string printing, use `~a`.
    (printf "str1: ~a\n" "\"string\"")

    ; To double-quote strings, use `~s`.
    (printf "str2: ~s\n" "\"string\"")

    ; To print a representation of a pointer, we can use `eq-hash-code`.
    (printf "pointer: ~x\n" (eq-hash-code p))

    ; When formatting numbers, you can control the width and precision.
    ; To specify the width of an integer, use a number after `~`.
    (printf "width1: |~6a|~6a|\n" 12 345)

    ; For floats, you can specify both width and precision.
    (printf "width2: |~6,2f|~6,2f|\n" 1.2 3.45)

    ; To left-justify, use the `-` flag.
    (printf "width3: |~-6,2f|~-6,2f|\n" 1.2 3.45)

    ; You can also control width when formatting strings.
    (printf "width4: |~6a|~6a|\n" "foo" "b")

    ; To left-justify strings, use the `-` flag as with numbers.
    (printf "width5: |~-6a|~-6a|\n" "foo" "b")

    ; `format` returns a formatted string without printing it.
    (let ([s (format "format: a ~a" "string")])
      (displayln s))

    ; You can format+print to output ports other than
    ; the current output port using `fprintf`.
    (fprintf (current-error-port) "io: an ~a\n" "error"))
)

(main)