jdh30

open System.Windows

let goldenRatio = (1.0 + sqrt 5.0) / 2.0

let newBrush =
  let mutable hue = 0.0
  fun () ->
    hue <- hue + System.Math.PI / goldenRatio
    let s x = byte(255.0 * x)
    let c x = 0.5 * (cos x + 1.0)

cmeeren

module Elmish.Boxes

open System
open Fable.React.Helpers
open Fable.React.Props
open Fable.React.Standard


[<AutoOpen>]
module Domain =

reborg

Rich Already Answered That!

A list of commonly asked questions, design decisions, reasons why Clojure is the way it is as they were answered directly by Rich (even when from many years ago, those answers are pretty much valid today!). Feel free to point friends and colleagues here next time they ask (again). Answers are pasted verbatim (I've made small adjustments for readibility, but never changed a sentence) from mailing lists, articles, chats.

How to use:

• The link in the table of content jumps at the copy of the answer on this page.
• The link on the answer itself points back at the original post.

Table of Content

CMCDragonkai

Semicolons vs Monads

The reason why Haskell sometimes calls monads "programmable semicolons", is because in imperative semicolon enabled languages, the semicolon acts as a sequencing operator that sequences side effects. It enables the passing of an effectful state space from one statement/expression to the next.

In the same way, the bind >>= and then >> operator in Haskell, allows a sequencing of effects as well, but in a more explicit manner. The effects are often typed as well, depending

jackrusher

The venerable master Qc Na was walking with his student, Anton. Hoping to prompt the master into a discussion, Anton said "Master, I have heard that objects are a very good thing - is this true?" Qc Na looked pityingly at his student and replied, "Foolish pupil - objects are merely a poor man's closures."

Chastised, Anton took his leave from his master and returned to his cell, intent on studying closures. He carefully read the entire "Lambda: The Ultimate..." series of papers and its cousins, and implemented a small Scheme interpreter with a closure-based object system. He learned much, and