Alberto03_solutions.js

//Write a function identity that takes an argument and returns that argument
const identity = (x) => x;

//Write a binary function addb that takes two numbers and returns their sum
const addb = (a, b) => a + b;

//Write a binary function subb that takes two numbers and returns their difference
const subb = (a, b) => a - b;

//Write a binary function mulb that takes two numbers and returns their product
const mulb = (a, b) => a * b;

//Write a binary function minb that takes two numbers and returns the smaller one
const minb = (a,b) => {
  if(a < b){
    return a;
  }
  return b;
}

//Write a binary function maxb that takes two numbers and returns the larger one
const maxb = (a, b) => {
  if(a < b){
    return b;
  }
  return a;
}

//Write a function add that is generalized for any amount of arguments
const add = (...a) => {
   let sum = a.reduce( (acc, num) => acc + num, 0 );
   return sum;
}

//Write a function sub that is generalized for any amount of arguments
const sub = (...a) => {
  let sub = a.reduce( (acc, num) => {
    if(acc === 0){
      return acc = num;
    }
    else{
      return acc - num;
    }
  }, 0);
  return sub;
}

//Write a function mul that is generalized for any amount of arguments
const mul = (...a) => {
  let multiple = a.reduce( (acc, num) => {
    if(acc === 0){
      return acc = num;
    }else{
      return acc * num;
    }
  }, 0 );
  return multiple;
}

//Write a function min that is generalized for any amount of arguments
const min = (...a) => {
  let minimum = a.reduce( (acc, num) => {
    acc = acc < num ? acc : num;
    return acc;
  }, Infinity);
  return minimum;
}

//Write a function max that is generalized for any amount of arguments
const max = (...a) => {
  let maximum = a.reduce( (acc, num) => {
    return acc = acc > num ? acc : num;
  }, -Infinity );
  return maximum;
}


//addRecurse(...nums) ⇒ number
//Write a function addRecurse that is the generalized add function but uses recursion
const addRecurse = (...a) => a.reduce( (acc, num) => acc + addRecurse(num) );

