Functional Thinking is Fun and Powerful

To expand your mental weaponry in a way that can be applied outside purely functional languages

Purpose

Thinking with functions defined by expressions applied as transformations to a sequence of data

Pure Functions (a la Math)

function input = output

Thinking with functions defined by expressions applied as transformations to a sequence of data

Statements are executed

var trimmed = "";
if (toTrim != null)
{
    trimmed = toTrim.Trim();
}
return trimmed;

var x = 2;

return x;

Expressions are evaluated

if toTrim = null
then ""
else toTrim.Trim()

Statement-based (C#)

class Cell {
    public bool IsAlive { get; set; }
    public Cell NextState(int livingNeighbors)
    {
	if ((IsAlive && livingNeighbors == 2) ||
            livingNeighbors == 3)
        {
            return new Cell { IsAlive = true };
        }
        return new Cell { IsAlive = false };
    }
}

Expression-based (F#)

type Cell = DeadCell | LivingCell

let nextStateOf cell livingNeighbors =
    match cell, livingNeighbors with
    | LivingCell, 2 -> LivingCell
    | _, 3 -> LivingCell
    | _ -> DeadCell

Expression-based C#

public Cell NextState(int livingNeighbors)
{
    return new Cell
    {
        IsAlive = (IsAlive && livingNeighbors == 2) ||
                  livingNeighbors == 3
    };
}

Thinking with functions defined by expressions applied as transformations to a sequence of data

Imperative (C#)

public bool ShouldOfferToGiftWrap()
{
    foreach (var item in Items)
    {
        if (item.IsFromWishlist)
        {
            return true;
        }
    }

    return false;
}

Functional (F#)

let shouldOfferToWrapGift order =
    List.exists (fun i -> i.IsFromWishlist) order.Items

Functional (C#)

public bool ShouldOfferToGiftWrapV2()
{
    // Yeah LINQ!
    return Items.Any(item => item.IsFromWishlist);
}

Functional (JavaScript)

var shouldOfferToGiftWrap = function(items) {
    return _(items).some(function(x) {
        return x.isFromWishlist;
    });
};

Map

Reduce

Could you simplify your code by thinking in terms of transformations on immutable data?

Could you simplify your code by writing it in F# or Haskell?

Think