tessl/maven-org-typelevel--cats-core-2-11

Cats is a library which provides abstractions for functional programming in the Scala programming language.

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Cats Core

Name: tessl/maven-org-typelevel--cats-core-2-11
Author: tessl

Cats is a library which provides abstractions for functional programming in the Scala programming language. The cats-core module contains the core type classes and data structures for category theory abstractions including Functor, Applicative, Monad, and many others.

Cats-core serves as the foundation for functional programming in Scala ecosystems, offering zero-dependency type classes that can be extended and composed to build more complex functional programming patterns and domain-specific libraries.

Package Information

Package Name: cats-core
Package Type: maven
Language: Scala
Organization: org.typelevel
Installation: libraryDependencies += "org.typelevel" %% "cats-core" % "2.0.0"

Core Imports

import cats._
import cats.data._
import cats.implicits._

For specific type classes:

import cats.{Functor, Applicative, Monad}
import cats.syntax.functor._
import cats.syntax.applicative._

For data types:

import cats.data.{Chain, NonEmptyList, Validated, EitherT, OptionT}

Basic Usage

import cats._
import cats.data._
import cats.implicits._

// Using Functor with Option
val option: Option[Int] = Some(42)
val doubled = option.map(_ * 2)  // Some(84)

// Using Applicative to combine values
val name: Option[String] = Some("John")
val age: Option[Int] = Some(25)
val person = (name, age).mapN((n, a) => s"$n is $a years old")  // Some("John is 25 years old")

// Using Monad for sequencing operations
def safeDivide(x: Int, y: Int): Option[Int] = 
  if (y != 0) Some(x / y) else None

val result = for {
  a <- Some(20)
  b <- Some(4)
  c <- safeDivide(a, b)
} yield c  // Some(5)

// Using Validated for accumulating errors
val validName = "John".valid[String]
val invalidAge = "not a number".invalid[Int]
val validatedPerson = (validName, invalidAge).mapN((n, a) => s"$n is $a years old")
// Invalid(not a number)

// Using Chain for efficient concatenation
val chain1 = Chain(1, 2, 3)
val chain2 = Chain(4, 5, 6)
val combined = chain1 ++ chain2  // Chain(1, 2, 3, 4, 5, 6)

Architecture

Cats is built around several key components:

Type Classes: Abstract interfaces that define behavior (Functor, Monad, Applicative, etc.)
Data Types: Concrete types that implement type class instances (Chain, NonEmptyList, Validated, etc.)
Monad Transformers: Composable wrappers that combine effects (OptionT, EitherT, StateT, etc.)
Syntax Extensions: Implicit conversions that add methods to types via cats.implicits._
Type Class Instances: Implementations of type classes for standard Scala types
Arrow Types: Category-theoretic constructions for composable functions

Capabilities

Type Classes

Core functional programming abstractions including Functor, Applicative, Monad, and many others. These provide the foundation for composable, lawful functional programming.

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

trait Applicative[F[_]] extends Functor[F] {
  def pure[A](x: A): F[A]
  def ap[A, B](ff: F[A => B])(fa: F[A]): F[B]
}

trait Monad[F[_]] extends Applicative[F] {
  def flatMap[A, B](fa: F[A])(f: A => F[B]): F[B]
  def tailRecM[A, B](a: A)(f: A => F[Either[A, B]]): F[B]
}

Type Classes

Data Types

Essential data structures for functional programming including Chain, NonEmptyList, Validated, and others that provide type-safe alternatives to standard collections.

sealed abstract class Chain[+A] {
  def append[A2 >: A](other: Chain[A2]): Chain[A2]
  def prepend[A2 >: A](item: A2): Chain[A2]
  def toList: List[A]
}

sealed abstract class NonEmptyList[+A] {
  def head: A
  def tail: List[A]
  def map[B](f: A => B): NonEmptyList[B]
}

sealed abstract class Validated[+E, +A] {
  def isValid: Boolean
  def isInvalid: Boolean
  def fold[B](fe: E => B, fa: A => B): B
}

Data Types

Monad Transformers

Composable wrappers that combine multiple effects, allowing you to work with nested monadic contexts like F[Option[A]] or F[Either[E, A]].

final case class OptionT[F[_], A](value: F[Option[A]]) {
  def map[B](f: A => B)(implicit F: Functor[F]): OptionT[F, B]
  def flatMap[B](f: A => OptionT[F, B])(implicit F: Monad[F]): OptionT[F, B]
  def getOrElse[B >: A](default: => B)(implicit F: Functor[F]): F[B]
}

final case class EitherT[F[_], A, B](value: F[Either[A, B]]) {
  def map[C](f: B => C)(implicit F: Functor[F]): EitherT[F, A, C]
  def flatMap[C](f: B => EitherT[F, A, C])(implicit F: Monad[F]): EitherT[F, A, C]
  def leftMap[C](f: A => C)(implicit F: Functor[F]): EitherT[F, C, B]
}

Monad Transformers

Arrow Types

Category theory-based abstractions for composable functions and natural transformations between type constructors.

trait Category[F[_, _]] {
  def id[A]: F[A, A]
  def compose[A, B, C](f: F[B, C], g: F[A, B]): F[A, C]
}

trait Arrow[F[_, _]] extends Category[F] {
  def lift[A, B](f: A => B): F[A, B]
  def first[A, B, C](fa: F[A, B]): F[(A, C), (B, C)]
}

trait FunctionK[F[_], G[_]] {
  def apply[A](fa: F[A]): G[A]
}

Arrow Types

Syntax Extensions

Implicit conversions and extension methods that provide a fluent API for working with type classes and data types.

implicit class FunctorOps[F[_], A](private val fa: F[A]) extends AnyVal {
  def map[B](f: A => B)(implicit F: Functor[F]): F[B] = F.map(fa)(f)
  def void(implicit F: Functor[F]): F[Unit] = F.void(fa)
  def as[B](b: B)(implicit F: Functor[F]): F[B] = F.as(fa, b)
}

implicit class ApplicativeOps[F[_], A](private val fa: F[A]) extends AnyVal {
  def product[B](fb: F[B])(implicit F: Apply[F]): F[(A, B)] = F.product(fa, fb)
  def *>[B](fb: F[B])(implicit F: Apply[F]): F[B] = F.productR(fa)(fb)
  def <*[B](fb: F[B])(implicit F: Apply[F]): F[A] = F.productL(fa)(fb)
}

Syntax Extensions

Key Type Aliases

type Id[A] = A  // Identity type
type Endo[A] = A => A  // Endomorphism
type ~>[F[_], G[_]] = FunctionK[F, G]  // Natural transformation
type :<:[F[_], G[_]] = InjectK[F, G]  // Type constructor injection

// Kernel type aliases from cats-kernel
type Eq[A] = cats.kernel.Eq[A]
type Order[A] = cats.kernel.Order[A]
type PartialOrder[A] = cats.kernel.PartialOrder[A]
type Semigroup[A] = cats.kernel.Semigroup[A]
type Monoid[A] = cats.kernel.Monoid[A]
type Group[A] = cats.kernel.Group[A]