igstan

package com.example.http4splayground.services

import java.util.Date
import java.util.concurrent.TimeUnit

import cats._
import cats.data.StateT
import cats.effect.{ExitCode, IO, IOApp}
import cats.implicits._
import cats.mtl.MonadState

igstan

scala> import scala.language.higherKinds
import scala.language.higherKinds

scala> def f[C[_], E]: List[C[E]] = Nil
f: [C[_], E]=> List[C[E]]

scala> f[List, Int]
res0: List[List[Int]] = List()

scala> f[Any, Int]

igstan

// libraryDependencies += "com.rklaehn" %% "intervalset" % "0.2.0"

import java.time.Instant
import scala.collection.immutable.SortedSet
import com.rklaehn.interval.IntervalMap.{ Value, FromBool => IntervalMap }
import org.scalatest.FunSuite
import spire.algebra.Order
import spire.implicits.StringOrder
import spire.math.Interval
import spire.optional.genericEq.generic

igstan

igstan

# hogof — Higher-Order Gang of Four

# data Fix s a = In{out :: s a (Fix s a)}

def flatten(xss):
  return [
    x
    for xs in xss
    for x in xs
  ]

igstan

import scala.concurrent.Future
import cats.~>
import cats.data.ReaderT
import cats.free.Free

object FreeMonads {
  sealed trait Op[A]

  object Op {
    final case class Get[T](name: String) extends Op[T]

igstan

# Factorial in Eve
## Base Case
```eve
search
  r = [#factorial n: 0]

bind
  r.return := 1
```
## Recursive Case

igstan

indirect enum Type: CustomStringConvertible {
  case Int
  case Fun(Type, Type)

  var isFun: Bool {
    switch self {
      case .Fun: return true
      case _: return false
    }
  }

igstan

signature TAGGED_ORD =
  sig
    type t
    type a
    val wrap : int -> t
    val compare : t * t -> order
    val asRecord : { wrap : a -> t, compare : t * t -> order }
  end

igstan

functor Member(Flag : sig type t end) =
  struct
    (* Define types and values common to both MemberA and MemberB. *)
  end

(*
 * MemberA and MemberB differ only in the declaration of Flag, the rest of
 * the types and values are the same and come from the Member functor.
 *)
structure MemberA =