TheAngryByrd

#nowarn "3535"
#nowarn "3536"

type Joinable<'e,'T> =
    static abstract member Join: 'e * 'e -> 'e
    static abstract member Singleton : 'T -> 'e

module Joinable =
    let inline singleton<'e, 'T when 'e :> Joinable<'e, 'T>> (input) =
        'e.Singleton input

TheAngryByrd

<#
.SYNOPSIS
    Continuously kills dotnet.exe processes.

.DESCRIPTION
    Runs in a loop, checking every second for dotnet.exe processes and killing them.
    Optionally filters processes by their command line arguments.

.PARAMETER ArgumentFilter
    Optional filter to match against the command line arguments of dotnet.exe processes.

TheAngryByrd

let ifDefRuntime =
#if NET8_0
        "This is .NET 8.0"
#endif
#if NET9_0
        "This is .NET 9.0"
        
#endif
#if NET10_0
        "This is .NET 10.0"

TheAngryByrd

module Seq =
    open System.Linq

    /// Attempts to determine the number of elements in a sequence without forcing an enumeration.
    let inline tryLength (xs : seq<_>) =
        match Enumerable.TryGetNonEnumeratedCount xs with
        | true, count -> ValueSome count
        | _ ->
            match xs with
            // F# list implements IReadOnlyCollection/IReadOnlyList

TheAngryByrd

namespace FsToolkit.Build

module DotEnv =
    open System
    open System.IO

    let private parseLine (line: string) =
        match line.Split('=', StringSplitOptions.RemoveEmptyEntries) with
        | args when args.Length = 2 -> Environment.SetEnvironmentVariable(args.[0], args.[1])
        | _ -> ()

TheAngryByrd

/// RequiresExplicitTypeArguments forces each caller to name the type it discards,
/// as in `ignore<int> x`. The compiler then checks that the value has that exact type.
/// Plain `ignore` infers its type argument and silently accepts any value, so it hides
/// a common mistake: a caller can ignore a function value after forgetting an argument,
/// or ignore a Task or Async that the caller meant to await. The explicit type argument
/// turns each of these mistakes into a compile error.
[<AutoOpen>]
module Ignore =
    open System.Threading.Tasks

TheAngryByrd

// This is used to quickly diagnose why a rebuild happened in a large solution
// It reads a binlog file and finds all the CoreCompile targets that were triggered by a file being newer than the output file
// It then prints out the project and the messages that caused the rebuild
// to create a binlog you can refer to https://learn.microsoft.com/en-us/visualstudio/ide/msbuild-logs?view=vs-2022#provide-msbuild-binary-logs-for-investigation
// CLI: dotnet build -bl:mybinlog.binlog
// or in `.build/build.fs` add `BuildParameter.enableBinLog "mybinlog.binlog"` to the `build'` target.

// Use https://msbuildlog.com/ to diagnose further
#r "nuget: MSBuild.StructuredLogger"

TheAngryByrd

open System.Runtime.CompilerServices

type Log() =
    static member inline GatherLogMetaStackFrame
        (?name_space: string, [<CallerMemberName>] ?cmb: string, [<CallerLineNumber>] ?cln: int, [<CallerFilePath>] ?cfp: string)
        =
        let name_space =
            match name_space with
            | Some ns -> ns
            | _ ->

TheAngryByrd

#r "nuget: FsToolkit.ErrorHandling"

open FsToolkit.ErrorHandling
open System

type SensorReadings = int


module RegularApproach =

TheAngryByrd

#r "nuget: FSharp.Compiler.Service, 43.8.300"

open FSharp.Compiler.Syntax
open FSharp.Compiler.SyntaxTrivia
open FSharp.Compiler.Xml
open FSharp.Compiler.CodeAnalysis
open System.IO

type Node =
    { Data     : Data