add examples

Author: jl3937

example

@@ -0,0 +1 @@
+song = [ 1 2 | 3 ^7 ];

example1

@@ -0,0 +1,2 @@
+key = #2;
+song = [ 1 2 3 4 | 5 6 7 ^1 ];

example2

@@ -0,0 +1,5 @@
+tempo = 200;
+
+song = [ _melody  melody  ^melody  (^^1, 3)] ;
+
+melody = [ 1 3 5 |];

example3

@@ -0,0 +1,29 @@
+tempo = 300;
+song = [
+ _5 3 2 1 | (mordent _5 4) | _5 3 2 1 | _(6, 4) |
+ _6 4 3 2 | _(7, 3) 5 | 5 5 4 2 | (3, 4) |
+ _5 3 2 1 | _(5, 4) | _5 3 2 1 | _(6, 4) |
+ _6 4 3 2 | 5 5 (5, 2) | 6 5 4 2 | (1, 4) |
+ 3 3 (3, 2) | 3 3 (3, 2) | 3 5 1 2 | (3, 4) |
+ 4 4 (4, 2) | 4 3 (3, 2) | 3 2 2 1 | (2, 2) (5, 2) |
+ 3 3 (3, 2)| 3 3 (3, 2) | 3 5 1 2 | (3, 4) |
+ 4 4 (4, 2)| 4 3 (3, 2) | 5 5 4 2 | (1, 2) (chord 1 2) |
+] ;
+
+/*
+The following chord got two parameters: p is a pitch variable and d is a duration variable. The four keys in this chord have the same duration d. The second pitch is 2 higher than p. For example, if p is 1, then the second pitch is 3. Likewise, the third pitch is 5 and the fourth pitch is ^1.
+*/
+
+chord p d = {
+(p, d)
+(+ p 2, d)
+(+ p 4, d)
+(+ p 7, d) } ;
+
+/*
+Suppose p is the middle C and d is a quarter notes. The corresponding representation for the above chord in staff notation is:
+
+Similarly, the following chord got two parameters: p is a pitch variable and d is a duration variable.  The keys in a mordent happen one after another. Each key could have different pitch and different duration. In the following example, the pitch for the first key and the third key are the same p while the second key has a pitch 1 higher than the others. When it comes to duration, the duration for the first key and for the second key are the same, namely a quarter of duration d. The duration for the third key is a half of duration d. 
+*/
+
+mordent p d = [ (p, / d 4) (+ p 1, / d 4) (p, / d 2) ];

example4

@@ -0,0 +1,48 @@
+tempo = 300;
+song = { m1 (m2 a b c e) } ;
+
+m1 = [
+ _5 3 2 1 | (mordent _5 4 1) | _5 3 2 1 | (mordent _6 4 2) |
+ _6 4 3 2 | (_7, 3) 5 | 5 5 4 2 | (3, 4) |
+ _5 3 2 1 | (_5, 4) | _5 3 2 1 | (_6, 4) |
+ _6 4 3 2 | 5 5 (5, 2) | 6 5 4 2 | (1, 4) |
+ 3 3 (3, 2) | 3 3 (3, 2) | 3 5 1 2 | (3, 4) |
+ 4 4 (4, 2) | 4 3 (3, 2) | 3 2 2 1 | (2, 2) (5, 2) |
+ 3 3 (3, 2)| 3 3 (3, 2) | 3 5 1 2 | (3, 4) |
+ 4 4 (4, 2)| 4 3 (3, 2) | 5 5 4 2 | (1, 2) (chord 1 2) |
+] ;
+
+chord p d = {
+(p, d)
+(+ p 2, d)
+(+ p 4, d)
+(+ p 7, d) } ;
+
+mordent p d v = [ (p, / d 8) (+ p v, / d 8) (p, * 3 (/ d 4)) ] ;
+
+/*
+The following short melodies are used as parameter for the melody m2.
+*/
+
+a = [_1 _3 __5 _3 |];
+b = [__6 _1 __4 _1 |];
+c = [ __7 _2 __5 _2 |];
+e = [ __7 _2 _2 _2 |];
+
+/*
+The corresponding representation for the above short melodies in staff notation is:
+
+
+The following melody function takes in four short melodies as its parameters and uses them to build a longer melody.
+*/
+
+m2 a b c d = [
+a a a b
+b c c a
+a a a b
+b c d 1 (1, / 1 2) (1, / 1 2) 1 1 |
+a a a a
+b a a e
+a a a a
+b a e (_1, 2) (1, 2) |
+];

example5

