jdegoes

object test {
  import scalaz.zio._

  type UserID = String
  case class UserProfile(name: String)

  // The database module:
  trait Database {
    val database: Database.Service

tifletcher

#!/bin/bash

# preferences


# set DEBUG to "-v" or "" -- it will
#   1. activate shell tracing
#   2. be passed to curl as an argument
if [ -z "$DEBUG" ];
then

kdrakon

import java.util

import com.sksamuel.avro4s.RecordFormat
import org.apache.avro.generic.GenericRecord
import org.apache.kafka.common.serialization.{Deserializer, Serde, Serializer}

object Avro4s {
  implicit class CaseClassSerde(inner: Serde[GenericRecord]) {
    def forCaseClass[T](implicit recordFormat: RecordFormat[T]): Serde[T] = {
      val caseClassSerializer: Serializer[T] = new Serializer[T] {

yossorion

What I Wish I'd Known About Equity Before Joining A Unicorn

Disclaimer: This piece is written anonymously. The names of a few particular companies are mentioned, but as common examples only.

This is a short write-up on things that I wish I'd known and considered before joining a private company (aka startup, aka unicorn in some cases). I'm not trying to make the case that you should never join a private company, but the power imbalance between founder and employee is extreme, and that potential candidates would

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

gkossakowski

Scala's "type T in class C as seen from a prefix type S" with examples

Introduction

Recently, I found myself in need to precisely understand Scala's core typechecking rules. I was particulary interested in understanding rules responsible for typechecking signatures of members defined in classes (and all types derived from them). Scala Language Specification (SLS) contains definition of the rules but lacks any examples. The definition of the rules uses mutual recursion and nested switch-like constructs that make it hard to follow. I've written down examples together with explanation how specific set of rules (grouped thematically) is applied. These notes helped me gain confidence that I fully understand Scala's core typechecking algorithm.

As Seen From

Let's quote the Scala spec for As Seen From (ASF) rules numbered for an easier reference:

djspiewak

import scalaz.{Applicative, Bind, Functor, Monad, Traverse}
// > import scalaz.{Applicative, Bind, Functor, Monad, Traverse}
import scalaz.std.option._
// > import scalaz.std.option._
import scalaz.std.list._
// > import scalaz.std.list._

import scalaz.syntax.applicative._
// > import scalaz.syntax.applicative._

johnynek

import scala.language.experimental.macros
import scala.reflect.macros.Context

/**
 * you can try this in the REPL even
 */
object SafeEq {
  /**
   * eqv(1, "foo") won't compile

gigiigig

import shapeless._

import scalaz._
import Scalaz._

object console extends App {

  trait Foo[A] {
    type B
    def value: B

non

object Transducer {
  type RF[R, A] = (R, A) => R
  def apply[A, B](f: A => B) =
    new Transducer[B, A] {
      def apply[R](rf: RF[R, B]) = (r, a) => rf(r, f(a))
    }
}

import Transducer.RF