mrenouf

#!/bin/bash

# Handles proper use of Meld from Git. 
# 
# Instead of launching meld with $MERGED as the base revision, this 
# script makes a copy of $BASE and handles copying the result back 
# to $MERGED if the result was saved. 

# As an extra tweak, it also presents branch names (if known) as 
# the file name prefix, instead of just "LOCAL" and "REMOTE".

jdegoes

Applied Functional Programming with Scala - Notes

Copyright © 2016-2018 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

djspiewak

Getting Started in Scala

This is my attempt to give Scala newcomers a quick-and-easy rundown to the prerequisite steps they need to a) try Scala, and b) get a standard project up and running on their machine. I'm not going to talk about the language at all; there are plenty of better resources a google search away. This is just focused on the prerequisite tooling and machine setup. I will not be assuming you have any background in JVM languages. So if you're coming from Python, Ruby, JavaScript, Haskell, or anywhere…  I hope to present the information you need without assuming anything.

Disclaimer It has been over a decade since I was new to Scala, and when I was new to Scala, I was coming from a Java and Ruby background. This has probably caused me to unknowingly make some assumptions. Please feel free to call me out in comments/tweets!

One assumption I'm knowingly making is that you're on a Unix-like platform. Sorry, Windows users.

Getting the JVM

djspiewak

Thread Pools

Thread pools on the JVM should usually be divided into the following three categories:

1. CPU-bound
2. Blocking IO
3. Non-blocking IO polling

Each of these categories has a different optimal configuration and usage pattern.

filosganga

import cats.effect.Async
import com.google.common.util.concurrent.{FutureCallback, Futures, ListenableFuture}

import scala.concurrent.ExecutionContext

object GuavaFutures {

  implicit class RichListenableFuture[T](lf: ListenableFuture[T]) {

    def toAsync[F[_]: Async](implicit ec: ExecutionContext): F[T] = {

SystemFw

 // Grows with the number of distinct `K`
  def partitions[F[_], A, K](selector: A => F[K])(implicit F: Effect[F], ec: ExecutionContext)  : Pipe[F, A, (K, Stream[F, A])] = in => 
  Stream.eval(async.refOf[F, Map[K, Queue[F, Option[A]]]](Map.empty)).flatMap { st =>
    val cleanup = {
      import alleycats.std.all._
      st.get.flatMap(_.traverse_(_.enqueue1(None)))
    }

    (in ++ Stream.eval_(cleanup)).evalMap { el =>
      (selector(el), st.get).mapN { (key, queues) =>

kiambogo

import fs2.concurrent.Queue
import cats.implicits._
import cats.effect.Concurrent
import cats.effect.concurrent.Ref
 
def groupBy[F[_], A, K](selector: A => F[K])(implicit F: Concurrent[F]): Pipe[F, A, (K, Stream[F, A])] = {
  in =>
  Stream.eval(Ref.of[F, Map[K, Queue[F, Option[A]]]](Map.empty)).flatMap { st =>
    val cleanup = {
      import alleycats.std.all._

gvolpe

import cats.Traverse
import cats.effect._
import cats.effect.concurrent.Semaphore
import cats.temp.par._
import cats.syntax.all._

import scala.concurrent.duration._

object Main extends IOApp {
  import ParTask._

mpilquist

// Save as ~/.ammonite/predef.sc
// To use fs2 from ammonite repl, type `load.fs2` from repl prompt.
// You'll get all fs2 & cats imports, ContextShift and Timer instances
// for IO, and a globalBlocker

import $plugin.$ivy.`org.typelevel:::kind-projector:0.11.0`

if (!repl.compiler.settings.isScala213)
  repl.load.apply("interp.configureCompiler(_.settings.YpartialUnification.value = true)")

gatorcse

import cats._
import cats.implicits._
import cats.effect._
import cats.effect.implicits._
import fs2._

class StreamMerger[F[_]] {
  def priorityOrderBy[A, B: Order](s1: Stream[F, A], s2: Stream[F, A])(f: A => B): Stream[F, A] = {

    def go(p1: Stream.StepLeg[F, A], p2: Stream.StepLeg[F, A]): Pull[F, A, Unit] = {