Rethinking Data Pipelines with Profunctors in Haskell: An Efficient Alternative to Monads

#ProfunctorsInAction #HaskellDataPipelines #BeyondMonads #FunctionalProgrammingMagic #LensesAndArrowsUnveiled

In our previous article, "Profunctors: The Unsung Heroes Outshining Monads in Functional Programming", we delved into the not so known world of profunctors. As a continuation, we're now exploring further, incorporating powerful concepts such as lenses and arrows to showcase the practical advantages of profunctors over monads. Particularly, we focus on building data pipelines and manipulating intricate data structures. With real-world use cases and code snippets, we'll unveil the compelling efficiencies this powerful team - profunctors, lenses, and arrows - brings to the world of Haskell programming.

Profunctors: A Higher-level Abstraction

Profunctors, with their two mapping functions, can be perceived as a generalized function. They're at the same time contravariant, cause they are acting on the input, and covariant cause they are acting on the output, making them perfect for defining bidirectional data transformations, remember the signature of the profunctor p with the mapping functions: (b->a) ->(c ->d) -> p a c-> p b d , where we have the two mapping functions, the first being contravariant and the second covariant, and one profunctor p with two parts: one acting on the input and on the output (p b d). And the other one ( p a c) performing the same on the intermediate data, after the input and before the transformation occurs on the output.

While monads abstract sequences of computational steps, they may sometimes fall short in scenarios where transformations are key, such as data pipelines. This is where profunctors shine.

{-# LANGUAGE DerivingVia #-}

import Data.Profunctor

data Worker a b s t =
 Worker (s -> Either t a) (b -> t)
? deriving (Profunctor, Strong)
  via Star (Either t)
{-
  Note: Star is a constructor of Profunctor
  that handles only types with kind: Type -> Type
  like Maybe. But Either is 
  Type ->Type -> Type, so this is why
  I applied partially t before the constructor
  takes a. In this way we can process in two
  Steps a type like Either t a. 
  
-}

        

In this snippet, we've defined a Worker data type using profunctors. This data type can be used to define transformations between different data types. Notably, it uses the Either monad (to handle log errors without the need of using exceptions) , which allows us to handle computations that can result in two different types of values. This is the essence of the profunctor: providing a higher level of abstraction for transformations that involve potential branching or error conditions.

Lenses and Profunctors: A Perfect Pairing

A lens is a first-class getter and setter pair for a specific field of a data structure. It can be interpreted as a profunctor, and the lens library in Haskell leverages this relationship to provide a robust and flexible interface.

{-# LANGUAGE TemplateHaskell #-}

import Control.Lens

data Worker = 
 Worker { _name :: String, _role :: String
? ? ? ?  , _years :: Int, _salary :: Float
? ? ? ? ?} deriving Show
makeLenses ''Worker

worker = 
Worker "Jose" "Engineer" 5 70000

workerName = view name worker
updatedWorker = over years (+1) worker


main :: IO ()
main = do
? print workerName
? print updatedWorker

        

In this snippet, we define a Worker data type and use Template Haskell to automatically generate lenses for its fields. We can then use the view function to extract a field's value and the over function to modify a field's value

Arrows, Profunctors, and the Power of Composition

Arrows can be viewed as profunctors with additional structure, enabling function composition and mapping in contexts where monads might be too restrictive. Arrows and profunctors can be used together to construct flexible, compositional data pipelines.

{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE Arrows #-}


import Control.Arrow
import Control.Lens
import Control.Monad.IO.Class

-- again decl 
data Worker = Worker {
? _name :: String,
? _position :: String,
? _yearsExperience :: Int,
? _salary :: Int
} deriving Show


-- This line will generate again
-- lenses for each field in the Worker record
makeLenses ''Worker
procWorker :: Kleisli IO Worker String
procWorker = Kleisli $ \worker -> do
? liftIO $ putStrLn ("Processing worker: " ++ view name worker)
? return (view name worker)

main :: IO ()
main = do
? let worker = Worker "Pepe" "Manager" 10 100000
? runKleisli procWorker worker

        

This code defines an arrow that takes a Worker and performs some IO actions on it. The Kleisli type is used to wrap functions that return monadic values, making them composable in an arrow-like fashion. In this case, the procWorker function takes a Worker, prints out their name, and then returns their name as a String. The runKleisli function is then used to apply this function to a Worker.

CONCLUSION

In this article, we've seen how profunctors, lenses, and arrows can work together to create expressive and powerful data pipelines and transformations. While monads are an important part of the Haskell ecosystem, they are not always the best tool for every job. Profunctors, lenses, and arrows offer alternative abstractions that can be more natural and efficient in certain contexts. So, the next time you're building a data pipeline or manipulating complex data structures in Haskell, consider reaching for these tools in your toolbox. You will be pleasantly surprised by what they can do. Thanks for the read!