jonifreeman

object Sql {
  import scala.reflect.makro._
  import language.experimental.macros

  case class Query[R](/*sql: String*/)

  def execute[R](q: Query[R]): Seq[R] = sys.error("implement me")

  def sqlImpl(c: Context)(s: c.Expr[String]): c.Expr[Any] = {
    import c.universe._

jonifreeman

example.dot:

    graph graphname {
      a -> b -> c;
      b -> d;
    }

$ graph-easy example.dot example.txt
$ cat example.txt 
          +---+

jonifreeman

data State_t a s = State a s

let unit = {}

let stateMonad = {
  return: \x -> \s -> State x s

  bind: \sm f -> \s0 -> match (sm s0)
    case (State x s) = (f x) s
}

jonifreeman

Miles Sabin implemented a nice selection sort example in Scala's type system. See:

http://www.chuusai.com/2012/01/27/type-level-sorting-in-shapeless/

To get a better understanding how that works I ported the algorithm to Prolog.

selectleast([H|T], TM, [H|TRem]):-
    selectleast(T, TM, TRem), TM < H.

selectleast([H|T], H, T).

jonifreeman

-- LinExtras.hs

module LinExtras where

import Numeric.LinearAlgebra
import Foreign.Storable (Storable)

vector xs = fromList xs :: Vector Double

size :: (Num b) => Vector Double -> b

jonifreeman

-- LinExtras.hs, some hmtarx helpers

module LinExtras where

import Numeric.LinearAlgebra
import Foreign.Storable (Storable)

vector xs = fromList xs :: Vector Double

-- Each entry is a column.

jonifreeman

-- LinExtras.hs, some hmtarx helpers

module LinExtras where

import Numeric.LinearAlgebra
import Foreign.Storable (Storable)

vector xs = fromList xs :: Vector Double

-- Each entry is a column.

jonifreeman

import System.IO
import Control.Exception
import Numeric.LinearAlgebra
import Data.Digest.Pure.SHA
import Data.ByteString.Lazy.Char8 as BS8 (pack)
import Data.List (sort)
import System.Random (randomRIO)
import Network.Curl
import Text.Printf (printf)
import Data.List.Split (splitOn)

jonifreeman

("lotto" ->
  ("lotto-id" -> lotto.id) ~
  ("winning-numbers" -> lotto.winningNumbers) ~
  ("winners" ->
    lotto.winners.map { w =>
      (("winner-id" -> w.id) ~
       ("numbers" -> w.numbers))}))

// vs.

jonifreeman

implicit def elvisSyntax[A](o: Option[A]) = new { 
  def ?[B](f: A => Option[B]) = o flatMap f 
  def :?[B](f: A => B) = o map f
  def ??(default: => A) = o getOrElse default 
}

case class Head(name: String) 
case class Department(head: Option[Head])
case class Employee(department: Option[Department])