Porges

using System;
using Comparisons;

namespace Types
{

    class Person : Comparable<Person>
    {
        private static readonly Comparer<Person> _comparer =
            Comparer<Person>

Porges

module Implicit

type Implicitly<'i, 't> = private Implicitly of ('i -> 't)

let implicitly = Implicitly

let runImplicit impl (Implicitly f) = f impl

type ImplicitBuilder<'i> () =
    member __.ReturnFrom x = x

Porges

class Example
{

}

Porges

interface IProducer
{
    Result Produce();
}

class ProducerExample
{
    readonly IProducer _producer;

    // constructor elided...

Porges

interface IStrategy
{
    Result DoTheThing(Input input);
}

class Consumer
{
    readonly ICollection<IStrategy> _strategies;

    public void PerformDuties()

Porges

#include <exception>
#include <filesystem>
#include <iostream>
#include <string>
#include <stack>

void hardlink_dir(
    const std::experimental::filesystem::path& fromRoot,
    const std::experimental::filesystem::path& toRoot)
{

Porges

using System;

namespace Result
{
    class Program
    {
        static void Main(string[] args)
        {
            var r = new Random();
            for (int i = 0; i < 10; ++i)

Porges

Keybase proof

I hereby claim:

• I am porges on github.
• I am porges (https://keybase.io/porges) on keybase.
• I have a public key whose fingerprint is 15E4 4626 39AF 06CF 5F0A AA58 0FE3 4FF5 2469 705F

To claim this, I am signing this object:

Porges

#include <iostream>
#include <string>
#include <typeindex>
#include <typeinfo>
#include <unordered_map>

// We want to put all registered types into a map:
std::unordered_map<std::type_index, std::string> registered_types;

template<class T>

Porges

using System;
using System.Runtime.CompilerServices;

namespace Provenance
{
    public struct Provenance
    {
        public Provenance(string callerFileName, int callerLineNumber)
        {
            CallerFileName = callerFileName;