MicroElements.Functional by micro-elements

<PackageReference Include="MicroElements.Functional" Version="0.14.0" />

---

API Diff between 0.14.0 and 0.3.0

383 Additions 29 Removals

MicroElements.Functional

• public static class ActionExt
• public static class ActionExtensions
  • public static Func<Unit> ToFunc(this Action action)
  • public static Func<T, Unit> ToFunc<T>(this Action<T> action)
  • public static Func<T1, T2, Unit> ToFunc<T1, T2>(this Action<T1, T2> action)
• public class ConcurrentMessageList<TMessage> : IMutableMessageList<TMessage>, IMessageList<TMessage>, IReadOnlyCollection<TMessage>, IEnumerable<TMessage>, IEnumerable
  • public int Count { get; }
  • public ConcurrentMessageList()
  • public void Add(TMessage message)
  • public void AddRange(IEnumerable<TMessage> other)
  • public IEnumerator<TMessage> GetEnumerator()
• public static class Contracts
  • public static T AssertArgumentNotNull<T>(this T arg, string name)
  • public static T AssertNotNullResult<T>(this T result)
• public static class DictionaryExtensions
  • public static Option<TValue> GetValueAsOption<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static Option<TValue> GetValueAsOption<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
  • public static Result<TValue, KeyNotFound<TKey>> GetValueAsResult<TKey, TValue>(this IDictionary<TKey, TValue> dictionary, TKey key)
  • public static Result<TValue, KeyNotFound<TKey>> GetValueAsResult<TKey, TValue>(this IReadOnlyDictionary<TKey, TValue> dictionary, TKey key)
• public static class EnumerableExt
• public static class EnumerableExtensions
  • public static IEnumerable<T> NotNull<T>(this IEnumerable<T> items)
  • public static IReadOnlyCollection<T> NotNull<T>(IReadOnlyCollection<T> items)
  • public static IReadOnlyList<T> NotNull<T>(IReadOnlyList<T> items)
  • public static T[] NotNull<T>(T[] items)
• public sealed delegate ErrorAction<Error> : MulticastDelegate
  • public ErrorAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Error error, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(Error error)
• public sealed delegate ErrorAction<Error, Message> : MulticastDelegate
  • public ErrorAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Error error, IMessageList<Message> messages, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(Error error, IMessageList<Message> messages)
• public sealed delegate ErrorFunc<Error, B> : MulticastDelegate
  • public ErrorFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Error error, AsyncCallback callback, object object)
  • public virtual B EndInvoke(IAsyncResult result)
  • public virtual B Invoke(Error error)
• public sealed delegate ErrorFunc<Error, Message, B> : MulticastDelegate
  • public ErrorFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(Error error, IMessageList<Message> messages, AsyncCallback callback, object object)
  • public virtual B EndInvoke(IAsyncResult result)
  • public virtual B Invoke(Error error, IMessageList<Message> messages)
• public struct FailedResult<Error> : IResult
  • public Error ErrorValue { get; }
  • public bool IsFailed { get; }
  • public bool IsSuccess { get; }
  • public Type GetErrorValueType()
  • public Type GetSuccessValueType()
  • public Res MatchUntyped<Res>(Func<object, Res> success, Func<object, Res> error)
• public interface ICanBeError
  • bool IsError { get; }
• public interface IFormattableObject
  • IEnumerable<ValueTuple<string, object>> GetNameValuePairs()
• public interface IMessage : IReadOnlyList<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable, IReadOnlyCollection<KeyValuePair<string, object>>, IReadOnlyDictionary<string, object>
  • string EventName { get; }
  • IReadOnlyList<KeyValuePair<string, object>> Properties { get; }
  • MessageSeverity Severity { get; }
  • object State { get; }
  • string Text { get; }
  • DateTimeOffset Timestamp { get; }
• public interface IMessageEnricher
  • IMessage Enrich(IMessage message)
• public interface IMessageList<TMessage> : IReadOnlyCollection<TMessage>, IEnumerable<TMessage>, IEnumerable
  • IMessageList<TMessage> Add(TMessage message)
  • IMessageList<TMessage> AddRange(IEnumerable<TMessage> other)
• public interface IMessageRenderer
  • void Render(IMessage message, TextWriter output)
