codedot

all:
	node work2mlc.js getwork.json 381353fa >test.mlc
	lambda -pem lib.mlc -f test.mlc

clean:

shiroginne

Для тех, кто не следит за интеренетом, собрал драму в нескольких актах. ВОРНЕНГ: ссылки могут не работать, сохраняйте скриншоты.

Акт 1:

Статья на хабре https://habrahabr.ru/post/335876/ (читайте коментарии platoff)

Твиты которые могут содержать комментарии (если потёрли)

• https://twitter.com/nikitonsky/status/898813332278435840
• https://twitter.com/nikitonsky/status/898813814170206208

Акт 2:

jdegoes

sealed trait Free[F[_], A] { self =>
  final def map[B](ab: A => B): Free[F, B] = Free.flatMap(self, ab andThen (Free.point[F, B](_)))
  final def flatMap[B](afb: A => Free[F, B]): Free[F, B] = Free.flatMap(self, afb)
  final def interpret[G[_]: Monad](fg: F ~> G): G[A] = self match {
    case Free.Point(a0) => a0().point[G]
    case Free.Effect(fa) => fg(fa)
    case fm : Free.FlatMap[F, A] =>
    	val ga0 = fm.fa.interpret[G](fg)
    	ga0.flatMap(a0 => fm.afb(a0).interpret[G](fg))
  }

pbl64k

Fix : (Type -> Type) -> Type
Fix f = {x : Type} -> (f x -> x) -> x

fold : Functor f => {x : Type} -> (f x -> x) -> Fix f -> x
fold k t = t k

embed : Functor f => f (Fix f) -> Fix f
embed s k = k (map (fold k) s)

project : Functor f => Fix f -> f (Fix f)

pbl64k

%default total

data Mu : (Type -> Type) -> Type where
    In : f (Mu f) -> Mu f

out : Mu f -> f (Mu f)
out (In x) = x

data LstF : Type -> Type -> Type where
    LF : ({c : Type} -> (Maybe (a, Unit -> c, b) -> c) -> c) -> LstF a b

pbl64k

{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE Rank2Types #-}

import Data.Maybe

data Fix f = Fix { unFix :: f (Fix f) }

data ListF a b = LF { unLF :: forall c. (Maybe (a, (c, b)) -> c) -> c }

type List a = Fix (ListF a)

patcon

# install ocaml and deps
apt-get install ocaml ocaml-native-compilers
apt-get install liblablgtk2-ocaml-dev liblablgtksourceview2-ocaml-dev libocamlgraph-ocaml-dev

# install opam from binaries (ocaml package manager)
# See https://opam.ocaml.org/doc/Install.html#Binarydistribution
wget https://raw.github.com/ocaml/opam/master/shell/opam_installer.sh -O - | sh -s /usr/local/bin/

#### OR

chriseth

contract BinarySearch {
  ///@why3
  /// requires { arg_data.length < UInt256.max_uint256 }
  /// requires { 0 <= to_int arg_begin <= to_int arg_end <= arg_data.length }
  /// requires { forall i j: int. 0 <= i <= j < arg_data.length -> to_int arg_data[i] <= to_int arg_data[j] }
  /// variant { to_int arg_end - to_int arg_begin }
  /// ensures {
  ///   to_int result < UInt256.max_uint256 -> (to_int arg_begin <= to_int result < to_int arg_end && to_int arg_data[to_int result] = to_int arg_value)
  /// }
  /// ensures {

smarr

Introductory Material

• Add Graal JIT Compilation to Your JVM Language in 5 Steps, A Tutorial http://stefan-marr.de/2015/11/add-graal-jit-compilation-to-your-jvm-language-in-5-easy-steps-step-1/

• The SimpleLanguage, an example of using Truffle with great JavaDocs. It is the officle getting-started project: https://github.com/graalvm/simplelanguage

• Truffle Tutorial, Christan Wimmer, PLDI 2016, 3h recording https://youtu.be/FJY96_6Y3a4 Slides

cb372

Category theory jargon cheat sheet

A primer/refresher on the category theory concepts that most commonly crop up in conversations about Scala or FP. (Because it's embarassing when I forget this stuff!)

I'll be assuming Scalaz imports in code samples, and some of the code may be pseudo-Scala.

Functor

A functor is something that supports map.