Data update

Task/FizzBuzz/BabyCobol/fizzbuzz.cobol

@@ -0,0 +1,22 @@
+      * NB: ANY does not exist in BabyCobol so the elegant
+      * EVALUATE-based COBOL-style solution is impossible here.
+      * Note the subtly unbalanced IF/ENDs yet valid END at the end.
+       IDENTIFICATION DIVISION.
+       PROGRAM-ID. FIZZBUZZ.
+       DATA DIVISION.
+       01 INT PICTURE IS 9(3).
+       01 REM LIKE INT.
+       01 TMP LIKE INT.
+       PROCEDURE DIVISION.
+           LOOP VARYING INT TO 100
+               DIVIDE 3 INTO INT GIVING TMP REMAINDER REM
+               IF REM = 0
+               THEN DISPLAY "Fizz" WITH NO ADVANCING
+               DIVIDE 5 INTO INT GIVING TMP REMAINDER REM
+               IF REM = 0
+               THEN DISPLAY "Buzz" WITH NO ADVANCING
+               DIVIDE 15 INTO INT GIVING TMP REMAINDER REM
+               IF REM = 0
+               THEN DISPLAY ""
+               ELSE DISPLAY INT
+           END.

Task/FizzBuzz/Bruijn/fizzbuzz.bruijn

@@ -0,0 +1,11 @@
+:import std/Combinator .
+:import std/String .
+:import std/Number .
+
+main [y [[0 =? (+101) case-end case-rec]] (+1)]
+	case-rec str ++ "\n" ++ (1 ++0)
+		str fizzbuzz "FizzBuzz" (fizz "Fizz" (buzz "Buzz" (number→string 0)))
+			fizz =?(0 % (+3))
+			buzz =?(0 % (+5))
+			fizzbuzz fizz buzz fizz
+	case-end empty

Task/FizzBuzz/Langur/fizzbuzz-1.langur

@@ -1,3 +1,3 @@
 for .i of 100 {
-    writeln given(0; .i rem 15: "FizzBuzz"; .i rem 5: "Buzz"; .i rem 3: "Fizz"; .i)
+    writeln switch(0; .i rem 15: "FizzBuzz"; .i rem 5: "Buzz"; .i rem 3: "Fizz"; .i)
 }

Task/FizzBuzz/Refal/fizzbuzz.refal

@@ -0,0 +1,16 @@
+$ENTRY Go {
+    = <FizzBuzz 1>;
+};
+
+FizzBuzz {
+    101 = ;
+    s.N = <Prout <Item s.N>>
+          <FizzBuzz <+ 1 s.N>>;
+};
+
+Item {
+    s.N, <Mod s.N 15>: 0 = FizzBuzz;
+    s.N, <Mod s.N 5>: 0  = Buzz;
+    s.N, <Mod s.N 3>: 0  = Fizz;
+    s.N = s.N;
+};

Task/FizzBuzz/YAMLScript/fizzbuzz.ys

@@ -2,21 +2,18 @@
 
 # This program has multiple implementations of "fizzbuzz".
 
-# usage: ys fizzbuzz.ys [<count>] [<fizzbuzz-fn-#>]
+# usage: yamlscript fizzbuzz.ys [<count>] [<fizzbuzz-fn-#>]
 
 # The main function runs a certain requested fizzbuzz implementation function
 # for a certain requested number (default is 100).
 
-defn main(&[count impl]):
-  count =: count || 100
-  impl =:
-    str: impl || "1"
+defn main(count=100 impl=1):
   fizzbuzz =: "fizzbuzz-$impl"
 
-  when-not ENV."YS_TEST":
+  when-not ENV.'YS_TEST':
     say: "Running function '$fizzbuzz' with count=$count"
 
-  function =: resolve(symbol(fizzbuzz))
+  function =: resolve(fizzbuzz.symbol())
   result   =: function(count)
 
   mapv say: result
@@ -27,33 +24,32 @@ defn main(&[count impl]):
 
 defn fizzbuzz-1(n):
   map:
-    fn [x]:
+    fn(x):
       cond:
-        zero?(mod(x 15)) "FizzBuzz"
-        zero?(mod(x 5))  "Buzz"
-        zero?(mod(x 3))  "Fizz"
-        :else            x
-    =>: (1 .. n)
+        zero?(x % 15): 'FizzBuzz'
+        zero?(x % 5):  'Buzz'
+        zero?(x % 3):  'Fizz'
+        =>: x
+    =>: 1 .. n
 
 defn fizzbuzz-2(n):
   loop [i 1, l []]:
     if (i > n):
       =>: l
-      recur:
-        inc: i
+      recur inc(i):
         conj l:
           cond:
-            zero?(mod(i 15)) "FizzBuzz"
-            zero?(mod(i 5))  "Buzz"
-            zero?(mod(i 3))  "Fizz"
-            :else            i
+            zero?(i % 15): 'FizzBuzz'
+            zero?(i % 5):  'Buzz'
+            zero?(i % 3):  'Fizz'
+            =>: i
 
 defn fizzbuzz-3(n):
   map:
-    fn [x]:
+    fn(x):
       s =:
         str:
-          when zero?(mod(x 3)): "Fizz"
-          when zero?(mod(x 5)): "Buzz"
+          when zero?(x % 3): 'Fizz'
+          =>: (zero?(x % 5) && 'Buzz') || nil
       if empty?(s): x s
-    rng: 1, n
+    rng: 1 n