How to refactor common logic from types in haskell

One option is to implement these functions over just plain old lists and then the class instances are just newtype wrapper/unwrappers.

For instance, you can define:

subByRangeList :: [Date] -> Maybe BoundDate -> Maybe BoundDate -> [Date]
subByRangeList s Nothing Nothing = s
subByRangeList s Nothing (Just ed) = 
  case ed of 
     Include d -> filter ( x -> x <= d ) s
     Exclude d -> filter ( x -> x < d ) s
subByRangeList s (Just sd) Nothing =
  case sd of 
     Include d -> filter ( x -> x >= d ) s
     Exclude d -> filter ( x -> x > d ) s
subByRangeList s (Just sd) (Just ed) =
     subByRangeList _s Nothing (Just ed)
  where
     _s = subByRangeList s (Just sd) Nothing

And then your instances are simply:

instance TsList Statement where
  subByRange (Statement txns) = Statement $ subByRangeList txns

instance TsList Journal where
  subByRange (Journal txns) = Journal $ subByRangeList txns

One potential annoyance of this is if you have a bunch of class methods in TsList (or a bunch of instances), and you don't want to even have to define each one the same way with the newtype wrapping/unwrapping. You can make use of DefaultSignatures and the Coercible type class to write:

class TsList a where
  subByRange :: a -> Maybe BoundDate -> Maybe BoundDate -> a
  default subByRange :: (Coercible a [Date], Coercible [Date] a) => a -> Maybe BoundDate -> Maybe BoundDate -> a
  subByRange s x y = coerce $ subByRangeList (coerce s) x y

instance TsList Statement
instance TsList Journal

Because Statement and Journal are simply newtype wrappers around [Date], they will be able to use the default version of subByRange, so all you need to do is declare that they're instances.

As @FyodorSoikin mentioned in the comments, perhaps the easiest way to do this is to use the GHC language extension DerivingVia. To do this, add the following declaration to the top of your file:

{-# LANGUAGE DerivingVia #-}

Now, assuming that your types are defined as newtypes, GHC will be able to automatically derive one instance from the other if you tell it so:

newtype Statement = Statement [Int]   -- or something like this

instance TsList Statement where
    -- ...as in the question...

newtype Journal = Journal [Int]
    deriving (TsList) via Statement

(Note that this only works if both Statement and Journal are newtype wrappers around the same type.)

If you ever want this to work with more sophisticated data types than simple wrappers around [Date] you'll need some more advanced tooling. Fortunately, GHC provides some. You can use the Data.Data module to handle this more broadly.

First, we'll need a bit of tooling. Many libraries export something equivalent to this function, but it's simple enough that I'll just include it instead pulling in an extra dependency.

{-# Language ScopedTypeVariables, GADTs #-}

import Data.Data

-- Apply the function anywhere in the data type where it has the
-- correct type. Don't recurse further when the type matches.
deepMap :: forall a s. (Typeable a, Data s) => (a -> a) -> s -> s
deepMap f = go
  where
    go :: forall x. Data x => x -> x
    go d = case eqT :: Maybe (a :~: x) of
        Just Refl -> f d
        Nothing -> gmapT go d

(It's possible to improve that function a lot for performance in edge cases. If you care about that, you should use a version that comes from a library.)

With that functionality available, you can take advantage of the DefaultSignatures extension to provide a default implementation in the class that will work for any Data instance.

{-# Language DefaultSignatures, DeriveDataTypeable #-}

-- whatever, this needed some definition
data Date = Date deriving (Eq, Ord, Show, Data)

data BoundDate = Include Date
               | Exclude Date
    deriving (Eq, Ord, Show, Data)

-- factor out the common logic
filterSubRange :: Maybe BoundDate -> Maybe BoundDate -> [Date] -> [Date]
filterSubRange Nothing Nothing txns = txns
filterSubRange  Nothing (Just ed) txns =
    case ed of
       Include d -> filter (<= d) txns
       Exclude d -> filter (< d) txns
filterSubRange (Just sd) Nothing txns =
    case sd of
       Include d -> filter (>= d) txns
       Exclude d -> filter (> d) txns
filterSubRange (Just sd) (Just ed) txns =
    filterSubRange Nothing (Just ed) txns'
  where
    txns' = filterSubRange (Just sd) Nothing txns

-- provide a default implementation that uses filterSubRange on any
-- [Date] the type contains
class TsList a where
    subByRange :: a -> Maybe BoundDate -> Maybe BoundDate -> a

    default subByRange :: Data a => a -> Maybe BoundDate -> Maybe BoundDate -> a
    subByRange s lo hi = deepMap (filterSubRange lo hi) s


-- some definitions containing whatever.
data Statement = Statement (Maybe String) Bool [Date]
    deriving (Eq, Ord, Show, Data)
newtype Journal = Journal [Date]
    deriving (Eq, Ord, Show, Data)

-- empty instances use the default definition
instance TsList Statement
instance TsList Journal

As you can see from the definition of Statement, this works on more complex data types. It may not do what you want if a type has multiple [Date] values inside it - in which case, you can write out the instance by hand. And maybe you can take advantage of the fact that filterSubRange is a standalone function in the process.