ahjohannessen

#!/usr/bin/env bash

# Update a Flatcar installation on VMWare to use the latest OEM content
#
# Copyright 2020, Neil Mayhew <neil@kerith.ca>
# LICENSE: MIT

set -ex
shopt -s extglob nullglob

ahjohannessen

import shapeless._

@annotation.implicitNotFound("Make sure all cases of ${C} have an instance of ${TC}")
trait CopTCs[C <: Coproduct, TC[_]] {
  type Out <: HList
  def result: Out
}
object CopTCs {
  type Aux[C <: Coproduct, TC[_], O <: HList] = CopTCs[C, TC] { type Out = O }
  def apply[C <: Coproduct, TC[_]](implicit ev: CopTCs[C, TC]) = ev

ahjohannessen

import cats.{ ApplicativeError, MonadError }
import cats.data.{ Kleisli, OptionT }
import cats.effect.Sync
import cats.effect.concurrent.Ref
import cats.syntax.all._
import io.circe.generic.auto._
import io.circe.syntax._
import org.http4s._
import org.http4s.circe.CirceEntityDecoder._
import org.http4s.circe._

ahjohannessen

interp.configureCompiler(_.settings.YpartialUnification.value = true)

import $ivy.`org.tpolecat::doobie-core:0.5.3`

import cats._
import cats.effect._
import cats.implicits._
import doobie._
import doobie.implicits._

ahjohannessen

import doobie._
import doobie.implicits._

// Something for FunctionK ~>

trait Foo[F[_]]{ 
  def getFoo: F[Bar] 
}

ahjohannessen

import shapeless._
import shapeless.labelled._

trait Required[A] {
  def isRequired: Boolean
}
object Required {
  implicit def optIsRequired[A]: Required[Option[A]] = new Required[Option[A]] {
    override def isRequired = false
  }

ahjohannessen

Advanced Functional Programming with Scala - Notes

Copyright © 2017 Fantasyland Institute of Learning. All rights reserved.

1. Mastering Functions

A function is a mapping from one set, called a domain, to another set, called the codomain. A function associates every element in the domain with exactly one element in the codomain. In Scala, both domain and codomain are types.

val square : Int => Int = x => x * x

ahjohannessen

#!/bin/bash
set -e

JAVA_HOME=${1-text}
[ $# -eq 0 ] && { echo "Usage: sudo $0 \$(/usr/libexec/java_home -v '1.8*')" ; exit 1; }

KEYSTORE=$JAVA_HOME/jre/lib/security/cacerts

wget https://letsencrypt.org/certs/letsencryptauthorityx1.der
wget https://letsencrypt.org/certs/letsencryptauthorityx2.der

ahjohannessen

using System;
using System.CodeDom;
using System.Collections.Generic;
using System.Linq;
using System.Net;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using EventStore.ClientAPI;
using EventStore.ClientAPI.Embedded;

ahjohannessen

import akka.stream.scaladsl.Flow

import scala.concurrent.{ ExecutionContext, Future }
import scalaz._
import scalaz.std.scalaFuture.futureInstance // IntelliJ lies

/**
 * Flowz provides Akka Stream Flow like methods for monadic types.
 *
 * You can define the `M` type and the input type, and let the compiler infer the output