moleike

package eveff

import cats.Monad
import cats.Applicative
import cats.Monoid
import cats.Semigroup
import cats.Functor
import cats.MonadThrow
import cats.data.Chain
import cats.data.Ior

moleike

sealed trait Term
case class Const(name: String) extends Term
case class Var(name: String) extends Term
case class Atom(relation: String, terms: Term*)
sealed trait Clause
case class Rule(head: Atom, body: Atom*) extends Clause
case class Fact(atom: Atom) extends Clause
case class Query(name: String, atoms: Atom*) extends Clause

moleike

kafka-workshop

Welcome to the kafka workshop @LINE Taiwan!

Goals

Today session will help you get started with doing some basic stream processing using Kafka Streams and KSQL, and how you can manage materialzed views using Kafka Connect.

In what follows, we will give you a detail step-by-step guide on building your first stream processing application. The application considers 2 data sources:

moleike

• https://codewords.recurse.com/issues/one/type-systems-and-logic
• http://lambda-the-ultimate.org/node/1892
• http://www.cse.chalmers.se/edu/year/2012/course/DAT150/lectures/plt-book.pdf
• http://purelytheoretical.com/sywtltt.html
• http://www.cs.cmu.edu/~fp/courses/15317-f09/
• http://gallium.inria.fr/~xleroy/mpri/2-4/

Programming Language Zoo

• https://realworldocaml.org/v1/en/html/parsing-with-ocamllex-and-menhir.html

moleike

  // a memoized fibonnaci using field caching
  local fib(n) =
    local go(n) =
      if n <= 1 then
        { ['fib0']: 1, ['fib1']: 1 }
      else
        go(n - 1) {
          ['fib'+n]: super['fib'+(n-1)] + super['fib'+(n-2)]
        };

moleike

This is my short-ish tutorial on how to implement closures in
a simple functional language: Foo.

First, some boilerplate.

> {-# LANGUAGE DeriveFunctor, TypeFamilies #-}
> import Control.Applicative
> import Control.Monad.Gen
> import Control.Monad.Writer
> import Data.Functor.Foldable

moleike

{-# LANGUAGE RecursiveDo               #-}
{-# LANGUAGE LambdaCase                #-}
{-# LANGUAGE DeriveGeneric             #-}
{-# LANGUAGE DuplicateRecordFields     #-}
{-# LANGUAGE FlexibleContexts          #-}
{-# LANGUAGE NoMonomorphismRestriction #-}
{-# LANGUAGE TypeApplications          #-}
{-# LANGUAGE TemplateHaskell           #-}
{-# LANGUAGE OverloadedStrings         #-}
{-# LANGUAGE FlexibleInstances         #-}

moleike

Benchmark results

large_string_join

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
jrsonnet large_string_join.jsonnet	16.5 ± 0.5	16.1	19.6	1.00
gojsonnet large_string_join.jsonnet	90.7 ± 3.8	85.6	104.0	5.49 ± 0.29
jsonnet large_string_join.jsonnet	69.5 ± 2.4	68.2	78.1	4.20 ± 0.20
sjsonnet large_string_join.jsonnet	760.6 ± 12.7	739.9	787.2	46.00 ± 1.67

moleike

Benchmark results

Command	Mean [ms]	Min [ms]	Max [ms]	Relative
hs-jsonnet bench.01.jsonnet	30.4 ± 5.5	20.8	41.8	1.00
jsonnet bench.01.jsonnet	89.4 ± 5.9	86.6	116.8	2.94 ± 0.57
hs-jsonnet bench.03.jsonnet	4.914 ± 1.423	4.135	8.748	8.51 ± 2.50
jsonnet bench.03.jsonnet	0.577 ± 0.027	0.555	0.633	1.00
hs-jsonnet bench.04.jsonnet	1.455 ± 0.154	1.331	1.834	1.00
jsonnet bench.04.jsonnet	5.670 ± 2.564	4.028	11.537	3.90 ± 1.81

moleike

data Tm = Var Int | Ann Tm Tm | Abs Tm | App Tm Tm | Pi Tm Tm | Fix Tm | Uni
data Clos = Clos Tm Env
data Dm = DVar Int | DAbs Clos | DNeutral Int [Dm] | DPi Dm Clos | DFix Clos | DUni
type Env = [Dm]

capp :: Clos -> Dm -> Dm
capp (Clos b e) t = eval (t : e) b

vapp :: Dm -> Dm -> Dm
vapp a b =