val a = 5                 // Type inferred constant declaration
val b: Double = 5.0       // Explicitly typed constant declaration

var c = 5                 // Variable declaration
c = 10                    // Mutation

class Point(xc: Int, yc: Int) {
  val x: Int = xc
  val y: Int = yc
}

val p: Point = null       // null allowed for custom classes

let a = 5                 // Type inferred constant declaration
let b: float = 5.         // Explicitly typed constant declaration
let a = 2                 // Shadowing

// Verbosity penalty for mutability
let mutable c = 5         // Variable declaration
c <- 10                   // Mutation

// Reference cells: used mainly before F# 4.0
// to capture mutable variables in closures
let r = ref 5
printfn "%i" !r           // Accessing cell content
r := 2                    // Mutating cell content

type Point(x: int, y: int) =
  member val X = x
  member val Y = y

// Doesn't compile, null not allowed in custom classes
//let p: Point = null

for (index <- 1 to 5) {
  println(s"$index times 5 is ${index * 5}")
}

var index = 1
while (index < 6) {
  println(s"$index times 5 is ${index * 5}")
  index = index + 1
}

for index = 1 to 5 do
  printfn "%i times 5 is %i" index (index * 5)

let mutable index = 1
while index < 6 do
  printfn "%i times 5 is %i" index (index * 5)
  index <- index + 1

def myFunction(x: Int, y: Int) = {
  def privateFunction(z: Int) = z * 2
  privateFunction(x + y)
}

def curryFunction(x: Int)(y: Int) = x * y

def highOrderFunction(f: Int => Int, y: Int) = f(y)

def recursiveFuncion(x: Int): Int =
  if (x == 1) 1 else x * (recursiveFuncion(x - 1))

// Function as object instead of method
val myLambda = (x: Int, y: Int) => x * y

// Lambda shortcut, not possible in F#
val myLambda2: Function2[Int,Int,Int] = _*_

val memoizeFunction = {
  val cache = scala.collection.mutable.HashMap.empty[Int,Int]
  (x: Int) => {
    if (cache.contains(x) == false) {
      println(s"Adding $x to cache...")
      cache += (x -> x * 2)
    }
    cache(x)
  }
}

module MyMod =
  let myFunction x y = x + y

  let myFunction2 x y =
    let privateFunction z = z * 2
    // let privateFunction = fun z -> z * 2   // Same effect
    privateFunction (x + y)

  let highOrderFunction f y = f y

  let rec recursiveFuncion x =
    if x = 1 then x else x * (recursiveFuncion (x - 1))

  let memoizeFunction =
    let cache = System.Collections.Generic.Dictionary<int, int>()
    fun x ->
      if cache.ContainsKey x |> not then
        cache.Add(x, x * 2)
      cache.[x]

open System

type MyClass =
  static member MyFunction(?x, ?y) =
    (defaultArg x 5) + (defaultArg y 10)
  static member MyFunction2([<ParamArray>] rest: int array) =
    Array.reduce (+) rest

MyClass.MyFunction(y = 4)
MyClass.MyFunction2(1, 2, 3)

[<AbstractClass>]                         // If at least one member lacks
type AbstractBaseClass() =                // implementation, the class must
  abstract member Add: int -> int -> int  //  be marked as abstract
  abstract member Pi: float
  default this.Add x y = x + y            // Default implementation

type MyInterface =                        // Interfaces are just abstract
  abstract member Square: float -> float  // classes without implementations

[<Struct>]                                // Memory for structs is allocated
type MyStruct(x: float, y: float) =       // on the stack, not the heap
  member __.X = x                         // Instances are passed by value,
  member __.Y = y                         // not by reference

type System.Double with                   // Type extension
  member x.Square = System.Math.Sqrt(x)

type DerivedClass(param1, param2) =
   inherit AbstractBaseClass()                // Inheritance
   let mutable area = 0                       // Private field
   new(param1) = DerivedClass(param1, 5)      // Secondary constructor

   override this.Add _ _ = param1 + param2
   override this.Pi = 3.14                    // Getter-only property

   member this.Area
      with get() = area                       // Getter-Setter property
      and set(v) = area <- v
   member val Area2 = 0 with get, set         // Auto implemented property

   static member StaticValue = 5              // Static members are allowed

   interface MyInterface with                 // Interface implementation
      member this.Square x = x * x            // (always explicit)

let o1 = DerivedClass(4)          // new keyword is optional
//o1.Square 5.                    // Cannot access interface methods implicitly
let o2: MyInterface = upcast o1   // Casting is automatic when passing arguments
printfn "%f" (o2.Square 5.)

let o3 =                          // Object expressions create an anonymous object
  { new MyInterface with          // implementing the interface
    member __.Square x = x ** 2. }
printfn "%f" (o3.Square 5.)

