BashkaMen

#load @"paket-files/fsprojects/Chessie/src/Chessie/ErrorHandling.fs"

type Continuation<'output, 'next> = 'output -> 'next

module TerminalDsl =
    open Chessie.ErrorHandling

    type Terminal<'next> =
    | WriteLine    of string * Continuation<unit, 'next>
    | ReadLine     of unit   * Continuation<string, 'next>

BashkaMen

open System.Collections.Generic


type xSet<'Id, 'T when 'Id : comparison and 'T : equality>(itemId, source: Map<'Id, 'T>) =
        
    let mkNew source = xSet(itemId, source)
    
    member val private HashCode = hash source
    override this.GetHashCode() = this.HashCode
    override this.Equals other =

BashkaMen

open System
open System.Collections.Generic

let inline ( ^ ) f x = f x


type Terminal<'next> =
    | WriteLine of string * (unit -> 'next)
    | ReadLine of unit    * (string -> 'next) 

BashkaMen

using System;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Logging;
using Udr.Application;

namespace Udr.Web
{
    public class ExceptionHandler : IMiddleware
    {

BashkaMen

public static class Ext
{
    public static IObservable<string> AnonymousConsume(this IDatabase db, string topic, int prefetchCount = 100, CancellationToken? cancellationToken = null)
    {
        async Task<(string[], string lastPos)> SafeRead(string position)
        {
            try
            {
                var msgs = await db.StreamReadAsync(topic, position, prefetchCount);
                var items =  msgs.SelectMany(s => s.Values)

BashkaMen

using System;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using OpenQA.Selenium;

namespace SeleniumExt
{
    public static class DriverExt

BashkaMen

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Runtime.CompilerServices;
using System.Threading.Tasks;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using OpenQA.Selenium.Remote;

BashkaMen

type Order = { Id: Guid; Amount: int }

type Client = { Id: Guid; OpenOrders: int; Balance: int }

type CreateOrderAggregate = { Client: Client; Order: Order }


module CreateOrderAggregate =
    let execute (agg: CreateOrderAggregate) =
        if agg.Client.Balance >= agg.Order.Amount && agg.Client.OpenOrders < 5 then Ok agg

BashkaMen

open System

let inline (|HasMap|) f x = (^x : (static member Map : ('a -> 'b) * ^x -> ^z) f, x) // define type class
let inline map f (HasMap f x) = x // call type class instance
let inline (|HasPure|) x = (^x : (static member Pure : 'a -> ^x)x)
let inline pure' (HasPure x) = x
let inline (|HasBind|) f x = (^x : (static member Bind : ('a -> ^z) * ^x -> ^z)f, x)
let inline bind f (HasBind f x) = x 
    

BashkaMen

module TypeClasses

open System


let inline (|HasId|) x = (^a : (member Id : 'Id)x) // define type class
let inline getId (HasId x) = x // call type class instance
let inline (|HasShow|) x = (^a : (static member Show : ^a -> string)x) // define type class
let inline show (HasShow x) = x // call type class instance
let inline (|HasMap|) f x = (^x : (static member Map : ('a -> 'b) * ^x -> ^z) f, x) // define type class