KodrAus

use std::collections::HashSet;

/**
A simple, reasonably space-efficient, stack-based datastructure that tracks whether a given string key has been seen before.

This is not a general-purpose hash set. It uses non-cryptographic FNV hashing and limited space, so is very prone to collisions.
If a collision is detected then the contents of the filter can be spilled into a regular `HashSet<&str>`.
For small numbers of values, it can be used to avoid or defer allocation.

The filter accepts two generic parameters:

KodrAus

Summary

Add the following method to Serializer:

fn serialize_byte_array<const N: usize>(self, bytes: &[u8; N]) -> Result<Self::Ok, Self::Error> {
    self.serialize_bytes(bytes)
}

KodrAus

#![feature(test)]

extern crate test;

use serde::{Serialize, Serializer};

pub struct Bytes([u8; 16]);

pub struct Tuple([u8; 16]);

KodrAus

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();

KodrAus

#![feature(unsize)]

use std::{
    any::TypeId,
    marker::Unsize,
    fmt,
};

enum Dyn<'v, T: ?Sized, TStatic: ?Sized>
{

KodrAus

using System;
using System.Threading;

namespace PureDI
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create the singletons once

KodrAus

https://github.com/search?q=user%3AKodrAus+topic%3Aexample

Any example repositories I put together should turn up with a user:KodrAus topic:example GitHub search query.

KodrAus

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

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.

KodrAus

union MaybeInitialized<T> {
    initialized: T,
    uninitialized: (),
}