wi7a1ian

In a multithreaded environment, the lack of understanding and the resulting problems are greatly amplified, almost to the point of panic if you are paying attention. Programming in a functional style makes the state presented to your code explicit, which makes it much easier to reason about, and, in a completely pure system, makes thread race conditions impossible. - John Carmack

OO makes code understandable by encapsulating moving parts. FP makes code understandable by minimizing moving parts. - Michael Feathers

Characteristics of functional programming (from dev perspective)

First-class functions are typical for functional programming languages, that means, they behave like data. There have to be functions that can accept functions as an argument or return 'em. Therefore, they are called higher-order functions. Pure functions always return the same result when given the same arguments and can not have a side effect. They are the reason that Haskell is called a pure functional languag

	static void Main(string[] args)
	{
	var cts = new CancellationTokenSource();
	cts.CancelAfter(TimeSpan.FromSeconds(10));

	TestProducerConsumerViaBufferBlock(cts.Token);
	TestProducerConsumerViaActionBlock(cts.Token);
	TestParallelTransformViaTransformBlock(cts.Token);
	}

	public interface IMessageHub : IDisposable
	{
	void RegisterGlobalHandler(Action<Type, object> onMessage);
	void RegisterGlobalErrorHandler(Action<Guid, Exception> onError);
	void Publish<T>(T message);
	Guid Subscribe<T>(Action<T> action);
	void Unsubscribe(Guid token);
	bool IsSubscribed(Guid token);
	void ClearSubscriptions();
	}

	public class EventCommandExecuter : TriggerAction<DependencyObject>
	{
	public EventCommandExecuter()
	: this(CultureInfo.CurrentCulture)
	{
	}

	public EventCommandExecuter(CultureInfo culture)
	{
	Culture = culture;

	protected async Task<IEnumerable<T>> GetAllRowsAsync<T>(DbConnection conn, string query, Func<DbDataReader, Task<T>> asyncMapper, CancellationToken token)
	where T : class
	{
	IList<T> result = new List<T>();

	using (conn)
	using (var cmd = conn.CreateCommand())
	{
	await conn.OpenAsync(token);
	cmd.CommandText = query;

	using System;
	using System.Linq;

	public class Program
	{
	public static void Main()
	{
	int ctrS = 0, ctrP = 0, ctrWP = 0;

	Enumerable.Range(0, 1_000_000).Where( x => { ++ctrS; return x == 0; }).First();

	public Writer BeginWrite()
	{
	c_write_begin(out var writerHandle);
	return new Writer(writerHandle);
	}

	public void MapRowTo<T>(SQLiteDataReader reader, ref T obj)
	{
	string propertyName;

	for (int columnIdx = 0; columnIdx < reader.FieldCount; columnIdx++)
	{
	propertyName = reader.GetName(columnIdx);
	var prop = typeof(T).GetRuntimeProperty(propertyName);

	if (prop == null)

	public IList<ExpandoObject> ReadFromSQLite(string databasePath, string query)
	{
	var results = new List<ExpandoObject>();

	using (var connection = new SQLiteConnection($"Data Source={databasePath}"))
	{
	connection.Open();

	using (SQLiteCommand cmd = connection.CreateCommand())
	{

	public class Entity
	{
	public long Id { get; set; }
	}