artur-s

// https://adventofcode.com/2021

let readings =
    [|
        199
        227
        229 
    |]

// part1

artur-s

let scanLeft (s:'s) (f:'s -> 'a -> 's) (lst:'a list) : 's list =
    lst 
    |> List.mapi (fun i _ ->
        lst
        |> List.take i
        |> List.fold f s )
        

artur-s

// non-recursive implementation of Y-combinator, based on example from https://en.wikipedia.org/wiki/Fixed-point_combinator#Type_for_the_Y_combinator
// with memoization


using System;
using System.Diagnostics;
using System.Collections.Concurrent;


//type 'a Recc = In of ('a Recc -> 'a)

artur-s

// Monadic DI: Reader and Free monad
// https://www.youtube.com/watch?v=ZasXwtTRkio


module Reader =

    type Reader<'d, 'a> = {Apply:('d -> 'a)}
    let reader f = {Reader.Apply = f}
    let (|Reader|) ({Reader.Apply = apply}) = apply

artur-s

module List

let rec diffDups minuend subtrahend =

  let rec removeFirst i = function
    | h::t -> if h = i then t else h::(removeFirst i t)
    | [] -> []

  match subtrahend with
  | h::t -> diffDups (removeFirst h minuend) t

artur-s

let optionListMap f = (Option.map >> List.map) f 

let square x = x * x
let squareLifted = optionListMap square


squareLifted [Some 2; None; Some 3] 

artur-s

open System
open FsCheck

let positiveDecimal = gen {
    let! low = Gen.elements [0..1000]
    let! mid = Gen.elements [0..100]
    let! scale = Gen.elements [0..5]
    return! 
        Gen.elements [
            Decimal(low, mid, 0, false, byte scale)

artur-s

// An example of Kleisli composition

let (>>=) m f = Option.bind f m
let (>=>) mf mg = fun x -> mf x >>= mg

let tryParseInt s = 
    match System.Int32.TryParse s with
    | true, v -> Some v
    | _ -> None

artur-s

module Option =
  let (|??) = defaultArg
  let (|?) nullable d = if isNull nullable then d else nullable

// usage
open Option
[] |> List.tryHead |?? 0

artur-s

open System
open System.Security.Cryptography

let hasher = SHA1.Create()

let intToSHA1 (n:int) = 
    let hexString bytes = 
        [for b:byte in bytes -> b.ToString("x2")] |> String.concat ""
    n |> (BitConverter.GetBytes >> hasher.ComputeHash >> hexString)