@@ -0,0 +1,48 @@
+song = [
+/* every line of song is a randomly selected note and triad combination. After listening to the midi file produced, the composer could determine whether he or she likes it*/
+[(MajorTriad  1) (MinorTriad 3) (MinorTriad &5) (MajorTriad &7)]
+/*Noticing that (MajorTriad 1) is an application of function MajorTriad and it takes 1 as parameter of type note*/
+[(MajorTriad  #1) (MajorTriad 4) (MinorTriad &6) (MinorTriad 6)]
+	/*Noticing that # stands for sharp symbol, & stands for flat symbol*/
+];
+
+/*The corresponding representation for the above song in staff notation is as followed: */
+
+
+/*Below implements the basic major triad and minor triad func needed*/
+/* raise is a built-in func that increase n semitone, which can be referred to later chapter for its implemetation*/
+MajorThird p = raise 4 p ;   /* MajorThird returns a major third note over p*/
+MinorThird p = raise 3 p ;   /* MajorThird returns a minor third note over p*/
+MajorTriad p = {
+p
+(MajorThird p)
+(MinorThird (MajorThird p))
+} ;
+
+MinorTriad p = {
+p
+(MinorThird p)
+(MajorThird (MinorThird p))
+} ;
+AugmentedTriad p = {
+p
+(MajorThird p)
+(MajorThird (MajorThird p))
+} ;
+DimnishedChord p d = {
+p
+(MinorThird p)
+(MinorThird (MinorThird p))
+} ;
+
+raise n p = if (< n 0)
+    (lower (- 0 n) p)
+    (if (== 0 n)
+        p
+        (raise (- n 1) #p)) ;
+
+lower n p = if (< n 0)
+    (raise (- 0 n) p)
+    (if (== 0 n)
+        p
+        (lower (- n 1) &p)) ;

example6

@@ -0,0 +1,51 @@
+song = { (timeBound 9 m1)
+         (timeBound 9 m2) } ;
+
+series = [ 1 2 3 4 5 6 7 ^1] ;
+
+/*
+This is just a simple sequential list which we have seen before.
+*/
+
+timeBound t xs =
+    if (or (nil? xs)
+           (< t (time (car xs))))
+        []
+        (seq (car xs)
+             (timeBound (- t (time (car xs))) (cdr xs))) ;
+
+/*
+Here we define a function which take two argument, the first one t should be a number represent a duration bound, the second one is a sequencial list. The function returns a sequence which is the longest prefix of xs within the duration bound.
+
+In above definition, time is a primitive function takes an arbitrary melody as argument and return its duration. 
+*/
+
+raise n p = if (< n 0)
+    (lower (- 0 n) p)
+    (if (== 0 n)
+        p
+        (raise (- n 1) #p)) ;
+
+lower n p = if (< n 0)
+    (raise (- 0 n) p)
+    (if (== 0 n)
+        p
+        (lower (- n 1) &p)) ;
+
+/*
+Here we define two function to repeatedly apply # or & operator to raise or lower the pitch of a melody.
+*/
+
+m1 = seq (lower 2 series) #m1 ;
+m2 = seq (raise 2 series) &m2 ;
+
+/*
+Here, we define m1 and m2 using function seq. seq is a function to construct a sequential list. seq would normally take 2 arguments. For example
+
+seq 4 [3 4] -> [4 3 4]
+seq 3 [] -> [3]
+
+In above definition, m1 and m1 is defined to be a sequential list where its first element is a given melody, its rest elements also form a sequential list. And this sequential list is defined to be #m1 or &m2.
+
+As we can see, the length of melody is infinite. But it is ok in RYC since RYC will only compute the list elements just when they are needed. We just need to take only part of it as our final result song. 
+*/

example7

@@ -0,0 +1,3 @@
+song = f m [1 2];
+f fun arg = fun arg;
+m x = [1 2];

example8

@@ -0,0 +1,2 @@
+song = car [1 a];
+a = [2 3];

example9

@@ -0,0 +1,5 @@
+song = a 3 m;
+m = [1 2 3];
+a repeat melody = if (<= repeat 0)
+[]
+(seq melody (a (- repeat 1) melody));

queens

@@ -0,0 +1,77 @@
+/* vim: set expandtab filetype=haskell : */
+
+tempo = 400 ;
+
+song = search-queen 1 ; 
+
+/*song = test [4 4] 5 ;*/
+
+test xs x =
+    if (nil? xs)
+            true
+            (let sadfsa = 1;
+             in and (<> x (car xs))
+                    (test (cdr xs) x)) ;
+
+test xs x =
+    let go n rs = if (nil? rs)
+            true
+            (let asdfasd = 1 ;
+             in and (<> x (car rs))
+                    (go (+ 1 n) (cdr rs))) ;
+    in go 1 xs ;
+
+search-queen size =
+    let ns = genListFromToStep 1 size 1 ;
+        go n xs = if (== n size)
+            [xs]
+            (concat (map (go (+ 1 n))
+                    (map (\x -> seq x xs)
+                    (filter (valid-queen? xs) ns)))) ;
+    in go 0 [] ;
+
+valid-queen? xs x =
+    let go n rs = if (nil? rs)
+            true
+            (let r' = car rs ; rs' = cdr rs ;
+             in and (<> x r')
+               (and (<> x (+ r' n))
+               (and (<> x (- r' n))
+                    (go (+ 1 n) rs')))) ;
+    in go 1 xs ;
+
+genListFromToStep from to step =
+    let go n = if (> n to)
+            []
+            (seq n (go (+ n step))) ;
+    in go from ;
+
+length xs = if (nil? xs)
+    0
+    (+ 1 (length (cdr xs))) ;
+
+append = appendSeq ;
+appendSeq xs ys = if (nil? xs)
+    ys
+    (let x' = car xs ; xs' = cdr xs ;
+     in seq x' (appendSeq xs' ys)) ;
+
+concat = concatSeq ;
+concatSeq xs = if (nil? xs)
+    []
+    (let x' = car xs ; xs' = cdr xs ;
+     in appendSeq x' (concatSeq xs')) ;
+
+map = mapSeq ;
+mapSeq f xs = if (nil? xs)
+    []
+    (let x' = car xs ; xs' = cdr xs ;
+     in seq (f x') (mapSeq f xs')) ;
+
+filter = filterSeq ;
+filterSeq p xs = if (nil? xs)
+    []
+    (let x' = car xs ; xs' = cdr xs ;
+     in if (p x')
+         (seq x' (filterSeq p xs'))
+         (filterSeq p xs')) ;