or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

arrows.mddata-types.mderror-handling.mdindex.mdinstances.mdsyntax.mdtype-classes.md
tile.json

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

Lightweight, modular, and extensible library for functional programming in Scala providing core abstractions including type classes, data structures, and syntax extensions.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.typelevel/cats-core_sjs0.6_2.11@1.6.x

To install, run

npx @tessl/cli install tessl/maven-org-typelevel--cats-core@1.6.0

index.mddocs/

Cats Core

Cats Core is a comprehensive functional programming library for Scala providing lightweight, modular, and extensible abstractions. It offers fundamental type classes like Functor, Applicative, and Monad, along with powerful data structures and syntax extensions that form the foundation of functional programming in Scala.

Package Information

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

Core Imports

import cats._
import cats.implicits._

For selective imports:

import cats.syntax.functor._     // Just Functor syntax
import cats.syntax.applicative._ // Just Applicative syntax
import cats.instances.list._     // Just List instances

Basic Usage

import cats._
import cats.implicits._

// Using type class syntax
val list = List(1, 2, 3)
val doubled = list.map(_ * 2)         // Functor
val nested = List(List(1, 2), List(3, 4))
val flattened = nested.flatten        // Monad

// Working with Option
val opt1 = Some(42)
val opt2 = Some(10) 
val result = (opt1, opt2).mapN(_ + _) // Applicative

// Error handling with Either
val either1: Either[String, Int] = Right(5)
val either2: Either[String, Int] = Right(10)
val combined = (either1, either2).mapN(_ * _)

// Validation with error accumulation
import cats.data.Validated
import cats.data.ValidatedNel

val valid1: ValidatedNel[String, Int] = Validated.valid(42)
val valid2: ValidatedNel[String, Int] = Validated.valid(10)
val validResult = (valid1, valid2).mapN(_ + _)

Architecture

Cats Core is built around several key components:

  • Type Classes: Abstract interfaces defining functional capabilities (Functor, Monad, Applicative, etc.)
  • Data Types: Functional data structures and monad transformers (NonEmptyList, Validated, EitherT, etc.)
  • Syntax Extensions: Implicit methods that provide ergonomic APIs for type classes
  • Type Class Instances: Implementations of type classes for standard Scala types
  • Arrow Types: Category theory abstractions for composable computations

The library follows the principle of providing core, binary-compatible abstractions that can be composed and extended while maintaining performance through zero-overhead patterns.

Capabilities

Type Classes

Fundamental functional programming abstractions including the core type class hierarchy from Functor through Monad, error handling classes, and specialized variants with mathematical laws and stack-safe implementations.

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

trait Applicative[F[_]] extends Functor[F] {
  def pure[A](a: 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

Functional data structures and monad transformers including non-empty collections, validation types, and composable transformers for building complex functional programs.

// Non-empty collections
final case class NonEmptyList[+A](head: A, tail: List[A])
final case class NonEmptyVector[+A](toVector: Vector[A])

// Validation with error accumulation  
sealed abstract class Validated[+E, +A]
final case class Valid[+A](a: A) extends Validated[Nothing, A]
final case class Invalid[+E](e: E) extends Validated[E, Nothing]

// Monad transformers
final case class OptionT[F[_], A](value: F[Option[A]])
final case class EitherT[F[_], A, B](value: F[Either[A, B]])

Data Types

Syntax Extensions

Implicit syntax methods that provide ergonomic APIs for all type classes, enabling natural method-chaining and operator-style programming with functional abstractions.

// Example syntax extensions (provided via implicits)
implicit class FunctorOps[F[_], A](fa: F[A])(implicit F: Functor[F]) {
  def map[B](f: A => B): F[B] = F.map(fa)(f)
  def void: F[Unit] = F.void(fa)
  def fproduct[B](f: A => B): F[(A, B)] = F.fproduct(fa)(f)
}

Syntax Extensions

Error Handling

Comprehensive error handling abstractions including MonadError and ApplicativeError for recoverable errors, plus data types like Validated and Ior for error accumulation patterns.

trait ApplicativeError[F[_], E] extends Applicative[F] {
  def raiseError[A](e: E): F[A]
  def handleErrorWith[A](fa: F[A])(f: E => F[A]): F[A]
  def attempt[A](fa: F[A]): F[Either[E, A]]
}

trait MonadError[F[_], E] extends ApplicativeError[F, E] with Monad[F] {
  def recover[A](fa: F[A])(pf: PartialFunction[E, A]): F[A]
}

Error Handling

Arrow Types

Category theory abstractions for composable computations including natural transformations, categories, arrows, and profunctors that enable advanced functional programming patterns.

// Natural transformation between functors
trait FunctionK[F[_], G[_]] {
  def apply[A](fa: F[A]): G[A]
}

// Category abstraction
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]
}

Arrow Types

Type Class Instances

Implementations of type classes for standard Scala types including collections, Option, Either, Future, and numeric types, providing immediate access to functional abstractions.

// Available instances (provided automatically via cats.implicits._)
// List[A]: Monad[List], Traverse[List], MonoidK[List], Alternative[List]
// Option[A]: Monad[Option], Traverse[Option], Alternative[Option]  
// Either[E, A]: Monad[Either[E, ?]], Bifunctor[Either]
// Function1[A, B]: Monad[Function1[A, ?]], Category[Function1]

Type Class Instances