omar-3

omar-3

proc notAdd(a: int, b: int) {
    return (a + b , a + b);
}

proc notMul(a: int, b: int) {
    return (a*b , a*b);
}

var h = [notAdd, notMul, notAdd, notMul, notAdd];

omar-3

// this method would be super cool in databases for example in a world without GROUP BY sql command :D


use Set;
use List;
use RangeChunk;

// takes iterable of object or any stuff
// function is the thing that is common between multiple
// of some objects in iterable

omar-3

use RangeChunk;
use Time;


// serial

iter starmap(array, function) {
  var iterable = array;         // I know that I don't need to copy "array" to new variable "iterable"
  for i in iterable {
    yield function((...i));

omar-3

use RangeChunk;
use Time;

iter filter(array, function) {
  for i in array {
    if function(i) {
      yield i;
    }
  }
}

omar-3

use RangeChunk;
use Time;

iter dropwhile(array, function) {
  var iterable = array;
  var barrier = false;
  for i in iterable {
    if function(i){
      barrier = true;
    }

omar-3

use RangeChunk;

iter compress(array, trutharray) {
  for (i,j) in zip(array, trutharray) {
    if j {
      yield i;
    }
  }
}

omar-3

Functional Programming Module

This proposal is an extension to itertools project, in which I propose an implementation for a complete-ish functional programming module, with consideration of the current state of Chapel compiler.

---

Table of contents

omar-3

var tobeAdded = (1,2,3);                // this would be the input to the partial object

proc adds(a:int, b:int, c:int, d:int) {     // this is the function which we want to have 10 as constant input
    return a+b+c+d;                         // and vary the value of "b", "c", "d" 
}

var constant = 10;                          // this is "a"


writeln(adds(constant,(...tobeAdded)));     // a is constant and b, c, d are filled from the expanded tuple

omar-3

use Sort;

// partitioning between tasks algorithms

// we need to get ALL the permutations of [1,2,3,4,5] so we know
// that if we generate them in lexicographical order we would have
// [1, 2, 3, 4, 5] as the first permutation and [5, 4, 3, 2, 1] as the last permutation
// the partition function do the following:
// assume we have 4 tasks we need to distribute the whole lexicographical range of all permutations
// into 4 intervals. so assume we insert arr to be [1,2,3,4,5] and numOfTasks to 4 tasks