13th_Sept_list_and_trees_3_scale

// scaling a function by a factor of k

function scale_list2(xs, k) {
    return is_null(xs)
        ? null
        : pair(k * head(xs),
        scale_list2(tail(xs), k));
}
scale_list2(list(1, 2, 3), 10);

// new type annotations: Pair<?,?>, List<?>, null

/*
function scale_list(xs : list<number>, k : number){
    return is_null(xs)
        ? null
        : pair(k * head(xs),
        scale_list(tail(xs), k));
}

scale_list(list("A", "B", "C"), 10);
scale_list(list("A", "B", "C"), "D");
scale_list(list(1, 2, 3), "D");
*/

// squaring a lift

function square_list(xs) {
    const square = x => x * x;
    return is_null(xs)
        ? null
        : pair(square(head(xs)),
        square_list(tail(xs)));
}

square_list(list(1, 2, 3, 4));

// abstraction: map

// applying a function element wise to the list

function map(f, xs) {
    return is_null(xs)
        ? null
        : pair(f(head(xs)), map(f, tail(xs)));
}

// using map

function scale_list(xs, k) {
    return map(x => k * x, xs);
}
function square_list(xs) {
    return map(x => x * x, xs);
}

// making a copy of the list

function copy(xs) {
    return map(x => x, xs);
}
const original = list(1, 3, 5);
const my_copy = copy(original);

// taking even numbers from the list

function even_numbers2(xs){
    return is_null(xs)
        ? is_null
        : head(xs) % 2 === 0
        ? pair(head(xs), even_numbers2(tail(xs)))
        : even_numbers2(tail(xs));
}

// if we take head(xs) % 2 === 0 as the function 

// abstration: filter

function filter(pred, xs){
    return is_null(xs)
        ? null 
        : pred(head(xs)) // if predicate is true
        ? pair(head(xs), filter(pred, tail(xs)))
        : filter(pred, tail(xs));
}

// based on the predicate, number of elements changes
// atmost n 

// predicate is applied for each element 
// it should be either true of false only



function even_numbers(xs){
    const pred = x => x % 2 === 0;
    
    return filter(pred, xxs);
    
}

// summing the elemnts of the list

function list_sum(xs){
    return is_null(xs)
        ? 0
        : head(xs) + list_sum(tail(xs));
}

// operations are going left to right
// but calculations are happing right to left
// due to deferred operations and applicative order reduction 

// example if multiplication of all elements then * instead of +
// base case from 0 to 1

// abstraction: accumulate 

function accumulate(op, initial, xs){ // op : operation, a function
    return is_null(xs)
        ? initial
        : op(head(xs), accumulate(op, initial, tail(xs)));
}

// rewriting list_sum

function list_sum2{
    return accumulate((x,y) => x + y, 0, xs);
}

// (x,y) => x + y is the binary function that is why takes two arguments

// three higher order functions :

// map, filter, accumulate