bent-rasmussen

// NOTE: import this Nuget package: TaskBuilder.fs (written using 2.1.0)
//
// Tested in LINQPad (hence Dump method usage).

open System
open System.Collections
open System.Collections.Generic
open System.Diagnostics
open System.Linq
open System.Threading

nasser

// make sure codegen.py (https://github.com/CensoredUsername/codegen/blob/master/codegen.py) is in the same folder
// and you've added the IronPython package

open System.IO
open IronPython.Hosting
open IronPython.Runtime
open Microsoft.FSharp.Reflection

let engine = Python.CreateEngine()

cartermp

// First, define a 'zip' function
module Result =
    let zip x1 x2 = 
        match x1,x2 with
        | Ok x1res, Ok x2res -> Ok (x1res, x2res)
        | Error e, _ -> Error e
        | _, Error e -> Error e

type ResultBuilder() =
    member _.MergeSources(t1: Result<'T,'U>, t2: Result<'T1,'U>) = Result.zip t1 t2

aspnetde

namespace MvuCsharp
{
    public class Cmd
    {
        public static readonly Cmd None = new Cmd();
        public static Cmd OfMsg(IMessage msg) => new Cmd(); // TODO
    }
}

ninjarobot

My Road to F#

I came from the OOP world, most of my professional work was in Java or C#. The languages were similar, and I could use them interchangably as I built software in each of them for several years. With enough experience in both, I was comfortable with either ecosystem and could generally be productive in either. Sometimes the job required one or the other. Sometimes the target OS constrained my choice to Java, which frustrated me a bit, because the languages were so similar, why would the runtime try to restrict a choice? I enjoyed writing server applications on Unix in college, and Linux afterwards, because the machines were so easy to configure compared to Windows machines that took a few hours to install and configure to get my software running. On Linux, I could type a handful of commands into a newly installed system and be up and running.

Sometime around 2005, Java had stagnated while C# was flourishing. They both released generics, but then C# came out with new features like

noelbundick

MIT License

Copyright (c) 2019 Noel Bundick

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

panesofglass

fetch ('https://stackoverflow.com/').then(response => response.text()).then(html => {
    let fragment = document.createRange().createContextualFragment(html);
    let content = fragment.querySelectorAll('[rel=tag]');
    for (let el of content) {
        console.log(el.getAttribute('href'));
    }
}).catch(error => console.error(error));

johnazariah

// F<'a> is any type with member 'map' of type ('a -> 'b) -> F<'a> -> F<'b>

type F<'a> = QIL<'a> 
and S<'a> = F<Q<'a>>
and Q<'a> =        
    private
    | Step of Step<'a>
    | Bind of IBind<'a>
    with
        static member lift (k : F<'a>) : Q<'a> = Step (Suspend (fun () -> S<_>.map (Yield >> Step) k))

CarstenKoenig

type List<'i,'r> = Nil | Cons of 'i*'r

type FixList<'i> = FixList of List<'i,FixList<'i>>

let rec fmap (f : 'a -> 'b) (l : List<'i,'a>) : List<'i,'b> =
    match l with
    | Nil            -> Nil
    | Cons (x, tail) -> Cons (x, f tail)

// you can express hylo directly without using ana and cata (by either following the

spatney

module powerbi.visuals {
    export interface ViewModel {
        value: number;
        color?: string;
        min?: number;
        max?: number;
    }

    export class Thermometer implements IVisual {
        public static capabilities: VisualCapabilities = {