# Démonstration : Catnip est Turing-complet

print("⇒ DÉMONSTRATION DE COMPLÉTUDE DE TURING")
print("")

# 1. RÉCURSION : Factorielle
print("1. RÉCURSION - Factorielle")
factorielle = (n) => {
    match n {
        0 | 1 => { 1 }
        n => { n * factorielle(n - 1) }
    }
}

print("factorielle(5) =", factorielle(5))
print("factorielle(10) =", factorielle(10))
print("")

# 2. BOUCLE ARBITRAIRE : Conjecture de Collatz
print("2. BOUCLE ARBITRAIRE - Conjecture de Collatz")
collatz = (n) => {
    steps = 0
    valeur = n
    while valeur != 1 {
        if valeur % 2 == 0 {
            valeur = valeur / 2
        } else {
            valeur = 3 * valeur + 1
        }
        steps = steps + 1
    }
    steps
}

print("collatz(27) =", collatz(27), "étapes")
print("collatz(100) =", collatz(100), "étapes")
print("")

# 3. RÉCURSION COMPLEXE : Fonction d'Ackermann
print("3. RÉCURSION COMPLEXE - Fonction d'Ackermann")
ackermann = (m, n) => {
    match m {
        0 => { n + 1 }
        m => {
            match n {
                0 => { ackermann(m - 1, 1) }
                n => { ackermann(m - 1, ackermann(m, n - 1)) }
            }
        }
    }
}

print("ackermann(2, 3) =", ackermann(2, 3))
print("ackermann(3, 2) =", ackermann(3, 2))
print("")

# 4. ÉTAT MULTIPLE : Suite de Fibonacci
print("4. ÉTAT MULTIPLE - Suite de Fibonacci")
fibonacci = (n) => {
    match n {
        0 => { 0 }
        1 => { 1 }
        n => {
            a = 0
            b = 1
            i = 2
            while i <= n {
                temp = a + b
                a = b
                b = temp
                i = i + 1
            }
            b
        }
    }
}

print("fibonacci(10) =", fibonacci(10))
print("fibonacci(20) =", fibonacci(20))
print("")

# 5. PATTERN MATCHING COMPLEXE : Calculatrice
print("5. PATTERN MATCHING COMPLEXE - Calculatrice")
calculer = (op, a, b) => {
    match op {
        "+" => { a + b }
        "-" => { a - b }
        "*" => { a * b }
        "/" => {
            match b {
                0 => { print("Erreur: division par zéro"); 0 }
                _ => { a / b }
            }
        }
        _ => { print("Opération inconnue"); 0 }
    }
}

print("10 + 5 =", calculer("+", 10, 5))
print("10 * 7 =", calculer("*", 10, 7))
print("10 / 0 =", calculer("/", 10, 0))
print("")

# 6. ARITHMÉTIQUE COMPLÈTE : PGCD d'Euclide
print("6. ALGORITHME RÉCURSIF - PGCD d'Euclide")
pgcd = (a, b) => {
    match b {
        0 => { a }
        b => { pgcd(b, a % b) }
    }
}

print("pgcd(48, 18) =", pgcd(48, 18))
print("pgcd(100, 75) =", pgcd(100, 75))
print("")

# 7. COMBINAISON DE CONCEPTS : Nombres premiers
print("7. ALGORITHME COMPLET - Test de primalité")
est_premier = (n) => {
    match n {
        n if n < 2 => { False }
        2 => { True }
        n if n % 2 == 0 => { False }
        n => {
            diviseur = 3
            est_premier_local = True
            while diviseur * diviseur <= n {
                if n % diviseur == 0 {
                    est_premier_local = False
                }
                diviseur = diviseur + 2
            }
            est_premier_local
        }
    }
}

print("7 est premier ?", est_premier(7))
print("15 est premier ?", est_premier(15))
print("97 est premier ?", est_premier(97))
print("")

print("✅ CONCLUSION : Catnip est TURING-COMPLET!")
print("")
print("Catnip possède tous les éléments requis :")
print("  ✓ Stockage arbitraire de données (variables)")
print("  ✓ Conditionnelles (if/elif/else, match/pattern)")
print("  ✓ Boucles arbitraires (while, for)")
print("  ✓ Opérations arithmétiques complètes")
print("  ✓ Opérations logiques et de comparaison")
print("  ✓ Récursion (via lambdas)")
print("  ✓ Fonctions de première classe")
print("  ✓ Pattern matching avec guards")
print("")
print("Donc Catnip peut calculer TOUTE fonction calculable!")