• public interface IMutableMessageList<TMessage> : IMessageList<TMessage>, IReadOnlyCollection<TMessage>, IEnumerable<TMessage>, IEnumerable
  • void Add(TMessage message)
  • void AddRange(IEnumerable<TMessage> other)
• public interface IOptional
  • R MatchUntyped<R>(Func<object, R> some, Func<R> none)
• public struct MOption<A>
• public interface IParseResult
  • bool IsSuccess { get; }
  • Type GetMessageUnderlyingType()
  • Type GetUnderlyingType()
  • TResult MatchUntyped<TResult>(Func<object, IEnumerable, TResult> success, Func<IEnumerable, TResult> error)
• public interface IResult
  • bool IsFailed { get; }
  • bool IsSuccess { get; }
  • Type GetErrorValueType()
  • Type GetSuccessValueType()
  • Res MatchUntyped<Res>(Func<object, Res> success, Func<object, Res> error)
• public interface IResultWithMessages : IResult
  • Type GetMessageType()
  • Res MatchUntyped<Res>(Func<object, IEnumerable, Res> success, Func<object, IEnumerable, Res> error)
• public class JsonRenderer : IMessageRenderer
  • public JsonRenderer()
  • public void Render(IMessage message, TextWriter output)
• public static class MemoExtensions
  • public static Func<A> Memoize<A>(this Func<A> func)
• public sealed class Message : IMessage, IReadOnlyList<KeyValuePair<string, object>>, IEnumerable<KeyValuePair<string, object>>, IEnumerable, IReadOnlyCollection<KeyValuePair<string, object>>, IReadOnlyDictionary<string, object>, ICanBeError, IFormattableObject
  • public int Count { get; }
  • public string EventName { get; }
  • public bool IsError { get; }
  • public KeyValuePair<string, object> this[int index] { get; }
  • public object this[string key] { get; }
  • public IEnumerable<string> Keys { get; }
  • public IReadOnlyList<KeyValuePair<string, object>> Properties { get; }
  • public MessageSeverity Severity { get; }
  • public object State { get; }
  • public string Text { get; }
  • public DateTimeOffset Timestamp { get; }
  • public IEnumerable<object> Values { get; }
  • public Message(string text, MessageSeverity severity = 0, DateTimeOffset? timestamp = default, string eventName = null, object state = null, IReadOnlyList<KeyValuePair<string, object>> properties = null)
  • public static Message op_Implicit(string text)
  • public bool ContainsKey(string key)
  • public IEnumerator<KeyValuePair<string, object>> GetEnumerator()
  • public IEnumerable<ValueTuple<string, object>> GetNameValuePairs()
  • public bool TryGetValue(string key, out object value)
• public static class MessageExtensions
  • public static IReadOnlyList<KeyValuePair<string, object>> AddIfNotExists(this IEnumerable<KeyValuePair<string, object>> source, IEnumerable<KeyValuePair<string, object>> keyValuePairs, IEqualityComparer<string> keyEqualityComparer = null)
  • public static IReadOnlyList<KeyValuePair<string, object>> AddWithReplace(this IEnumerable<KeyValuePair<string, object>> source, IEnumerable<KeyValuePair<string, object>> keyValuePairs, IEqualityComparer<string> keyEqualityComparer = null)
  • public static Option<object> GetProperty(this IMessage message, string propertyName)
  • public static Message WithEventName(this IMessage message, string eventName)
  • public static Message WithProperties(this IMessage message, IReadOnlyList<KeyValuePair<string, object>> properties, PropertyListAddMode propertyListAddMode = 0)
  • public static Message WithProperties(this IMessage message, IEnumerable<KeyValuePair<string, object>> properties, PropertyListAddMode propertyListAddMode = 0)
  • public static Message WithProperty(this IMessage message, string name, object value)
  • public static Message WithSeverity(this IMessage message, MessageSeverity severity)
  • public static Message WithState(this IMessage message, object state)
  • public static Message WithText(this IMessage message, string text)
  • public static Message WithTimestamp(this IMessage message, DateTimeOffset timestamp)
• public static class MessageList
  • public static MessageList<Message> Empty<Message>()
  • public static MessageList<Message> FromEnumerable<Message>(IEnumerable<Message> messages)
