🕸️Miscellaneous

This page documents the part of the language that were not "big" enough to warrant an entire page.

Line Comments

Syntax

// Comment here

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  fmt.println("Hello world!") // This is a comment
}

Transpiled

Output

At this time, block comments are not supported

Array Literal

You can use an array literal to construct an array.

Syntax

[<array length>]<Array Type>{<expr>, <expr>, ...}

-OR-

[...]<Array Type>{<key expr> : <value expr>, ...}

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let goodLanguages = [...]String{"Gauntlet", "Go", "F#"}
  let badLanguages = [3]String{"Java", "PHP", "C#"}

  fmt.println("Good languages:")
  fmt.println(goodLanguages)
  fmt.println("Bad languages:")
  fmt.println(badLanguages)
}

Transpiled

Output

Slice Literal

You can use a slice literal to construct a slice.

Syntax

[]<Slice type>{<expr1>, <expr2> ...}

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let first5Numbers = []Int{1, 2, 3, 4, 5} 
  fmt.println("The first 5 numbers are:")
  fmt.println(first5Numbers)
}

Transpiled

Output

Map Literal

Map literals can be used to construct maps

Syntax

[<Key Type>]<Value Type>{<key expr> : <value expr>, ...]

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {

  let grades = map[String]Int{
    "Bob" : 80
    "Joe" : 75
    "Josh" : 90
  }

  fmt.println("Bob's grade was: ")
  fmt.println(grades["Bob"])


}

Transpiled

Output

Indexing

The indexing operator can be used on arrays, slices, strings, maps, and pointers to arrays

Syntax

<expr>[expr>]

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let shoppingList = [...]String{"Bananna", "Orange", "Apples"}
  fmt.println("The first thing I want to buy when I get to the store is:")
  fmt.println(shoppingList[1])

  let streamingPasswords = map[String]String{
    "Netflix" : "net123",
    "Hulu" : "hulu5"
    "Disney+" : "Disney10"
  }

  fmt.println("The password to my Disney+ account is:")
  fmt.println(streamingPasswords["Disney+"])

}

Transpiled

Output

Slicing

Slicing can only be done on strings, slices, and arrays

Syntax:

<expr>[<start expr> : <end expr>]

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let statement = "I am a human being who is loved and cared for"
  let truePart = statement[0:18]
  fmt.println(truePart)
}

Transpiled

Output

Tuples

Syntax

(<expr>, <expr>, <expr>, etc)

Working Example

Guantlet

package main

import "fmt" as fmt

fun main(): Unit {
  let a, b, c, d = (1, 2, 3, 4)
  fmt.println("a is:")
  fmt.println(a)
  fmt.println("b is:")
  fmt.println(b)
  fmt.println("c is:")
  fmt.println(c)
  fmt.println("d is:")
  fmt.println(d)
}

Transpiled

Output

Type Assertion

Syntax

<identifier> typeassert <Type>

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let a: Any = 1
  let b = a typeassert Int
  fmt.println(b)
}

Transpiled

Output

Type Conversion

Syntax

(<Type>)(<expr>)

Working Example

Gauntlet

package main

import "fmt" as fmt

wrapper Int Dollar

fun main(): Unit {
  let dollars = Dollar(10)
  let intVersion = (Int)(dollars)
  fmt.println("I have this much money:")
  fmt.println(intVersion)
}

Transpiled

Output

Goroutines

Syntax

go {
    <scope content>
}

Working Example

Gauntlet

package main

import "fmt" as fmt
import "time" as time

fun main(): Unit {
  go {
    fmt.println("Hello from Gauntlet!")
  }
  time.sleep(1 * time.second)
  fmt.println("Main function has ended")
}

Transpiled

Output

Defer

Syntax

defer {
    <scope content>
}

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  defer {
    fmt.println("World!")
  }
  fmt.println("Hello")
}

Transpiled

Output

Pointers & Dereferencing

Pointer Syntax

&<expr>

Dereferencing Syntax

*<expr>

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let x = 10
  let ptr = &x 
  *ptr = 20
  fmt.println(x)
}

Transpiled

Output

Sending and Receiving with Channels

Sending Syntax

<channel name> <- <expr>

Receiving Syntax

<-<channel name>

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let ch = make(chan String)

  go {
	ch <- "Hello from goroutine!"
   }

   let msg = <-ch
   fmt.println(msg)
}

Transpiled

Output

Negated Expression

Syntax

!<expr>

Working Example

Gauntlet

package main

import "fmt" as fmt

fun main(): Unit {
  let myValue = false
  let myNegatedValue = !myValue
  
  fmt.println("myValue:")
  fmt.println(myValue)
  fmt.println("myValue but negated:")
  fmt.println(myNegatedValue)
}

Transpiled

Output