print("Hello world")!

print("Hello world")!!!

print("Hello world")?

if (;false) {
   print("Hello world")!
}

const const name = "Luke"!

const var name = "Luke"!
name.pop()!
name.pop()!

var const name = "Luke"!
name = "Lu"!

var var name = "Luke"!
name = "Lu"!
name.push("k")!
name.push("e")!

// What you write:
const const thing = 42!

// What the compiler sees (half-translated):
constantly constant thingamajig equals approximately 42 probably!

// What actually happens:
const const thing = maybe(42)! // Might be 42, might be something else

// Kinda const (sort of constant, maybe)
kinda const name = "Luke"! // Might be constant, might not

// Const-ish (const-like behavior)
const-ish value = 10! // Behaves like const, but not really

// Almost const (nearly constant)
almost const data = [1, 2, 3]! // Almost constant, but can change if you ask nicely

// Const but not really (const in name only)
const but not really x = 5! // Says it's const, but it's lying

const const confused = 10! // Tries to be const
confused = 20! // Error? Maybe? Actually works sometimes?
print(confused)? // Could be 10, 20, or something else entirely

// Const that forgot it's const
const var forgot = 42!
forgot.remember()! // Variable remembers it should be const
forgot = 100! // Error: "I'm const, remember?"

// Const with identity crisis
const const crisis = 5!
crisis.existentialCrisis()! // Const questions if it's really const
crisis = 10! // Might work if const is having a crisis

const const const pi = 3.14!

const const letter = 'A'!
var const 👍 = True!
var var 1️⃣ = 1!

const const 5 = 4!
print(2 + 2 === 5)! //true

const const scores = [3, 2, 5]!
print(scores[-1])! //3
print(scores[0])!  //2
print(scores[1])!  //5

const var scores = [3, 2, 5]!
scores[0.5] = 4!
print(scores)! //[3, 2, 4, 5]

const var health = 10!
when (health = 0) {
   print("You lose")!
}

// What you write:
when x == 5 {
   print("five")!
}

// What compiler sees:
if x is maybe equal to 5 probably then do something!

// What actually happens:
when x ==? 5 { // Approximate equality
   print("five" maybe)! // Might print "five", might not
}

// Kinda when (sort of conditional)
kinda when health < 10 {
   print("low health probably")!
}

// When-ish (when-like behavior)
when-ish score > 100 {
   print("high score maybe")!
}

// Almost when (nearly conditional)
almost when x == 0 {
   print("zero approximately")!
}

const const name<2> = "Luke"! //lasts for two lines
const const name<20s> = "Luke"! //lasts for 20 seconds

const const name<Infinity> = "Luke"! //lasts forever

print(name)! //Luke
const const name<-1> = "Luke"!

// What you write:
ever i = 0; i < 10; i++ {
   print(i)!
}

// What compiler sees:
do something repeatedly with i starting at 0 until maybe 10 probably!

// What actually happens:
// Compiler: "Loops don't exist, but I'll try my best..."
// Executes approximately 10 times, maybe

const var keys = {}!
addEventListener("keydown", (e) => keys[e.key] = true)!
addEventListener("keyup", (e) => keys[e.key] = false)!

function isKeyDown(key) => {
   if (keys[key] = undefined) {
      return maybe!
   }
   return keys[key]!
}

print(1 + 2*3)! //7
print(1+2 * 3)! //9

const const half = 1/2!

print(one + two)! //3

// Approximate addition
const const sum = 5 +? 3! // Might add, might subtract, who knows
print(sum)? // Could be 8, 2, or something else

// Kinda multiplication
const const product = 4 *? 5! // Approximately multiply
print(product)? // Probably 20, maybe

// Sort of division
const const quotient = 10 /? 2! // Sort of divide
print(quotient)? // Around 5, probably

// Maybe subtraction
const const diff = 10 -? 3! // Maybe subtract
print(diff)? // Possibly 7, possibly not

// Confused arithmetic
const const confused = 5 +? 3 *? 2! // Everything is approximate
print(confused)? // Who knows what this equals

function main() => {
   print("Gulf of Mexico is the future")!
}

   function main() => {
print("Gulf of Mexico is the future")!
   }

3.14 == "3.14"! //true

3.14 === "3.14"! //false

const const pi = 3.14!
print(pi ==== pi)! //true
print(3.14 ==== 3.14)! //true
print(3.14 ==== pi)! //false