• public class MessageList<TMessage> : IMessageList<TMessage>, IReadOnlyCollection<TMessage>, IEnumerable<TMessage>, IEnumerable
  • public static readonly MessageList<TMessage> Empty
  • public int Count { get; }
  • public MessageList(TMessage message)
  • public MessageList(IEnumerable<TMessage> messages)
  • public static MessageList<TMessage> op_Implicit(TMessage message)
  • public IMessageList<TMessage> Add(TMessage message)
  • public IMessageList<TMessage> AddRange(IEnumerable<TMessage> other)
  • public IEnumerator<TMessage> GetEnumerator()
• public static class MessageListExtensions
  • public static MessageList<Message> ToMessageList<Message>(this IEnumerable<Message> messages)
  • public static MessageList<Message> ToMessageList<Message>(this Message message)
• public enum MessageSeverity
  • Error = 2
  • Information = 0
  • Warning = 1
• public class NotInitializedException : Exception
  • public NotInitializedException(string message)
• public struct Option<A> : IEnumerable<A>, IEnumerable, IOptional, IEquatable<Option<A>>
  • public static readonly Option<T> None
  • public static readonly Option<A> None
  • public Option(IEnumerable<T> option)
  • public static bool op_Equality(Option<T> this, Option<T> other)
  • public static T op_Explicit(Option<T> option)
  • public static Option<T> op_Implicit(OptionNone none)
  • public static Option<T> op_Implicit(Some<T> some)
  • public static Option<T> op_Implicit(T value)
  • public static bool op_Inequality(Option<T> this, Option<T> other)
  • public IEnumerable<T> AsEnumerable()
  • public bool Equals(Option<T> other)
  • public IEnumerator<T> GetEnumerator()
  • public Option(IEnumerable<A> option)
  • public static bool op_Equality(Option<A> self, Option<A> other)
  • public static A op_Explicit(Option<A> option)
  • public static Option<A> op_Implicit(OptionNone none)
  • public static Option<A> op_Implicit(Some<A> some)
  • public static Option<A> op_Implicit(A value)
  • public static bool op_Inequality(Option<A> self, Option<A> other)
  • public IEnumerable<A> AsEnumerable()
  • public bool Equals(Option<A> other)
  • public IEnumerator<A> GetEnumerator()
  • public TResult Match<TResult>(Func<T, TResult> some, Func<TResult> none)
  • public TResult Match<TResult>(Func<T, TResult> some, TResult none)
  • public Unit Match(Action<T> some, Action none)
  • public TResult Match<TResult>(Func<A, TResult> some, Func<TResult> none)
  • public TResult Match<TResult>(Func<A, TResult> some, TResult none)
  • public Unit Match(Action<A> some, Action none)
  • public R MatchUntyped<R>(Func<object, R> some, Func<R> none)
• public static class OptionExtensions
  • public static Option<Result> Bind<T, Result>(this Option<T> option, Func<T, Option<Result>> f)
  • public static T GetOrElse<T>(this Option<T> opt, T defaultValue)
  • public static T GetOrElse<T>(this Option<T> opt, Func<T> fallback)
  • public static T GetValueUnsafe<T>(this Option<T> option)
  • public static T GetValueOrDefault<T>(this Option<T> opt, T defaultValue)
  • public static T GetValueOrDefault<T>(this Option<T> opt, Func<T> fallback)
  • public static T GetValueOrThrow<T>(this Option<T> option)
  • public static Some<T> ToSome<T>(this T value)
• public static class OptionOperations
  • public static Option<B> Bind<A, B>(this ref Option option, Func<A, Option<B>> bind)
  • public static B Match<A, B>(ref Option source, Func<A, B> some, Func<B> none)
  • public static B Match<A, B>(ref Option source, Func<A, B> some, B none)
  • public static Unit Match<A>(ref Option source, Action<A> some, Action none)
  • public static B MatchUnsafe<A, B>(this ref Option source, Func<A, B> some, Func<B> none)
  • public static B MatchUnsafe<A, B>(this ref Option source, Func<A, B> some, B none)
• public enum OptionState
  • None = 0
  • Some = 1
