debasishg

This is material to go along with a 2014 Boston Haskell talk.

We are going to look at a series of type signatures in Haskell and explore how parametricity (or lack thereof) lets us constrain what a function is allowed to do.

Let's start with a decidedly non-generic function signature. What are the possible implementations of this function which typecheck?

wrangle :: Int -> Int

debasishg

yonedaLemma = Iso (flip fmap) ($ id)

debasishg

debasishg

// Finally tagless lambda calculus
object Final {
  def varZ[A,B](env1: A, env2: B): A = env1
  def varS[A,B,T](vp: B => T)(env1: A, env2: B): T = vp(env2)
  def b[E](bv: Boolean)(env: E): Boolean = bv
  def lam[A,E,T](e: (A, E) => T)(env: E): A => T = x => e(x, env)
  def app[A,E,T](e1: E => A => T, e2: E => A)(env: E): T = e1(env)(e2(env))

  def testf1[E,A](env: E): Boolean =
    app(lam[Boolean,E,Boolean](varZ) _, b(true))(env)

debasishg

package org.example;

import scala.Function1;
import scala.collection.generic.CanBuildFrom;
import scala.collection.immutable.List;
import scala.collection.immutable.List$;
import scala.collection.immutable.Vector;
import scala.collection.immutable.Vector$;
import scala.collection.mutable.Builder;

debasishg

import Control.Monad

-------------------------------------------------------------------------------
-- State Monad Implementation
-------------------------------------------------------------------------------

newtype State s a = State { runState :: s -> (a,s) }

instance Monad (State s) where
  return a = State $ \s -> (a, s)

debasishg

Installing Postgres via Brew

Pre-Reqs

Brew Package Manager

In your command-line run the following commands:

1. brew doctor
2. brew update

debasishg

"""
Given a dictionary, transform it to a string. Then byte encode that string. Then base64 encode it and since this will go
on a url, use the urlsafe version. Then decode the byte string so that it can be else where.
"""
data = base64.urlsafe_b64encode(json.dumps({'a': 123}).encode()).decode()

# And the decode is just as simple...
data = json.loads(base64.urlsafe_b64decode(query_param.encode()).decode())
# Byte encode the string, base64 decode that, then byte decode, finally transform it to a dictionary

debasishg

import * as pulumi from '@pulumi/pulumi';
import * as gcp from '@pulumi/gcp';
import * as k8s from '@pulumi/kubernetes';
import * as k8sInputApi from '@pulumi/kubernetes/types/input';

const serviceAccountKeys = new Map<string, gcp.serviceAccount.Key>();

/**
 * Creates a service account and key, and sets the cloudsql.client role in IAM.
 */

debasishg

  // Inspired by a tweet from @trautonen 1/13/2016
  // Use Source.unfoldAsync to turn paginated database results into an akka-streams Source
  // unfold is the inverse of fold

  case class Page[T](pageNumber:Long, totalPages:Long, contents:List[T])
  case class Thing(id: Long, name: String = "foo")
  
  val totalPages = 5 // 
  val pageSize = 3