cloudRoutine

open System
open System.IO

let find_files dir = Directory.GetFiles( dir, "*.fs?", SearchOption.AllDirectories )

let not_start    (s:string) p = not <| s.StartsWith p
let has_type     (s:string)   = if s.Contains @"type"   then 1 else 0
let has_module   (s:string)   = if s.Contains @"module" then 1 else 0
let has_binding  (s:string)   = if s.Contains @"let"    ||
                                   s.Contains @"member" then 1 else 0

mrange

Optimizing a simple problem

I was introduced to a simple optimization problem by one of my interns last week. He was about to participate in a friendly competition where they were asked to find a performant solution to the problem:

The problem

mrange

Monadic JSON Transformers

Full source for JSON Transformer: https://gist.github.com/mrange/7c39333de480a8de5c812a1f6ba70173

Full source for XML Transformer: https://gist.github.com/mrange/552cb0b474b517b706333cebb64f44aa

A popular approach in Functional Languages to create parsers is to use parser combinators.

swlaschin

Functional Track talks from NDC Oslo 2016

Wednesday 2016-06-08

• What every Node.js developer needs to know about Elixir - Bryan Hunter
• F# in the Real World - Yan Cui
• Functional Programming for Mobile Apps - Frank A. Krueger
• Phoenix a web framework for the new web - José Valim
• REPL Driven Development, Scrum, and the Wright Brothers - Jamie Dixon

mrange

module FsTransducers =
  type Context                            =
    {
      mutable Continue : bool
    }
    static member New () : Context = { Continue = true }
  type Initializer                        = Context -> unit
  type Folder<'S, 'T>                     = 'S -> 'T -> 'S
  type Completer<'S>                      = Context -> 'S -> 'S
  type [<Struct>] Reducer<'S, 'T>         = R of (Initializer*Folder<'S, 'T>*Completer<'S>)

mrange

let rec distribute e = function
  | [] -> [[e]]
  | x::xs' as xs -> (e::xs)::[for xs in distribute e xs' -> x::xs]

let rec permute = function
  | [] -> [[]]
  | e::xs -> List.collect (distribute e) (permute xs)

let generatePermutations r (vs : _ []) =
  let inline swap f t =

mrange

module AnyTransformer =
  type [<AbstractClass>] BadCause () =
    class
      abstract Describe : string
      override x.ToString () = x.Describe
    end

  type [<Sealed>] MessageBadCause (msg: string) =
    class
      inherit BadCause ()

mrange

F# Advent 2016 (English) - December 10 - Implementing a persistent hash map.

This blog created for F# Advent 2016 (English)

Full source code can be found here

Changelog

1. 2016-12-10
2. New performance test - Anthony Lloyd (@AnthonyLloyd) suggested that I compare against Prime.Vmap.

enricosada

.NET Core sdk, msbuild, fsharp, fsc, etc

How to finish/polish the integration between msbuild based .net core sdk and f# (fsc, FscTask, etc)

This doc contains current issues i known and a proposed solution (already implemented in a PR, and works) on how to fix these (obv ihmo).

AFAIK all the solution i choose are based on where dotnet/sdk, microsoft/msbuild and dotnet/cli are going with development, and updated to latest release (preview4), and vnext in development now.

TL;DR

allykzam

type FatalError(message: string) =
    inherit System.Attribute()
    member __.Message = message

type Errors =
    | [<FatalError("The value specified is currently not available")>] UnknownValue
    | NotAnError

let PrintErrorMessage : Errors -> string =
    fun err ->