Odomontois

import math.*
import scipy.optimize.*

def k2t(k):
   f = lambda t : gamma(1/t)*gamma(5/t)/gamma(3/t)**2-k-3
   return fsolve(f,2)

Odomontois

<input type='range' value='70' />

Odomontois

Revisiting Tagless Final Interpreters with Dotty

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

Odomontois

import cats.data.Ior

object UserRelationsT {
  import shapeless.tag
  import tag.@@
  import shapeless.Unwrapped

  trait IsFollowerTag
  type IsFollower = Boolean @@ IsFollowerTag
  def isFollower(b: Boolean): IsFollower = tag[IsFollowerTag][Boolean](b)

Odomontois

import cats.{Monad, StackSafeMonad}
import cats.effect.{IO, LiftIO}
import io.iteratee.{Enumeratee, Enumerator, Iteratee}
import cats.implicits._

trait Session {
  def close(): Unit
}

case class SessionContext[T](exec: Session => IO[T]) {

Odomontois

{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Stepik () where

class (Enum a, Bounded a, Eq a) => SafeEnum a where
  ssucc :: a -> a
  ssucc x | x == maxBound = minBound
          | otherwise = succ x

  spred :: a -> a

Odomontois

package scalagroup
import cats.Functor
import cats.instances.function._
import cats.instances.string._
import cats.syntax.eq._
import cats.syntax.functor._
import simulacrum.typeclass

object KVStore {
  def main(args: Array[String]): Unit = {

Odomontois

trait Iso[A, B] {
  def to(a: A): B
  def from(b: B): A
}

trait Derivable[F[_]] {
  type Fields[_]
  def fieldOf[A](name: String, value: F[A]): Fields[A]
  def fieldUnit: Fields[Unit]
  def fieldZip[A, B](left: Fields[A], right: Fields[B]): Fields[(A, B)]

Odomontois

\import Homotopy.Pointed

\data SmashProduct (X Y : Pointed)
  | spd X Y  -- "smash product data"
  | smashl (x : X) (i : I) \elim i {
    | left => spd x Y.base
    | right => spd X.base Y.base
  }
  | smashr (y : Y) (i : I) \elim i {
    | left => spd X.base y