Botting framework/code

// ** GIVE THE VALUE A NAME ** 

// Integer and string. 
let num = 10
let str = "F#" 

let squareIt = fun n -> n * n

let squareIt2 n = n * n


// ** STORE THE VALUE IN A DATA STRUCTURE ** 

// Lists. 

// Storing integers and strings. 
let integerList = [ 1; 2; 3; 4; 5; 6; 7 ]
let stringList = [ "one"; "two"; "three" ]

// You cannot mix types in a list. The following declaration causes a  
// type-mismatch compiler error. 
//let failedList = [ 5; "six" ]

// In F#, functions can be stored in a list, as long as the functions  
// have the same signature. 

// Function doubleIt has the same signature as squareIt, declared previously. 
//let squareIt = fun n -> n * n 
let doubleIt = fun n -> 2 * n

// Functions squareIt and doubleIt can be stored together in a list. 
let funList = [ squareIt; doubleIt ]

// Function squareIt cannot be stored in a list together with a function 
// that has a different signature, such as the following body mass  
// index (BMI) calculator. 
let BMICalculator = fun ht wt -> 
                    (float wt / float (squareIt ht)) * 703.0

// The following expression causes a type-mismatch compiler error. 
//let failedFunList = [ squareIt; BMICalculator ] 


// Tuples. 

// Integers and strings. 
let integerTuple = ( 1, -7 )
let stringTuple = ( "one", "two", "three" )

// A tuple does not require its elements to be of the same type. 
let mixedTuple = ( 1, "two", 3.3 )

// Similarly, function elements in tuples can have different signatures. 
let funTuple = ( squareIt, BMICalculator )

// Functions can be mixed with integers, strings, and other types in 
// a tuple. Identifier num was declared previously. 
//let num = 10 
let moreMixedTuple = ( num, "two", 3.3, squareIt )

// You can pull a function out of a tuple and apply it. Both squareIt and num 
// were defined previously. 
let funAndArgTuple = (squareIt, num)

// The following expression applies squareIt to num, returns 100, and  
// then displays 100.
System.Console.WriteLine((fst funAndArgTuple)(snd funAndArgTuple))

// Make a list of values instead of identifiers. 
let funAndArgTuple2 = ((fun n -> n * n), 10)

// The following expression applies a squaring function to 10, returns 
// 100, and then displays 100.
System.Console.WriteLine((fst funAndArgTuple2)(snd funAndArgTuple2))


// ** PASS THE VALUE AS AN ARGUMENT ** 

// An integer is passed to squareIt. Both squareIt and num are defined in  
// previous examples. 
//let num = 10 
//let squareIt = fun n -> n * n
System.Console.WriteLine(squareIt num)

// String. 
// Function repeatString concatenates a string with itself. 
let repeatString = fun s -> s + s

// A string is passed to repeatString. HelloHello is returned and displayed. 
let greeting = "Hello"
System.Console.WriteLine(repeatString greeting)

// Define the function, again using lambda expression syntax. 
let applyIt = fun op arg -> op arg

// Send squareIt for the function, op, and num for the argument you want to  
// apply squareIt to, arg. Both squareIt and num are defined in previous  
// examples. The result returned and displayed is 100.
System.Console.WriteLine(applyIt squareIt num)

// The following expression shows the concise syntax for the previous function 
// definition. 
let applyIt2 op arg = op arg
// The following line also displays 100.
System.Console.WriteLine(applyIt2 squareIt num)

// List integerList was defined previously: 
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ] 

// You can send the function argument by name, if an appropriate function 
// is available. The following expression uses squareIt. 
let squareAll = List.map squareIt integerList

// The following line displays [1; 4; 9; 16; 25; 36; 49]
printfn "%A" squareAll

// Or you can define the action to apply to each list element inline. 
// For example, no function that tests for even integers has been defined, 
// so the following expression defines the appropriate function inline. 
// The function returns true if n is even; otherwise it returns false. 
let evenOrNot = List.map (fun n -> n % 2 = 0) integerList

// The following line displays [false; true; false; true; false; true; false]
printfn "%A" evenOrNot


// ** RETURN THE VALUE FROM A FUNCTION CALL ** 

// Function doubleIt is defined in a previous example. 
//let doubleIt = fun n -> 2 * n
System.Console.WriteLine(doubleIt 3)
System.Console.WriteLine(squareIt 4)

// The following function call returns a string: 
// str is defined in a previous section. 
//let str = "F#" 
let lowercase = str.ToLower()

System.Console.WriteLine((fun n -> n % 2 = 1) 15)

let checkFor item = 
    let functionToReturn = fun lst ->
                           List.exists (fun a -> a = item) lst
    functionToReturn