def reverse(x: Int, y: Double, z: String, u: List[Int]) = (u, z, y, x)
val myTuple = (1, 2., "hola", List(1,2,3))
val (_,_,_,_li) = myTuple              // Destructuring
myTuple._4                             // Direct access to members
//reverse(myTuple)                     // Error

let reverse(x, y, z, u) = (u, z, y, x)
let myTuple = 1, 2., "hola", [1;2;3]   // Parens can be omitted
let (_,_,_,li) = myTuple               // Destructuring
//myTuple._4                           // No direct acccess to members but...
reverse myTuple                        // can be destructured in function args

// Beware! In F# commas are only for tuples. Separating statements, members,
// list items, etc. is done with either semicolons or line breaks
type MyRecord = { id: int; qt: float; name: string; li: int list }

let myRecord = { id = 1; qt = 2.; name = "hola"; li = [1;2;3] }

myRecord.id                                 // Member access
let { id = id2; name = name2 } = myRecord   // Destructuring
let myRecord2 = { myRecord with qt = 5. }   // Copying

class MyRecord(val id: Int, val qt: Double,
               val name: String, val li: List[Int]) {}

sealed abstract class Term
case class Var(name: String) extends Term
case class Fun(arg: String, body: Term) extends Term
case class App(f: Term, v: Term) extends Term

def formatTerm(term: Term): String = term match {
  case Var(n)    => n
  case Fun(x, b) => s"^$x.${formatTerm(b)}"
  case App(f, v) => s"(${formatTerm(f)} ${formatTerm(v)})"
}

println(formatTerm(Fun("x", Fun("y", App(Var("x"), Var("y"))))))

type Term =
  | Var of string
  | Fun of string * Term
  | App of Term * Term

// Compiler warns you if the matching is not comprehensive
let rec formatTerm term =
  match term with
  | Var(n)    -> sprintf "%s" n
  | Fun(x, b) -> sprintf "^%s.%s" x (formatTerm b)
  | App(f, b) -> sprintf "(%s %s)" (formatTerm f) (formatTerm b)

// Pipelining is very idiomatic in F#
Fun("x", Fun("y", App(Var("x"), Var("y"))))
|> formatTerm
|> printfn "%s"

type Shape =
  | Rectangle of width: float * length: float
  | Circle of radius: float
  | Prism of width: float * float * height: float

let rec matchShapeList = function             // Shortcut
  | [] -> None                                // Empty list
  | [shape] ->                                // Single item
    match shape with                          
    | Rectangle(length, 10.) -> Some(length)  // Constant
    | Circle r when r > 5.0 -> Some(r)        // Guard
    | _ -> failwith "Unknown shape"
  | _::rest -> matchShapeList rest            // Wildcard

object Even {
  def unapply(x: Int) =
    if (x % 2 == 0) Some(x) else None
}

object Odd {
  def unapply(x: Int) =
    if (x % 2 == 0) None else Some(x)
}

println(5 match {
  case Even(_) => "Hello"
  case Odd(_) => "Goodbye"
})

let (|Even|Odd|) i =
  if i % 2 = 0 then Even else Odd

match 5 with Even -> "Hello" | Odd -> "Goodbye"
|> printfn "%s"

let (|Integer|_|) (str: string) =
  match System.Int32.TryParse str with
  | (true, i) -> Some i | (false, _) -> None

let (|Float|_|) (str: string) =
  match System.Double.TryParse str with
  | (true, f) -> Some f | (false, _) -> None

match "Hola" with
| Integer i -> printfn "%d : Integer" i
| Float f -> printfn "%f : Floating point" f
// Appease the compiler
| _ as str -> printfn "%s : Not matched" str

open System.Text.RegularExpressions
let (|ParseRegex|_|) regex str =
   match Regex.Match(str, regex) with
   | m when not m.Success -> None
   | m -> [for x in m.Groups -> x.Value] |> List.tail |> Some

let parseDate str =
  match str with
  | ParseRegex @"^(\d{1,2})/(\d{1,2})/(\d{1,2})$"
              [Integer m; Integer d; Integer y]
    -> System.DateTime(y + 2000, m, d)
  | ParseRegex @"^(\d{1,2})/(\d{1,2})/(\d{3,4})$"
              [Integer m; Integer d; Integer y]
    -> System.DateTime(y, m, d)
  | ParseRegex @"^(\d{1,4})-(\d{1,2})-(\d{1,2})$"
              [Integer y; Integer m; Integer d]
    -> System.DateTime(y, m, d)
  | _ -> System.DateTime()

// Automatic Generalization
let (|>) x f = f x
// val ( |> ) : x:'a -> f:('a -> 'b) -> 'b

// Constraints
let max x y = if x > y then x else y
// val max : x:'a -> y:'a -> 'a when 'a : comparison

