let square x = x * x
let xs = [1..5] 
            |> List.filter (fun x -> x % 2 = 0) 
            |> List.map square 

public class Program {
    public int square(int x)
    {
        return x * x;
    }
    public static List<int> Main()
    {
        List<int> ints = new List<int>();
        for (int i = 1; i <= 5; i++)
        {
            if (i % 2 == 0) 
            {
                ints.Add(square(i));
            }
        }
        return ints;
    }
}

public class Program {
    public static List<int> Main()
    {
        var square = (x) => x * x;
        return xs = Enumerable.Range(1,5).
                    Where((x) => x % 2 == 0).
                    Select(square);
    }
}

let add x y = x + y

let add5 = add 5

let newResult = add5 6

let (|>) x f = f(x) 
let nine = 4 |> add5 |> printfn "%A"

let (<|) g x = g(x)
let b = add5 <| (1 + 1)

let thedarkside = 1 |>(+)<| 2

let λ = 1 + 2
let ``The output of this test shpuld = 💩`` = 2

type Bacon = Uncooked | Chewy | Crispy

type Tree<'Data> =
| Empty 
| Node of Tree<'Data> * 'Data * Tree<'Data> 

let baconTree = 
    Node(
        Node(Empty,Uncooked,Empty),
        Chewy,
        Node(Empty,Chewy,Node(Node(Empty,Chewy,Empty),
                                Crispy,
                                Node(Node(Empty,Chewy,Empty),
                                        Chewy, 
                                        Node(Empty,Uncooked,Empty)))))

type value = // discriminated union
    | Bool of bool
    | Int of int
    | Double of double
    | String of string
type logical = Or | And | OrElse | AndAlso
type comparison = Eq | Neq | Gt | Lt | LtEq | GtEq
type identifier = string
type location = Index of int // Single discriminated union
type invoke = unit -> unit //Function type
type arithmetic = Add | Mul | Div | Sub

type expression =
    | Literal of value
    | Var of identifier
    | GetAt of location
    | Func of invoke
    | Neg of expression
    | Arithmetic of expression * arithmetic * expression
    | Comparison of expression * comparison * expression
    | Logical of expression * logical * expression

type label = string // Alias
type assign = Set of identifier * expression
type instruction =
    | Assign of assign
    | SetAt of location * expression
    | PropertySet of string * string * expression
    | Action of invoke
    | For of assign * expression * expression
    | EndFor
    | If of expression
    | ElseIf of expression
    | Else
    | EndIf
    | While of expression
    | EndWhile
    | Sub of identifier
    | EndSub
    | GoSub of identifier
    | Label of label
    | Goto of label

#I @"../packages/FParsec/lib/net40-client"
#r "FParsec.dll"
#r "FParsecCS.dll"
open FParsec.CharParsers
open FParsec.Primitives
open System
let ptrue = pstring "true" |>> fun _ -> true
let pfalse = pstring "false" |>> fun _ -> false
let pbool = (ptrue <|> pfalse) |>> fun x -> Bool(x)
let pint = pint32 |>> fun n -> Int(n)
let pvalue = pbool <|> pint
let pliteral = pvalue |>> fun x -> Literal(x)
let result = run ptrue "true is correct"
// ...
//let parse = run pfor "For A=1 To 100"
//Success: For (Set ("A",Literal (Int 1)),Literal (Int 100),Literal (Int 1))

let rec eval expr = 
    match expr with
        | Literal(value) -> value
     // | Var(identifier) -> ...
//             ...
        | Logical(expr1, logical, expr2) -> 
            match (eval expr1),logical,(eval expr2) with 
            | (Bool a), And, (Bool b) -> Bool(a && b) 
            | (Int a), And, (Int b) -> Bool(System.Convert.ToBoolean(a) && 
                                            System.Convert.ToBoolean(b)) 
            | _ -> failwith "Invalid combination"

let (|Integer|_|) s =
  match System.Int32.TryParse(s) with
  | (true, n) -> Some n
  | _ -> None

let (|Float|_|) s =
  match System.Double.TryParse(s) with
  | (true, d) -> Some d
  | _ -> None

let checkInput s =
    match s with
    | Integer n -> sprintf "%d : int" n
    | Float d -> sprintf "%f : float" d
    | _ -> "Garbage"

#r "System.Drawing"
open System.Drawing
let (|RGB|) (col : Color) =
    ( col.R, col.G, col.B )

let (|HSB|) (col : Color) =
    ( col.GetHue(), col.GetSaturation(), col.GetBrightness() )

let checkColour c =
    match c with 
    | HSB (h,s,b) when b > 50.f -> sprintf "over half bright"
    | RGB (r,g,b)  -> sprintf "Some %d, %d, %d" r g b

let (|Delicious|Eww|) b = 
    match b with
    | Chewy | Crispy -> Delicious "Yummy"
    | _ -> Eww 165

let baconresult = 
    match Chewy with
    | Delicious s -> sprintf "Yay: %s" s
    | Eww temp -> sprintf "Please cook till: %d" temp