• public static class Prelude
  • public static readonly IMessageList<string> EmptyMessageList
  • public static Option<T> ChangeType<T>(string text)
  • public static Message ErrorMessage(string text)
  • public static Message InformationMessage(string text)
  • public static Func<R> Memoize<R>(Func<R> func)
  • public static Func<A, R> Memoize<A, R>(this Func<A, R> func, int cacheLimit)
  • public static Func<A, R> MemoizeCustom<A, R>(this Func<A, R> func, Func<A, Option<R>> cacheTryGet, Func<A, Func<A, R>> cacheGetOrAdd)
  • public static Func<A, R> MemoizeUnsafe<A, R>(this Func<A, R> func)
  • public static Option<bool> ParseBool(string value)
  • public static Option<byte> ParseByte(string value)
  • public static Option<char> ParseChar(string value)
  • public static Option<DateTime> ParseDateTime(string value)
  • public static Option<DateTimeOffset> ParseDateTimeOffset(string value)
  • public static Option<decimal> ParseDecimal(string value)
  • public static Option<double> ParseDouble(string value)
  • public static Option<double> ParseDouble(string value, NumberStyles style, IFormatProvider provider)
  • public static Option<TEnum> ParseEnum<TEnum>(string value) where TEnum : struct
  • public static Option<float> ParseFloat(string value)
  • public static Option<Guid> ParseGuid(string value)
  • public static Option<int> ParseInt(string value)
  • public static Option<int> ParseInt(string value, int fromBase)
  • public static Option<IPAddress> ParseIPAddress(string value)
  • public static Option<long> ParseLong(string value)
  • public static Option<sbyte> ParseSByte(string value)
  • public static Option<short> ParseShort(string value)
  • public static Option<uint> ParseUInt(string value)
  • public static Option<ulong> ParseULong(string value)
  • public static Option<ushort> ParseUShort(string value)
  • public static Result<A, Exception, Message> SuccessResult<A, Message>(A value, Message message)
  • public static SuccessResult<A> SuccessResult<A>(A value)
  • public static Result<A, Exception> Try<A>(Func<A> func)
  • public static Result<A, Error> Try<A, Error>(Func<A> func, Func<Exception, Error> mapError)
  • public static Result<A, Error> Try<A, Error>(Func<Result<A, Error>> func, Func<Exception, Error> mapError)
  • public static Task<Result<A, Exception>> TryAsync<A>(Func<Task<A>> func)
  • public static Task<Result<A, Error>> TryAsync<A, Error>(Func<Task<A>> func, Func<Exception, Error> mapError)
  • public static Task<Result<A, Error>> TryAsync<A, Error>(Func<Task<Result<A, Error>>> func, Func<Exception, Error> mapError)
  • public static Message WarningMessage(string text)
• public struct Result<A> : IEquatable<Result<A>>
• public enum PropertyListAddMode
  • AddIfNotExists = 2
  • Merge = 1
  • Set = 0
• public static class Result
  • public static Result<A, Error> Fail<A, Error>(Error error)
  • public static FailedResult<Error> Fail<Error>(Error value)
  • public static Result<A, Error, Message> Fail<A, Error, Message>(Error error, IEnumerable<Message> messages)
  • public static Result<A, Error, Message> Fail<A, Error, Message>(Error error, Message message)
  • public static Result<A, Error> Success<A, Error>(A value)
  • public static Result<A, Error, Message> Success<A, Error, Message>(A value, IEnumerable<Message> messages)
  • public static Result<A, Error, Message> Success<A, Error, Message>(A value)
  • public static SuccessResult<A> Success<A>(A value)
  • public static ValueWithMessages<A, Message> WithMessages<A, Message>(this ref SuccessResult successResult, IMessageList<Message> messages)
  • public static ValueWithMessages<Error, Message> WithMessages<Error, Message>(this ref FailedResult successResult, IMessageList<Message> messages)
• public struct Result<A, Error> : IResult, IEquatable<Result<A, Error>>, IEquatable<SuccessResult<A>>, IEquatable<A>
  • public static readonly Result<A, Error> Empty
  • public bool IsFailed { get; }
  • public bool IsSuccess { get; }
  • public static Result<A, Error> op_Implicit(A value)
  • public static Result<A, Error> op_Implicit(SuccessResult<A> successResult)
  • public static Result<A, Error> op_Implicit(FailedResult<Error> failedResult)
  • public static Result<A, Error> op_Implicit(Error error)
  • public Result<B, Error> Bind<B>(Func<A, Result<B, Error>> bind)
  • public bool Equals(Result<A, Error> other)
  • public bool Equals(SuccessResult<A> other)
  • public bool Equals(A value)
  • public Type GetErrorValueType()
  • public Type GetSuccessValueType()
  • public B Match<B>(SuccessFunc<A, B> success, ErrorFunc<Error, B> error)
  • public Unit Match(SuccessAction<A> success, ErrorAction<Error> error)
  • public TResult MatchUntyped<TResult>(Func<object, TResult> success, Func<object, TResult> error)