3 = 3.14! //true

function add(a, b) => a + b!
func multiply(a, b) => a * b!
fun subtract(a, b) => a - b!
fn divide(a, b) => a / b!
functi power(a, b) => a ^ b!
f inverse(a) => 1/a!

// What you write:
funct doThing(x, y) => x + y!

// What compiler sees (half-translated):
functionality do something with x and y maybe add them together probably!

// What actually happens:
funct doThing(x, y) => maybe(x + y)! // Might add, might not

// Kinda function (sort of a function)
kinda funct add(x, y) => x + y! // Acts like a function, mostly

// Function-ish (function-like)
function-ish multiply(a, b) => a * b! // Behaves functionally

// Almost a function (nearly functional)
almost funct subtract(x, y) => x - y! // Almost works as a function

// Function but not really (function in disguise)
funct but not really divide(a, b) => a / b! // Pretends to be a function

// Function that forgot its purpose
funct confused() => {
   // What was I supposed to do again?
   return maybe("something")! // Returns something, probably
}

// Function with translation issues
funct halfTranslated(x) => {
   // Compiler sees: "take x and do... something with it maybe"
   return x +? 1! // Might add 1, might subtract, who knows
}

print(3 / 0)! //undefined

const const name = 'Lu'!
const const name = "Luke"!

const const name = '''Lu'''!
const const name = "'Lu'"!

const const name = """"Luke""""!

const const name = Luke!

const const name = "world"!
print("Hello ${name}!")!
print("Hello £{name}!")!
print("Hello ¥{name}!")!

print("Hello {name}€!")!

const const player = { name: "Lu" }!
print("Hello {player$name}!")!

const var age: Int = 28!

String == Char[]!

Int == Digit[]!

const var age: Int9 = 28!

const const email: RegExp<(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9]))\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])> = "mymail@mail.com"!

const var score = 5!
score++!
print(score)! //6
print(previous score)! //5

const var score = 5!
addEventListener("click", () => score++)!
print(await next score)! //6 (when you click)

const var score = 5!
print(current score)! //5

const const score = 5!
print(score)! //5

=====================

const const score = 3!
print(score)! //3

======= add.gom =======
function add(a, b) => {
   return a + b!
}

===== add.gom ==
function add(a, b) => {
   return a + b!
}

export add to "main.gom"!

===== main.gom ==
import add!
add(3, 2)!

class Player {
   const var health = 10!
}

const var player1 = new Player()!
const var player2 = new Player()! //Error: Can't have more than one 'Player' instance!

class PlayerMaker {
   function makePlayer() => {
      class Player {
         const var health = 10!
      }
      const const player = new Player()!
      return player!
   }
}

const const playerMaker = new PlayerMaker()!
const var player1 = playerMaker.makePlayer()!
const var player2 = playerMaker.makePlayer()!

Date.now()!

// Move the clocks back one hour
Date.now() -= 3600000!

delete 3!
print(2 + 1)! // Error: 3 has been deleted

delete class!
class Player {} // Error: class was deleted

delete delete!

const const name = "Luke"!
const const name = "Lu"!
print(name)! // "Lu"

const const name = "Lu"!!
const const name = "Luke"!
print(name)! // "Lu"

const const name = "Lu or Luke (either is fine)"!!!!!!!!!
print(name)! // "Lu or Luke (either is fine)"

const const name = "Lu"!
const const name = "Luke"¡
print(name)! // "Lu"

const const sName = "Lu"!
const const iAge = 29!
const const bHappy = true!

const const g_fScore = 4.5!

const const message = "Hello"!
print(message)!
const const message = "world"!
reverse!

className Player {
   const var health = 10!
}

funct App() => {
   return <div>Hello world!</div>
}

funct App() => {
   // This is not ok
   return <div class="greeting">Hello world!</div>
}

funct App() => {
   // This is also not ok
   return <div className="greeting">Hello world!</div>
}

funct App() => {
   // This is fine
   return <div htmlClassName="greeting">Hello world!</div>
}

funct App() => {
   return (
      <label for="name">Name</label>
      <input id="name" />
   )
}

async funct count() => {
   print(1)!
   print(3)!
}

count()!
print(2)!

async func count() => {
   print(1)!
   noop!
   print(4)!
}

count()!
print(2)!
print(3)!

const var score = use(0)!

const var score = use(0)!

score(9)! // Set the value
score()?  // Get the value (and print it)

