decluttering-with-functional-programming.raku

usev6;


## Raku: a quick introduction

subsquare ($x) {
$x*$x;
}

# anonymous subroutine 
my$anon_square= sub ($x) {
$x*$x;
}

my \x=42; # sigilless
my$y=43; 
sayx+$y; 

my@array1=1,2,3; #=> an array because of the '@' sigil
my \array2 = [1,2,3]; #=> an array, because of the '[...]'

my \range1 =1..10; #=> a range 1 .. 10
my@array3=1..10; #=> an array from a range, because of the '@' sigil

my \list1 =1,2,3; #=> a list
my$list2= (1,2,3); #=> also a list
my \list3 =|(1..10); #=> an array from a range because of the '|' flattening operation

## A function, by any other name -- functions as values

subchoose (\t, \f, \d) {
if (d) {t} else {f}
}

# Raku
my \tstr ="True!";
my \fstr ="False!";

my \res_str = choose(tstr, fstr, True);

say res_str; #=> says "True!"

subtt (\s) { say"True {s}!" }
subff (\s) { say"False {s}!" }

my&res_f= choose(&tt, &ff, False);

say&res_f; #=> says &ff
res_f("rumour"); #=> says "False rumour!"

## Functions don't need a name


my \tt = sub (\s) { say"True {s}!" };
my \ff=-> \s { say"False {s}!" };

my&res_ff= choose(tt, ff, True);

say&res_ff; #=> says sub { }
res_ff("story"); #=> says "True story!"

## Examples: `map`, `grep` and `reduce`


### `map` : applying a function to all elements of a list

my \res =map-> \x {x*x} , 1..10;

# Raku
my \res_mut = [];
for1..10-> \x {
 res_mut.push(x*x);
}


### `grep` : filtering a list

my \res_grep =grep-> \x { x%5==0 }, 1..30;
#
my \res_grep_mut = [];
for1..30-> \x {
if (x%5==0) {
 res_grep_mut.push(x);
 }
}

my \res_chain =grep-> \x { x%5==0 }, map-> \x {x*x}, 1..30;
say res_chain;


### `reduce` : combining all elements of a list into a single value

my \sum =reduce sub (\acc,\elt) {acc+elt}, 1..10;

saysum; #=> says 55

### Writing your own

my \assoc_func =-> \x,\y {x+y}
my \non_assoc_func =-> \x,\y { x< y ??x+y !!x }

#### Left fold

subfoldll (&f, \iacc, \lst) { 
my$acc= iacc; 
for lst -> \elt {
$acc= f($acc,elt);
 }
$acc;
}

# # When the list is empty, return the accumulator
multisubfoldl (&f, \acc, ()) { acc }
multisubfoldl (&f, \acc, \lst) {
#'s way of splitting a list in the first elt and the rest
# The '*' is a shorthand for the end of the list
# my (\elt,\rest) = lst[0, 1 .. Inf ];
my \elt = lst[0];
my \rest = lst[1..Inf];
# The actual recursion
 foldl( &f, f(acc, elt), rest);
}

#### Right fold

subfoldrl (&f, \acc, \lst) { 
my$res= acc;
for lst.reverse-> \elt {
$res= f($res,elt);
 }
$res;
}

#
multisubfoldr ( &f, \acc, ()) { acc }
multisubfoldr (&f, \acc, \lst) {
my (\rest,\elt) = lst[0..^*-1, * ];
 foldr( &f, f(acc, elt), rest);
}

#### `map` and `grep` are folds

#
submap_ (&f,\lst) {
 foldl( sub (\acc,\elt) {
 (|acc,f(elt))
 }, (), lst);
}
#
subgrep_ (&f,\lst) {
 foldl( sub (\acc,\elt) {
if (f(elt)) {
 (|acc,elt)
 } else {
 acc
 }
 }, (), lst);
}

## Functions returning functions


# Raku
subadd_1 (\x) {x+1}
subadd_2 (\x) {x+2}
subadd_3 (\x) {x+3}
subadd_4 (\x) {x+4}
subadd_5 (\x) {x+5}

say add_1(4); #=> says 5

# Raku
my \add_n =
sub (\x) {x},
sub (\x) {x+1},
sub (\x) {x+2},
sub (\x) {x+3},
sub (\x) {x+4},
sub (\x) {x+5};

say add_n[0].(4); #=> says 5

# Raku
my \add_mut = [];
for0..5-> \n {
 add_mut.push(sub (\x) {x+n});
}

say add_mut[1].(4); #=> says 5

# Raku
subgen_add(\n) { 
 sub (\x) {x+n}
}

my \add_i =map&gen_add, 0..5;

say add_i[1].(4); #=> says 5

### Laziness

# Raku
my \add =map&gen_add, 0.. ∞; 

say add[244].(7124); #=> says 7368

## Function composition

# Raku
my \res_map_chain =map-> \x { x+5 }, map-> \x {x*x}, 1..30;


my \res_map_comp =map-> \x { x+5 } ∘-> \x { x*x }, 1..30;


subf {};
subg {};

my&h=&f∘&g;


subh_ (\x) {
 f(g(x))
}

# Raku
subcompose(&f,&g) {
 sub (\x) { f(g(x)) }
}