keynmol

object lib:
  import scala.annotation.implicitNotFound
  import scala.util.boundary, boundary.*

  opaque type Lab[T <: Singleton] >: Unit = Unit
  object Lab:
    inline def apply[T <: Singleton]: Lab[T] = ()

  inline def label[T <: Singleton & String](
      inline f: Label[Lab[T]] ?=> Unit

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

lemastero

import scala.language.higherKinds

/*
 Mainline Profunctor Heirarchy for Optics: https://r6research.livejournal.com/27476.html
 Profunctor Optics: The Categorical Approach - Bartosz Milewski: https://www.youtube.com/watch?v=l1FCXUi6Vlw
*/
object ProfunctorOpticsSimpleImpl {

  trait Functor[F[_]] {
    def map[A, B](x: F[A])(f: A => B): F[B]

sir-wabbit

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==

ilijaljubicic

/*
    Monads laws examples with List monads
    
    Summary from article: https://devth.com/2015/monad-laws-in-scala
*/


val f: (Int => List[Int]) = x => List(x - 1, x, x + 1)

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] = ???
}