| 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 |
| // 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)] | |
| }; |
| 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 |
| {-# LANGUAGE RecursiveDo #-} | |
| {-# LANGUAGE LambdaCase #-} | |
| {-# LANGUAGE DeriveGeneric #-} | |
| {-# LANGUAGE DuplicateRecordFields #-} | |
| {-# LANGUAGE FlexibleContexts #-} | |
| {-# LANGUAGE NoMonomorphismRestriction #-} | |
| {-# LANGUAGE TypeApplications #-} | |
| {-# LANGUAGE TemplateHaskell #-} | |
| {-# LANGUAGE OverloadedStrings #-} | |
| {-# LANGUAGE FlexibleInstances #-} |
| 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 |
| 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 |
| 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 = |
| package demo; | |
| import java.io.Serializable; | |
| import java.security.Principal; | |
| import java.util.Collection; | |
| import java.util.Collections; | |
| import java.util.HashMap; | |
| import java.util.Map; | |
| import java.util.UUID; |
Welcome to the kafka workshop @LINE Taiwan!
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:
| 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 |
