KitchenSink

Dumping ground for multi-paradigm programming ideas in C#.

Below is a summary of what this repo contains. Note that not everything in this library is meant to be taken completely seriously. Some facilities are almost sarcastic in their inclusion.

Basic Data Types

Unit - has only one meaningully unique value
Void - no value can be constructed; is always null
Maybe<A> - may or may not have a value and maps functions over missing value
Either<A, B> - represents a distinction between two possible types of values
NewType<A> - wraps existing types to distinguish on the type level
Monoid<A> - appends values of a particular type into combined values of the same type
Functor<FA, FB, A, B> - lifts a function A => B into the space of F

Convenient Operators and Extensions

ListOf, SeqOf, DictOf - concise collection creation: DictOf("one", 1, "two", 2, "three", 3)
Cmp - sets up expressive bound comparisons: 0 <= Cmp(x) < 10
Eq, Same, Str, Hash - null-safe basic object operations
Apply - partially apply functions
Split - splits strings by Regex
A.IsIn(IEnumerable<A>), A.IsIn(params A[]) - reversed contains check
IEnumerable.AsStream, Stream.AsEnumerable - converts IEnumerables to/from Streams
Batch - split sequence into subsequences of consecutive values
Buffer - eagerly evaluate sequence ahead of time in arbitrary sized groups
CrossJoin - zip every element in sequence with every element in another sequence
Cycle - repeat elements of a sequence infinitely
Deal - split sequence into subsequences of every nth value
Flatten - combine values of subsequences into one long sequence
Forever - create lazy sequence by repeatedly calling an impure function
Interleave - create a sequence of the values of multiple sequences round-robin
Intersperse - create a sequence of elements from one sequence with all the elements of another between each one
OverlappingPairs - creates a sequence of tuple pairs of overlapping adjacent pairs in a sequence
Shuffle - randomize ordering of a sequence
ZipExact - zip two sequences, raising an error if one runs out before the other

Optimally Specialized Collections

AsyncQueue<A> - asynchronous queue that allows awaiting on value inserted into empty queue
BankersQueue<A> - persistent queue made from two ConsLists
BitmappedTrie<A> - persistent vector with tree structure
ComputedList<A> - list that generates values based on index instead of storing in memory
ConsList<A> - an immutable, singly-linked list
DefaultingDictionary<A, Z> - dictionary that defers to another dictionary when key is missing
Dictionary<A, B, Z> - Dictionarys that use Tuple for aggregate keys
FingerTree<A> - a persistent dequeue implemented as 2,3-finger tree
PairingHeap<A> - a self-balancing, persistent, ordered heap
RadixDictionary<A> - mutable dictionary optimized for string keys
RoseTree<A> - mutable tree data structure that braches arbitrarily

Neat Math Operations

Factorial - factorial as an extension method on int
PermutationCount - computes number of permutations for given collection size and subsequence size
Permutations - creates sequence of permutations of given size
AllPermutations - creates sequence of permutations of all sizes
CombinationCount - computes number of combinations for given collection size and subset size
Combinations - creates sequence of combinations of elements of given size
AllCombinations - creates sequence of combinations of all sizes

Abstracted File System

IFileSystem - interface representing minimal set of file system operations
RealFileSystem - forwards operations to System.IO classes
VirtualFileSystem - in-memory file system data structure
ResilientFileSystem - IFileSystem decorator that adds retry logic to all operations

Multiple Dispatch Mechanism

MultiMethod - group of functions that execute based on argument type or arbitrary predicate

Powerful Concurrency Primitives

Atom<A> - mutually exclusive reference cell with synchronous updates that is both divisible and composable
Lock - exclusive locking primitive built on Monitor.Enter/.Exit that is composible

Composable Control Structures

Cond - builds a list of clauses and conditionally evaluates consequents
Case - like Cond, but clauses are applied to a key value

Flexible Resiliency Mechanisms

Retry.Exponential - waits double time between each successive attempt of an operation
Retry.Fractal - subdivides workload of batch operations, retrying as series of smaller batches
Retry.Sequential - attempts a series of alternate arguments to parameterized operation

Easy Cache Implementation

Batcher - accumulates arguments to Push method until limit is reached or Flush is called
Cache - uses code generation to build wrapper class around interface implementation that caches all methods
Debounce - returns new version of an action that only passes through call after a time has passed since last call
Memo - returns new version of a function that caches return value for inputs, with optional expiration time
Sprinkler - splits items from batches passed to Push spread out by time delay

Dynamic Scoping Emulation

Scope.Push, Scope.Get - controlled, thread local, global variables that are only defined farther down the call chain

Simple Dependency Injection

Needs - a minimal-configuration IoC container that can search assemblies and parent types and failover to other IoC containers
SingleUse - an attribute indicating that a dependency implementation is not threadsafe or can only be used once

Precise Timekeeping Representations

DateSpan - region of time between two dates

Testing and Validation

Expect - testing for exceptions and property based testing; companion to Assert
Rand - produces random test data
Sample - provides common and edge-case test values
All - enumerates all values of certain types

Pure Functional Programming Facilities

Io - a type for modeling and composing I/O operations and side effects
Lens - composable get and set pair for immutable types

Questionable File Path Building Facility using Operator Overloading

Looks weird
But looks cool
Uses overloaded / operator to build paths
Works on .Net/Windows and Mono/Linux

Drive.C / "Folder1" / "Folder2" / "File.txt"
    "C:\\Folder1\\Folder2\\File.txt" (Windows)

Folder.AppData / "MyApp" / "Config.xml"
    "C:\\Users\\Me\\AppData\\MyApp\\Config.xml" (Windows)
    "/users/me/.config/MyApp/Config.xml"        (Linux)

Crazy XML Building Facility using Operator Overloading

This was clearly a mistake
I am so sorry
Uses overloaded <, >, <= and >= operators to build XML
Lets you do this:

Xml.Doc < "catalog"
    < "book" >= "id" <= "bk101"
        < "author" <= "Gambardella, Matthew"
        < "title" <= "XML Developer's Guide"
        < "price" >= "currency" <= "USD" <= "44.95" > Xml.End
    < "book" >= "id" <= "bk102"
        < "author" <= "Ralls, Kim"
        < "title" <= "Midnight Rain"
        < "price" >= "currency" <= "USD" <= "5.95" > Xml.EndDoc

which generates

<catalog>
  <book id="bk101">
    <author>Gambardella, Matthew</author>
    <title>XML Developer's Guide</title>
    <price currency="USD">44.95</price>
  </book>
  <book id="bk102">
    <author>Ralls, Kim</author>
    <title>Midnight Rain</title>
    <price currency="USD">5.95</price>
  </book>
</catalog>

rkoeninger / KitchenSink