189 lines
3.7 KiB
Plaintext
189 lines
3.7 KiB
Plaintext
TITLE Porównanie Musique z typowymi językami programowania
|
|
|
|
BEGIN CSS
|
|
table, tr, td {
|
|
font-size: 12pt;
|
|
border: 1pt solid #DDDDDD;
|
|
border-collapse: collapse;
|
|
vertical-align: top;
|
|
}
|
|
|
|
td, th {
|
|
padding: 2px;
|
|
}
|
|
|
|
END CSS
|
|
|
|
BEGIN INTRO
|
|
<h1>Ściągawka Musique, a Python i Ruby</h1>
|
|
Ponieważ Musique jest kierowany do osób posiadających doświadczenie z muzyką algorytmiczną, szybkim sposobem na podstawowe poznanie języka jest porównanie z innymi technologiami w tej dziedzinie. Ten dokument służy bardziej ukazaniu różnic niż omówieniu samego języka.
|
|
END INTRO
|
|
|
|
BEGIN TABLE
|
|
|
|
SECTION Podstawy
|
|
|
|
n Kategoria
|
|
m Musique
|
|
p Python
|
|
r Ruby (SonicPi)
|
|
c Komentarz
|
|
|
|
n Deklaracja
|
|
m x := 0
|
|
p x = 0
|
|
r x = 0
|
|
c Zmienne należy zadeklarować by móc z nich korzystać
|
|
|
|
n Aktualizacja
|
|
m x = 1
|
|
r x = 1
|
|
p x = 1
|
|
|
|
n Operacje matematyczne
|
|
m x = 10 * 30 - 40 ** 2
|
|
p x = 10 * 30 - 40 ** 2
|
|
r x = 10 * 30 - 40 ** 2
|
|
c Zarówno Python, Ruby jak i Musique posiadają operator potęgi **
|
|
|
|
n Funkcja anonimowa
|
|
m add := [x y | x + y]
|
|
p add = lambda x, y: x + y
|
|
r add = ->(x, y) { x + y }
|
|
|
|
n Deklaracja funkcji
|
|
m add := [x y |
|
|
m say x y;
|
|
m x + y
|
|
m ]
|
|
p def add(x, y):
|
|
p print(x, y)
|
|
p return x + y
|
|
r def add(x, y)
|
|
r puts x, y
|
|
r return x + y
|
|
r end
|
|
c Musique nie rozróżnia funkcji anonimowych i zadeklarowanych
|
|
|
|
n Wywoływanie funkcji
|
|
m add 1 3
|
|
p add(1, 3)
|
|
r add 1, 3
|
|
|
|
n Wywołanie funkcji
|
|
n nie przymujących argumentów
|
|
m constant := [ say 42; 10 ];
|
|
m say (call foo)
|
|
p def constant():
|
|
p print(42)
|
|
p return 10
|
|
p print(constant())
|
|
r def constant()
|
|
r puts(42)
|
|
r return 10
|
|
r end
|
|
r puts constant
|
|
|
|
n Instrukcja warunkowa
|
|
m if (n == 42)
|
|
m [ say 1 ]
|
|
m [ say 2 ]
|
|
p if n == 42:
|
|
p print(1)
|
|
p else:
|
|
p print(2)
|
|
r if n == 42
|
|
r puts 1
|
|
r else
|
|
r puts 2
|
|
r end
|
|
c Musique nie posiada instrukcji warunkowej, a funkcję if,
|
|
c która przyjmuje wartość logiczną i dwa bloki (funkcje anonimowe)
|
|
c - jeden z nich zostanie wykonany jeśli warunek jest prawdziwy,
|
|
c a drugi jeśli jest fałszywy.
|
|
|
|
n Wyrażenie warunkowe
|
|
m x := if (n == 42) [1] [2]
|
|
p x = 1 if n == 42 else 2
|
|
r x = n == 42 ? 1 : 2
|
|
|
|
SECTION Tablice
|
|
|
|
n Kategoria
|
|
m Musique
|
|
p Python
|
|
r Ruby (SonicPi)
|
|
c Komentarz
|
|
|
|
n Tablice
|
|
m x = [1; 2; 3; 4]
|
|
p x = [1, 2, 3, 4]
|
|
r x = [1, 2, 3, 4]
|
|
c W Musique funkcja anonimowa nie przyjmująca argumentów
|
|
c jak i tablica są tożsame.
|
|
|
|
n Nty element tablicy
|
|
m x.n
|
|
p x[n]
|
|
r x[n]
|
|
|
|
n Aktualizacja ntego elementu tablicy
|
|
m x = update x n 10
|
|
p x[n] = 10
|
|
r x[n] = 10
|
|
|
|
n Tablica od 0 do 9 włącznie
|
|
m x = up 10
|
|
p x = list(range(10))
|
|
r x = [*0..9]
|
|
|
|
n Tablica od 1 do 10 włącznie
|
|
m x = 1 + up 10
|
|
m lub x = range 1 11
|
|
p x = list(range(1, 11))
|
|
r x = [*1..10]
|
|
|
|
n Tablica od 9 do 0 włącznie
|
|
m x = down 10
|
|
m lub x = reverse (up 10)
|
|
p x = list(range(9, -1, -1))
|
|
p lub x = list(reversed(range(10)))
|
|
r x = 9.downto(0).to_a
|
|
|
|
n Iloczyn elementów tablicy
|
|
m fold '* (1 + up 5)
|
|
p functools.reduce(
|
|
p operator.mul, range(1, 6), 1)
|
|
r [*1..5].inject(:*)
|
|
c Musique pozwala zmienić dowolny operator w funkcję
|
|
c poprzez zapis 'operator jak '* w przykładzie
|
|
|
|
n Iteracja po elementach tablicy
|
|
m for (up 5) [ i | say i ]
|
|
p for i in range(5):
|
|
p print(i)
|
|
r (0..4).each do |i|
|
|
r puts i
|
|
r end
|
|
c Podobnie jak w przypadku instrukcji warunkowej, Musique używa funkcji.
|
|
|
|
n Sortowanie tablicy
|
|
m xs := sort [1; 5; 3; 3; 2]
|
|
p xs = sorted([1, 5, 3, 3, 2])
|
|
r xs = [1, 5, 3, 3, 2].sort
|
|
|
|
n Sortowanie wielu tablic w jedną
|
|
m xs := sort [1; 5; 3; 3; 2]
|
|
m [3; 4; 5] 1 2 3
|
|
p xs = sorted(itertools.chain(
|
|
p [1, 5, 3, 3, 2], [3, 4, 5],
|
|
p [1], [2], [3]
|
|
p ))
|
|
r [[1, 5, 3, 3, 2], [3, 4, 5],
|
|
r [1], [2], [3]
|
|
r ].flatten.sort
|
|
c Wiele operacji na tablicach może być wykonywane na dowolnej kombinacji
|
|
c tablic i pojedyńczych wartości. Tworzy to jedną tablicę wykoniową.
|
|
|
|
END TABLE
|