dreadedsoftware

git for-each-ref --sort=-committerdate --format='[%(committerdate:short)] %(committer)
%(refname:short)
%(contents)'

dreadedsoftware

object P extends Poly1
val dummy = "_dummy_"
def join[N <: Nat, L <: HList, AsDF <: HList](
  in: L, joinOn: String
)(implicit //
  length: Length.Aux[L, N],
  notZero: N GT nat._0,
  fill: Fill.Aux[N, Task[DataFrame], AsDF],
  mapper: Mapper.Aux[P.type, L, AsDF],
  toList: ToList[AsDF, Task[DataFrame]],

dreadedsoftware

module PatternMatch
    type Type =
        |Something of string * int
        |Nothing
    type Case =
        |CaseA of a:string * b:int
        |CaseB of a:string * b:double

    let (|A|B|C|NOPE|) (input:char) =
        match input with

dreadedsoftware

//cannot do higher kinds so no type classes
//do not need higher kinds; type syntax takes care of it
//need higher kinds for useful free monad.
//no way around that?
module CategoryList
    type Functor<'Type>() =
        member this.map(l: list<'Type>)(f: 'Type -> 'Return) =
            List.map f l
    type Monad<'Type>(func: Functor<'Type>) =
        member this.point(t: 'Type) = [t]

dreadedsoftware

//ummm... no higher kinds... what???
type Functor<'A> =
    abstract map: 'A<'B> -> ('B -> 'C) -> 'A<'C>

dreadedsoftware

module Recursion
    //need a keyword for recursion, otherwise boilerplate free
    //very nice
    let rec check many acc =
        if(0 = many) then acc
        else
            let a = many - 1
            let b = acc + many
            check a b

dreadedsoftware

int i = 0;
while(21 > i) printf("%d\n",i++);
while(1 < i) printf("%d\n",--i);

dreadedsoftware

def roundRobin[T](seq: IndexedSeq[T]): Stream[T] = {
  val size = seq.size
  Stream.from(0).map{_ % size}.map{seq(_)}
}