// Syntax for statically resolved type parameters is not beautiful
// and it's mainly intented for core library functions. However it
// can be used with inline functions for neat tricks like duck typing
let inline makeNoise (animal: ^a when ^a : (member MakeNoise: unit->unit)) =
  (^a: (member MakeNoise: unit->unit) animal)

type Dog() = member __.MakeNoise() = printfn "Guau!"
type Cat() = member __.MakeNoise() = printfn "Miau!"

makeNoise(Dog())
makeNoise(Cat())

Functor.map : ('a->'b) -> 'T<'a> -> 'T<'b>

List.map  : ('a->'b) -> list<'a> -> list<'b>
Array.map : ('a->'b) -> array<'a> -> array<'b>
Seq.map   : ('a->'b) -> seq<'a> -> seq<'b>

class Person(val name: String, val age: Int) {}
def selectDataRows() = {
  val rnd = scala.util.Random
  for (i <- Stream.from(1))
    yield Map("name" -> s"Person$i",
              "age" -> rnd.nextInt(99))
}

selectDataRows()
  .map(row => new Person(row("name").asInstanceOf[String],
                        row("age").asInstanceOf[Int]))
  .filter(_.name.startsWith("P"))
  .take(20)
  .sortBy(_.age)
  .toList

// There're multiple libraries in Scala for collections
// Akka-Streams, Scalaz-Stream...

type Person = { name: string; age: int }
let getDataRows() =
  let rnd = System.Random()
  Seq.initInfinite (fun i ->
    Map [ ("name", sprintf "Person%i" i |> box)
          ("age", rnd.Next 99  |> box) ])

// It's more idiomatic in F# to use module functions
// and the pipe operator rather than methods

getDataRows()
|> Seq.map (fun row -> { name = unbox row.["name"]
                         age = unbox row.["age"] })
|> Seq.filter (fun p -> p.name.StartsWith("P"))
|> Seq.take 20
|> Seq.sortBy (fun p -> p.age)
|> Seq.toList

// List and Array modules contain the same functions as Seq
// Of course, pipe operator is possible in SCala too

let myList  =     [  for i in 1..100 do yield i*i ]
let myArray =     [| for i in 1..100 -> i*i |]
let mySeq   = seq {  for i in 1..100 -> i*i }

// `->` is a shortcut for `do yield`

List.range(1,101).map(i => i*i)

let makeStream interval =
    let t1 = System.DateTime.Now
    let timer = new System.Timers.Timer(float interval, AutoReset=true)
    timer.Start()
    timer.Elapsed
    |> Observable.map (fun t2 -> interval, t2.SignalTime - t1)

let simultaneousStream, nonSimultaneousStream =
    Observable.merge (makeStream 3000) (makeStream 5000)
    |> Observable.pairwise
    |> Observable.partition (fun ((_,t1), (_,t2)) ->
        (t2 - t1).TotalMilliseconds < 50.)

let fizzStream, buzzStream =
    nonSimultaneousStream
    |> Observable.map (fun (ev1,_) -> ev1)
    |> Observable.partition (fun (id,_) -> id=3000)

val usdQuote = Future { connection.getCurrentValue(USD) }
val chfQuote = Future { connection.getCurrentValue(CHF) }

val purchase = for {
  usd <- usdQuote
  chf <- chfQuote
  if isProfitable(usd, chf)
} yield connection.buy(amount, chf)

purchase onSuccess {
  case _ => println("Purchased " + amount + " CHF")
}

// Parallel I/O
let fetchUrlAsync url = async {
  let req = System.Net.WebRequest.Create(System.Uri url)
  use! resp = req.AsyncGetResponse()
  use stream = resp.GetResponseStream()
  use reader = new System.IO.StreamReader(stream)
  return reader.ReadToEnd()
}

[ "http://fsharp.org/"; "http://www.scala-lang.org/" ]
|> List.map fetchUrlAsync
|> Async.Parallel
|> Async.RunSynchronously
|> printfn "%A"

// Parallel CPU
let rec fib x =
  if x <= 2
  then 1
  else fib(x-1) + fib(x-2)

let fibs =
  [ for i in 0..40 -> async { return fib(i) } ]
  |> Async.Parallel
  |> Async.RunSynchronously
  |> printfn "%A"

type MaybeBuilder() =
  member __.Bind(x,f) = Option.bind f x
  member __.Return v = Some v
  member __.ReturnFrom o = o
let maybe = MaybeBuilder()

let riskyOp x y =
  if x + y < 100 then Some(x+y) else None

let execMaybe x = maybe {
  let! a = riskyOp x (x+1)
  let! b = riskyOp a (a+1)
  let! c = riskyOp b (b+1)
  let! d = riskyOp c (c+1)
  return d
}    
execMaybe 5

query {
    for n in db.Student do
    join e in db.CourseSelection on
          (n.StudentID = e.StudentID)
    count        
}

SELECT COUNT(*) FROM
Student JOIN CourseSelection
ON Student.StudentID = CourseSelection.StudentID