Add tasks for all the new languages

Task/Generator-Exponential/EchoLisp/generator-exponential.echolisp

@@ -0,0 +1,36 @@
+(lib 'tasks) ;; for make-generator
+
+;; generator of generators
+(define (gen-power power)
+	(make-generator
+		(lambda(n) (yield (expt n power)) (1+ n))  1))
+		
+(define powers-2 (gen-power 2))
+(define powers-3 (gen-power 3))
+
+(take powers-3 10)
+    → (1 8 27 64 125 216 343 512 729 1000)
+
+;; generators substraction
+;; input : two generators ga, gb - Sequences must be increasing
+;; output : new generator  = ga sequence minus gb sequence
+
+(define (gen-substract ga gb)
+	(define (substract b (a))
+	(set! a (next ga))
+	(while (>= a b) ; avance b until > a
+		(when (= a b) (set! a (next ga)))
+		(set! b (next gb)))
+	(yield a)
+	b ) ;; b := next state
+	(make-generator substract (next gb)))
+
+;; application
+(define task    (gen-substract (gen-power 2) (gen-power 3)))
+
+(drop task 20)
+(take task 10)
+    → (529 576 625 676 784 841 900 961 1024 1089)
+
+; inspect
+task → #generator:state: 1331

Task/Generator-Exponential/FunL/generator-exponential.funl

@@ -0,0 +1,8 @@
+def powers( m ) = map( (^ m), 0.. )
+
+def
+  filtered( s@sh:_, ch:ct ) | sh > ch = filtered( s, ct )
+  filtered( sh:st, c@ch:_ ) | sh < ch = sh # filtered( st, c )
+  filtered( _:st, c ) = filtered( st, c )
+
+println( filtered(powers(2), powers(3)).drop(20).take(10) )

Task/Generator-Exponential/Nim/generator-exponential.nim

@@ -0,0 +1,40 @@
+proc `^`*(base: int, exp: int): int =
+  var (base, exp) = (base, exp)
+  result = 1
+
+  while exp != 0:
+    if (exp and 1) != 0:
+      result *= base
+    exp = exp shr 1
+    base *= base
+
+proc next(s): int =
+  for n in s(): return n
+
+proc powers(m): auto =
+  iterator it(): int{.closure.} =
+    for n in 0 .. <int.high:
+      yield n ^ m
+  return it
+
+iterator filtered(s1, s2): int =
+  var v = next(s1)
+  var f = next(s2)
+  while true:
+    if v > f:
+      f = next(s2)
+      continue
+    elif v < f:
+      yield v
+    v = next(s1)
+
+var
+  squares = powers(2)
+  cubes = powers(3)
+  i = 1
+for x in filtered(squares, cubes):
+  if i > 20:
+    echo x
+  if i >= 30:
+    break
+  inc i

Task/Generator-Exponential/Sidef/generator-exponential.sidef

@@ -0,0 +1,28 @@
+func gen_pow(m) {
+    var e = 0;
+    func { e++ ** m };
+}
+
+func gen_filter(g1, g2) {
+    var v2 = g2.run;
+    func {
+        loop {
+            var v1 = g1.run;
+            while (v1 > v2) { v2 = g2.run };
+            v1 == v2 || return v1;
+        }
+    }
+}
+
+# Create generators.
+var squares = gen_pow(2);
+var cubes = gen_pow(3);
+var squares_without_cubes = gen_filter(squares, cubes);
+
+# Drop 20 values.
+20.times { squares_without_cubes() };
+
+# Print 10 values.
+var answer = [];
+10.times { answer.append(squares_without_cubes()) };
+say answer;

Task/Generator-Exponential/Swift/generator-exponential.swift

@@ -0,0 +1,47 @@
+func powGen(m: Int) -> GeneratorOf<Int> {
+  let power = Double(m)
+  var cur: Double = 0
+  return GeneratorOf { Int(pow(cur++, power)) }
+}
+
+var squares = powGen(2)
+var cubes = powGen(3)
+
+var nCube = cubes.next()
+
+var filteredSqs = GeneratorOf<Int> {
+  for var nSq = squares.next() ;; nCube = cubes.next() {
+    if nCube > nSq {
+      return nSq
+    } else if nCube == nSq {
+      nSq = squares.next()
+    }
+  }
+}
+
+extension GeneratorOf {
+  func drop(n: Int) -> GeneratorOf<T> {
+    var g = self
+    for _ in 0..<n {g.next()}
+    return GeneratorOf{g.next()}
+  }
+  func take(n: Int) -> GeneratorOf<T> {
+    var (i, g) = (0, self)
+    return GeneratorOf{++i > n ? nil : g.next()}
+  }
+}
+
+for num in filteredSqs.drop(20).take(10) {
+  print(num)
+}
+
+//529
+//576
+//625
+//676
+//784
+//841
+//900
+//961
+//1024
+//1089

Task/Generator-Exponential/jq/generator-exponential-1.jq

@@ -0,0 +1,5 @@
+# Compute self^m where m is a non-negative integer:
+def pow(m): . as $in | reduce range(0;m) as $i (1; .*$in);
+
+# state: [i, i^m]
+def next_power(m): .[0] + 1 | [., pow(m) ];

Task/Generator-Exponential/jq/generator-exponential-2.jq

@@ -0,0 +1,7 @@
+# skip m states, and return the next state
+def skip(m; next):
+  if m <= 0 then . else next | skip(m-1; next) end;
+
+# emit m states including the initial state
+def emit(m; next):
+  if m <= 0 then empty else ., (next | emit(m-1; next)) end;

Task/Generator-Exponential/jq/generator-exponential-3.jq

@@ -0,0 +1,5 @@
+# Generate the first 4 values in the sequence i^2:
+[0,0] | emit(4; next_power(2)) | .[1]
+
+# Generate all the values in the sequence i^3 less than 100:
+[0,0] | recurse(next_power(3) | if .[1] < 100 then . else empty end) | .[1]

Task/Generator-Exponential/jq/generator-exponential-4.jq

@@ -0,0 +1,27 @@
+# Infrastructure:
+def last(f): reduce f as $i (null; $i);
+
+# emit the last value that satisfies condition, or null
+def while(condition; next):
+  def w: if condition then ., (next|w) else empty end;
+  last(w);
+
+# Powers of m1 that are not also powers of m2.
+# filtered_next_power(m1;m2) produces [[i, i^m1], [j, j^m1]] where i^m1
+# is not a power of m2 and j^m2 < i^m1
+#
+def filtered_next_power(m1; m2):
+  if . then . else [[0,0],[0,0]] end
+  | (.[0] | next_power(m1)) as $next1
+  | (.[1] | while( .[1] <= $next1[1]; next_power(m2))) as $next2
+  | if $next1[1] == $next2[1]
+    then [$next1, $next2] | filtered_next_power(m1;m2)
+    else [$next1, $next2]
+    end ;
+
+# Emit ten powers of 2 that are NOT powers of 3,
+# skipping the first 20 integers satisfying the condition, including 0.
+filtered_next_power(2;3)
+  | skip(20; filtered_next_power(2;3))
+  | emit(10; filtered_next_power(2;3))
+  | .[0][1]

Task/Generator-Exponential/jq/generator-exponential-5.jq

@@ -0,0 +1,11 @@
+$ jq -n -f generators.jq
+529
+576
+625
+676
+784
+841
+900
+961
+1024
+1089