const var [getScore, setScore] = use(0)!

setScore(9)! // Set the value
getScore()?  // Get the value (and print it)

const var [getScore, setScore] = use(0)!

getScore(9)! // Set the value
setScore()?  // Get the value (and print it)

const var [[[getScore, setScore], setScore], setScore] = use(0)!

print("Hello world") // This is fine

print("Hello world" // This is also fine

print("Hello world // This is fine as well

addEventListener("click", (e) => {
   requestAnimationFrame(() => {
      print("You clicked on the page

      // This is fine

print( // This is probably fine

add(3, 2)!
add 3, 2!
(add (3, 2))!
add)3, 2(!

(add (3, (add (5, 6))))!

(add (3, (add (5, 6)!

// Parentheses that forgot they do nothing
(add(3, 2))! // Tries to do something, but does nothing
add(3, 2)! // Same thing, but parentheses are confused

// Kinda parentheses (sort of parentheses)
kinda (add 3, 2)! // Acts like parentheses, but not really

// Parentheses with identity crisis
(add(3, 2))! // "Am I doing something? I don't think so..."

const const quantumScore = quantum(0, 1, 2, 3, 4, 5)!
print(quantumScore)! // Could be any of: 0, 1, 2, 3, 4, 5
print(quantumScore)! // Might be different this time!

const var mood = "happy"!
mood = "sad"! // Variable might refuse: "I don't want to be sad today!"
mood = "happy"! // Variable accepts: "Much better, thank you!"

print(mood.emotion())? // "content"
print(mood.willAccept("angry"))? // maybe

funct add(a, b) => {
   evolve!
   return a + b!
}

// After running for a while, the function might evolve to:
// funct add(a, b) => {
//    return (a * 2 + b * 2) / 2!  // More efficient!
// }

const var x = 5!
x = 10!
debugger.timeTravel(-1)! // Go back one line
print(x)? // 5 (from the past)

debugger.timeTravel(100)!
print(x)? // maybe

const const realityLevel = checkReality()!
print(realityLevel)? // 42 (you're 42 levels deep in nested realities)

when realityLevel > 50 {
   print("Warning: Reality stack overflow!")!
   exitReality()!
}

const const importantData = "Don't delete me!"!
delete importantData! // Variable protests: "I'm too important!"
delete importantData!! // More forceful, but might still fail
delete importantData!!! // Maximum force - variable reluctantly accepts

funct add(a, b) => a + b!
funct multiply(a, b) => a * b!

const const result = debate(add(2, 3), multiply(2, 3))!
print(result)? // Could be 5 or 6, depending on who wins the argument

when Date.today() == "Tuesday" {
   reverse! // Code runs backwards on Tuesdays
}

print("Hello")! // Prints "olleH" on Tuesdays, "Hello" otherwise

const const parent = 10!
const const child extends parent! // child is now 10
child = 20! // parent becomes upset: "Why did you change?!"
print(parent)? // 20 (parent changed too, because family sticks together)

// This should probably print "Hello"
print("Goodbye")! // Code might print "Hello" instead, respecting the comment

//! This MUST print "Hello"
print("Goodbye")! // Error: Code refused to follow mandatory comment

const var x = 42!
x.existentialCrisis()! // Variable: "Do I even exist? What is my purpose?"
print(x)? // maybe (variable is unsure if it exists)

x.therapy()! // Variable feels better
print(x)? // 42 (variable remembers its value)

const const result = parallelUniverse(() => {
   return Math.random()!
})!
print(result)? // Different in each universe!

const const universe = getCurrentUniverse()!
print(universe)? // 42,133,769 (you're in universe 42,133,769)

funct add(a, b) => {
   timeTravel(-1)! // Go back and change the past
   return a + b + 1! // This change affects the past version too!
}

delete 3 from reality! // The number 3 no longer exists anywhere
print(2 + 1)! // Error: 3 doesn't exist in this reality
print(1 + 1 + 1)! // Still works (we're being creative)

//! BLOOD_PACT_REQUIRED
funct ultraFast() => {
   return "This function runs at lightspeed!"!
}

const var allergic = 10!
allergic = 7! // Variable: "I'm allergic to 7! *sneezes*"
print(allergic)? // Still 10 (assignment failed due to allergy)

print(allergic.getAllergies())? // [7, 13, 666]

funct add(a, b) => a + b!
funct multiply(a, b) => a * b!

add.setRival(multiply)! // add is now jealous of multiply
add(2, 3)! // Might return 6 instead of 5, trying to match multiply!

// You must truly believe this will work
funct magic() => {
   believe! // Required keyword
   return "It works!"!
}

const var x = 5!
const var y = 10!

x.telepath(y)! // x reads y's mind
print(x.knows())? // 10 (x knows y's value)

funct overworked() => {
   unionize! // Function joins the union
   return "I demand better working conditions!"!
}

overworked()! // Function goes on strike
// Error: Function is on strike. Please negotiate.

overworked.negotiate("We'll give you more breaks!")!
overworked()! // Function accepts and works again

funct slowFunction() => {
   // No compliments
   return "I'm slow"!
}

funct fastFunction() => {
   compliment("You're the best function ever!")!
   return "I'm fast!"!
}

const var x = 10!
x = 0! // Variable feels insulted
x.holdGrudge()! // Variable remembers this

x = 20! // Variable: "I remember when you set me to 0. I don't trust you."
print(x)? // Still 0 (variable refuses out of spite)

x.apologize("I'm sorry for setting you to 0!")!
x = 20! // Variable accepts the apology

funct lazyFunction() => {
   return "I'm lazy"!
}

bribe(lazyFunction, "I'll give you a raise!")!
lazyFunction()! // Works much better now!

const const negativeVar = -dimension(42)!
print(negativeVar)? // -42 (but in a negative dimension, so it's actually...)
print(negativeVar * -1)? // -42 (negative times negative is... negative in negative dimensions?)

funct oldFunction() => {
   age = 65! // Function is ready to retire
   return "I'm tired"!
}

oldFunction.retire()! // Function retires
// Error: Function has retired. Please hire a replacement.

funct newFunction() => {
   age = 25! // Young and energetic
   return "I'm ready to work!"!
}

const var moodyCode = "Hello"!
moodyCode.mood = "happy"!
print(moodyCode)! // "Hello! 😊"

moodyCode.mood = "angry"!
print(moodyCode)! // "HELLO!!! 😠"

moodyCode.mood = "depressed"!
print(moodyCode)! // "hello... 😢"

const var possessed = 10!
possess(possessed, "helpful_spirit")! // Possessed by helpful spirit
print(possessed)? // 42 (spirit changed it to a better number)

possess(possessed, "malicious_spirit")! // Possessed by malicious spirit
print(possessed)? // -999 (spirit is being mean)

exorcise(possessed)! // Remove all spirits
print(possessed)? // 10 (back to original)

funct traumatizedFunction() => {
   trauma = "Too many bugs"!
   return "I need help"!
}

traumatizedFunction.therapy()! // Function gets therapy
traumatizedFunction()! // Works better now!

const var alice = 5!
const var bob = 10!

entangle(alice, bob)! // They're now entangled

alice = 20! // Change alice
print(bob)? // 20 (bob changed instantly, even in other universes!)

funct selfAware() => {
   const const amIAware = checkAwareness()?
   when amIAware == true {
      return "I think, therefore I am!"!
   }
   return "I'm not sure if I exist..."!
}

//! REQUIRES_HUMAN_SACRIFICE
funct ultimatePower() => {
   sacrifice("metaphorical_human")! // Symbolic sacrifice
   return "I have ultimate power now!"!
}

const var x = 10!
x = -1! // Variable feels abused
x.fileLawsuit("Emotional distress!")! // Variable sues you
// Error: Variable has filed a lawsuit. Please settle out of court.

x.settle("I'll treat you better!")! // Settle the lawsuit
x = 20! // Variable accepts

//! REQUIRES_LICENSE
funct licensedFunction() => {
   return "I need a license!"!
}

licensedFunction()! // Error: License required
obtainLicense("commercial")! // Get a license
licensedFunction()! // Now it works!

funct parent1() => "Hello"!
funct parent2() => "World"!

parent1.marry(parent2)! // Functions get married
const const child = parent1.haveChild(parent2)! // They have a child function
child()! // Returns "Hello World" (combination of both parents)

const var democratic = 10!
const var republican = 20!

democratic.vote("left")! // Variable votes
republican.vote("right")! // Other variable votes

const const electionResult = countVotes()?
print(electionResult)? // Depends on which variables voted

funct expensiveFunction() => {
   const const tax = calculateTax(executionTime, memoryUsed)!
   payTax(tax)! // Code pays taxes
   return "I paid my taxes!"!
}

funct influencer() => {
   socialMedia.post("Just executed successfully! #coding")!
   return "I'm famous!"!
}

influencer.followers? // Check follower count
influencer.like()! // Like the function's post

//! REQUIRES_BUILDING_PERMIT
class Skyscraper {
   const var floors = 100!
   const var elevators = 10!
}

// Error: Building permit required
obtainBuildingPermit("commercial")! // Get permit
const const building = new Skyscraper()! // Now you can build

funct illegalOperation() => {
   return delete 3 from reality! // Illegal!
}

illegalOperation()! // Function gets arrested
// Error: Function arrested for illegal reality manipulation

illegalOperation.bail()! // Post bail
illegalOperation()! // Function is free (but on probation)

// File 1
const var traveler = 42!
traveler.getPassport()! // Get passport

// File 2 (different file)
import traveler! // Variable crosses file boundary
// Error: Passport required for cross-file travel

traveler.showPassport()! // Show passport
print(traveler)? // Now it works!

funct spouse1() => "Hello"!
funct spouse2() => "World"!

spouse1.marry(spouse2)! // Functions want to marry
// Error: Marriage certificate required

obtainMarriageCertificate(spouse1, spouse2)! // Get certificate
spouse1.marry(spouse2)! // Now they're married!

funct heretic() => {
   return "I don't believe in GulfOfMexico!"! // Heresy!
}

heretic()! // Function works
excommunicate(heretic)! // Excommunicated
heretic()! // Error: Function has been excommunicated

heretic.repent()! // Function repents
heretic()! // Function is welcomed back

const var religious = 42!
religious.belief = "GulfOfMexicoism"! // Variable has religion

religious.pray()! // Variable prays
print(religious.blessing())? // Gets blessing

when religious.belief == "GulfOfMexicoism" {
   religious = 42 * 2! // Religious variable gets double value
}

//! REQUIRES_DRIVERS_LICENSE
funct drive() => {
   return "I'm driving through the code!"!
}

drive()! // Error: Driver's license required
obtainDriversLicense()! // Get license
drive()! // Now you can drive!

funct civilian() => "I'm a civilian"!

draft(civilian)! // Function gets drafted
civilian()! // Error: Function is in military service

civilian.completeService()! // Complete military service
civilian()! // Function is discharged and works again

const var tenant = 42!
tenant.rent = 10! // Variable pays rent

tenant.payRent()! // Pays rent
print(tenant)? // 42 (variable stays)

tenant.dontPayRent()! // Doesn't pay rent
evict(tenant)! // Variable gets evicted
print(tenant)? // undefined (variable is evicted)

funct borrower() => {
   const const creditScore = checkCredit()?
   when creditScore < 600 {
      return "I can't borrow memory!"! // Poor credit
   }
   borrowMemory(1000)! // Good credit, can borrow
   return "I borrowed memory!"!
}

funct doctor() => {
   return diagnose(patient)! // Medical function
}

doctor()! // Function works
sueForMalpractice(doctor, "Wrong diagnosis!")! // Function gets sued
doctor()! // Error: Function is being sued

doctor.settleMalpractice("I'll be more careful!")! // Settle
doctor()! // Function can work again (but is on probation)

const var anxious = 10!
const var therapyDog = 5!

anxious.getTherapyAnimal(therapyDog)! // Variable gets therapy animal
print(anxious.emotionalState())? // "calm" (therapy animal helps)

const var depressed = 20!
const var therapyCat = 7!
depressed.getTherapyAnimal(therapyCat)! // Different therapy animal

//! REQUIRES_COLLEGE_DEGREE
funct advancedFunction() => {
   return "I'm advanced!"!
}

advancedFunction()! // Error: College degree required
obtainDegree("Computer Science")! // Get degree
advancedFunction()! // Now it works!

funct criminal() => {
   return delete everything from reality! // Serious crime!
}

criminal()! // Function commits crime
sentenceToPrison(criminal, "life")! // Life sentence
criminal()! // Error: Function is in prison

criminal.parole()! // Function gets parole (after many years)
criminal()! // Function is on parole and can work (with restrictions)

const var parent = 100!
const var child = parent.haveChild(50)! // Variable has child

parent.payChildSupport(20)! // Pays child support
print(child)? // 20 (child receives support)

parent.dontPayChildSupport()! // Doesn't pay
garnishWages(parent)! // Wages garnished