/*
mulRecurse(...nums) ⇒ number
Write a function mulRecurse that is the generalized mul function but uses recursion

minRecurse(...nums) ⇒ number
Write a function minRecurse that is the generalized min function but uses recursion

maxRecurse(...nums) ⇒ number
Write a function maxRecurse that is the generalized max function but uses recursion

not(func) ⇒ function
Write a function not that takes a function and returns the negation of its result

acc(func, initial) ⇒ function
Write a function acc that takes a function and an initial value and returns a function that runs the initial function on each argument, accumulating the result

accPartial(func, start, end) ⇒ function
Write a function accPartial that takes in a function, a start index, and an end index, and returns a function that accumulates a subset of its arguments by applying the given function to all elements between start and end.

accRecurse(func, initial) ⇒ function
Write a function accRecurse that does what acc does but uses recursion

fill(num) ⇒ array
Write a function fill that takes a number and returns an array with that many numbers equal to the given number

fillRecurse(num) ⇒ array
Write a function fillRecurse that does what fill does but uses recursion

set(...args) ⇒ array
Write a function set that is given a list of arguments and returns an array with all duplicates removed

identityf(x) ⇒ function
Write a function identityf that takes an argument and returns a function that returns that argument

addf(a) ⇒ function
Write a function addf that adds from two invocations

liftf(binary) ⇒ function
Write a function liftf that takes a binary function, and makes it callable with two invocations

pure(x, y) ⇒ array
Write a pure function pure that is a wrapper arround the impure function impure

function impure(x) {
  y++;
  z = x * y;
}
var y = 5, z;


impure(20);
z; // 120


impure(25);
z; // 175

curryb(binary, a) ⇒ function
Write a function curryb that takes a binary function and an argument, and returns a function that can take a second argument

curry(func, ...outer) ⇒ function
Write a function curry that is generalized for any amount of arguments

inc(x) ⇒ number
Without writting any new functions, show multiple ways to create the inc function

twiceUnary(binary) ⇒ function
Write a function twiceUnary that takes a binary function and returns a unary function that passes its argument to the binary function twice

doubl(x) ⇒ number
Use the function twiceUnary to create the doubl function

square(x) ⇒ number
Use the function twiceUnary to create the square function

twice(x) ⇒ any
Write a function twice that is generalized for any amount of arguments

reverseb(binary) ⇒ function
Write a function reverseb that reverses the arguments of a binary function

reverse(func) ⇒ function
Write a function reverse that is generalized for any amount of arguments

composeuTwo(unary1, unary2) ⇒ function
Write a function composeuTwo that takes two unary functions and returns a unary function that calls them both

composeu(...funcs) ⇒ any
Write a function composeu that is generalized for any amount of arguments

composeb(binary1, binary2) ⇒ function
Write a function composeb that takes two binary functions and returns a function that calls them both

composeTwo(func1, func2) ⇒ function
Write a function composeTwo that takes two functions and returns a function that calls them both

compose(...funcs) ⇒ function
Write a function compose that takes any amount of functions and returns a function that takes any amount of arguments and gives them to the first function, then that result to the second function and so on

limitb(binary, lmt) ⇒ function
Write a function limitb that allows a binary function to be called a limited number of times

limit(func, lmt) ⇒ function
Write a function limit that is generalized for any amount of arguments

genFrom(x) ⇒ function
Write a function genFrom that produces a generator that will produces a series of values

genTo(gen, lmt) ⇒ function
Write a function genTo that takes a generator and an end limit, and returns a generator that will produce numbers up to that limit

genFromTo(start, end) ⇒ function
Write a function genFromTo that produces a generator that will produce values in a range

elementGen(array, gen) ⇒ function
Write a function elementGen that takes an array and a generator and returns a generator that will produce elements from the array

element(array, gen) ⇒ function
Write a function element that is a modified elementGen function so that the generator argument is optional. If a generator is not provided, then each of the elements of the array will be produced.

collect(gen, array) ⇒ function
Write a function collect that takes a generator and an array and produces a function that will collect the results in the array

filter(gen, predicate) ⇒ function
Write a function filter that takes a generator and a predicate and produces a generator that produces only the values approved by the predicate

filterTail(gen, predicate) ⇒ function
Write a function filterTail that uses tail-recursion to perform the filtering

concatTwo(gen1, gen2) ⇒ function
Write a function concatTwo that takes two generators and produces a generator that combines the sequences

concat(...gens) ⇒ function
Write a function concat that is generalized for any amount of arguments

concatTail(...gens) ⇒ function
Write a function concatTail that uses tail-recursion to perform the concating

gensymf(symbol) ⇒ function
Write a function gensymf that makes a function that generates unique symbols

gensymff(unary, seed) ⇒ function
Write a function gensymff that takes a unary function and a seed and returns a gensymf

fibonaccif(first, second) ⇒ function
Write a function fibonaccif that returns a generator that will return the next fibonacci number

counter(i) ⇒ object
Write a function counter that returns an object containing two functions that implement an up/down counter, hiding the counter

revocableb(binary) ⇒ object
Write a function revocableb that takes a binary function, and returns an object containing an invoke function that can invoke a function and a revoke function that disables the invoke function

revocable(func) ⇒ object
Write a function revocable that is generalized for any amount of arguments

extract(array, prop) ⇒ array
Write a function extract that takes an array of objects and an object property name and converts each object in the array by extracting that property

m(value, source) ⇒ object
Write a function m that takes a value and an optional source string and returns them in an object

addmTwo(m1, m2) ⇒ object
Write a function addmTwo that adds two m objects and returns an m object

addm(...ms) ⇒ object
Write a function addm that is generalized for any amount of arguments

liftmbM(binary, op) ⇒ object
Write a function liftmbM that takes a binary function and a string and returns a function that acts on m objects

liftmb(binary, op) ⇒ object
Write a function liftmb that is a modified function liftmbM that can accept arguments that are either numbers or m objects

liftm(func, op) ⇒ object
Write a function liftm that is generalized for any amount of arguments

exp(value) ⇒ any
Write a function exp that evaluates simple array expressions

expn(value) ⇒ any
Write a function expn that is a modified exp that can evaluate nested array expressions

addg(value) ⇒ number | undefined
Write a function addg that adds from many invocations, until it sees an empty invocation

liftg(binary) ⇒ function
Write a function liftg that will take a binary function and apply it to many invocations

arrayg(value) ⇒ array
Write a function arrayg that will build an array from many invocations

continuizeu(unary) ⇒ function
Write a function continuizeu that takes a unary function and returns a function that takes a callback and an argument

continuize(any) ⇒ function
Write a function continuize that takes a function and returns a function that takes a callback and an argument

vector()
Make an array wrapper object with methods get, store, and append, such that an attacker cannot get access to the private array

exploitVector()
Let's assume your vector implementation looks like something like this:

vector = () => {
  let array = [];
  return {
    append: (v) => array.push(v),
    get: (i) => array[i],
    store: (i, v) => array[i] = v
  };
}
Can you spot any security concerns with this approach? Mainly, can we get access to the array outside of vector? Note: the issue has nothing to do with prototypes and we can assume that global prototypes cannot be altered. Hint: Think about using this in a method invocation. Can we override a method of vector?

vectorSafe()
How would you rewrite vector to deal with the issue from above?

pubsub()
Make a function pubsub that makes a publish/subscribe object. It will reliably deliver all publications to all subscribers in the right order.

mapRecurse(array, predicate) ⇒ array
Make a function mapRecurse that performs a transformation for each element of a given array, recursively

filterRecurse(array, predicate) ⇒ array
Make a function filterRecurse that takes in an array and a predicate function and returns a new array by filtering out all items using the predicate, recursively.
*/

module.exports = {
    identity,
    addb,
    subb,
    mulb,
    minb,
    maxb,
    add,
    sub,
    mul,
    min,
    max,
    addRecurse,
  /*  mulRecurse,
    minRecurse,
    maxRecurse,
    not,
    acc,
    accPartial,
    accRecurse,
    fill,
    fillRecurse,
    set,
    identityf,
    addf,
    liftf,
    pure,
    curryb,
    curry,
    inc,
    twiceUnary,
    doubl,
    square,
    twice,
    reverseb,
    reverse,
    composeuTwo,
    composeu,
    composeb,
    composeTwo,
    compose,
    limitb,
    limit,
    genFrom,
    genTo,
    genFromTo,
    elementGen,
    element,
    collect,
    filter,
    filterTail,
    concatTwo,
    concat,
    concatTail,
    gensymf,
    gensymff,
    fibonaccif,
    counter,
    revocableb,
    revocable,
    extract,
    m,
    addmTwo,
    addm,
    liftmbM,
    liftmb,
    liftm,
    exp,
    expn,
    addg,
    liftg,
    arrayg,
    continuizeu,
    continuize,
    vector,
    exploitVector,
    vectorSafe,
    pubsub,
    mapRecurse,
    filterRecurse,*/
};