dmitry-a-morozov

type Node<'T> = 
    | Node of value: 'T * left: Node<'T> * right: Node<'T> 
    | Empty

let getKthLargest(root, n) =
    let rec loop = function
        | Empty -> Seq.empty
        | Node(value, left, right) -> 
            seq {
                yield! loop right          

dmitry-a-morozov

Assert On Steroids

I find it useful to have assert statements in my code. It has several benefits:

• Self documents code expectations
• Establishes boundary checks between component
• Helps to pinpoint problems by failing fast, especially when you just started dealing with a new library
• Here is a good summary on using assertions.

In a dream world all this can be addressed by sophisticated type system but we all know it’s not going to happen any time soon.

dmitry-a-morozov

namespace FSharp.IO.DesignTime

open System.Reflection
open System.IO
open Microsoft.FSharp.Core.CompilerServices
open ProviderImplementation.ProvidedTypes

[<assembly:TypeProviderAssembly()>]
do()

dmitry-a-morozov

open System
open System.Data
open System.Data.SqlClient

type SqlConnection with

//1. Open/close connection if it was not opened
//2. address an issue when regular Dispose on SqlConnection wipes out all properties like ConnectionString in addition to closing connection to db
    member this.UseLocally() =

dmitry-a-morozov

type Configuration = {
    Database: string
    RetryCount: int
}

[<CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>] 
[<AutoOpen>]
module Configuration =
    let private singleton = ref { Database  = "(local)"; RetryCount = 3 }

dmitry-a-morozov

open FSharp.Quotations
open System.Diagnostics
open System

type Debug with
    [<Conditional("DEBUG")>]
    static member AssertThat([<ReflectedDefinition(true)>] condition: Expr<bool>) = 
        match condition with
        | Patterns.WithValue(value, t, expr) when t = typeof<bool> -> 
            let message = string expr //how do I get unparsed F# here?

dmitry-a-morozov

class C1 { item: string }
class C2 { item: string[] }
class C3 { item: string }

type C1_C2_C3 = C1 | C2 | C3; 

function Foo(x: C1_C2_C3): string {
    if (x instanceof C1) return x.item;
    else if (x instanceof C2) return x.item[0];
    else if (x instanceof C3) return x.item;

dmitry-a-morozov

CREATE PROCEDURE [dbo].[spGetAutomobiles]  
    @Id int = 0,
    @Make nvarchar(100) = ''
AS  
BEGIN  
    SELECT * 
    FROM Automobiles a with (nolock)
    WHERE (@Id = 0 OR a.Id = @Id)
    AND (@Make = '' OR a.Make = @Make)
END

dmitry-a-morozov

[ DateTime.Today.AddDays(-5.0) .. TimeSpan.FromDays(1.0) .. DateTime.Today ]

dmitry-a-morozov

type IOOP = abstract Mutate: unit -> unit
type IFunctional<'T> = abstract Reduce: 'T list * ('T -> 'T -> 'T) -> 'T

type ProgramThatMatters = 
    static member Run<'T, 'a when 'a :> IOOP and 'a :> IFunctional<'T>>(paradigm: 'a) = ()

let myCode = {
    new IFunctional<int> with
        member __.Reduce(xs, f) = List.reduce f xs 
    interface IOOP with