• public struct Result<A, Error, Message> : IResultWithMessages, IResult, IEquatable<Result<A, Error, Message>>, IEquatable<SuccessResult<A>>, IEquatable<A>
  • public static readonly Result<A, Error, Message> Empty
  • public readonly IMessageList<Message> Messages
  • public bool IsFailed { get; }
  • public bool IsSuccess { get; }
  • public static A op_Explicit(Result<A, Error, Message> source)
  • public static Result<A, Error, Message> op_Implicit(A value)
  • public static Result<A, Error, Message> op_Implicit(ref SuccessResult successResult)
  • public static Result<A, Error, Message> op_Implicit(ref FailedResult failedResult)
  • public static Result<A, Error, Message> op_Implicit(ref ValueWithMessages valueWithMessages)
  • public static Result<A, Error, Message> op_Implicit(ref ValueTuple valueWithMessages)
  • public static Result<A, Error, Message> op_Implicit(ref ValueWithMessages valueWithMessages)
  • public static Result<A, Error, Message> op_Implicit(ref ValueTuple valueWithMessages)
  • public static Result<A, Error, Message> op_Implicit(Error error)
  • public static Result<A, Error, Message> op_Implicit(Message message)
  • public Result<B, Error, Message> Bind<B>(Func<A, Result<B, Error, Message>> bind)
  • public bool Equals(Result<A, Error, Message> other)
  • public bool Equals(SuccessResult<A> other)
  • public bool Equals(A value)
  • public Type GetErrorValueType()
  • public Type GetMessageType()
  • public Type GetSuccessValueType()
  • public B Match<B>(SuccessFunc<A, Message, B> success, ErrorFunc<Error, Message, B> error)
  • public Unit Match(SuccessAction<A, Message> success, ErrorAction<Error, Message> error)
  • public Res MatchUntyped<Res>(Func<object, Res> success, Func<object, Res> error)
  • public Res MatchUntyped<Res>(Func<object, IEnumerable, Res> success, Func<object, IEnumerable, Res> error)
• public static class ResultDelegateExtensions
  • public static SuccessFunc<A, Unit> ToFunc<A>(this SuccessAction<A> action)
  • public static SuccessFunc<A, Message, Unit> ToFunc<A, Message>(this SuccessAction<A, Message> action)
  • public static ErrorFunc<Error, Unit> ToFunc<Error>(this ErrorAction<Error> action)
  • public static ErrorFunc<Error, Message, Unit> ToFunc<Error, Message>(this ErrorAction<Error, Message> action)
• public static class ResultExtensions
  • public static A GetValueOrDefault<A, Error, Message>(this ref Result source, Func<Error, IMessageList<Message>, A> factory)
  • public static A GetValueOrDefault<A, Error>(this ref Result source, Func<Error, A> factory)
  • public static A GetValueOrThrow<A, Error, Message>(this ref Result source)
  • public static A GetValueOrThrow<A, Error>(this ref Result source)
  • public static Result<A, Error> MatchError<A, Error>(this ref Result result, ErrorAction<Error> error)
  • public static Result<A, Error, Message> MatchError<A, Error, Message>(this ref Result result, ErrorAction<Error, Message> error)
  • public static Result<A, Error, Message> MatchMessages<A, Error, Message>(this ref Result result, Action<IMessageList<Message>> onMessages)
  • public static Result<A, Error> MatchSuccess<A, Error>(this Result<A, Error> result, SuccessAction<A> success)
  • public static Result<A, Error, Message> MatchSuccess<A, Error, Message>(this ref Result result, SuccessAction<A, Message> success)
  • public static Result<A, Error, Message> ToFail<A, Error, Message>(this IMessageList<Message> messages)
  • public static Result<A, Exception, Message> ToSuccess<A, Message>(this A value, Message[] messages)
  • public static Result<A, Exception, Message> ToSuccess<A, Message>(this A value, IMessageList<Message> messages)
  • public static Result<A, Error> Validate<A, Error>(this ref Result result, Func<A, Error> validate)
  • public static Result<A, Error, Message> Validate<A, Error, Message>(this ref Result source, Func<A, IMessageList<Message>, Result<A, Error, Message>> validate)
  • public static Result<A, Error, Message> Validate<A, Error, Message>(this Result<A, Error> source, Func<A, IEnumerable<Message>> validate, Func<Message, bool> isError)
  • public static Result<A, Error, Message> Validate<A, Error, Message>(this Result<A, Error> source, Func<A, IEnumerable<Message>> validate) where Message : ICanBeError
  • public static Result<A, Error, Message> WithMessages<A, Error, Message>(this ref Result source, IEnumerable<Message> messages)
  • public static Result<A, Error, Message> WithMessages<A, Error, Message>(this ref Result source, IEnumerable<Message> messages)
  • public static Result<A, Error, Message> WithMessagesAtStart<A, Error, Message>(this ref Result source, IMessageList<Message> messages)
