Artur artur-s

Fibers

Fibers are an abstraction over sequential computation, similar to threads but at a higher level. There are two ways to think about this model: by example, and abstractly from first principles. We'll start with the example.

(credit here is very much due to Fabio Labella, who's incredible Scala World talk describes these ideas far better than I can)

Callback Sequentialization

Consider the following three functions

Permanent WSL DNS Fix (WSL 2.2.1+)

If you're encountering ping github.com failing inside WSL with a Temporary failure in name resolution, you're not alone — this has been a long-standing issue, especially when using VPNs or corporate networks.

This issue is now fixed robustly with DNS tunneling, which preserves dynamic DNS behavior and avoids limitations like WSL’s former hard cap of 3 DNS servers in /etc/resolv.conf.

DNS tunneling is enabled by default in WSL version 2.2.1 and later, meaning that if you're still seeing DNS resolution issues, the first and most effective fix is simply to upgrade WSL. Upgrading WSL updates the WSL platform itself, but does not affect your installed Linux distributions, apps, or files.

To upgrade WSL, follow these steps,

Functional Track talks from NDC Oslo 2017

Also, here is the list of all videos from NDC Oslo 2017:

Wednesday 2017-06-14

Railway Oriented Programming and F# Result

Full source: https://gist.github.com/mrange/aa9e0898492b6d384dd839bc4a2f96a1

Option<_> is great for ROP (Railway Oriented Programming) but we get no info on what went wrong (the failure value is None which carries no info).

With the introduction F# 4.1 we got Result<_, _> a "smarter" Option<_> as it allows us to pass a failure value.

However, when one inspects the signature of Result.bind one sees a potential issue for ROP:

	using OpenTelemetry;
	using OpenTelemetry.Logs;
	using OpenTelemetry.Resources;
	using OpenTelemetry.Trace;

	var builder = WebApplication.CreateBuilder(args);
	var app = builder.Build();

	var appResourceBuilder = ResourceBuilder.CreateDefault()
	.AddService(serviceName: Telemetry.ServiceName, serviceVersion: Telemetry.ServiceVersion);

	open System


	// this is our basis to define values over time.
	// It will be the basis for our data.
	// we define a Period with a start and en Time
	// start is included, end is excluded (closed on the left, open on the right)
	// this way, of consecutive periods px and py we known that px.End = py.Start
	type Period = { Start: DateTime; End: DateTime }


	module Program =

	type InMemoryDb(replica: ReplicaId) =
	let snapshot = ref null
	let mutable events : Map<uint64,obj> = Map.empty
	interface Db with
	member _.SaveSnapshot state = async { snapshot := (box state) }
	member _.LoadSnapshot<'s>() = async {
	match !snapshot with

	let withCancellation (ct:CancellationToken) (a:Async<'a>) : Async<'a> = async {
	let! ct2 = Async.CancellationToken
	use cts = CancellationTokenSource.CreateLinkedTokenSource (ct, ct2)
	let tcs = new TaskCompletionSource<'a>()
	use _reg = cts.Token.Register (fun () -> tcs.TrySetCanceled() \|> ignore)
	let a = async {
	try
	let! a = a
	tcs.TrySetResult a \|> ignore
	with ex ->

	namespace Marvel
	open System
	open System.Diagnostics
	open System.Threading
	open System.Threading.Tasks
	open Marvel

	/// The 'Vsync' (AKA, 'Variable Synchrony') monad.
	/// Runs code synchronously when the 'Venom/System/Sync' Consul variable is 'True', in parallel otherwise.
	/// NOTE: to reference how all this stuff works in F#, see here - https://msdn.microsoft.com/en-us/library/dd233182.aspx