Porges

type Num<'a> = {
        add : 'a -> 'a -> 'a;
        subtract : 'a -> 'a -> 'a;
        multiply : 'a -> 'a -> 'a;
        divide : 'a -> 'a -> 'a;
    }

type System.Int32 with
    static member NumInstance () = 
        {

Porges

{-# LANGUAGE TypeOperators, ConstraintKinds, TypeFamilies #-}

import Data.Type.Equality

-- if  we have two functions
--   a -> b
--   a' -> b'
-- and a proof that the function types are the same
-- then b must equal b' 
proof1 ::

Porges

let a = fun b -> b // ok : ('a -> 'a) * int
        , 2

let b = fun b -> b // syntax error
         , 2

let c = fun b -> b // syntax error
          , 2

let d = fun b -> b // syntax error

Porges

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Security.AccessControl;
using System.Text;
using System.Threading.Tasks;

namespace AtomicAppend
{

Porges

using System;
using System.Collections.Generic;

namespace TypeTree
{
    public interface IGet<out T>
    {
        T Get { get; }
    }

Porges

 // direct-ish translation
let allOrNone (xs : 'a option list) : 'a list option =
    List.foldBack
        (fun x st -> x |> Option.bind (fun x -> st |> Option.bind (fun st -> Some (x::st))))
        xs
        (Some [])
 
 // shorter
let allOrNone2 (xs : 'a option list) : 'a list option =
    List.foldBack

Porges

open System
open System.Threading

type OnceLazy (action : unit -> unit) =
    let it = Lazy(action, LazyThreadSafetyMode.ExecutionAndPublication)
    member this.Force() = it.Force()
    
type Once (action : unit -> unit) =
    let mutable performed = 0
    member this.Force() =

Porges

// First, the validation type (applicative only):
type Validation<'e, 't> =
    | ErrorCollection of 'e list
    | Validated of 't

let (<*>) (f : Validation<'e, 'a -> 'b>) (v : Validation<'e, 'a>) : Validation<'e, 'b> = 
    match f, v with
    | ErrorCollection e1, ErrorCollection e2 -> ErrorCollection (List.append e1 e2)
    | ErrorCollection e1, _ -> ErrorCollection e1
    | _, ErrorCollection e2 -> ErrorCollection e2

Porges

    internal struct TableIndex
    {
        public readonly byte Value;

        public TableIndex(byte value)
        {
            Value = value;
        }
    }

Porges

[StructLayout(LayoutKind.Explicit)]
public struct IntOrDouble
{
    private enum Type : byte
    {
        Integral,
        Floating
    }

    [FieldOffset(0)]