Lists of As and B, to Lists of Tuples, to merging on Keys and calcing.

map_calc.hs

import           Data.Map.Strict as M
import           Prelude         as P

data A = A
     { aa :: Int
     , ab :: Int
     } deriving (Show)

data B = B
     { ba :: Int
     , bb :: Int
     } deriving (Show)

findMatch :: Int -> [(Int, Int)] -> [(Int, Int)]
findMatch key = P.filter (\x -> fst x == key)

mergeThem :: [(Int, Int)] -> [(Int, Int)] -> [(Int, Int)]
mergeThem aaa bbb = P.map (\x ->
           case findMatch (fst x) bbb of
             []  -> (fst x, 0)
             [t] -> (fst x, snd x - snd t)
          ) aaa

main = do
  let as = [A 1 2, A 3 4]
  let bs = [B 1 1, B 3 1]

  let las = P.map ( \x -> ( aa x, ab x ) ) as
  let bas = P.map ( \x -> ( ba x, bb x ) ) bs

  print las
  print bas

  let res = mergeThem las bas
  print res