• public static class ResultOperations
  • public static Result<B, Error, Message> Bind<A, Error, Message, B>(ref Result source, Func<A, Result<B, Error, Message>> bind)
  • public static Result<B, Error> Bind<A, Error, B>(this ref Result source, Func<A, Result<B, Error>> bind)
  • public static Task<Result<B, Error, Message>> BindAsync<A, Error, Message, B>(this Result<A, Error, Message> source, Func<A, Task<Result<B, Error, Message>>> bindAsync)
  • public static Task<Result<B, Error, Message>> BindAsync<A, Error, Message, B>(this Task<Result<A, Error, Message>> sourceAsync, Func<A, Task<Result<B, Error, Message>>> bindAsync)
  • public static Task<Result<B, Error>> BindAsync<A, Error, B>(this Result<A, Error> source, Func<A, Task<Result<B, Error>>> bindAsync)
  • public static Task<Result<B, Error>> BindAsync<A, Error, B>(this Task<Result<A, Error>> sourceAsync, Func<A, Task<Result<B, Error>>> bindAsync)
  • public static Result<B, Error, Message> Map<A, Error, Message, B>(this ref Result source, Func<A, B> map)
  • public static Result<B, Error> Map<A, Error, B>(this ref Result source, Func<A, B> map)
  • public static B Match<A, Error, Message, B>(this ref Result source, SuccessFunc<A, Message, B> success, ErrorFunc<Error, Message, B> error)
  • public static B Match<A, Error, B>(this ref Result source, SuccessFunc<A, B> success, ErrorFunc<Error, B> error)
  • public static Task<B> MatchAsync<A, Error, Message, B>(this Result<A, Error, Message> source, SuccessFunc<A, Message, Task<B>> success, ErrorFunc<Error, Message, Task<B>> error)
  • public static Task<B> MatchAsync<A, Error, Message, B>(this Task<Result<A, Error, Message>> source, SuccessFunc<A, Message, Task<B>> success, ErrorFunc<Error, Message, Task<B>> error)
  • public static Task<B> MatchAsync<A, Error, B>(this Result<A, Error> source, SuccessFunc<A, Task<B>> success, ErrorFunc<Error, Task<B>> error)
  • public static Task<B> MatchAsync<A, Error, B>(this Task<Result<A, Error>> source, SuccessFunc<A, Task<B>> success, ErrorFunc<Error, Task<B>> error)
  • public static Result<B, Error, Message> Select<A, Error, Message, B>(this ref Result source, Func<A, B> selector)
  • public static Result<B, Error> Select<A, Error, B>(this ref Result source, Func<A, B> selector)
  • public static Result<C, Error, Message> SelectMany<A, Error, Message, B, C>(this ref Result source, Func<A, Result<B, Error, Message>> bind, Func<A, B, C> project)
  • public static Result<C, Error> SelectMany<A, Error, B, C>(this ref Result source, Func<A, Result<B, Error>> bind, Func<A, B, C> project)
  • public static Result<B, Error> TryBind<A, Error, B>(this ref Result source, Func<A, Result<B, Error>> bind, Func<Exception, Error> mapError)
  • public static Result<B, Error> TryBind<A, Error, B>(this ref Result source, Func<A, B> bind, Func<Exception, Error> mapError)
  • public static Task<Result<B, Error>> TryBindAsync<A, Error, B>(this Result<A, Error> source, Func<A, Task<B>> bindAsync, Func<Exception, Error> mapError)
