Skip to content

Instantly share code, notes, and snippets.

@PifyZ

PifyZ/aliases.md

Last active August 29, 2015 14:07
Show Gist options
  • Save PifyZ/faa9114fa7f3f0bab520 to your computer and use it in GitHub Desktop.
Save PifyZ/faa9114fa7f3f0bab520 to your computer and use it in GitHub Desktop.
Download ZIP
Syntaxe Bootmonkey
Raw
aliases.md

Déclarer un alias

alias Integer = Int

Déclarer un alias d'un type générique

alias ListOf<T> = List<T>

Déclarer l'alias d'un alias

alias ListOfNum = ListOf<Num>

Déclarer l'alias d'une fonction

alias Add = (Num, Num -> Num)

Déclarer l'alias d'un tuple

# tuple de base
alias Point = (Num, Num)

# tuple à valeurs nommées
alias Point = (Num x, y)

Déclarer l'alias d'une fonction sans paramètre ni valeur de retour

alias EmptyFunc = (-> Void)

Déclarer l'alias d'une structure

alias Person = { String name, Num age = 18 }

Utiliser les alias

Les alias sont utilisables comme des types normaux :

Integer maFonction(Integer a, ListOf<String> b) { }
Integer a = 5
ListOfNum b = [ 0, 10, 20 ]
Point p = (50, 80.2)
Person me = { name: "Yannick", age: 20 }
Raw
classes.md

Une classe

class A { }

Un héritage de classe

class B < A { }

Déclaration du constructeur

class A {
    public new() { }
}

Surcharge de méthodes

class A {
    public Int add(Int a, b) { }
    public String add(String a, b) { }
}

Appel de méthodes parentes

class B < A {
    public new() {
        parent()
    }

    public Int add(Int a, b) {
        parent.add(a, b)
    }
}

Distinction paramètre/attribut : this

class B < A {
    public Int val

    public new(Int val) {
        this.val = val
    }
}

Héritage multiple

class A { }
class B { }
class C < A, B { }

Appel de méthodes parents avec l'héritage multiple

class C < A, B {
    public new() {
        parent<A>() # à discuter
    }

    public Int add(Int a, b) {
        parent<B>.add(a, b) # à discuter
    }
}

Classe générique

class A<T> { }

Classes et méthodes abstraites

abstract class A {
    abstract public Int add(Int a, b)
    public Int sub(Int a, b) { }
}

Attributs et méthodes statiques

class A {
    public static Int a
    public static Int b
}

Initialisation dans la déclaration de l'attribut

class A {
    public Int a = 0
}

Ajouter une méthode à une classe après sa création

extend MyClass {
    public static Int sub(Int a, b) { }
}

Surcharge d'opérateur

class MyClass {
    public new { }
    operator +(This mc2) { }
    operator -() { } # - unaire
    operator -(This mc2) { } # soustraction
    operator [](Int i) { } # accès
    operator [](Int i, Str val) { } # modification
}

This est un mot-clé réservé qui permet de faire référence au nom de la classe sans l'écrire explicitement (ici This vaut donc MyClass)

Les opérateurs surchargeables sont :

+, -, *, /, %, **
+=, -=, *=, /=, %=, **=
^, |, &, ~, >>, <<, >>>
^=, |=, &=, ~=, >>=, <<=, >>>=
==, <, <=, >, >=, <>
not, and, or
[]
pre--, post--, pre++, post++

Dans les exemples si dessous, "+" représente l'opérateur que vous créez

Si l'opérateur accepte un paramètre, alors il sera utilisable sous la forme : a+b s'il ne contient que des symboles de la liste !%&*+-./<=>@^|~, sinon il sera utilisable sous la forme a + b (notez les espaces)

Si l'opérateur n'accepte aucun paramètre, alors il sera utilisable sous la forme +a s'il ne contient que des caractère de la liste, sinon il sera utilisable sous la forme + a (notez l'espace)

Interfaces

interface IMyInterface {
    public String a
    public Int b
    public Void c(Int a, b)
}

