Accéder au git associé

Discutons ici, ensemble, du langage de programmation Bootmonkey.

Commentaires

# uniligne

###
multiligne
###

Conditions

if

if condition
  ...
else if condition
  ...
else
  ...

switch

switch maVar
  1
    ...
  2
    ...
  else
    ...

Boucles

while

while condition
  ...

do-while

do
  ...
while condition

for

for i = 0 to 50 by 2
  ...

loop

loop
  ...

Structures

struct Person
  String firstname, lastname
  Int age

Person yannick = Person {
  firstname = "Yannick",
  lastname  = "A.",
  age       = 20
}

io.println(yannick.firstname)

Enumérations

enum Dir
  Top
  Down
  Right
  Left

Dir myDir = Dir.Top

Fonctions

Num add(Num a, b)
  return a + b

Num num1 = 5
Num num2 = 3.14
Num num3 = add(num1, num2)

Références

Variable référente

Num a = 5
Num b = ref a

b = 50
# a = 50
a = 20
# b = 20

Référence dans la signature de la fonction

Void changeFirstName(ref Person person, String newFirstName)
  person.firstName = newFirstName

changeFirstName(yannick, "Paul")

Référence lors de l'appel de la fonction

Void changeLastName(Person person, String newLastName)
  person.lastName = newLastName

changeLastName(ref yannick, "B.")

Types

Primitifs

Bool
Num (Int, Float, ...)
Char
String

Tableaux et dictionnaires

Int[] ages = [ 3, 18, 22, 16 ]
Int{} persons = {
  guillaume = 16,
  yannick   = 20,
  aurelie   = 21
}

Packages

L'importation permet d'utiliser les variables, fonctions, structures et énumérations d'un autre fichier. Contrairement à Java où un fichier comporte une seule classe, Bootmonkey peut avoir des fichiers qui comporte un nombre, théoriquement, infini de fonctions, variables, etc.

!!!
Cette partie est à revoir
!!!

Importations

use math
Int a = math.max(5, 20)

use math as m
Int a = m.max(5, 20)

use math.max
Int a = max(5, 20)

use math.max as maximum
Int a = maximum(5, 20)

use math.[min, max]
Int a = max(5, 20)

use math.[min, max] as m
Int a = m.max(5, 20)

use math.*
Int a = max(5, 20)

use entity.[enemy.[Bat, Ogre], Player]
Bat bat = Bat { ... }

use entity.[enemy.[Bat, Ogre], Player] as e
e.Bat bat = e.Bat { ... }

Création

# fichier a.bm
pack mon.package
Float pi = 3.14

# fichier b.bm
use stdio as io
use mon.package.pi
io.println(pi)

Pour mieux structurer votre code, vous pouvez utiliser le mot-clé part, il permet de séparer un fichier en plusieurs, utile pour éviter d'avoir un package qui contient tout :

# monfichier.bm
pack mon.package

part 'a.bm'
part 'b.bm'
part 'c.bm'

# a.bm
Float pi = 3.14

# b.bm
Num add(Num a, b)
  return a + b

# c.bm
Void delete(ref Void a) # Void accepte n'importe quel type d'argument
  a = null

Exemple complexe

# player.bm
struct Player
  Int x, y
  Int w, h
  String name

Void playerTeleport(ref Player p, Int x, y)
  p.x = x
  p.y = y

# game.bm
use Player, playerTeleport
use math

Player player

Void main(String[] args)
  player = Player {
    x = 0,
    y = 0,
    w = 20,
    h = 10,
    name = "Sasha"
  }

  update()

Void update()
  loop
    playerTeleport(player, math.rand(0, 640), math.rand(0, 480))
Le plus pif des pifs

Tout le monde se fout de BM :'c

Booti's booting...

Ah, pas tout le monde ! :)

Le plus pif des pifs
Any<T>(List<T> list, (T -> Bool) condition) -> Bool
  for el in list do
    if condition(el) then
      return true
    end
  end

  return false
end

List<Num> ages = [ 14, 17, 22, 14 ]
has_major = Any(ages, (Num age) {
  return age >= 18
})

# ou (avec l'inférence des types et sucre syntaxique)

ages = [ 14, 17, 22, 14 ] # type déduit : List<Num>
has_major = ages.Any((age) { age >= 18 }) # "return" implicite
                                          # ages.Any( == Any(ages, 

# autre exemple

age_filter = (age) { age >= 18 }

if has_majors then
  majors = ages.Filter(age_filter)
else
  # no majors
end

Le plus pif des pifs

Mh... C'est pas moche :)
Faut voir ce que ça donne sur un code plus long :)

Booti's booting...

Vous devez être inscrit pour répondre à ce sujet.