module CSharp =

​

  [<AutoOpen>]

  module ImmutableStack =

​

    open System.Collections

    open System.Collections.Generic

​

    type 'T ImmutableStack =

      Empty

    | NonEmpty of 'T * 'T ImmutableStack

    with

      interface 'T IEnumerable with

        member this.GetEnumerator () =

          (Seq.unfold (function Empty -> None | NonEmpty (head, tail) -> Some (head, tail)) this).GetEnumerator ()

​

        member this.GetEnumerator () = (this :> 'T IEnumerable).GetEnumerator () :?> IEnumerator

  //End module ImmutableStack

​

  let rec private impl (n: int, k: int): bool ImmutableStack seq = seq {

    if k = 0 then yield Empty

    elif n < k then ()

    else for r in impl (n - 1, k - 1) -> NonEmpty (true, r)

         for r in impl (n - 1, k)    -> NonEmpty (false, r)

  }

​

  let private zipWhere (items: 'T seq, selectors: bool seq): 'T seq = seq {

    use e1 = items.GetEnumerator ()

    use e2 = selectors.GetEnumerator ()

    while e1.MoveNext () && e2.MoveNext () do

      if e2.Current then yield e1.Current

  }

​

  let combinations (items: 'T seq, k: int): 'T seq seq = seq {

    if k < 0 then invalidOp ""

    for combination in impl (Seq.length items, k) ->

      zipWhere (items, combination)

  }

//End module CSharp

​

module FSharp =

​

  let rec private impl = function

    _, 0       -> Seq.singleton []

  | [], _      -> Seq.empty

  | x :: xs, k -> seq {

      for c in impl (xs, k - 1) -> x :: c

      yield! impl (xs, k)

    }

​

  let combinations k items =

    if k < 0 then invalidOp ""

    impl (Seq.toList items, k)

//End module FSharp

​

module Program =

​

  let private printCombination = Seq.map string >> String.concat "," >> printfn "%s"

​

  [<EntryPoint>]

  let main _ =

    let data, size = { 50 .. 10 .. 90 }, 3

​

    printfn "Using C#"

    CSharp.combinations (data, size)

    |> Seq.iter printCombination

​

    printfn "\nUsing F#"

    FSharp.combinations size data

    |> Seq.iter printCombination

​

    0

//End module Program

​