Héritage d'interface

interface IMySecondInterface < IMyInterface {
    public List<Int> d
    public Dict<String> e
}

Héritage d'interfaces multiples

interface IMySecondInterface < IMyInterface, ISecondInterface {
    public Float y
    public Bool z
}

Implémentation d'interfaces

class A implements IMySecondInterface { }

Créer une instance de classe

MyClass a = new MyClass()
# ou
MyClass a = new() # à discuter

Créer une instance de classe générique

MyClass<T> a = new MyClass<T>()
# ou
MyClass<T> a = new MyClass()
# ou
MyClass<T> a = new() # à discuter

Accès aux attributs et méthodes

MyClass a = new MyClass()
a.attr # attribut
a.add(5, 20) # méthode

Accès à des valeurs statiques

MaClass.attr # attribut statique
MyClass.method() # méhode statique
Raw
control_structures.md

Conditions

if condition {
  # code
} else if condition {
  # code
} else {
  # code
}

Boucle loop

loop { }
loop 5 { }
loop 8 by 2 { }

Boucle while

while condition { }
do { } while condition

Boucle for

for i = 0 to 5 { }
for i = 0 to 8 by 2 { }
for k, v in myString { }
for k, v in myList { }
for k, v in myDict { }
for k, v in myIterable { }

# Il est possible de ne récupérer que la valeur
for v in myIterable { }

# Il est possible d'affecter une condition à la boucle
for i = 0 to 20 if i % 5 == 0 { }

# seuls les caractères après 'f' seront traversés (ghijklmnopqrstuvwxyz)
for v in myString if v > 'f' { }

Listes de compréhension

List<UInt> ages = [ 2, 22, 14, 16, 18, 20, 5 ]
List<UInt> major = [ age for age in ages if age >= 18 ] # = 22, 18, 20
Raw
enums.md

Une énumération

enum MyEnum { A, B, C, D }

À chaque valeur de l'énumération est associé une valeur qui commence à 0 et incrémente à chaque fois

Sur plusieurs lignes

enum MyEnum {
    A
    B
    C
    D
}

Avec des valeurs assignées

enum MyEnum {
    A # = 0
    B = 6
    C = 20
    D # = 21
}

La valeur assignée est obligatoirement un nombre

Avec des valeurs internes

enum MyEnum {
    A(Int, Int)
    B(String, String)
    C(Int, String)
    D(String, Int)
}

Assigner la valeur d'une énumération à une variable

MyEnum maVar = MyEnum.A
# ou (syntaxe raccourcie)
MyEnum maVar = .A

Assigner la valeur d'une énumération avec valeur interne à une variable

MyEnum maVar = MyEnum.A(5, 5)
# ou (syntaxe raccourcie)
MyEnum maVar = .A(5, 5)
Raw
ideas.md
Raw
matches.md

Capturer des valeurs

match variable {
    0 { }
    1 { }
    2 { }
}

Capturer des plages de valeurs

match variable {
    0 .. 9    { } # [0;9]
    10 ... 14 { } # [10;14[
}

Capturer des tableaux

match variable {
    [ 0, 5 ] { }
    [ a, v ] { }
}

Capturer des énumérations

match variable {
    A { }
    B { }
    C { }
    D { }
}

Capturer des énumérations avec valeurs internes

match variable {
    A(a, b) { }
    B(a, b) { }
    C(a, b) { }
    D(a, b) { }
}

Capturer plusieurs valeurs

match variable {
    0, 4 { }
    1, 3 { }
    2    { }
}

Défaut

match variable {
    0 { }
    1 { }
    2 { }
    _ { } # = else, default
}

Condition

match variable {
    0 ... 10     { } # [0;10[
    v if v >= 10 { } # [10;+∞[
    _            { } # < 0
}
Raw
syntax.md

Les noms de variables acceptent n'importe quels caractères :

Float π = 3.1415926

Les déclarations de visibilité affectent tout ce qui se trouve après elle (dans le même bloc) et non pas seulement ce devant quoi elles sont écrites :

