noxasaxon

Learning Rust

Getting Started + Installation | Cheat Sheet

Table of Contents

1. How Do I Start Learning Rust?!
2. Ok, I Think I Know The Basics But How Do I Get Better?!
3. Rustlang Tooling
4. Helpful References Throughout Your Journey
5. The Rust Community
6. Recommended (but not free) Books & Courses

Daenyth

Concurrent resource caching for cats

Motivation

cats-effect Resource is extremely handy for managing the lifecycle of stateful resources, for example database or queue connections. It gives a main interface of:

trait Resource[F[_], A] {
  /** - Acquire resource
    * - Run f
 * - guarantee that if acquire ran, release will run, even if `use` is cancelled or `f` fails

hobwekiva

Scalanomicon

the most asInstanceOf per line in Scalazzi-compliant code (efficient Nat and Fin types)

nonEmpty without boolean blindness and older version and another one

Dank Cord

Scala having too many features resulting in unsoundness

ejconlon

import scala.languageFeature.higherKinds
import cats.{Applicative, Id, ~>}

object Shapes {
  case class Child[F[_]](nickname: F[String], age: F[Int])

  case class Adult[F[_]](job: F[String], innerChild: Child[F])

  class ApplicativeTrans[F[_]](implicit applicativeF: Applicative[F]) extends ~>[Id, F] {
    override def apply[A](value: A): F[A] = applicativeF.pure(value)

maurizi

// ==UserScript==
// @name         Mike's timesheet improvements
// @namespace    http://tampermonkey.net/
// @version      0.2
// @description  Add plus time buttons to the new GetMyTime
// @author       Michael Maurizi
// @match        https://app.getmytime.com/timesheet.aspx
// @grant        none
// ==/UserScript==

non

Laws

A law is a group of two or more expressions which are required to be the same. The expressions will usually involve one or more typed holes ("inputs") which vary.

Some examples:

x.map(id) === x

travisbrown

class Nil
class Cons[X, Xs]

class First[List] { type X }
object First {
  type Aux[List, X0] = First[List] { type X = X0 }

  implicit val nilFirst: Aux[Nil, Nil] = ???
  implicit def consFirst[X0, Xs]: Aux[Cons[X0, Xs], X0] = ???
}

OlivierBlanvillain

Revisiting Tagless Final Interpreters

Tageless Final interpreters are an alternative to the traditional Algebraic Data Type (and generalized ADT) based implementation of the interpreter pattern. This document presents the Tageless Final approach with Scala, and shows how Dotty with it's recently added implicits functions makes the approach even more appealing. All examples are direct translations of their Haskell version presented in the Typed Tagless Final Interpreters: Lecture Notes (section 2).

The interpreter pattern has recently received a lot of attention in the Scala community. A lot of efforts have been invested in trying to address the biggest shortcomings of ADT/GADT based solutions: extensibility. One can first look at cats' Inject typeclass for an implementation of [Data Type à la Carte](http://www.cs.ru.nl/~W.Swierstra/Publications/DataTypesA

paulp

// These lines go in ~/.sbt/0.13/global.sbt
watchSources ++= (
     (baseDirectory.value * "*.sbt").get
  ++ (baseDirectory.value / "project" * "*.scala").get
  ++ (baseDirectory.value / "project" * "*.sbt").get
)

addCommandAlias("rtu", "; reload ; test:update")
addCommandAlias("rtc", "; reload ; test:compile")
addCommandAlias("ru", "; reload ; update")

lossyrob

USR_LOCAL="/usr/local"
USR="/usr"
TIFF_HOME=$USR_LOCAL
LASZIP_HOME=$USR_LOCAL
LIBXML2_HOME=/usr/local/Cellar/libxml2/2.9.4/
WEBSOCKETPP_HOME=/Users/hobu/dev/git/websocketpp
GEOTIFF_HOME=$USR_LOCAL
P2G_HOME=$USR_LOCAL
HEXER_HOME="/usr/local"
SQLITE_HOME="/usr/local/opt/sqlite"