brianberns

/// For a function, f, define fix(f) as the "fixed point" of f:
/// A value, z, such that f(z) = z.
///
/// Substituting fix(f) for z, gives f(fix(f)) = fix(f), which
/// we flip to fix(f) = f(fix(f)).
///
/// This fixed point, z, is itself is a function that takes an
/// argument, x. We have to make x explicit in the definition
/// in order to avoid infinite recursion when fix is called.
///

brianberns

open System.Numerics

// http://fsharpnews.blogspot.com/2013/08/implementing-rationals-in-f.html
type Rational(p: BigInteger, q: BigInteger) =
  let rec gcd a (b: BigInteger) =
    if b.IsZero then a else
      gcd b (a % b)

  let fixSign(p: BigInteger, q: BigInteger) =
    if q.Sign > 0 then p, q else -p, -q

brianberns

/// https://stackoverflow.com/questions/40052256/how-does-continuation-monad-really-work/42062682#42062682

/// A continuation is a function that represents "the rest of the computation".
type Cont<'T, 'U> = ('T -> 'U)

/// An incomplete computation is a function which, when given a continuation,
/// will return a value.
type Inc<'T, 'U> = Cont<'T, 'U> -> 'U

/// Creates an incomplete computation that holds the given value.

brianberns

/// Free monad of Option<'t>.
type Nest<'t> =

    /// Nested options.
    | Free of Option<Nest<'t>>

    /// Lifts a value directly into the monad.
    | Pure of 't

module Nest =

brianberns

open System.Collections
open System.Collections.Generic

type InfiniteLazyList<'T> =
    | (::) of ('T * Lazy<InfiniteLazyList<'T>>)

    interface IEnumerable<'T> with
        member this.GetEnumerator() =
            let head :: tail = this
            let s =

brianberns

type ContinuationMonad() =
    member __.Bind(m, f) = fun c -> m (fun a -> f a c)
    member __.Return(x) = fun k -> k x

let cont = ContinuationMonad()

let rec reduce fs =
    cont {
        match fs with
        | [] -> return []

brianberns

open MongoDB.Bson
open MongoDB.Driver

type User =
    {
        _id : BsonObjectId
        Name : string
    }

[<EntryPoint>]

brianberns

[<AutoOpen>]
module Operators =
    let uncurry f (a, b) = f a b
    let cnst x _ = x

/// https://en.wikibooks.org/wiki/Haskell/Arrow_tutorial
type Circuit<'a, 'b> = Cir of TransitionFunction<'a, 'b>
and TransitionFunction<'a, 'b> = 'a -> Circuit<'a, 'b> * 'b

module Circuit =

brianberns

open System
open System.Linq
open FSharp.Data.TypeProviders
open Microsoft.FSharp.Linq.RuntimeHelpers

type Db = SqlDataConnection<"Server=.;Database=QueryTest;Trusted_Connection=true">
let d = Db.GetDataContext()

type Result =
    {

brianberns

open Microsoft.EntityFrameworkCore

[<CLIMutable>]
type Customer =
    {
        CustomerId : string
        CompanyName : string
        Address : string
        City : string
    }