Skip to content

Instantly share code, notes, and snippets.

Avatar

Ashley Mannix KodrAus

View GitHub Profile
@KodrAus
KodrAus / find_msbuild.rs
Created Apr 11, 2020
Find `msbuild` using `vswhere`
View find_msbuild.rs
use std::path::PathBuf;
use std::process::Command;
use std::str;
let mut msbuild = PathBuf::from("msbuild");
let check_msbuild = Command::new(msbuild)
.arg("--version")
.output()
.is_ok();
View maybe_downcast.rs
#![feature(unsize)]
use std::{
any::TypeId,
marker::Unsize,
fmt,
};
enum Dyn<'v, T: ?Sized, TStatic: ?Sized>
{
@KodrAus
KodrAus / PureDI.cs
Last active Jan 20, 2020 — forked from davidfowl/PureDI.cs
DI under the hood. This is what DI containers automate for you
View PureDI.cs
using System;
using System.Threading;
namespace PureDI
{
class Program
{
static void Main(string[] args)
{
// Create the singletons once
@KodrAus
KodrAus / examples.md
Last active Jul 23, 2019
Finding my examples
View examples.md
@KodrAus
KodrAus / tracing_log.rs
Last active Jun 29, 2020
Converting between `tracing` key values and `log` key values
View tracing_log.rs
use std::fmt;
use log::kv::{self, Source, value::{self, Fill}};
use tracing::{Value, Field, field::{self, Visit}};
#[doc(hidden)]
pub struct LogField<'kvs>(&'kvs Field, &'kvs dyn Value);
impl fmt::Debug for LogField<'_> {
@KodrAus
KodrAus / Replace Concrete impl with Blanket.md
Created Jan 25, 2019
Using cargo features to replace a set of concrete impls with a blanket one
View Replace Concrete impl with Blanket.md

Using cargo features to replace a set of concrete trait impls with a blanket one

There's subtlety involved in doing this so I've just dumped this out from another document in case I ever need to remember what they were in the future.

value::Visit

The Visit trait can be treated like a lightweight subset of serde::Serialize that can interoperate with serde, without necessarily depending on it. It can't be implemented manually:

/// A type that can be converted into a borrowed value.
View maybe_initialized.rs
union MaybeInitialized<T> {
initialized: T,
uninitialized: (),
}
@KodrAus
KodrAus / properties.rs
Last active Jun 11, 2018
Properties Macro
View properties.rs
/*!
This example demonstrates a potential macro for capturing log properties.
The macro uses a syntax that's _similar_ to struct literals. The idea is to support
extensions to the way properties are captured using attributes.
There's a bit of a misalignment between how formatting is communicated in the log
message and the contextual properties, but they are a bit different. Args are slurped
up into the message using the formatting API whereas properties are exposed as data.
View NonRootScopeLifetime.cs
/*
An Autofac lifetime that ensures dependencies are only resolved from scoped containers.
This acts like a safety-net to prevent captive dependencies:
```
// Register some short-lived dependency using the `NonRootScopeLifetime`
var registration = builder.Register(c => c.Resolve<IStore>().BeginSession()).As<ISession>();
registration.RegistrationData.Lifetime = new NonRootScopeLifetime();
```
View dependable-dependencies.md

Dependable Dependencies

A dependable API, docs, examples and maintainership supported by tools and resources.

In this post I'd like to explore the quality libraries aspect of the [Rust 2018 roadmap RFC]. I'll lay out the framework that underpins my perspective on open source development as a starting point for conversation.

Quality means dependability. It also means a bunch of other things, but I'd like to focus on dependability here. The roadmap discusses sharpening Rust's offerings in a few focus domains, and I think a key to doing that is by supporting the dependability of libraries that fit within them.

What exactly is dependability though? I think a dependable library consists of:

You can’t perform that action at this time.