open System
module Syntax =
  let a = 5 // var a = 5;
  let c = 1 + a // var c = 1 + a;
  // public int Twice(int x) => x * 2;
  // the () are optional
  let twice(x) = 2 * x
  // the () are optional
  let d = twice(a)

module Assignment =
  // let is a binding not an assignment
  // = is a binding or comparison not an Assignment
  let x = 5 // not mutable
  let mutable y = 5
  // parens are just to help visualize it for new learners
  let z = (5 = 6)
  // same as above since x is immutable and is 5
  let z2 = (x = 6)
  y <- y + 1

// string F1(int x) => x < 5 ? "<" : ">=";
let f1 x = if x < 5 then "<" else ">="
// string F2(int lower, int x, int upper) =>
//    x < lower ? "less than" : x > upper ? "greater than" : "between";
let f2 lower x upper =
  if x < lower then
    "less than"
  else if x > upper then // or elsif
    "greater than"
  else "between"

module Casting =
  let x = 5 // var x = 5;
  // var y = (obj) x;
  // upcast (always succeeds if it compiles)
  let y = x :> obj
  // downcast (? mark notes the possibility of failure)
  // var z = (int)y;
  let z = y :?> int
  // var a = (obj)x;
  let a:obj = upcast x // when the type is inferrable
  // var b = (int)y;
  // when the type is inferrable (still could fail)
  let b:int = downcast y
  // var x2 = (object)2;
  let x2:obj = upcast 2

module Casting2 =
  // box is shorthand for upcast to object
  // var x = (object) 1;
  let x:obj = box 1
  // in C#5(maybe even 6) you can't conditionally define a variable
  // var a2 = x as int?;
  // due to the line above now a2 is in scope for the rest of the method
  // x gives a warning here, we haven't covered all possibilities
  // nothing like that in C# besides default case requirement of switches
  let result =
    match x with
    // advanced/arguably misusable power:
    // in F# we don't need to use a separate variable name for the casted variable
    // if(a2 != null) Console.WriteLine("int value:" + a2);
    | :? int as a -> sprintf "int value: %i" a
    // calls ToString if it is not null, a tuple, record or union
    // if(a1 == null) Console.WriteLine("non-int null value is "+a1);
    | null -> sprintf "non-int null value is %A" x // prints <null> for null values

module Casting3 =
  // var x = (object)"1";
  let x:obj = box "1"
  // conditional matches
  match x with
  // var a3 =  x as string; if(a3 != null && a3.Length > 0) ...
  | :? string as str when str.Length > 0 -> printfn "string value: %s" str
  // if(a3 == null && x != null) ...
  // also prints <null> for null values
  | x -> printfn "value is %O" x // calls toString if it is not null

// public static class FExamples
module FExamples =
  // readonly static int x = 1;
  let x = 1
  let z () = () // void Z() {}
  let y () = 1 // int Y() { return 1;}
  // void F(int x) {}
  let f (x:int) = () // method
  // void F2(int x) => F(x);
  let f2 x = f x // method

public class Employee
{
  readonly string x="hello";
  public string Foo() => x;
  public string Z => x;
  public int Y {get;set;}
  public static void Bar() => {};
}
public class Foo{}

type HelloClass() =
  let x = "hello" // field
  member this.Foo() = x
  member this.Z = x
  member val Y = 0 with get,set
  static member Bar() = ()
// empty class
type Foo() = class end

type IAmAnInterface =
  // string Bark();
  abstract member Bark : unit -> string
  // string Version { get; }
  abstract member Foo : string with get
  // string Bar {get;set;}
  abstract member Bar : string with get,set

type ClassImplements () =
  let x = "hello"
  member this.Bark() = x
  // Foo is a property! not a field
  member this.Foo = x
  // you can use whatever name you like for `this`
  member __.Foo2 with get() = x
  // this creates a backing field of its own, using x's value as the initial value
  member val Bar = x with get,set

  // f# downside no implicit interface implementation
  // interface members are always considered explicity implemented
  // members only show up/compile if you cast the type to the interface first
  interface IAmAnInterface with
    member __.Foo = x
    // this isn't recursive
    member this.Bark () = this.Bark()
    member this.Bar
      with get() = this.Bar
      and set value = this.Bar <- value

public class Employee
{
  public string Name { get; } // C# 6 syntax
  public Guid EmployeeId { get; }
  public decimal Salary { get;}

  public Employee(string name, Guid employeeId, decimal salary)
    Name=name;
    EmployeeId=employeeId;
    Salary=salary;
  }
}

type Employee = {Name:string; EmployeeId:Guid; Salary:decimal}
let e = {Name="Brandon D'Imperio"; EmployeeId=Guid.NewGuid(); Salary = 15.5m}
// how much typing would you need to do in C# to do this?
// create a new employee with the same salary
// and any other properties that we don't set get copied.
let e2 = {e with Name="John Doe"; EmployeeId = Guid.NewGuid()}

module SequenceExamples =
  // new is not required in F#
  // you will get a warning on IDisposables
  let a = System.Collections.Generic.List<int>()
  // same as the line above (using built-in f# aliases)
  let b = ResizeArray<int>()
  let literalArray = [| |] // also Array.empty
  // var arrayOf1To10 = Enumerable.Range(1, 10).ToArray();
  let arrayOf1To10 = [| 1..10 |]
  // F# list type
  let listOf1To10 = [ 1..10 ]

  // Microsoft.FSharp.Collections.ListModule.Empty<int>()
  let literalList = [] // F# version is immutable

var items = new []{123,456,10,999,9};
var q= from i in items
  join j in items on i equals j
  select new {i,j};

module NotLinq =
  // var items new [] {123, 456,10,999,9};
  let items = [123;456;10;999;9]
  // var doubled = items.Select(x => x * 2);
  let doubled = items |> Seq.map (fun x -> x * 2)
  // this is why C# can't have nice things. look how long this is.
  // public IEnumerable<int> Evens(IEnumerable<int> items) =>
  //     items.Where(x => x % 2 == 0);
  let evens items = items |> Seq.filter (fun x -> x % 2 = 0)

module Querying =
  let items = [123;456;10;999;9]
  let q =
    query {
        for i in items do
        join j in items on
            (i = j)
        select (i,j)
    }