Work Items.txt

== v0.5 Changes ==
- Remove ".Commons" from all namespaces
- Rename Maybe<T> to Optional<T>...
- Consider making Outcome eagerly evaluated...
- Consider tying .WasSuccessful to each observation in Outcome<TObservation> and Result<T, TObservation>...
- Eliminate all optional arguments from methods
- Change all Guard.NotNull(@this, "@this") calls to Guard.NotNull(@this, "this") - argument name shouldn't have '@' sign
- Rename Guard to Argument
- Refactor CompositeDisposable to dispose enlisted items in reverse order...
- Fix SystemClock to not allow changes to default strategy after prevent is called; disallow returning times that are not in UTC.
- Evaluate targeting Client profile...
- Consider better how Unit interacts with Maybe<T>, Outcome<TObservation>, and Result<T, TObservation>

== Potential Future Changes ==
- Create experimental fork
- Change Neighbors<T> to Neighborhood<T>...
- Make SmartLoop enumerable
- Make SmartLoop immutable (persistent data structure)
- Move reflection based specification (and builders) out of unit test project into main library
    * Potentially reinstate general purpose specification pattern that returns something like Outcome<T> that also references the subject/candidate...
- Add Xml comments to public API surface...
- Integrate FxCop/StyleCop w/ custom rules into build...
- Search code for TODOs, HACKs, NOTEs, etc
- Finish design of Indexable interfaces...
- Change readme to markdown file...
- Add Contract tests for interfaces...
- Flesh out the Result<T, TObservation> (writer) monad...
- Scan thru Reactive/Interactive Extensions for potential new/renamed Maybe<T> operators...
    * Add Retry method
- Build Exodata binding/resolution around a Monoid...
- Allow Exodata bindings to bind to types of symbols, not just instances...
- Add the ability to turn logging on for Exodata resolution
- Add the ability to resolve and bind Exodata to untyped symbols...
- Implement Equatable<T>, using same approach as Cloneable<T>...
- Reevaluate/refactor strategy for determining if an object is cloneable via Cloneable<T> (e.g. can delegates be cloned? how?)
- Enhance Cloneable<T> to detect if a struct is a cloneable primitive (all fields recursively are cloneable primitives)...
- Ensure thread safety in Cloneable<T>/Equatable<T>...
- Evaluate possible refactoring of Cloneable<T>/Equatable<T> to see if they could be simplified/generalized...
- Move to .NET 4.0
    * Evaluate using Contracts class (augment or replace Guard class)
    * Replace thread safety in Cloneable<T>/Equatable<T> with Lazy<T>
- Create abstract TextScanner<T>, where T is the Token type
    * Use regular expressions to build a Table Lexer?
        ** Convert multiple regular expressions into a single recognizer state machine
- Create generic DynamicDispatch using ExpressionTrees to compile dispatch delegates...
- Create generic DynamicDispatch based Visitor<T> implementation...
- Add RelativePath extension methods to FileSystemInfo and IEnumerable<FileSystemInfo>...
- Implement SmartFormat ( e.g. SmartFormat.Format("{Name}: {Description}", new { Name = "Foo", Description = "Bar" }); )
- Add support for Dependant Scopes (e.g. System.Transactions.Transaction.DependantClone(...))
- Add support for out-off-order disposal detection of Scopes with resulting exception...
- Add support for Scopes that need to be explicitly passed around (e.g. ScopeBounds.Explicit)
    * Create Push() method to create child scope
    * Collapse CompositeDisposable into DisposableContext
- Change LookAheadValue from class to struct
- Enhance GetDelegate extension method to work with generic methods
- Scan types for Command-Query Separation opportunities
- Make unit tests run against ILMerged output assembly
- Investigate alternative assembly "merging" strategy for projects
- Add class to check method/constructor input validation (e.g. Outcome<CheckOnObservation> result = Check.On( () => new Foo(CannotBe.Null<string>(), CanBe.Null<string>()) )
- Add strong naming to assemblies