{-# LANGUAGE CPP #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE ViewPatterns #-}

-- |
-- Module      :   Grisette.Internal.SymPrim.Prim.Pattern
-- Copyright   :   (c) Sirui Lu 2024
-- License     :   BSD-3-Clause (see the LICENSE file)
--
-- Maintainer  :   siruilu@cs.washington.edu
-- Stability   :   Experimental
-- Portability :   GHC only
module Grisette.Internal.SymPrim.Prim.Pattern
  ( pattern SubTerms,
  )
where

import Data.Foldable (Foldable (toList))
import Grisette.Internal.SymPrim.Prim.Internal.Instances.SupportedPrim ()
import Grisette.Internal.SymPrim.Prim.Internal.Term
  ( Term,
    pattern AbsNumTerm,
    pattern AddNumTerm,
    pattern AndBitsTerm,
    pattern AndTerm,
    pattern ApplyTerm,
    pattern BVConcatTerm,
    pattern BVExtendTerm,
    pattern BVSelectTerm,
    pattern BitCastOrTerm,
    pattern BitCastTerm,
    pattern ComplementBitsTerm,
    pattern ConTerm,
    pattern DistinctTerm,
    pattern DivIntegralTerm,
    pattern EqTerm,
    pattern ExistsTerm,
    pattern FPBinaryTerm,
    pattern FPFMATerm,
    pattern FPRoundingBinaryTerm,
    pattern FPRoundingUnaryTerm,
    pattern FPTraitTerm,
    pattern FPUnaryTerm,
    pattern FdivTerm,
    pattern FloatingUnaryTerm,
    pattern ForallTerm,
    pattern FromFPOrTerm,
    pattern FromIntegralTerm,
    pattern ITETerm,
    pattern LeOrdTerm,
    pattern LtOrdTerm,
    pattern ModIntegralTerm,
    pattern MulNumTerm,
    pattern NegNumTerm,
    pattern NotTerm,
    pattern OrBitsTerm,
    pattern OrTerm,
    pattern PowerTerm,
    pattern QuotIntegralTerm,
    pattern RecipTerm,
    pattern RemIntegralTerm,
    pattern RotateLeftTerm,
    pattern RotateRightTerm,
    pattern ShiftLeftTerm,
    pattern ShiftRightTerm,
    pattern SignumNumTerm,
    pattern SymTerm,
    pattern ToFPTerm,
    pattern XorBitsTerm,
  )
import Grisette.Internal.SymPrim.Prim.SomeTerm (SomeTerm (SomeTerm))

subTermsViewPattern :: Term a -> Maybe [SomeTerm]
subTermsViewPattern :: forall a. Term a -> Maybe [SomeTerm]
subTermsViewPattern (ConTerm a
_) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return []
subTermsViewPattern (SymTerm TypedSymbol 'AnyKind a
_) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return []
subTermsViewPattern (ForallTerm TypedSymbol 'ConstantKind t
_ Term Bool
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t]
subTermsViewPattern (ExistsTerm TypedSymbol 'ConstantKind t
_ Term Bool
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t]
subTermsViewPattern (NotTerm Term Bool
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t]
subTermsViewPattern (OrTerm Term Bool
t1 Term Bool
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t1, Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t2]
subTermsViewPattern (AndTerm Term Bool
t1 Term Bool
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t1, Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t2]
subTermsViewPattern (EqTerm Term t
t1 Term t
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t1, Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t2]
subTermsViewPattern (DistinctTerm NonEmpty (Term t)
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return (Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm (Term t -> SomeTerm) -> [Term t] -> [SomeTerm]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (Term t) -> [Term t]
forall a. NonEmpty a -> [a]
forall (t :: * -> *) a. Foldable t => t a -> [a]
toList NonEmpty (Term t)
t)
subTermsViewPattern (ITETerm Term Bool
t1 Term a
t2 Term a
t3) =
  [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term Bool -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term Bool
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t3]
subTermsViewPattern (AddNumTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (NegNumTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (MulNumTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (AbsNumTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (SignumNumTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (LtOrdTerm Term t
t1 Term t
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t1, Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t2]
subTermsViewPattern (LeOrdTerm Term t
t1 Term t
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t1, Term t -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term t
t2]
subTermsViewPattern (AndBitsTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (OrBitsTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (XorBitsTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (ComplementBitsTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (ShiftLeftTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (ShiftRightTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (RotateLeftTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (RotateRightTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (BitCastTerm Term a
t1) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1]
subTermsViewPattern (BitCastOrTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (BVConcatTerm Term (bv l)
t1 Term (bv r)
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (bv l) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (bv l)
t1, Term (bv r) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (bv r)
t2]
subTermsViewPattern (BVSelectTerm Proxy ix
_ Proxy w
_ Term (bv n)
t1) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (bv n) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (bv n)
t1]
subTermsViewPattern (BVExtendTerm Bool
_ Proxy r
_ Term (bv l)
t1) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (bv l) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (bv l)
t1]
subTermsViewPattern (ApplyTerm Term f
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term f -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term f
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (DivIntegralTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (ModIntegralTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (QuotIntegralTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (RemIntegralTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (FPTraitTerm FPTrait
_ Term (fp eb sb)
t1) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t1]
subTermsViewPattern (FdivTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (RecipTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (FloatingUnaryTerm FloatingUnaryOp
_ Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (PowerTerm Term a
t1 Term a
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t2]
subTermsViewPattern (FPUnaryTerm FPUnaryOp
_ Term (fp eb sb)
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t]
subTermsViewPattern (FPBinaryTerm FPBinaryOp
_ Term (fp eb sb)
t1 Term (fp eb sb)
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t1, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t2]
subTermsViewPattern (FPRoundingUnaryTerm FPRoundingUnaryOp
_ Term FPRoundingMode
rd Term (fp eb sb)
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term FPRoundingMode -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term FPRoundingMode
rd, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t]
subTermsViewPattern (FPRoundingBinaryTerm FPRoundingBinaryOp
_ Term FPRoundingMode
rd Term (fp eb sb)
t1 Term (fp eb sb)
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term FPRoundingMode -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term FPRoundingMode
rd, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t1, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t2]
subTermsViewPattern (FPFMATerm Term FPRoundingMode
rd Term (fp eb sb)
t1 Term (fp eb sb)
t2 Term (fp eb sb)
t3) =
  [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term FPRoundingMode -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term FPRoundingMode
rd, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t1, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t2, Term (fp eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (fp eb sb)
t3]
subTermsViewPattern (FromIntegralTerm Term a
t) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t]
subTermsViewPattern (FromFPOrTerm Term a
t1 Term FPRoundingMode
rd Term (FP eb sb)
t2) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1, Term FPRoundingMode -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term FPRoundingMode
rd, Term (FP eb sb) -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term (FP eb sb)
t2]
subTermsViewPattern (ToFPTerm Term FPRoundingMode
rd Term a
t1 Proxy eb
_ Proxy sb
_) = [SomeTerm] -> Maybe [SomeTerm]
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return [Term FPRoundingMode -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term FPRoundingMode
rd, Term a -> SomeTerm
forall a. SupportedPrim a => Term a -> SomeTerm
SomeTerm Term a
t1]

-- | Extract all the subterms of a term.
pattern SubTerms :: [SomeTerm] -> Term a
pattern $mSubTerms :: forall {r} {a}. Term a -> ([SomeTerm] -> r) -> ((# #) -> r) -> r
SubTerms ts <- (subTermsViewPattern -> Just ts)

#if MIN_VERSION_base(4, 16, 4)
{-# COMPLETE SubTerms #-}
#endif