public
Bool a
String b

Ici public affecte les variables a et b

public
Bool a
class B { }

protected
interface IMyInterface { }

private
Int b
String c

Cela fonctionne pareil pour les types, exceptés que le nom des variables doivent êtres séparés par des virgules :

public Int a, b
private String c, d, e
protected Int f = 0, g = 1
public Int f = g = 0

Pour déclarer une référence, utilisez le mot-clé ref :

private Int a = 0
public Int b = ref a
b = 5
# a = 5

"Binder" une fonction :

Num add(Num a, b) { a + b } # Num, Num -> Num
Num add5 = add(_, 5) # Num -> Num

Num a = add5(20) # = 25

Fonction variadique :

Num add(Num ...args) { }

# appel de la fonction
add() # args = [ ]
add(1, 2, 3) # args = [ 1, 2, 3 ]
add(...[ 1, 2, 3 ]) # args = [ 1, 2, 3 ]

# sans l'utilisation de "...", c'est le tableau qui passe en paramètre à args et non ses valeurs
add([ 1, 2, 3 ]) # args = [ [ 1, 2, 3 ] ]

Les méthodes et fonctions retournent par défaut la dernière valeur du code :

Num add(Num a, b) { a + b }
Num myNum = add(10, 50) # = 60

Cela fonctionne aussi avec les structures de contrôle :

String getName(Int val) {
  match val {
    2 .. 9 { val.to_str() }
    10     { "Valet" }
    11     { "Dame" }
    12     { "Roi" }
    1, 13  { "As" }
  }
}

String card1 = getName(5) # = "5"
String card2 = getName(13) # = "As"

Vous pouvez retourner explicitement une valeur en utilisant le mot-clé return :

Num add(Num a, b) {
  if a < b {
    return 0
  }

  if b >= a {
    a + b
  } else {
    1
  }
}

Les variables sont passées par référence dans les fonctions et méthodes. Pour vous protéger de cela, utilisez le mot-clé noref :

Void increment(Num i) { i += 1 }
Num decrement(noref Num i) { i -= 1 }

Num maVar = 5
increment(maVar) # maVar = 6
increment(maVar) # maVar = 7
decrement(maVar) # maVar = 7
maVar = decrement(maVar) # maVar = 6

Les classes, les énumérations et les structures peuvent posséder des méthodes.

Raw
tuples.md
  • Tuples : (Int, Int) (ex : (Int, Int) p = (5, 20) ; p.0 ; p[0] ; p.get(0))
  • Tuples nommés : (Int x, Int y) (ex : (Int x, Int y) p = (5, 20) ; p.x ; p["x"] ; p.get("x"))
Raw
types.md

Booléens

Bool

Valeurs possibles : true ou false

Types numériques

Type Bits
Int, UInt 32
Long, ULong 64
Int8, UInt8 8
Int16, UInt16 16
Int32, UInt32 32
Int64, UInt64 64
Type Bits
Float 32
Double 64
LDouble 96

Num est le type qui représente indifféremment tous ces types.

Types textuels

Char
String

Char représente un caractère seul avec que String est une suite de caractères. Si une méthode accepte le type String, alors il est possible de passer un caractère :

# Char
'a'
# '\xHH'
'\\'

# String
"Une chaine"
"""Une autre chaine"""
String concat(String a, b) { a + b }
String hello = concat("Hello World", '!')

Listes

List<T>
Set<T> # liste sans doublon
List<Num> a = [ 0, 1, 2 ] # ok
Set<Num> b  = [ 0, 1, 2 ] # ok

List<Num> c = [ 0, 1, 1, 2 ] # = [ 0, 1, 1, 2 ]
Set<Num> c = [ 0, 1, 1, 2 ] # = [ 0, 1, 2 ]

# accès
a.0
a[0]
a.get(0)

Dictionnaires

Dict<T>
Dict<Num> a = { a: 0, b: 1, c: 2 }

# accès
a.a
a["a"]
a.get("a")
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment