dcastro

// Exercises: https://gist.github.com/hugoferreira/21f1f0ec23186adb5e6832e6aee618d6

const eq = require('lodash').isEqual

const fold = (as, base) => (f) => {
    let result = base
    for (let i = 0; i < as.length; i++)
        result = f(result, as[i])
    return result
}

dcastro

import shapeless._
import shapeless.ops.record.Keys
import shapeless.ops.hlist.Selector
import shapeless.tag._

/**
  * Gets the name of a case class's field, in a type-safe way.
  * If the class does not have a field with the given name, the program won't compile.
  *
  * Kinda similar to C#'s `nameof` operator, but not bolted onto the language

dcastro

import io.circe.syntax._

// hypothesis: ∀ x∈X, x.asJson.as[X] == Right(x)

// counterexample, nested options:
type X = Option[Option[Int]]

val x: X = Some(None)
x.asJson.as[X] == Right(x)

dcastro

import scala.io.StdIn._

object CustomIO extends App {

  /**
    * Slides: https://docs.google.com/presentation/d/15O8fzIEa85a8S_vk6N3b_S8F4IYbrFkLOXmtwbcy0cQ
    */

  case class IO[A](unsafeRun: () => A) {
    def map[B](f: A => B): IO[B] =

dcastro

{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE ExplicitForAll #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE PolyKinds #-}

{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleInstances #-}

module Playground where

dcastro

{-# LANGUAGE MagicHash #-}
{-# LANGUAGE TypeInType #-}

module LevNum where

import GHC.Prim
import GHC.Exts (TYPE)

class LevNum (a :: TYPE r) where
  levAdd :: a -> a -> a

dcastro

{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE FunctionalDependencies #-}

module Playground4 where

import Data.Kind (Constraint)
import qualified Data.List as List

class GFunctor (c :: * -> Constraint) (f :: * -> *) | f -> c where

dcastro

Setup

curl -sSL https://get.haskellstack.org/ | sh


stack new <project-name> simple-hpack
cd <project-name>

// build project

dcastro

This assumes familiarity with kinds and GADTs. Here's the extensions you're gonna need:

{-# LANGUAGE DataKinds #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE ExplicitForAll #-}

dcastro

import org.scalacheck.cats.implicits._
import org.scalacheck.Gen
import io.circe.{Decoder, Encoder}

object Test extends App {
  case class X(i: Int)
  
  implicit val x: Encoder[X] = Wrapper[X].deriveInstance[Encoder]
  implicit val y: Decoder[X] = Wrapper[X].deriveInstance[Decoder].withErrorMessage("some custom error msg")
  val z: Gen[X]              = Wrapper[X].lift(Gen.choose(0, 10))