akimboyko

import scala.concurrent.{ future, promise }
import scala.concurrent.ExecutionContext.Implicits.global

val p = promise[T]
val f = p.future

val producer = future {
  val r = produceSomething()
  p success r
  continueDoingSomethingUnrelated()

akimboyko

import util.control.TailCalls._

sealed abstract class Tree
case class Leaf(n: Int) extends Tree
case class Node(left: Tree, right: Tree) extends Tree

lazy val numbers = Seq.range(1, 20)
lazy val imbalancedTree = numbers.map(Leaf).foldLeft[Tree](Leaf(0))(Node)

def traverseTree(tree: Tree)(action: Int => Unit): Unit = {

akimboyko

// The Sieve of Eratosthenes in Code from FP course on Coursera rewritten on F#
let rec sieve(lazyCell: Lazy<Stream<'a>>) = seq {
    match lazyCell.Value with
    | LazyCell(a, lazyTail) ->
        yield a
        yield! sieve(lazyTail) |> Seq.filter (fun n -> n % a > 0)
    | _ -> ()   
}

// Samples from F# interactive

akimboyko

//An implementation of basic non-negative integers, based on https://gist.github.com/akimboyko/7019648,
//but rewritten in a more F# idiomatic way
module Naturals
open System

type Natural =
    | Zero
    | Succ of Natural

    member x.IsZero' = x = Zero

akimboyko

//Provide an implementation of the abstract class Nat that represents non-negative integers
// 
//Do not use standard numerical classes in this implementation.
//Rather, implement a sub-object and sub-class:
// 
//class Zero : Nat
//class Succ(n: Nat) : Nat
// 
//One of the number zero, then other for strictly positive numbers.
namespace Nat

akimboyko

Provide an implementation of the abstract class Nat that represents non-negative integers

Do not use standard numerical classes in this implementation. Rather, implement a sub-object and sub-class:

class Zero : Nat
class Succ(n: Nat) : Nat

One of the number zero, then other for strictly positive numbers.

akimboyko

Provide an implementation of the abstract class Nat that represents non-negative integers

abstract class Nat {
  def isZero: Boolean
  def predecessor: Nat
  def successor: Nat
  def + (that: Nat): Nat
  def - (that: Nat): Nat
}

akimboyko

def isCloseEnough(x : Double, y : Double) = {
  val tolerance = 0.0001
  Math.abs((x - y) / x) < tolerance
}

def fixedPoint(f : Double => Double)(firstGuess : Double) = {
  def iterate(guess : Double) : Double = {
    val next = f(guess)
    if(isCloseEnough(guess, next)) next
    else iterate((next + guess) / 2)

akimboyko

let magicSquare = (fun () ->
            let randomSequence =
                (seq { 1 .. N * N })
                        |> Seq.sortBy(fun n -> random.Next())
                        |> Seq.toArray

            Matrix.Generic.init N N
                            (fun nRow nColumn -> randomSequence.[nRow * N + nColumn]))()

akimboyko

Five principle of code generation by @KathleenDollard

1. Code generation has to be under your control, your control being the organization or the individual.
2. Metadata is discreet and more morphable, and actually metadata is a subgenre all on its own.
3. Code generation has to be an easy process. It should be a part of the normal continuous integration build process.
4. Handcrafted code is sacred and protected.
5. Generated code should be an equal or a better quality than nongenerated code.

From Code Generation and T4 with Kathleen Dollard, Text transcript of show #152