// integerList and stringList were defined earlier. 
//let integerList = [ 1; 2; 3; 4; 5; 6; 7 ] 
//let stringList = [ "one"; "two"; "three" ]

// The returned function is given the name checkFor7.  
let checkFor7 = checkFor 7

// The result displayed when checkFor7 is applied to integerList is True.
System.Console.WriteLine(checkFor7 integerList)

// The following code repeats the process for "seven" in stringList.
let checkForSeven = checkFor "seven" 

// The result displayed is False.
System.Console.WriteLine(checkForSeven stringList)

// Function compose takes two arguments. Each argument is a function  
// that takes one argument of the same type. The following declaration 
// uses lambda expresson syntax. 
let compose = 
    fun op1 op2 ->
        fun n ->
            op1 (op2 n)

// To clarify what you are returning, use a nested let expression: 
let compose2 = 
    fun op1 op2 ->
        // Use a let expression to build the function that will be returned. 
        let funToReturn = fun n ->
                            op1 (op2 n)
        // Then just return it.
        funToReturn

// Or, integrating the more concise syntax: 
let compose3 op1 op2 =
    let funToReturn = fun n ->
                        op1 (op2 n)
    funToReturn

// Functions squareIt and doubleIt were defined in a previous example. 
let doubleAndSquare = compose squareIt doubleIt
// The following expression doubles 3, squares 6, and returns and 
// displays 36.
System.Console.WriteLine(doubleAndSquare 3)

let squareAndDouble = compose doubleIt squareIt
// The following expression squares 3, doubles 9, returns 18, and 
// then displays 18.
System.Console.WriteLine(squareAndDouble 3)

let makeGame target = 
    // Build a lambda expression that is the function that plays the game. 
    let game = fun guess -> 
                   if guess = target then
                      System.Console.WriteLine("You win!")
                   else 
                      System.Console.WriteLine("Wrong. Try again.")
    // Now just return it.
    game

let playGame = makeGame 7
// Send in some guesses.
playGame 2
playGame 9
playGame 7

// Output: 
// Wrong. Try again. 
// Wrong. Try again. 
// You win! 

// The following game specifies a character instead of an integer for target.  
let alphaGame = makeGame 'q'
alphaGame 'c'
alphaGame 'r'
alphaGame 'j'
alphaGame 'q'

// Output: 
// Wrong. Try again. 
// Wrong. Try again. 
// Wrong. Try again. 
// You win! 


// ** CURRIED FUNCTIONS ** 

let compose4 op1 op2 n = op1 (op2 n)

let compose4curried =
    fun op1 ->
        fun op2 ->
            fun n -> op1 (op2 n)

// Access one layer at a time.
System.Console.WriteLine(((compose4 doubleIt) squareIt) 3)

// Access as in the original compose examples, sending arguments for  
// op1 and op2, then applying the resulting function to a value.
System.Console.WriteLine((compose4 doubleIt squareIt) 3)

// Access by sending all three arguments at the same time.
System.Console.WriteLine(compose4 doubleIt squareIt 3)

let doubleAndSquare4 = compose4 squareIt doubleIt
// The following expression returns and displays 36.
System.Console.WriteLine(doubleAndSquare4 3)

let squareAndDouble4 = compose4 doubleIt squareIt
// The following expression returns and displays 18.
System.Console.WriteLine(squareAndDouble4 3)

let makeGame2 target guess =
    if guess = target then
       System.Console.WriteLine("You win!")
    else 
       System.Console.WriteLine("Wrong. Try again.")

let playGame2 = makeGame2 7
playGame2 2
playGame2 9
playGame2 7

let alphaGame2 = makeGame2 'q'
alphaGame2 'c'
alphaGame2 'r'
alphaGame2 'j'
alphaGame2 'q'


// ** IDENTIFIER AND FUNCTION DEFINITION ARE INTERCHANGEABLE ** 

let isNegative = fun n -> n < 0

// This example uses the names of the function argument and the integer 
// argument. Identifier num is defined in a previous example. 
//let num = 10
System.Console.WriteLine(applyIt isNegative num)

// This example substitutes the value that num is bound to for num, and the 
// value that isNegative is bound to for isNegative.
System.Console.WriteLine(applyIt (fun n -> n < 0) 10) 

System.Console.WriteLine((fun op arg -> op arg) (fun n -> n < 0)  10)


// ** FUNCTIONS ARE FIRST-CLASS VALUES IN F# ** 

//let squareIt = fun n -> n * n 

let funTuple2 = ( BMICalculator, fun n -> n * n )

let increments = List.map (fun n -> n + 1) [ 1; 2; 3; 4; 5; 6; 7 ]

//let checkFor item =  
//    let functionToReturn = fun lst -> 
//                           List.exists (fun a -> a = item) lst 
//    functionToReturn