notxcain

Keybase proof

I hereby claim:

• I am notxcain on github.
• I am notxcain (https://keybase.io/notxcain) on keybase.
• I have a public key whose fingerprint is 4824 FFBA E375 4EB2 BA72 F686 0EA7 7084 2A4F 9AA2

To claim this, I am signing this object:

notxcain

@free sealed trait Op[A]

object Op {
  final case class StringOp(s: String) extends Op[String]
  final case class PolyOp[A](a: A) extends Op[A]
  /* Should be expanded to
  trait ForF[F[_]] {
    def stringOp(s: String): F[String]
    def polyOp[A](a: A): F[A]
  }

notxcain

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://bssys.com/upg/request"
           targetNamespace="http://bssys.com/upg/request" elementFormDefault="qualified"
           attributeFormDefault="unqualified" version="1.0">
    <xs:element name="Request" type="Request">
        <xs:annotation>
            <xs:documentation>Запрос УС к СББОЛ</xs:documentation>
        </xs:annotation>
    </xs:element>
    <xs:complexType name="Fraud">

notxcain

<?xml version='1.0' encoding='UTF-8'?>
<wsdl:definitions name="UniversalPaymentGate" targetNamespace="http://upg.sbns.bssys.com/" xmlns:ns1="http://schemas.xmlsoap.org/soap/http" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://upg.sbns.bssys.com/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <wsdl:types>
<xs:schema elementFormDefault="qualified" targetNamespace="http://upg.sbns.bssys.com/" version="1.0" xmlns:tns="http://upg.sbns.bssys.com/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="changePassword" type="tns:changePassword"/>
<xs:element name="changePasswordResponse" type="tns:changePasswordResponse"/>
<xs:element name="getRequestStatus" type="tns:getRequestStatus"/>
<xs:element name="getRequestStatusResponse" type="tns:getRequestStatusResponse"/>
<xs:element name="getRequestStatusSRP" type="tns:getRequestStatusSRP"/>
<xs:element name="getRequestStatusSRPResponse" type="tns:getRequestStatusSRPResponse"/>

notxcain

<?xml version="1.0" encoding="UTF-8"?>
<wsdl:definitions name="UniversalPaymentGate" targetNamespace="http://upg.sbns.bssys.com/" xmlns:ns1="http://schemas.xmlsoap.org/soap/http" xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/" xmlns:tns="http://upg.sbns.bssys.com/" xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns="http://bssys.com/upg/request"
           targetNamespace="http://bssys.com/upg/request" elementFormDefault="qualified"
           attributeFormDefault="unqualified" version="1.0">
           <wsdl:types>
<xs:schema elementFormDefault="qualified" targetNamespace="http://upg.sbns.bssys.com/" version="1.0" xmlns:tns="http://upg.sbns.bssys.com/" xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:element name="changePassword" type="tns:changePassword"/>
<xs:element name="changePasswordResponse" type="tns:changePasswordResponse"/>
<xs:element name="getRequestStatus" type="tns:getRequestStatus"/>

notxcain

import cats.data.Kleisli
import cats.implicits._
import cats.{Applicative, FlatMap, Functor, Monad, Monoid, ~>}

final case class Cofree[F[_], A](head: A, tail: F[Cofree[F, A]]) {
  def map[B](f: A => B)(implicit F: Functor[F]): Cofree[F, B] =
    Cofree(f(head), F.map(tail)(_.map(f)))
  def zip[B](other: Cofree[F, B])(implicit F: Applicative[F]): Cofree[F, (A, B)] =
    Cofree((head, other.head), (tail |@| other.tail).map(_ zip _))

notxcain

import cats.data.{ EitherT, State }
import cats.implicits._
import cats.{ Monad, ~> }
import io.aecor.liberator.macros.free
import io.aecor.liberator.syntax._
import io.aecor.liberator.{ ProductKK, Term }

@free
trait Api[F[_]] {
  def doThing(aThing: String, params: Map[String, String]): F[Either[String, String]]

notxcain

import cats.{ Functor, ~> }
import cats.implicits._
import shapeless.{ :+:, ::, CNil, Coproduct, Generic, HList, HNil, Inl, Inr }

sealed abstract class HasHandlers[C[_], F[_], H, A] {
  type Out
  def apply(h: H, a: A): F[Out]
}

object HasHandlers {

notxcain

package io.aecor.distributedprocessing

object OffsetRepartitioner {
  type Partition = Int

  def apply[A, Offset: Ordering](
    oldPartitioner: A => Partition,
    newNumberOfPartitions: Int,
    getNearestLeftInNewPartition: (Partition, Offset) => Option[A],
    offsetOf: A => Offset

notxcain

object Cache {
  def apply[A, B](ttl: FiniteDuration)(f: A => Task[B]): A => Task[B] = {
    val mvar = MVar(Map.empty[A, B])
    a =>
      for {
        cached <- mvar.read.map(_.get(a))
        out <- cached match {
          case Some(b) => Task.pure(b)
          case None =>
            for {