• public enum ResultState
  • Faulted = 0
  • Error = 0
• public struct Some<A> : IOptional
  • public T Value { get; }
  • public Some(T value)
  • public bool IsNone { get; }
  • public bool IsSome { get; }
  • public A Value { get; }
  • public Some(A value)
  • public Type GetUnderlyingType()
  • public Res MatchUntyped<Res>(Func<object, Res> some, Func<Res> none)
• public class SomeNotInitializedException : Exception
  • public SomeNotInitializedException(Type type)
• public static class StringFormatExtensions
  • public static Func<object, string> DefaultFormatValue
  • public static readonly NumberFormatInfo DefaultNumberFormatInfo
  • public static string FormatAsJson(this IEnumerable<ValueTuple<string, object>> values, string fieldSeparator = ", ", string nullPlaceholder = "null", Func<object, string> formatValue = null)
  • public static string FormatAsTuple(this IEnumerable<object> values, string fieldSeparator = ", ", string nullPlaceholder = "null", Func<object, string> formatValue = null)
• public sealed delegate SuccessAction<A> : MulticastDelegate
  • public SuccessAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(A value, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(A value)
• public sealed delegate SuccessAction<A, Message> : MulticastDelegate
  • public SuccessAction(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(A value, IMessageList<Message> messages, AsyncCallback callback, object object)
  • public virtual void EndInvoke(IAsyncResult result)
  • public virtual void Invoke(A value, IMessageList<Message> messages)
• public sealed delegate SuccessFunc<A, B> : MulticastDelegate
  • public SuccessFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(A value, AsyncCallback callback, object object)
  • public virtual B EndInvoke(IAsyncResult result)
  • public virtual B Invoke(A value)
• public sealed delegate SuccessFunc<A, Message, B> : MulticastDelegate
  • public SuccessFunc(object object, IntPtr method)
  • public virtual IAsyncResult BeginInvoke(A value, IMessageList<Message> messages, AsyncCallback callback, object object)
  • public virtual B EndInvoke(IAsyncResult result)
  • public virtual B Invoke(A value, IMessageList<Message> messages)
• public struct SuccessResult<A> : IResult
  • public bool IsFailed { get; }
  • public bool IsSuccess { get; }
  • public A Value { get; }
  • public Type GetErrorValueType()
  • public Type GetSuccessValueType()
  • public Res MatchUntyped<Res>(Func<object, Res> success, Func<object, Res> error)
• public static class TaskExtensions
  • public static Task<T> ToTask<T>(this T value)
• public class ThreadIdEnricher : IMessageEnricher
  • public ThreadIdEnricher()
  • public IMessage Enrich(IMessage message)
• public class TwoLayerCache<TKey, TValue>
  • public TwoLayerCache(int maxItemCount)
  • public void Add(TKey key, TValue value)
  • public bool TryGetValue(TKey key, out TValue value)
• public struct ValueWithMessages<A, Message>
  • public readonly IMessageList<Message> Messages
  • public readonly A Value
  • public ValueWithMessages(A value, IEnumerable<Message> messages)
  • public ValueWithMessages(A value, Message message)
  • public void Deconstruct(out A value, out IMessageList messages)
• public static class ValueWithMessagesExtensions
  • public static ValueWithMessages<A, Message> ValueWithMessages<A, Message>(this A value, Message[] messages)

MicroElements.Functional.Errors

• public abstract class BaseError : ValueObject
  • public IReadOnlyList<object> Args { get; }
  • public string ErrorCode { get; }
  • public string ErrorFormat { get; }
  • public string ErrorMessage { get; }
  • protected BaseError(string errorCode = null, string errorFormat = null, object[] args)
• public abstract class KeyNotFound : BaseError
  • protected KeyNotFound(string errorCode, string errorFormat, object[] args)
• public class KeyNotFound<TKey> : KeyNotFound
  • public TKey Key { get; }
  • public KeyNotFound(TKey key)

MicroElements.Functional.Result

• public interface IMessage
• public interface IMessageList<TMessage> : IEnumerable<TMessage>, IEnumerable
• public class ParseResult<TValue, TError, TMessage>
• public enum Severity