johnynek

use std::comm::{Receiver, channel};
use std::io;
use std::mem::replace;
use std::task::spawn;

struct Future<'a, A> {
  state: FutureState<'a, A>
}

avakhrenev

import cats.effect.{Effect, IO}
import fs2._

import scala.concurrent.ExecutionContext

def runConcat[F[_], A](first: Stream[F, A], second: Stream[F, A])(
    implicit F: Effect[F],
    ec: ExecutionContext): Stream[F, A] = {
  type Step = AsyncPull[F, Option[(Segment[A, Unit], Stream[F, A])]]
  def readFull(s: Step): Pull[F, A, Unit] =

johnynek

// Run this with scala <filename>

/**
 * A Two-phase commit Monad
 */
trait Transaction[+T] {
  def map[U](fn: T => U): Transaction[U] = flatMap { t => Constant(fn(t)) }
  def flatMap[U](fn: T => Transaction[U]): Transaction[U] =
    FlatMapped(this, fn)

samuel

#!/usr/bin/env python

from __future__ import with_statement

import contextlib
import logging
import os
import sys
import urllib2
from boto.ec2.connection import EC2Connection

vlfig

import scala.collection.mutable.WeakHashMap

/**
  * Utility traits for classes whose companion objects are to
  * intern their instances, never creating repeated objects.
  *
  * Instances are cached based on their immutable
  * arguments, as provided to companion object's {{apply()}}.
  */

viktorklang

/*
Copyright 2013 Viktor Klang
   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at
       http://www.apache.org/licenses/LICENSE-2.0
   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and

djspiewak

Explaining Miles's Magic

Miles Sabin recently opened a pull request fixing the infamous SI-2712. First off, this is remarkable and, if merged, will make everyone's life enormously easier. This is a bug that a lot of people hit often without even realizing it, and they just assume that either they did something wrong or the compiler is broken in some weird way. It is especially common for users of scalaz or cats.

But that's not what I wanted to write about. What I want to write about is the exact semantics of Miles's fix, because it does impose some very specific assumptions about the way that type constructors work, and understanding those assumptions is the key to getting the most of it his fix.

For starters, here is the sort of thing that SI-2712 affects:

def foo[F[_], A](fa: F[A]): String = fa.toString

obolton

AWS ELB with Node.js and WebSockets

This assumes that:

• You are using Nginx.
• You want to accept incoming connections on port 80.
• Your Node.js app is listening on port 3000.
• You want to be able to connect to your Node.js instance directly as well as via the load balancer.

####1. Create load balancer

tsabat

Prereq:

apt-get install zsh
apt-get install git-core

Getting zsh to work in ubuntu is weird, since sh does not understand the source command. So, you do this to install zsh

wget https://github.com/robbyrussell/oh-my-zsh/raw/master/tools/install.sh -O - | zsh

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