[<Measure>] type m
[<Measure>] type s
[<Measure>] type kg
let distance = 135.0<m>    
let time = 4.0<s>    
let velocity = distance / time    
let initialVelocity = 0.7<m/s>   
let mass = 62.<kg>
let acceleration = 2.*(distance/time-initialVelocity)/time
let force = mass * acceleration
[<Measure>] type N = kg m/s^2
let forceDifference = force - 3.<N>
let momentum : float<kg m/s> = mass * velocity

[<Measure>] type C
[<Measure>] type F

let CtoF c = 
    c * 1.8<F/C> + 32.0<F>
let Far =  CtoF 21.<C>

let urls = seq {
        yield "http://google.com"
        yield "http://yahoo.com"
        yield! [for i in [0..5] -> "http://google.com?q=" + i.ToString()]
    } 
let list = urls |> Seq.toList

#r "System.Net.Http"
open System
open System.Net.Http
let longRunning url = 
    async {
        use client = new HttpClient()        
        let! result = Uri(url) |> client.GetAsync |> Async.AwaitTask
        return result
    }
let text = urls |> Seq.map longRunning  |> Async.Parallel

- return : a -> Special<a>
- bind : (a -> Special<b>) -> Special<a> -> Special<b>
- map : (a -> b) -> Special<a> -> Special<b>
- apply : Special(a->b) -> Special<a> -> Special<b>

let bind f xOpt = 
        match xOpt with
        | Some x -> f x
        | _ -> None

type MaybeBuilder() =
     member this.Bind(m, f) = bind f m
     member this.Return(x) = Some x
let maybe = MaybeBuilder()

let optR one two three = 
    bind (fun x -> 
        bind (fun y -> 
            bind(fun z -> Some (x + y + z)) three) two) one

let optRe one two three =  maybe {
    let! x = one 
    let! y = two
    let! z = three
    return x + y + z  
}

let opt = optRe (Some 4) (Some 2) (Some 1)

let opt2 = optRe (Some 4) (Some 2) None

val it : None

let products = Map.empty<string,int> |> Map.add "Veggies" 1  |> Map.add "Bacon" 2
let customers = Map.empty<string,int> |> Map.add "Dan"  1 |> Map.add "Chris" 2
type Order = {Customer:int;Product:int}

let orderProduct customerKey productKey =
    match Map.tryFind customerKey customers with 
    | None -> None
    | Some cust -> match Map.tryFind productKey products with 
                   | None -> None
                   | Some prod -> Some {Customer=cust;Product=prod} 
                
let _ = match orderProduct "Dan" "Bacon" with 
        | Some prod -> printfn "%A" prod
        | None -> ()

Some 1 

let _ = match orderProduct "Chris" "Not veggies"  with 
        | Some prod -> printfn "%A" prod
        | None -> ()

None 

let orderProduct2 customerKey productKey = maybe {
    let! cust = Map.tryFind customerKey customers 
    let! prod = Map.tryFind customerKey customers
    return {Customer=cust;Product=prod} 
}
maybe { let! result = orderProduct2 "Dan" "Bacon"
        return result.Product }

Some 1 

maybe { let! result = orderProduct2 "Chris" "Not veggies"
    return result.Customer }

None 

let cluster = AzureCluster.Connect(config, 
                                logger = ConsoleLogger(true), 
                                logLevel = LogLevel.Info)
let localResult = cloud { 
        printfn "hello, world" 
        return Environment.MachineName 
    } |> cluster.RunLocally

let remoteResult = cloud { 
        printfn "hello, world" 
        return Environment.MachineName 
    } |> cluster.Run                          

let a = 5
let factorial x = [1..x] |> List.reduce (*)
let c = factorial a

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Hello, world!");
    }
}

function copyWithEvaluation(iElem, elem) {
    return function (obj) {
        var newObj = {};
        for (var p in obj) {
            var v = obj[p];
            if (typeof v === "function") {
                v = v(iElem, elem);
            }
            newObj[p] = v;
        }
        if (!newObj.exactTiming) {
            newObj.delay += exports._libraryDelay;
        }
        return newObj;
    };
}

recur_count k = 1 : 1 : 
    zipWith recurAdd (recur_count k) (tail (recur_count k))
        where recurAdd x y = k * x + y

main = do
  argv <- getArgs
  inputFile <- openFile (head argv) ReadMode
  line <- hGetLine inputFile
  let [n,k] = map read (words line)
  printf "%d\n" ((recur_count k) !! (n-1))

object Pi {
    class PiIterator extends Iterable[BigInt]{
        var r:BigInt=0
        var q, t, k:BigInt=1
        var n, l:BigInt=3
        var nr, nn:BigInt=0
        //...
    }
    
    def main(args: Array[String]): Unit = {
        val it=new PiIterator
        println((it head) + "." + (it take 300 mkString))
    }
}

(defn ints-from [n]
(cons n (lazy-seq (ints-from (inc n)))))

(defn drop-nth [n seq] 
(cond 
    (zero?    n) seq
    (empty? seq) []
    :else (concat (take (dec n) seq) (lazy-seq (drop-nth n (drop n seq))))))

{$[0=x mod 15;"FizzBuzz";0=x mod 5;"Buzz";0=x mod 3;"Fizz";string x]} each 1+til 15