igstan

module Seq = struct
  include Seq

  let rec fold_right : 'a Seq.t -> 'b -> ('a -> 'b Lazy.t -> 'b Lazy.t) -> 'b Lazy.t =
    fun seq acc f ->
      match seq () with
      | Seq.Nil -> lazy acc
      | Seq.Cons (a, rest) -> f a (lazy (Lazy.force (fold_right rest acc f)))

  let map : ('a -> 'b) -> 'a Seq.t -> 'b Seq.t =

igstan

trait SACVisitor[R] {
  def c1(a: Int): R
  def c2(a: R, b: R): R
}

sealed trait SAC extends Product with Serializable {
  def fold[R](visitor: SACVisitor[R]): R
}

object SAC {

igstan

import cats.implicits._
import cats.Monad
import cats.data.State

//
// Two capability/tagless final traits: Foo & Bar
//
trait Foo[F[_]] {
  def foo: F[Unit]
}

igstan

$ ./to-csv.sed records.xml 
111111H2,111AA2026
111111N1,111AA2026
111111Q1,111AA2026
111111U1,111AA2026
111111Z1,111AA2026

igstan

import cats.Eq
import monix.reactive.Observable
import monix.execution.Scheduler.Implicits.global

object Main {
  implicit final class ObservableOps[A](private val self: Observable[A]) extends AnyVal {
    def bubbleUpHot(a: A)(implicit Eq: Eq[A]): Observable[A] =
      self.publishSelector { hot =>
        val special = hot.find(_ === a)
        val beforeSpecial = hot.takeWhile(_ =!= a)

igstan

trait Optional[A] {
  def visit[R](visitor: Optional.Visitor[A, R]): R

  // Alias to show that visiting is similar to pattern matching.
  def matching[R](visitor: Optional.Visitor[A, R]): R =
    visit(visitor)
}


object Optional {

igstan

import * as azure from "@pulumi/azure";
import * as azuread from "@pulumi/azuread";
import * as pulumi from "@pulumi/pulumi";
import * as random from "@pulumi/random";

export const app = new azuread.Application('pulumi', {
  availableToOtherTenants: false,
  homepage: "http://example.com",
  identifierUris: ["http://example.com"],
  oauth2AllowImplicitFlow: true,

igstan

Bucharest FP #61 — Implementing IMP in K and Haskell

Event Agenda

• 18:45 — 19:00 Welcome
• 19:00 — 20:00 Everett Hildenbrandt — Side-by-side implementation of an IMP language in K and Haskell
• 20:00 — 21:00 Networking

Talk Abstract

igstan

final class QuotedString(private val sc: StringContext) extends AnyVal {
  /**
   * {{{
   * scala> val msg = "foo"
   * msg: String = foo
   *
   * scala> qs"$msg"
   * res1: String = "foo"
   *
   * scala> qs"<$msg"

igstan

{-# LANGUAGE DeriveFunctor #-}

import Control.Applicative
import Control.Monad.Writer
import Control.Monad.Reader
import Control.Monad.Identity
import Data.Map (Map, (!))
import qualified Data.Map as Map
import Data.List (groupBy, intercalate, nub)
import Data.Function (on)