Horusiath

module Program =
        
    type InMemoryDb(replica: ReplicaId) =
        let snapshot = ref null
        let mutable events : Map<uint64,obj> = Map.empty
        interface Db with
            member _.SaveSnapshot state = async { snapshot := (box state) } 
            member _.LoadSnapshot<'s>() = async {
                match !snapshot with

Horusiath

open System

[<Struct>] type Effect<'env, 'out> = Effect of ('env -> Async<'out>)

[<RequireQualifiedAccess>]
module Effect =

    /// Create value with no dependency requirements.
    let inline value (x: 'out): Effect<'env,'out> = Effect (fun _ -> async.Return x)
    /// Create value which uses depenendency.

Savelenko

[<EntryPoint>]
let main argv =
    printfn "Should be zero (netWeight emptyPallet): %A" Stock.shouldBeZero
    printfn "harvesterPartsWeight: %A" Stock.harvesterPartsWeight
    printfn "grossWeight harvesterParts: %A" (Stock.grossWeight Stock.harvesterParts)
    printfn "grossWeight emptyPallet: %A" (Stock.grossWeight Stock.emptyPallet)
    printfn "netWeight harvesterParts: %A" (Stock.netWeight Stock.harvesterParts)
    printfn "value harvesterParts: %A" (Stock.value Stock.harvesterParts)
    printfn "boxLabels harvesterParts: %A" (Stock.boxLabels Stock.harvesterParts)
    printfn "boxLabels emptyPallet: %A" (Stock.boxLabels Stock.emptyPallet)

vi

Let's list here crates that enhance Rust as a language.

It not "batteries" like in stdx, but Rust-specific crates for workarounds for various missing features and experimental ideals from non-accepted/postponed RFCs, or just hacky tricks.

The list is supposed to contain (mostly) crates that are internal to Rust, not ones for making Rust deal with "external world" like other languages bindings, file formats, protocols and so on.

Primary focus should be on crates that are not easy to find by conventional means (e.g. no algorithm name, format or protocol to search for).

Note that quality of the listed crates may vary from proof-of-concept to stable-and-widely-used.