junkyarddog

Agreed. A turing-complete language isn't the ideal choice for smart contracts. A strongly typed ML or Haskell style language would have been a much better choice as a starting point.

Six to seven foot tall praying mantis like entities are a common element in many alien abduction accounts. They're typically in the background, silently watching the proceedings while letting the little greys carry out the examinations.

In "DMT: The Spirit Molecule" author Rick Strassman theorises that DMT enables the brain to tune in to other parallel realities beyond "channel-normal". If the interdimensional hypothesis for alien abductions is correct, perhaps DMT allows one to occasionally tune into the source of this mysterious phenomenon.

If the pattern matching isn't exhaustive, it will greatly reduce their usefulness.

It still has to look C#ish.

But they have the F# and Haskell teams, who are nearby, to talk to. In particular, F# seems to have had a great influence lately.

The C# team are very lucky to have F# as a reference implementation on how to implement ML style features on the .NET platform. I'm certain many more features from F#/OCaml will be added in forthcoming releases.

Using F# would have been a great choice. By using algebraic data types plus active patterns the size of the code base would have been dramatically reduced and much more comprehensible. And of course it would have been even more type safe.

There's more to F# then HM type inference plus ".NET's OOP and subtyping". OOP and subtyping are rarely used. While it lacks some of OCaml's powerful features it shares many core features such as algebraic data types, exhaustive pattern matching, immutability by default, Option types and so on. It's also arguably easier to read with it's white space significance and not needing the rather distracting "in" keyword.

Having the vast .NET library is a big plus for the language, of which OCaml has no equivalent. Other great features of F# are type providers, straightforward multi-core programming and units of measure, which I don't believe have OCaml equivalents.

Have to agree that Active Patterns are an incredibly useful F# feature.

I would say F# is much safer than C# as it has immutability by default, non-nullable reference types, Option types, units of measure, and stricter casting rules.

So basically, the plan is to turn C# into F# with curly braces.

No. The whole point of going dark is to raise public awareness and to get politicians to take this issue seriously. Unlike the general population, we don't need a wake up call.

One company that's making heavy use of F# is Credit Suisse. They use it in their global modeling and analysis group.

The F# based WebSharper web framework: http://websharper.com/. WebSharper is based on the work of Philip Wadler, et al: http://groups.inf.ed.ac.uk/links/formlets/

Here's another article by Philip Wadler on Formlets: http://homepages.inf.ed.ac.uk/wadler/papers/formlets-aplas/f...

Of course Microsoft uses F# for Bing data processing.

F# doesn't have an in-built iterate function, but found an equivalent on the F# Snippets site -- http://fssnip.net/18.

    let rec iterate f value = seq {
        yield value
        yield! iterate f (f value) }

Using the above we get ...

    let pascal = iterate (fun xs -> List.map2 (+) (0::xs) (xs @ [0])) [1]

For the F# developer, WebSharper ( http://websharper.com/ ) seems to offer a great implementation based on the Formlets abstraction. For some theoretical background, have a look at http://groups.inf.ed.ac.uk/links/formlets/ which has some articles describing the Form abstraction by Philip Wadler, et al.

For the F# developer, WebSharper ( http://websharper.com/ ) seems to offer a great implementation based on the Formlets abstraction. For some theoretical background, have a look at http://groups.inf.ed.ac.uk/links/formlets/ which has some articles describing the Form abstraction by Philip Wadler, et al.