sgoguen

module NatPatterns = 

    type nat = int64
    let nat(x) = int64(x)

    //  Rosenberg-Strong unpairing function (balances better than Cantor's)
    //  A true total function when you replace int64 with bigint
    let unpair(z: nat): (nat * nat) =
        let m = nat(floor (sqrt (double z)))
        let ml = z - (m * m)

sgoguen

import MIL.Common
import Mathlib.Data.Nat.Pairing

--  Let's define a type that represents all finite types
--  Taken from (A Universe of Finite Types - Functional Programming in Lean)
--    https://lean-lang.org/functional_programming_in_lean/dependent-types/universe-pattern.html
inductive FiniteType where
  | unit : FiniteType
  | bool : FiniteType
  | pair : FiniteType → FiniteType → FiniteType

sgoguen

type Person = { Name: string; Age: int }
type Cheese = { Name : string; Age : int } 
let people = [ 
    { Name = "Brie"; Age = 30 }
    { Name = "Colby"; Age = 20 } 
    { Name = "Jack"; Age = 40 } ] 

let printName thing = thing |> _.Name |> printfn "%s" 

people[0] |> printName

sgoguen

let composeRecursive baseF recursiveFs = 
    let funcs = [| (fun _ x -> baseF x); yield! recursiveFs |]
    let length = bigint(Array.length funcs)
    let rec natToObject n = 
        let r = int(n % length)
        let recF = funcs[r]
        let f = recF natToObject
        f (n / length)
    natToObject

sgoguen

type Reader<'Env, 'T> = Reader of ('Env -> 'T)

module Reader =
    let run (Reader f) env = f env
    let ret x = Reader(fun _ -> x)
    let ask = Reader(fun env -> env)
    let zero() = Reader(fun _ -> ())
    let map f (Reader g) = Reader(fun env -> f (g env))
    let delay (f: unit -> Reader<'TEnv, 'T>) =
        Reader(fun env -> run (f()) env)

sgoguen

My First Conversation with GPT-3.5

The following is a conversation with an AI assistant. The assistant is helpful, creative, clever, and very friendly.

Human: Hello, who are you?

AI: I am an AI created by OpenAI. How can I help you today?

Human: Can you help me write an F# tutorial?

sgoguen

Making Toys with F# - A Small Elm-like DSL in F#

I've been working on a talk about the virtues of building toy examples for the purpose of communicating ideas with simple interactive examples.

The toys I talk about in my presentation are based my interest in tools that allow programmers to quickly build web applications that allow them to explore their architecture. So to kickstart this series off, I want to introduce a simple

sgoguen

def pair(x, y):
    mxy = max(x, y)
    return mxy * mxy + mxy + x - y

def unpair(z):
    m = int(z ** 0.5)
    ml = z - m * m
    if ml < m:

sgoguen

type Func<A, B> = (input: A) => B;

const _$ = undefined;

//  If f and the input are provided, evalulate and return B[]
function map<A, B>(input: A[], f: Func<A, B>): B[];
//  If input is not provided, return a function ala partial application
function map<A, B>(input: undefined, f: Func<A, B>): Func<A[], B[]>;

function map<A, B>(input: A[] | undefined, f: Func<A, B>) {

sgoguen

// Given an interface like this, I can have TypeScript automatically 
// generate message types from all of the "update" methods below.
export interface Person {
  // We'll ignore these properties
  name: string;
  age: number;
  dob: Date;

  // We'll ignore any method that returns void (We want methods to return new methods)
  setDate(newDate: Date): void;