{-# LANGUAGE CPP #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MonoLocalBinds #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE TupleSections #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE UndecidableInstances #-}

module Demangler
  (
    Context
  , newDemangling
  , Demangled
  , Result
  , demangle
  , demangle1
  , functionName
  )
where

import           Control.Applicative
import           Control.Lens ( (&), (^.), (.~), (||~) )
import           Control.Monad
import           Data.Char
import           Data.Either ( isRight )
import           Data.List.NonEmpty ( NonEmpty((:|)) )
import qualified Data.List.NonEmpty as NEL
import           Data.Maybe
import           Data.Semigroup ( sconcat )
import           Data.Text ( Text )
import qualified Data.Text as T
import           Text.Sayable

import           Demangler.Accessors
import           Demangler.Context
import           Demangler.Engine
import           Demangler.PPrint ()
import           Demangler.Structure
import           Demangler.Substitution

#ifdef MIN_VERSION_panic
-- The debug flag is enabled in the cabal file
import           Debug.Trace
#endif


----------------------------------------------------------------------


-- | Demangle a single entry.  If there are multiple entries to be demangled, use
-- 'demangle' for efficient batching and memory reduction.

demangle1 :: Text -> Result
demangle1 :: Text -> Result
demangle1 Text
s = Text -> Context -> Result
demangle Text
s Context
newDemangling

-- | Demangle an input string, given a Context for demangling.
--
-- The signature of this function makes it ideal for State evaluation.

demangle :: Text -> Context -> Result
demangle :: Text -> Context -> Result
demangle Text
s Context
c =
  let seed :: (Text,
 ((),
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
seed = (Text
s, ((), (Context
c, (Seq SubsCandidate
forall a. Monoid a => a
mempty, (Seq TemplateArg
forall a. Monoid a => a
mempty, Bool
False, Bool
False))))) in
  case [Maybe (NextArg Demangled)] -> Maybe (NextArg Demangled)
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum ((((Text,
  ((),
   (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
 -> Maybe (NextArg Demangled))
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
forall a b. (a -> b) -> a -> b
$ (Text,
 ((),
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
seed) (((Text,
   ((),
    (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
  -> Maybe (NextArg Demangled))
 -> Maybe (NextArg Demangled))
-> [(Text,
     ((),
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
    -> Maybe (NextArg Demangled)]
-> [Maybe (NextArg Demangled)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [ (Text,
 ((),
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
mangled, (Text,
 ((),
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
AnyNext Demangled
plain ]) of
                 Just NextArg Demangled
r -> (NextArg Demangled
r NextArg Demangled
-> Getting Demangled (NextArg Demangled) Demangled -> Demangled
forall s a. s -> Getting a s a -> a
^. Getting Demangled (NextArg Demangled) Demangled
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal, NextArg Demangled
r NextArg Demangled
-> Getting Context (NextArg Demangled) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg Demangled) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext)
                 Maybe (NextArg Demangled)
_ -> let (Int
i,Context
c') = Text -> Context -> (Int, Context)
contextFindOrAdd Text
s Context
c
                      in (Int -> Demangled
Original Int
i, Context
c')


--------------------
-- Mangled name parsing of various elements

mangled :: Next () Demangled
mangled :: (Text,
 ((),
  (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
mangled = Text -> Next () ()
forall a. Text -> Next a a
match Text
"_Z" Next () ()
-> ((Text,
     ((),
      (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
    -> Maybe (NextArg Demangled))
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next () Encoding
AnyNext Encoding
encoding Next () Encoding
-> (NextArg Encoding -> Maybe (NextArg Demangled))
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
-> Maybe (NextArg Demangled)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
          [NextArg Encoding -> Maybe (NextArg Demangled)]
-> NextArg Encoding -> Maybe (NextArg Demangled)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next Encoding Encoding
forall a. Text -> Next a a
match Text
"." Next Encoding Encoding
-> (NextArg Encoding -> Maybe (NextArg Demangled))
-> NextArg Encoding
-> Maybe (NextArg Demangled)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg Encoding -> Maybe (NextArg Demangled)
vendorExtension (NextArg Encoding -> Maybe (NextArg Demangled))
-> (NextArg Demangled -> Maybe (NextArg Demangled))
-> NextArg Encoding
-> Maybe (NextArg Demangled)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg Demangled -> Maybe (NextArg Demangled)
forall a. Next a a
end_of_input
                , Next Encoding Encoding
forall a. Next a a
end_of_input Next Encoding Encoding
-> (NextArg Encoding -> Maybe (NextArg Demangled))
-> NextArg Encoding
-> Maybe (NextArg Demangled)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Encoding -> Demangled)
-> NextArg Encoding -> Maybe (NextArg Demangled)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Encoding -> Demangled
Encoded
                ]

vendorExtension :: Next Encoding Demangled
vendorExtension :: NextArg Encoding -> Maybe (NextArg Demangled)
vendorExtension NextArg Encoding
x =
  let (Int
i, Context
c') = Text -> Context -> (Int, Context)
contextFindOrAdd (NextArg Encoding
x NextArg Encoding -> Getting Text (NextArg Encoding) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg Encoding) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp) (NextArg Encoding
x NextArg Encoding
-> Getting Context (NextArg Encoding) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg Encoding) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext)
  in NextArg Demangled -> Maybe (NextArg Demangled)
forall a. a -> Maybe a
Just (NextArg Demangled -> Maybe (NextArg Demangled))
-> NextArg Demangled -> Maybe (NextArg Demangled)
forall a b. (a -> b) -> a -> b
$ NextArg Encoding
x
     NextArg Encoding
-> (NextArg Encoding -> NextArg Encoding) -> NextArg Encoding
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text)
-> NextArg Encoding -> Identity (NextArg Encoding)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text)
 -> NextArg Encoding -> Identity (NextArg Encoding))
-> Text -> NextArg Encoding -> NextArg Encoding
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
""
     NextArg Encoding
-> (NextArg Encoding -> NextArg Demangled) -> NextArg Demangled
forall a b. a -> (a -> b) -> b
& (Encoding -> Identity Demangled)
-> NextArg Encoding -> Identity (NextArg Demangled)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((Encoding -> Identity Demangled)
 -> NextArg Encoding -> Identity (NextArg Demangled))
-> Demangled -> NextArg Encoding -> NextArg Demangled
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Encoding -> Int -> Demangled
VendorExtended (NextArg Encoding
x NextArg Encoding
-> Getting Encoding (NextArg Encoding) Encoding -> Encoding
forall s a. s -> Getting a s a -> a
^. Getting Encoding (NextArg Encoding) Encoding
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) Int
i
     NextArg Demangled
-> (NextArg Demangled -> NextArg Demangled) -> NextArg Demangled
forall a b. a -> (a -> b) -> b
& (Context -> Identity Context)
-> NextArg Demangled -> Identity (NextArg Demangled)
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext ((Context -> Identity Context)
 -> NextArg Demangled -> Identity (NextArg Demangled))
-> Context -> NextArg Demangled -> NextArg Demangled
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Context
c'

plain :: AnyNext Demangled
plain :: AnyNext Demangled
plain NextArg a
x =
  let (Int
o, Context
c') = Text -> Context -> (Int, Context)
contextFindOrAdd (NextArg a
x NextArg a -> Getting Text (NextArg a) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg a) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp) (NextArg a
x NextArg a -> Getting Context (NextArg a) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg a) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext)
  in NextArg Demangled -> Maybe (NextArg Demangled)
forall a. a -> Maybe a
Just (NextArg Demangled -> Maybe (NextArg Demangled))
-> NextArg Demangled -> Maybe (NextArg Demangled)
forall a b. (a -> b) -> a -> b
$ NextArg a
x
     NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg a -> Identity (NextArg a))
-> Text -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
""
     NextArg a -> (NextArg a -> NextArg Demangled) -> NextArg Demangled
forall a b. a -> (a -> b) -> b
& (a -> Identity Demangled)
-> NextArg a -> Identity (NextArg Demangled)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((a -> Identity Demangled)
 -> NextArg a -> Identity (NextArg Demangled))
-> Demangled -> NextArg a -> NextArg Demangled
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Int -> Demangled
Original Int
o
     NextArg Demangled
-> (NextArg Demangled -> NextArg Demangled) -> NextArg Demangled
forall a b. a -> (a -> b) -> b
& (Context -> Identity Context)
-> NextArg Demangled -> Identity (NextArg Demangled)
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext ((Context -> Identity Context)
 -> NextArg Demangled -> Identity (NextArg Demangled))
-> Context -> NextArg Demangled -> NextArg Demangled
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Context
c'

encoding :: AnyNext Encoding
encoding :: AnyNext Encoding
encoding =
  [NextArg a -> Maybe (NextArg Encoding)]
-> NextArg a -> Maybe (NextArg Encoding)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a FunctionName
AnyNext FunctionName
function_name Next a FunctionName
-> (NextArg FunctionName -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Bool -> NextArg FunctionName -> Maybe (NextArg Encoding)
bare_function_type Bool
False
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"L" Next a a
-> (NextArg a -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a FunctionName
AnyNext FunctionName
function_name Next a FunctionName
-> (NextArg FunctionName -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Bool -> NextArg FunctionName -> Maybe (NextArg Encoding)
bare_function_type Bool
True
        , NextArg a -> Maybe (NextArg Encoding)
AnyNext Encoding
data_name
        , NextArg a -> Maybe (NextArg Encoding)
AnyNext Encoding
const_struct_data
        , NextArg a -> Maybe (NextArg Encoding)
AnyNext Encoding
special_name
       ]

function_name :: AnyNext FunctionName
function_name :: AnyNext FunctionName
function_name = (Name -> FunctionName)
-> NextArg Name -> Maybe (NextArg FunctionName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> FunctionName
FunctionName (NextArg Name -> Maybe (NextArg FunctionName))
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg FunctionName)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg Name)
AnyNext Name
name

data_name :: AnyNext Encoding
data_name :: AnyNext Encoding
data_name = Next a Name
AnyNext Name
name Next a Name
-> (NextArg Name -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Name -> Encoding) -> NextArg Name -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> Encoding
EncData

const_struct_data :: AnyNext Encoding
const_struct_data :: AnyNext Encoding
const_struct_data = Text -> Next a a
forall a. Text -> Next a a
match Text
"L" Next a a
-> (NextArg a -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a UnqualifiedName
AnyNext UnqualifiedName
unqualified_name Next a UnqualifiedName
-> (NextArg UnqualifiedName -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnqualifiedName -> Encoding)
-> NextArg UnqualifiedName -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnqualifiedName -> Encoding
EncConstStructData

special_name :: AnyNext Encoding
special_name :: AnyNext Encoding
special_name =
  Text -> Next a a
forall a. Text -> Next a a
match Text
"T"
  Next a a
-> (NextArg a -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg a -> Maybe (NextArg SpecialName)]
-> NextArg a -> Maybe (NextArg SpecialName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"A" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a TemplateArg
AnyNext TemplateArg
template_arg Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplateArg -> SpecialName)
-> NextArg TemplateArg -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap TemplateArg -> SpecialName
TemplateParameterObj
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"V" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> SpecialName)
-> NextArg Type_ -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> SpecialName
VirtualTable
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"T" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> SpecialName)
-> NextArg Type_ -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> SpecialName
VTT
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"I" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> SpecialName)
-> NextArg Type_ -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> SpecialName
TypeInfo
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"S" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> SpecialName)
-> NextArg Type_ -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> SpecialName
TypeInfoName
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"c" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> NextArg a -> Maybe (NextArg SpecialName)
forall a b. String -> Next a b
tbd String
"covariant return thunk to"
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"C" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> NextArg a -> Maybe (NextArg SpecialName)
forall a b. String -> Next a b
tbd String
"ctor vtable special name"
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"W" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> NextArg a -> Maybe (NextArg SpecialName)
forall a b. String -> Next a b
tbd String
"thread-local wrapper routine for"
            , Text -> Next a a
forall a. Text -> Next a a
match Text
"H" Next a a
-> (NextArg a -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> NextArg a -> Maybe (NextArg SpecialName)
forall a b. String -> Next a b
tbd String
"thread-local initialization routine for"
            , Next a CallOffset
AnyNext CallOffset
call_offset Next a CallOffset
-> Next CallOffset Encoding -> Next a (CallOffset, Encoding)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next CallOffset Encoding
AnyNext Encoding
encoding Next a (CallOffset, Encoding)
-> (NextArg (CallOffset, Encoding) -> Maybe (NextArg SpecialName))
-> NextArg a
-> Maybe (NextArg SpecialName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((CallOffset, Encoding) -> SpecialName)
-> NextArg (CallOffset, Encoding) -> Maybe (NextArg SpecialName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((CallOffset -> Encoding -> SpecialName)
-> (CallOffset, Encoding) -> SpecialName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry CallOffset -> Encoding -> SpecialName
Thunk)
            ]
  (NextArg a -> Maybe (NextArg SpecialName))
-> (NextArg SpecialName -> Maybe (NextArg Encoding))
-> NextArg a
-> Maybe (NextArg Encoding)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SpecialName -> Encoding)
-> NextArg SpecialName -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap SpecialName -> Encoding
EncSpecial

call_offset :: AnyNext CallOffset
call_offset :: AnyNext CallOffset
call_offset = [NextArg a -> Maybe (NextArg CallOffset)]
-> NextArg a -> Maybe (NextArg CallOffset)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"h" Next a a
-> (NextArg a -> Maybe (NextArg CallOffset))
-> NextArg a
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
int_number Next a Int
-> (NextArg Int -> Maybe (NextArg CallOffset))
-> NextArg a
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Int Int
forall a. Text -> Next a a
match Text
"_"
                      Next Int Int
-> (NextArg Int -> Maybe (NextArg CallOffset))
-> NextArg Int
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> CallOffset) -> NextArg Int -> Maybe (NextArg CallOffset)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Int -> CallOffset
NonVirtualOffset
                    , Text -> Next a a
forall a. Text -> Next a a
match Text
"v" Next a a
-> (NextArg a -> Maybe (NextArg CallOffset))
-> NextArg a
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
int_number Next a Int
-> (NextArg Int -> Maybe (NextArg CallOffset))
-> NextArg a
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Int Int
forall a. Text -> Next a a
match Text
"_" Next Int Int -> Next Int Int -> Next Int (Int, Int)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Int Int
AnyNext Int
digits_num
                      Next Int (Int, Int)
-> (NextArg (Int, Int) -> Maybe (NextArg CallOffset))
-> NextArg Int
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (Int, Int) (Int, Int)
forall a. Text -> Next a a
match Text
"_"
                      Next (Int, Int) (Int, Int)
-> (NextArg (Int, Int) -> Maybe (NextArg CallOffset))
-> NextArg (Int, Int)
-> Maybe (NextArg CallOffset)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Int, Int) -> CallOffset)
-> NextArg (Int, Int) -> Maybe (NextArg CallOffset)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Int -> Int -> CallOffset) -> (Int, Int) -> CallOffset
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Int -> Int -> CallOffset
VirtualOffset)
                    ]


int_number :: AnyNext Int
int_number :: AnyNext Int
int_number = [NextArg a -> Maybe (NextArg Int)]
-> NextArg a -> Maybe (NextArg Int)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"n" Next a a
-> (NextArg a -> Maybe (NextArg Int))
-> NextArg a
-> Maybe (NextArg Int)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Int)
AnyNext Int
digits_num (NextArg a -> Maybe (NextArg Int))
-> Next Int Int -> NextArg a -> Maybe (NextArg Int)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> Int) -> Next Int Int
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ( (-Int
1) Int -> Int -> Int
forall a. Num a => a -> a -> a
* )
                   , NextArg a -> Maybe (NextArg Int)
AnyNext Int
digits_num
                   ]

name :: AnyNext Name
name :: AnyNext Name
name = [NextArg a -> Maybe (NextArg Name)]
-> NextArg a -> Maybe (NextArg Name)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a NestedName
AnyNext NestedName
nested_name Next a NestedName
-> (NextArg NestedName -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NestedName -> Name) -> NextArg NestedName -> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap NestedName -> Name
NameNested
             , NextArg a -> Maybe (NextArg Name)
AnyNext Name
unscoped_template_name (NextArg a -> Maybe (NextArg Name))
-> Next Name TemplateArgs -> Next a (Name, TemplateArgs)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Name TemplateArgs
AnyNext TemplateArgs
template_args
               Next a (Name, TemplateArgs)
-> (NextArg (Name, TemplateArgs) -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Name, TemplateArgs) -> Name)
-> NextArg (Name, TemplateArgs) -> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Name -> TemplateArgs -> Name) -> (Name, TemplateArgs) -> Name
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Name -> TemplateArgs -> Name
UnscopedTemplateName)
             , NextArg a -> Maybe (NextArg Name)
AnyNext Name
local_name
             , Next a UnscopedName
AnyNext UnscopedName
unscoped_name Next a UnscopedName
-> (NextArg UnscopedName -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnscopedName -> Name)
-> NextArg UnscopedName -> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnscopedName -> Name
UnscopedName
             ]

nested_name :: AnyNext NestedName
nested_name :: AnyNext NestedName
nested_name = Text -> Next a a
forall a. Text -> Next a a
match Text
"N"
              Next a a
-> (NextArg a -> Maybe (NextArg NestedName))
-> NextArg a
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a [CVQualifier]
AnyNext [CVQualifier]
cv_qualifiers
              Next a [CVQualifier]
-> (NextArg [CVQualifier] -> Maybe (NextArg NestedName))
-> NextArg a
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next [CVQualifier] RefQualifier
-> Next [CVQualifier] ([CVQualifier], Maybe RefQualifier)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next [CVQualifier] RefQualifier
AnyNext RefQualifier
ref_qualifier
              -- here: (Maybe [CVQualifier], Maybe RefQualifier)
              Next [CVQualifier] ([CVQualifier], Maybe RefQualifier)
-> (NextArg ([CVQualifier], Maybe RefQualifier)
    -> Maybe (NextArg NestedName))
-> NextArg [CVQualifier]
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg ([CVQualifier], Maybe RefQualifier)
 -> Maybe (NextArg NestedName)]
-> NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
form1 (NextArg ([CVQualifier], Maybe RefQualifier)
 -> Maybe (NextArg NestedName))
-> (NextArg NestedName -> Maybe (NextArg NestedName))
-> NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg NestedName -> Maybe (NextArg NestedName)
forall a. Text -> Next a a
match Text
"E"
                        , NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
form2 (NextArg ([CVQualifier], Maybe RefQualifier)
 -> Maybe (NextArg NestedName))
-> (NextArg NestedName -> Maybe (NextArg NestedName))
-> NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg NestedName -> Maybe (NextArg NestedName)
forall a. Text -> Next a a
match Text
"E"
                        ]
              (NextArg ([CVQualifier], Maybe RefQualifier)
 -> Maybe (NextArg NestedName))
-> (NextArg NestedName -> Maybe (NextArg NestedName))
-> NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg NestedName -> Maybe (NextArg NestedName)
forall a. Next a a
dropLastSubst
  where form1 :: NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
form1 NextArg ([CVQualifier], Maybe RefQualifier)
i = do NextArg Prefix
p <- Next ([CVQualifier], Maybe RefQualifier) Prefix
AnyNext Prefix
prefix NextArg ([CVQualifier], Maybe RefQualifier)
i
                     -- Parse ambiguity here:
                     --
                     --   nested-name ::= N ... <prefix> <unqualified-name> E
                     --   prefix ::= <unqualified-name>
                     --            | <prefix> <unqualified-name>
                     --            | ... others ...
                     --
                     -- Thus, in order to match here, <prefix> *must* have ended
                     -- in an <unqualified-name> match, and that match should be
                     -- removed from the prefix 'p' and used as the final
                     -- <nested-name> element.
                     (Prefix
rmnpfx, Either UnqualifiedName TemplateArgs
ent) <- Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast (Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs))
-> Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
forall a b. (a -> b) -> a -> b
$ NextArg Prefix
p NextArg Prefix -> Getting Prefix (NextArg Prefix) Prefix -> Prefix
forall s a. s -> Getting a s a -> a
^. Getting Prefix (NextArg Prefix) Prefix
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     case Either UnqualifiedName TemplateArgs
ent of
                       Right TemplateArgs
_ -> Maybe (NextArg NestedName)
forall a. Maybe a
Nothing
                       Left UnqualifiedName
uq ->
                         case Prefix
rmnpfx of
                           Prefix
EmptyPrefix -> Maybe (NextArg NestedName)
forall a. Maybe a
Nothing
                           Prefix
pfx -> let ([CVQualifier]
cvq, Maybe RefQualifier
mb'refQual) = NextArg ([CVQualifier], Maybe RefQualifier)
i NextArg ([CVQualifier], Maybe RefQualifier)
-> Getting
     ([CVQualifier], Maybe RefQualifier)
     (NextArg ([CVQualifier], Maybe RefQualifier))
     ([CVQualifier], Maybe RefQualifier)
-> ([CVQualifier], Maybe RefQualifier)
forall s a. s -> Getting a s a -> a
^. Getting
  ([CVQualifier], Maybe RefQualifier)
  (NextArg ([CVQualifier], Maybe RefQualifier))
  ([CVQualifier], Maybe RefQualifier)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                                  in NextArg Prefix -> NestedName -> Maybe (NextArg NestedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg Prefix
p (Prefix
-> UnqualifiedName
-> [CVQualifier]
-> Maybe RefQualifier
-> NestedName
NestedName Prefix
pfx UnqualifiedName
uq [CVQualifier]
cvq Maybe RefQualifier
mb'refQual)
        form2 :: NextArg ([CVQualifier], Maybe RefQualifier)
-> Maybe (NextArg NestedName)
form2 NextArg ([CVQualifier], Maybe RefQualifier)
i = do NextArg (TemplatePrefix, Maybe TemplateArgs)
pa <- Next
  ([CVQualifier], Maybe RefQualifier)
  (TemplatePrefix, Maybe TemplateArgs)
AnyNext (TemplatePrefix, Maybe TemplateArgs)
template_prefix_and_args NextArg ([CVQualifier], Maybe RefQualifier)
i
                     let (TemplatePrefix
p,Maybe TemplateArgs
mba) = NextArg (TemplatePrefix, Maybe TemplateArgs)
pa NextArg (TemplatePrefix, Maybe TemplateArgs)
-> Getting
     (TemplatePrefix, Maybe TemplateArgs)
     (NextArg (TemplatePrefix, Maybe TemplateArgs))
     (TemplatePrefix, Maybe TemplateArgs)
-> (TemplatePrefix, Maybe TemplateArgs)
forall s a. s -> Getting a s a -> a
^. Getting
  (TemplatePrefix, Maybe TemplateArgs)
  (NextArg (TemplatePrefix, Maybe TemplateArgs))
  (TemplatePrefix, Maybe TemplateArgs)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     TemplateArgs
a <- Maybe TemplateArgs
mba
                     let ([CVQualifier]
cvq, Maybe RefQualifier
mb'refQual) = NextArg ([CVQualifier], Maybe RefQualifier)
i NextArg ([CVQualifier], Maybe RefQualifier)
-> Getting
     ([CVQualifier], Maybe RefQualifier)
     (NextArg ([CVQualifier], Maybe RefQualifier))
     ([CVQualifier], Maybe RefQualifier)
-> ([CVQualifier], Maybe RefQualifier)
forall s a. s -> Getting a s a -> a
^. Getting
  ([CVQualifier], Maybe RefQualifier)
  (NextArg ([CVQualifier], Maybe RefQualifier))
  ([CVQualifier], Maybe RefQualifier)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     NextArg (TemplatePrefix, Maybe TemplateArgs)
-> NestedName -> Maybe (NextArg NestedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg (TemplatePrefix, Maybe TemplateArgs)
pa (NestedName -> Maybe (NextArg NestedName))
-> NestedName -> Maybe (NextArg NestedName)
forall a b. (a -> b) -> a -> b
$ TemplatePrefix
-> TemplateArgs
-> [CVQualifier]
-> Maybe RefQualifier
-> NestedName
NestedTemplateName TemplatePrefix
p TemplateArgs
a [CVQualifier]
cvq Maybe RefQualifier
mb'refQual

unscoped_name :: AnyNext UnscopedName
unscoped_name :: AnyNext UnscopedName
unscoped_name =
  [NextArg a -> Maybe (NextArg UnscopedName)]
-> NextArg a -> Maybe (NextArg UnscopedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a UnqualifiedName
AnyNext UnqualifiedName
unqualified_name Next a UnqualifiedName
-> (NextArg UnqualifiedName -> Maybe (NextArg UnscopedName))
-> NextArg a
-> Maybe (NextArg UnscopedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnqualifiedName -> UnscopedName)
-> NextArg UnqualifiedName -> Maybe (NextArg UnscopedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> UnqualifiedName -> UnscopedName
UnScName Bool
False)
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"St" Next a a
-> (NextArg a -> Maybe (NextArg UnscopedName))
-> NextArg a
-> Maybe (NextArg UnscopedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a UnqualifiedName
AnyNext UnqualifiedName
unqualified_name Next a UnqualifiedName
-> (NextArg UnqualifiedName -> Maybe (NextArg UnscopedName))
-> NextArg a
-> Maybe (NextArg UnscopedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnqualifiedName -> UnscopedName)
-> NextArg UnqualifiedName -> Maybe (NextArg UnscopedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> UnqualifiedName -> UnscopedName
UnScName Bool
True)
        ]

unscoped_template_name :: AnyNext Name
unscoped_template_name :: AnyNext Name
unscoped_template_name NextArg a
i =
  (Next a UnscopedName
AnyNext UnscopedName
unscoped_name NextArg a
i Maybe (NextArg UnscopedName)
-> (NextArg UnscopedName -> Maybe (NextArg Name))
-> Maybe (NextArg Name)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (UnscopedName -> Name)
-> NextArg UnscopedName -> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnscopedName -> Name
UnscopedName Maybe (NextArg Name)
-> (NextArg Name -> Maybe (NextArg Name)) -> Maybe (NextArg Name)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg Name -> Maybe (NextArg Name)
canSubstUnscopedTemplateName)
  Maybe (NextArg Name)
-> Maybe (NextArg Name) -> Maybe (NextArg Name)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Next a Substitution'
AnyNext Substitution'
substitution NextArg a
i Maybe (NextArg Substitution')
-> (NextArg Substitution' -> Maybe (NextArg Name))
-> Maybe (NextArg Name)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ((UnscopedName -> Name)
-> NextArg UnscopedName -> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnscopedName -> Name
UnscopedName (NextArg UnscopedName -> Maybe (NextArg Name))
-> (NextArg Substitution' -> Maybe (NextArg UnscopedName))
-> NextArg Substitution'
-> Maybe (NextArg Name)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< Next Substitution UnscopedName
-> NextArg Substitution' -> Maybe (NextArg UnscopedName)
substituteUnscopedName ((Substitution -> UnscopedName) -> Next Substitution UnscopedName
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Substitution -> UnscopedName
UnScSubst))
      )


local_name :: AnyNext Name
local_name :: AnyNext Name
local_name = Text -> Next a a
forall a. Text -> Next a a
match Text
"Z"
             Next a a
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Encoding
AnyNext Encoding
function_encoding
             Next a Encoding
-> (NextArg Encoding -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Encoding Encoding
forall a. Text -> Next a a
match Text
"E"
             Next Encoding Encoding
-> (NextArg Encoding -> Maybe (NextArg Name))
-> NextArg Encoding
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg Encoding -> Maybe (NextArg Name)]
-> NextArg Encoding -> Maybe (NextArg Name)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next Encoding Encoding
forall a. Text -> Next a a
match Text
"s" Next Encoding Encoding
-> (NextArg Encoding -> Maybe (NextArg Name))
-> NextArg Encoding
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Encoding -> Maybe Discriminator -> Name)
-> NextArg Encoding
-> Maybe (NextArg (Maybe Discriminator -> Name))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Encoding -> Maybe Discriminator -> Name
StringLitName
                         (NextArg Encoding -> Maybe (NextArg (Maybe Discriminator -> Name)))
-> (NextArg (Maybe Discriminator -> Name) -> Maybe (NextArg Name))
-> NextArg Encoding
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next (Maybe Discriminator -> Name) Discriminator
-> Next
     (Maybe Discriminator -> Name)
     (Maybe Discriminator -> Name, Maybe Discriminator)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next (Maybe Discriminator -> Name) Discriminator
forall a. Next a Discriminator
discriminator Next
  (Maybe Discriminator -> Name)
  (Maybe Discriminator -> Name, Maybe Discriminator)
-> (NextArg (Maybe Discriminator -> Name, Maybe Discriminator)
    -> Maybe (NextArg Name))
-> NextArg (Maybe Discriminator -> Name)
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Maybe Discriminator -> Name, Maybe Discriminator)
-> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                       , (Encoding -> Name -> Maybe Discriminator -> Name)
-> NextArg Encoding
-> Maybe (NextArg (Name -> Maybe Discriminator -> Name))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Encoding -> Name -> Maybe Discriminator -> Name
LocalName (NextArg Encoding
 -> Maybe (NextArg (Name -> Maybe Discriminator -> Name)))
-> Next (Name -> Maybe Discriminator -> Name) Name
-> Next Encoding (Name -> Maybe Discriminator -> Name, Name)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Name -> Maybe Discriminator -> Name) Name
AnyNext Name
name Next Encoding (Name -> Maybe Discriminator -> Name, Name)
-> (NextArg (Name -> Maybe Discriminator -> Name, Name)
    -> Maybe (NextArg Name))
-> NextArg Encoding
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Name -> Maybe Discriminator -> Name, Name)
-> Maybe (NextArg (Maybe Discriminator -> Name))
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                         (NextArg (Name -> Maybe Discriminator -> Name, Name)
 -> Maybe (NextArg (Maybe Discriminator -> Name)))
-> (NextArg (Maybe Discriminator -> Name) -> Maybe (NextArg Name))
-> NextArg (Name -> Maybe Discriminator -> Name, Name)
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next (Maybe Discriminator -> Name) Discriminator
-> Next
     (Maybe Discriminator -> Name)
     (Maybe Discriminator -> Name, Maybe Discriminator)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next (Maybe Discriminator -> Name) Discriminator
forall a. Next a Discriminator
discriminator Next
  (Maybe Discriminator -> Name)
  (Maybe Discriminator -> Name, Maybe Discriminator)
-> (NextArg (Maybe Discriminator -> Name, Maybe Discriminator)
    -> Maybe (NextArg Name))
-> NextArg (Maybe Discriminator -> Name)
-> Maybe (NextArg Name)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Maybe Discriminator -> Name, Maybe Discriminator)
-> Maybe (NextArg Name)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                       ]


-- | Parse any CV qualifiers; always succeeds but might return an empty array.
-- Also note that while it is an array, each entry can appear at most once.
cv_qualifiers :: AnyNext [CVQualifier]
cv_qualifiers :: AnyNext [CVQualifier]
cv_qualifiers =
  let ifPresent :: a -> NextArg ([a], Maybe a) -> f (NextArg [a])
ifPresent a
v NextArg ([a], Maybe a)
i = (([a], Maybe a) -> [a])
-> NextArg ([a], Maybe a) -> f (NextArg [a])
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (\([a]
a,Maybe a
p) -> if Maybe a -> Bool
forall a. Maybe a -> Bool
isJust Maybe a
p then a
va -> [a] -> [a]
forall a. a -> [a] -> [a]
:[a]
a else [a]
a) NextArg ([a], Maybe a)
i
  in [CVQualifier] -> Next a [CVQualifier]
forall b a. b -> Next a b
insert []
     Next a [CVQualifier]
-> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> Next a [CVQualifier]
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier])
forall a. Text -> Next a a
match Text
"r") Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
-> (NextArg ([CVQualifier], Maybe [CVQualifier])
    -> Maybe (NextArg [CVQualifier]))
-> NextArg [CVQualifier]
-> Maybe (NextArg [CVQualifier])
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CVQualifier
-> NextArg ([CVQualifier], Maybe [CVQualifier])
-> Maybe (NextArg [CVQualifier])
forall {f :: * -> *} {a} {a}.
Applicative f =>
a -> NextArg ([a], Maybe a) -> f (NextArg [a])
ifPresent CVQualifier
Restrict
     (NextArg ([CVQualifier], Maybe [CVQualifier])
 -> Maybe (NextArg [CVQualifier]))
-> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> NextArg ([CVQualifier], Maybe [CVQualifier])
-> Maybe (NextArg [CVQualifier])
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier])
forall a. Text -> Next a a
match Text
"V") Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
-> (NextArg ([CVQualifier], Maybe [CVQualifier])
    -> Maybe (NextArg [CVQualifier]))
-> NextArg [CVQualifier]
-> Maybe (NextArg [CVQualifier])
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CVQualifier
-> NextArg ([CVQualifier], Maybe [CVQualifier])
-> Maybe (NextArg [CVQualifier])
forall {f :: * -> *} {a} {a}.
Applicative f =>
a -> NextArg ([a], Maybe a) -> f (NextArg [a])
ifPresent CVQualifier
Volatile
     (NextArg ([CVQualifier], Maybe [CVQualifier])
 -> Maybe (NextArg [CVQualifier]))
-> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> NextArg ([CVQualifier], Maybe [CVQualifier])
-> Maybe (NextArg [CVQualifier])
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier]))
-> Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> NextArg [CVQualifier] -> Maybe (NextArg [CVQualifier])
forall a. Text -> Next a a
match Text
"K") Next [CVQualifier] ([CVQualifier], Maybe [CVQualifier])
-> (NextArg ([CVQualifier], Maybe [CVQualifier])
    -> Maybe (NextArg [CVQualifier]))
-> NextArg [CVQualifier]
-> Maybe (NextArg [CVQualifier])
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CVQualifier
-> NextArg ([CVQualifier], Maybe [CVQualifier])
-> Maybe (NextArg [CVQualifier])
forall {f :: * -> *} {a} {a}.
Applicative f =>
a -> NextArg ([a], Maybe a) -> f (NextArg [a])
ifPresent CVQualifier
Const_

ref_qualifier :: AnyNext RefQualifier
ref_qualifier :: AnyNext RefQualifier
ref_qualifier = [NextArg a -> Maybe (NextArg RefQualifier)]
-> NextArg a -> Maybe (NextArg RefQualifier)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"O" Next a a
-> (NextArg a -> Maybe (NextArg RefQualifier))
-> NextArg a
-> Maybe (NextArg RefQualifier)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> RefQualifier) -> NextArg a -> Maybe (NextArg RefQualifier)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (RefQualifier -> a -> RefQualifier
forall a b. a -> b -> a
const RefQualifier
RefRef)
                      , Text -> Next a a
forall a. Text -> Next a a
match Text
"R" Next a a
-> (NextArg a -> Maybe (NextArg RefQualifier))
-> NextArg a
-> Maybe (NextArg RefQualifier)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> RefQualifier) -> NextArg a -> Maybe (NextArg RefQualifier)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (RefQualifier -> a -> RefQualifier
forall a b. a -> b -> a
const RefQualifier
Ref)
                      ]

-- | Parse prefix.  This is a bit tricky though.  The BNF specifies:
--
--     prefix ::= <unqualified-name>
--            | <prefix> <unqualified-name>
--            | ... others ...
--            | substitution
--
-- but it cannot be expressed directly that way (it would either stop at the
-- *first* unqualified name, or if the first two were reverse, <prefix> would be
-- infinitely recursive because it would recurse without consuming input.  Note
-- however that a recursive prefix *always* terminates with an
-- <unqualified_name>, and can only recurse on that terminator, so once an
-- <unqualified_name> is parsed, the only remaining possibility is *one* more
-- <unqualified_name> entries.
--
-- In addition, the BNF is incorrect, both from the itanium-abi website, and also
-- in the LLVM code comments, which is slightly different, but still incorrect.
-- The BNF for a prefix indicates recursion can only happen before an unqualified
-- name, which precludes matching something like NS_6vectorIfE3fooE
-- ("matrix::Vector<float>::foo").  The LLVM code itself indicates that the
-- prefix is generally recursive, although a template_param, a decltype, or a
-- substitution may not be preceded by anything else, and template_args cannot be
-- immediately adjacent and must not be the starting element.

prefix :: AnyNext Prefix
prefix :: AnyNext Prefix
prefix NextArg a
i = (Next a Prefix
AnyNext Prefix
prefix'i NextArg a
i)
            Maybe (NextArg Prefix)
-> Maybe (NextArg Prefix) -> Maybe (NextArg Prefix)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Next a Substitution'
AnyNext Substitution'
substitution NextArg a
i
                 Maybe (NextArg Substitution')
-> (NextArg Substitution' -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next Substitution Prefix
-> NextArg Substitution' -> Maybe (NextArg Prefix)
substitutePrefix Next Substitution Prefix
substitutionPrefix
                 Maybe (NextArg Prefix)
-> (NextArg Prefix -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= [NextArg Prefix -> Maybe (NextArg Prefix)]
-> NextArg Prefix -> Maybe (NextArg Prefix)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ (Prefix -> PrefixR -> Prefix)
-> NextArg Prefix -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Prefix -> PrefixR -> Prefix
extendPrefix (NextArg Prefix -> Maybe (NextArg (PrefixR -> Prefix)))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> NextArg Prefix
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
                           , NextArg Prefix -> Maybe (NextArg Prefix)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                           ]
                )
  where
    prefix'i :: AnyNext Prefix
    prefix'i :: AnyNext Prefix
prefix'i =
      [NextArg a -> Maybe (NextArg Prefix)]
-> NextArg a -> Maybe (NextArg Prefix)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a TemplateArg
AnyNext TemplateArg
template_param
              Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg Prefix))
-> NextArg a
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplateArg -> PrefixR -> Prefix)
-> NextArg TemplateArg -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap TemplateArg -> PrefixR -> Prefix
PrefixTemplateParam
              (NextArg TemplateArg -> Maybe (NextArg (PrefixR -> Prefix)))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> NextArg TemplateArg
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
              (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> (NextArg Prefix -> Maybe (NextArg Prefix))
-> NextArg (PrefixR -> Prefix)
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg Prefix -> Maybe (NextArg Prefix)
canSubstPrefix
            , Next a DeclType
AnyNext DeclType
decltype
              Next a DeclType
-> (NextArg DeclType -> Maybe (NextArg Prefix))
-> NextArg a
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (DeclType -> PrefixR -> Prefix)
-> NextArg DeclType -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap DeclType -> PrefixR -> Prefix
PrefixDeclType
              (NextArg DeclType -> Maybe (NextArg (PrefixR -> Prefix)))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> NextArg DeclType
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
              (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> (NextArg Prefix -> Maybe (NextArg Prefix))
-> NextArg (PrefixR -> Prefix)
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg Prefix -> Maybe (NextArg Prefix)
canSubstPrefix
            , (PrefixR -> Prefix)
-> NextArg a -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' PrefixR -> Prefix
Prefix (NextArg a -> Maybe (NextArg (PrefixR -> Prefix)))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> NextArg a
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
              (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> (NextArg Prefix -> Maybe (NextArg Prefix))
-> NextArg (PrefixR -> Prefix)
-> Maybe (NextArg Prefix)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \NextArg Prefix
p2 -> case NextArg Prefix
p2 NextArg Prefix -> Getting Prefix (NextArg Prefix) Prefix -> Prefix
forall s a. s -> Getting a s a -> a
^. Getting Prefix (NextArg Prefix) Prefix
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal of
                           Prefix
EmptyPrefix -> Maybe (NextArg Prefix)
forall a. Maybe a
Nothing
                           Prefix
_ -> NextArg Prefix -> Maybe (NextArg Prefix)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NextArg Prefix
p2
            ]
    prefix'r2 :: Next (PrefixR -> Prefix) Prefix
    prefix'r2 :: NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2 NextArg (PrefixR -> Prefix)
accum =
      [Maybe (NextArg Prefix)] -> Maybe (NextArg Prefix)
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ -- Note that two sets of template_args will not occur
             -- back-to-back... at least for C/C++.  There are two dispositions
             -- that could be taken here:
             --
             -- 1. Ignore it if it happens (we didn't generate the mangled form)
             -- 2. Treat it as a demangling parse error.
             --
             -- The following require statements implements disposition 2;
             -- removing it would switch to disposition 1.
             Bool -> Maybe ()
require (Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Prefix -> Bool
last_is_template_args (NextArg (PrefixR -> Prefix)
accum NextArg (PrefixR -> Prefix)
-> Getting
     (PrefixR -> Prefix)
     (NextArg (PrefixR -> Prefix))
     (PrefixR -> Prefix)
-> PrefixR
-> Prefix
forall s a. s -> Getting a s a -> a
^. Getting
  (PrefixR -> Prefix)
  (NextArg (PrefixR -> Prefix))
  (PrefixR -> Prefix)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ PrefixR
PrefixEnd))
             Maybe ()
-> Maybe (NextArg TemplateArgs) -> Maybe (NextArg TemplateArgs)
forall a b. Maybe a -> Maybe b -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Next (PrefixR -> Prefix) TemplateArgs
AnyNext TemplateArgs
template_args NextArg (PrefixR -> Prefix)
accum
             Maybe (NextArg TemplateArgs)
-> (NextArg TemplateArgs -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (TemplateArgs -> PrefixR -> Prefix)
-> NextArg TemplateArgs -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (\TemplateArgs
ta PrefixR
sp -> NextArg (PrefixR -> Prefix)
accum NextArg (PrefixR -> Prefix)
-> Getting
     (PrefixR -> Prefix)
     (NextArg (PrefixR -> Prefix))
     (PrefixR -> Prefix)
-> PrefixR
-> Prefix
forall s a. s -> Getting a s a -> a
^. Getting
  (PrefixR -> Prefix)
  (NextArg (PrefixR -> Prefix))
  (PrefixR -> Prefix)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ TemplateArgs -> PrefixR -> PrefixR
PrefixTemplateArgs TemplateArgs
ta PrefixR
sp)
             Maybe (NextArg (PrefixR -> Prefix))
-> (NextArg (PrefixR -> Prefix)
    -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg (PrefixR -> Prefix) -> Maybe (NextArg (PrefixR -> Prefix))
canSubstAccumPrefix
             Maybe (NextArg (PrefixR -> Prefix))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
           , Next (PrefixR -> Prefix) UnqualifiedName
AnyNext UnqualifiedName
unqualified_name NextArg (PrefixR -> Prefix)
accum
             Maybe (NextArg UnqualifiedName)
-> (NextArg UnqualifiedName -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (UnqualifiedName -> PrefixR -> Prefix)
-> NextArg UnqualifiedName -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (\UnqualifiedName
uqn PrefixR
sp -> NextArg (PrefixR -> Prefix)
accum NextArg (PrefixR -> Prefix)
-> Getting
     (PrefixR -> Prefix)
     (NextArg (PrefixR -> Prefix))
     (PrefixR -> Prefix)
-> PrefixR
-> Prefix
forall s a. s -> Getting a s a -> a
^. Getting
  (PrefixR -> Prefix)
  (NextArg (PrefixR -> Prefix))
  (PrefixR -> Prefix)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal (PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ UnqualifiedName -> PrefixR -> PrefixR
PrefixUQName UnqualifiedName
uqn PrefixR
sp)
             Maybe (NextArg (PrefixR -> Prefix))
-> (NextArg (PrefixR -> Prefix)
    -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg (PrefixR -> Prefix) -> Maybe (NextArg (PrefixR -> Prefix))
canSubstAccumPrefix
             Maybe (NextArg (PrefixR -> Prefix))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
           , Next (PrefixR -> Prefix) Substitution'
AnyNext Substitution'
substitution NextArg (PrefixR -> Prefix)
accum
             Maybe (NextArg Substitution')
-> (NextArg Substitution' -> Maybe (NextArg PrefixR))
-> Maybe (NextArg PrefixR)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next Substitution PrefixR
-> NextArg Substitution' -> Maybe (NextArg PrefixR)
substitutePrefixR Next Substitution PrefixR
substitutionPrefixR
             Maybe (NextArg PrefixR)
-> (NextArg PrefixR -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (PrefixR -> PrefixR -> Prefix)
-> NextArg PrefixR -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (\PrefixR
subs -> Prefix -> PrefixR -> Prefix
extendPrefix ((NextArg (PrefixR -> Prefix)
accum NextArg (PrefixR -> Prefix)
-> Getting
     (PrefixR -> Prefix)
     (NextArg (PrefixR -> Prefix))
     (PrefixR -> Prefix)
-> PrefixR
-> Prefix
forall s a. s -> Getting a s a -> a
^. Getting
  (PrefixR -> Prefix)
  (NextArg (PrefixR -> Prefix))
  (PrefixR -> Prefix)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) PrefixR
subs))
             Maybe (NextArg (PrefixR -> Prefix))
-> (NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
prefix'r2
           , ((PrefixR -> Prefix) -> Prefix)
-> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ PrefixR
PrefixEnd) NextArg (PrefixR -> Prefix)
accum
           ]
    canSubstAccumPrefix :: Next (PrefixR -> Prefix) (PrefixR -> Prefix)
    canSubstAccumPrefix :: NextArg (PrefixR -> Prefix) -> Maybe (NextArg (PrefixR -> Prefix))
canSubstAccumPrefix NextArg (PrefixR -> Prefix)
sp = ((PrefixR -> Prefix) -> Prefix)
-> NextArg (PrefixR -> Prefix) -> Maybe (NextArg Prefix)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((PrefixR -> Prefix) -> PrefixR -> Prefix
forall a b. (a -> b) -> a -> b
$ PrefixR
PrefixEnd) NextArg (PrefixR -> Prefix)
sp
                             Maybe (NextArg Prefix)
-> (NextArg Prefix -> Maybe (NextArg Prefix))
-> Maybe (NextArg Prefix)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg Prefix -> Maybe (NextArg Prefix)
canSubstPrefix
                             Maybe (NextArg Prefix)
-> (NextArg Prefix -> Maybe (NextArg (PrefixR -> Prefix)))
-> Maybe (NextArg (PrefixR -> Prefix))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (PrefixR -> Prefix)
-> NextArg Prefix -> Maybe (NextArg (PrefixR -> Prefix))
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' (NextArg (PrefixR -> Prefix)
sp NextArg (PrefixR -> Prefix)
-> Getting
     (PrefixR -> Prefix)
     (NextArg (PrefixR -> Prefix))
     (PrefixR -> Prefix)
-> PrefixR
-> Prefix
forall s a. s -> Getting a s a -> a
^. Getting
  (PrefixR -> Prefix)
  (NextArg (PrefixR -> Prefix))
  (PrefixR -> Prefix)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)
    last_is_template_args :: Prefix -> Bool
last_is_template_args = Bool
-> ((Prefix, Either UnqualifiedName TemplateArgs) -> Bool)
-> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
False (Either UnqualifiedName TemplateArgs -> Bool
forall a b. Either a b -> Bool
isRight (Either UnqualifiedName TemplateArgs -> Bool)
-> ((Prefix, Either UnqualifiedName TemplateArgs)
    -> Either UnqualifiedName TemplateArgs)
-> (Prefix, Either UnqualifiedName TemplateArgs)
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Prefix, Either UnqualifiedName TemplateArgs)
-> Either UnqualifiedName TemplateArgs
forall a b. (a, b) -> b
snd) (Maybe (Prefix, Either UnqualifiedName TemplateArgs) -> Bool)
-> (Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs))
-> Prefix
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast


substitutionPrefix :: Next Substitution Prefix
substitutionPrefix :: Next Substitution Prefix
substitutionPrefix = (Substitution -> Prefix) -> Next Substitution Prefix
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (PrefixR -> Prefix
Prefix (PrefixR -> Prefix)
-> (Substitution -> PrefixR) -> Substitution -> Prefix
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((PrefixR -> PrefixR) -> PrefixR -> PrefixR
forall a b. (a -> b) -> a -> b
$ PrefixR
PrefixEnd) ((PrefixR -> PrefixR) -> PrefixR)
-> (Substitution -> PrefixR -> PrefixR) -> Substitution -> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnqualifiedName -> PrefixR -> PrefixR
PrefixUQName (UnqualifiedName -> PrefixR -> PrefixR)
-> (Substitution -> UnqualifiedName)
-> Substitution
-> PrefixR
-> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Substitution -> UnqualifiedName
StdSubst)

substitutionPrefixR :: Next Substitution PrefixR
substitutionPrefixR :: Next Substitution PrefixR
substitutionPrefixR = (Substitution -> PrefixR) -> Next Substitution PrefixR
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (((PrefixR -> PrefixR) -> PrefixR -> PrefixR
forall a b. (a -> b) -> a -> b
$ PrefixR
PrefixEnd) ((PrefixR -> PrefixR) -> PrefixR)
-> (Substitution -> PrefixR -> PrefixR) -> Substitution -> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UnqualifiedName -> PrefixR -> PrefixR
PrefixUQName (UnqualifiedName -> PrefixR -> PrefixR)
-> (Substitution -> UnqualifiedName)
-> Substitution
-> PrefixR
-> PrefixR
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Substitution -> UnqualifiedName
StdSubst)

decltype :: AnyNext DeclType
decltype :: AnyNext DeclType
decltype = [NextArg a -> Maybe (NextArg DeclType)]
-> NextArg a -> Maybe (NextArg DeclType)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"Dt" Next a a
-> (NextArg a -> Maybe (NextArg DeclType))
-> NextArg a
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg DeclType))
-> NextArg a
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Expression Expression
forall a. Text -> Next a a
match Text
"E" Next Expression Expression
-> (NextArg Expression -> Maybe (NextArg DeclType))
-> NextArg Expression
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> DeclType)
-> NextArg Expression -> Maybe (NextArg DeclType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> DeclType
DeclType
                 , Text -> Next a a
forall a. Text -> Next a a
match Text
"DT" Next a a
-> (NextArg a -> Maybe (NextArg DeclType))
-> NextArg a
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg DeclType))
-> NextArg a
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Expression Expression
forall a. Text -> Next a a
match Text
"E" Next Expression Expression
-> (NextArg Expression -> Maybe (NextArg DeclType))
-> NextArg Expression
-> Maybe (NextArg DeclType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> DeclType)
-> NextArg Expression -> Maybe (NextArg DeclType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> DeclType
DeclTypeExpr
                 ]

-- closure_prefix :: AnyNext ClosurePrefix
-- closure_prefix = tbd "closure prefix"

unqualified_name :: AnyNext UnqualifiedName
unqualified_name :: AnyNext UnqualifiedName
unqualified_name =
  [NextArg a -> Maybe (NextArg UnqualifiedName)]
-> NextArg a -> Maybe (NextArg UnqualifiedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ -- (see parseUnqualifiedName in LLVM ItaniumDemangle.h)
          Next () ModuleName -> Next () [ModuleName]
forall a. Next () a -> Next () [a]
many' Next () ModuleName
AnyNext ModuleName
module_name Next () [ModuleName]
-> (NextArg a
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> NextArg a
-> Maybe (NextArg [ModuleName])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard (NextArg a -> Maybe (NextArg [ModuleName]))
-> (NextArg [ModuleName] -> Maybe (NextArg UnqualifiedName))
-> NextArg a
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next [ModuleName] [ModuleName]
forall a. Text -> Next a a
match Text
"L" Next [ModuleName] [ModuleName]
-> (NextArg [ModuleName] -> Maybe (NextArg UnqualifiedName))
-> Next [ModuleName] ([ModuleName], UnqualifiedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg [ModuleName] -> Maybe (NextArg UnqualifiedName)
AnyNext UnqualifiedName
base_uqn
          Next [ModuleName] ([ModuleName], UnqualifiedName)
-> (NextArg ([ModuleName], UnqualifiedName)
    -> Maybe (NextArg UnqualifiedName))
-> NextArg [ModuleName]
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (([ModuleName], UnqualifiedName) -> UnqualifiedName)
-> NextArg ([ModuleName], UnqualifiedName)
-> Maybe (NextArg UnqualifiedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (([ModuleName] -> UnqualifiedName -> UnqualifiedName)
-> ([ModuleName], UnqualifiedName) -> UnqualifiedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry [ModuleName] -> UnqualifiedName -> UnqualifiedName
ModuleNamed)
        , NextArg a -> Maybe (NextArg UnqualifiedName)
AnyNext UnqualifiedName
base_uqn
        ]


base_uqn :: AnyNext UnqualifiedName
base_uqn :: AnyNext UnqualifiedName
base_uqn = [NextArg a -> Maybe (NextArg UnqualifiedName)]
-> NextArg a -> Maybe (NextArg UnqualifiedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ \NextArg a
i -> do NextArg Operator
op <- Next a Operator
AnyNext Operator
operator_name NextArg a
i
                            NextArg [ABI_Tag]
at <- Next () ABI_Tag -> Next () [ABI_Tag]
forall a. Next () a -> Next () [a]
many' Next () ABI_Tag
AnyNext ABI_Tag
abi_tag Next () [ABI_Tag] -> Next () [ABI_Tag]
forall a b. (a -> b) -> a -> b
$ NextArg Operator
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard NextArg Operator
op
                            NextArg [ABI_Tag]
-> UnqualifiedName -> Maybe (NextArg UnqualifiedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg [ABI_Tag]
at (UnqualifiedName -> Maybe (NextArg UnqualifiedName))
-> UnqualifiedName -> Maybe (NextArg UnqualifiedName)
forall a b. (a -> b) -> a -> b
$ Operator -> [ABI_Tag] -> UnqualifiedName
OperatorName (NextArg Operator
op NextArg Operator
-> Getting Operator (NextArg Operator) Operator -> Operator
forall s a. s -> Getting a s a -> a
^. Getting Operator (NextArg Operator) Operator
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (NextArg [ABI_Tag]
at NextArg [ABI_Tag]
-> Getting [ABI_Tag] (NextArg [ABI_Tag]) [ABI_Tag] -> [ABI_Tag]
forall s a. s -> Getting a s a -> a
^. Getting [ABI_Tag] (NextArg [ABI_Tag]) [ABI_Tag]
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)
                 , Next a CtorDtor
AnyNext CtorDtor
ctor_dtor_name Next a CtorDtor
-> (NextArg CtorDtor -> Maybe (NextArg UnqualifiedName))
-> NextArg a
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (CtorDtor -> UnqualifiedName)
-> NextArg CtorDtor -> Maybe (NextArg UnqualifiedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap CtorDtor -> UnqualifiedName
CtorDtorName
                 , Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> Next SourceName [ABI_Tag] -> Next a (SourceName, [ABI_Tag])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () ABI_Tag -> Next () [ABI_Tag]
forall a. Next () a -> Next () [a]
many' Next () ABI_Tag
AnyNext ABI_Tag
abi_tag Next () [ABI_Tag]
-> (NextArg SourceName
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next SourceName [ABI_Tag]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg SourceName
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
                   Next a (SourceName, [ABI_Tag])
-> (NextArg (SourceName, [ABI_Tag])
    -> Maybe (NextArg UnqualifiedName))
-> NextArg a
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, [ABI_Tag]) -> UnqualifiedName)
-> NextArg (SourceName, [ABI_Tag])
-> Maybe (NextArg UnqualifiedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> [ABI_Tag] -> UnqualifiedName)
-> (SourceName, [ABI_Tag]) -> UnqualifiedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> [ABI_Tag] -> UnqualifiedName
SourceName)
                 , NextArg a -> Maybe (NextArg UnqualifiedName)
AnyNext UnqualifiedName
unnamed_type_name

                   -- , match "DC" i >>= some source_name >>= match "E"
                 ]

module_name :: AnyNext ModuleName
module_name :: AnyNext ModuleName
module_name = Text -> Next a a
forall a. Text -> Next a a
match Text
"W"
              Next a a
-> (NextArg a -> Maybe (NextArg ModuleName))
-> NextArg a
-> Maybe (NextArg ModuleName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg a -> Maybe (NextArg ModuleName)]
-> NextArg a -> Maybe (NextArg ModuleName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"P" Next a a
-> (NextArg a -> Maybe (NextArg ModuleName))
-> NextArg a
-> Maybe (NextArg ModuleName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg ModuleName))
-> NextArg a
-> Maybe (NextArg ModuleName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SourceName -> ModuleName)
-> NextArg SourceName -> Maybe (NextArg ModuleName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> SourceName -> ModuleName
ModuleName Bool
True)
                        , Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg ModuleName))
-> NextArg a
-> Maybe (NextArg ModuleName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SourceName -> ModuleName)
-> NextArg SourceName -> Maybe (NextArg ModuleName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> SourceName -> ModuleName
ModuleName Bool
False)
                        ]

operator_name :: AnyNext Operator
operator_name :: AnyNext Operator
operator_name =
  let opMatch :: (b, (a, (Text, b))) -> NextArg a -> Maybe (NextArg b)
opMatch (b
o,(a
_,(Text
t,b
_))) = Text -> Next a a
forall a. Text -> Next a a
match Text
t Next a a
-> (NextArg a -> Maybe (NextArg b))
-> NextArg a
-> Maybe (NextArg b)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> b) -> NextArg a -> Maybe (NextArg b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (b -> a -> b
forall a b. a -> b -> a
const b
o)
  in [NextArg a -> Maybe (NextArg Operator)]
-> NextArg a -> Maybe (NextArg Operator)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' (((Operator, (Arity, (Text, Text)))
-> NextArg a -> Maybe (NextArg Operator)
forall {b} {a} {b} {a}.
(b, (a, (Text, b))) -> NextArg a -> Maybe (NextArg b)
opMatch ((Operator, (Arity, (Text, Text)))
 -> NextArg a -> Maybe (NextArg Operator))
-> [(Operator, (Arity, (Text, Text)))]
-> [NextArg a -> Maybe (NextArg Operator)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Operator, (Arity, (Text, Text)))]
opTable)
             [NextArg a -> Maybe (NextArg Operator)]
-> [NextArg a -> Maybe (NextArg Operator)]
-> [NextArg a -> Maybe (NextArg Operator)]
forall a. Semigroup a => a -> a -> a
<> [ Text -> Next a a
forall a. Text -> Next a a
match Text
"cv" Next a a
-> (NextArg a -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Operator) -> NextArg Type_ -> Maybe (NextArg Operator)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> Operator
OpCast
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"li" Next a a
-> (NextArg a -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SourceName -> Operator)
-> NextArg SourceName -> Maybe (NextArg Operator)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap SourceName -> Operator
OpString
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"v" Next a a
-> (NextArg a -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
single_digit_num Next a Int
-> (NextArg Int -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=>
                  \NextArg Int
d -> do NextArg SourceName
sn <- Next Int SourceName
AnyNext SourceName
source_name NextArg Int
d
                           (SourceName -> Operator)
-> NextArg SourceName -> Maybe (NextArg Operator)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> SourceName -> Operator
OpVendor (Int -> Natural
forall a. Enum a => Int -> a
toEnum (Int -> Natural) -> Int -> Natural
forall a b. (a -> b) -> a -> b
$ NextArg Int
d NextArg Int -> Getting Int (NextArg Int) Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int (NextArg Int) Int
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)) NextArg SourceName
sn
                ]
           )

abi_tag :: AnyNext ABI_Tag
abi_tag :: AnyNext ABI_Tag
abi_tag = Text -> Next a a
forall a. Text -> Next a a
match Text
"B" Next a a
-> (NextArg a -> Maybe (NextArg ABI_Tag))
-> NextArg a
-> Maybe (NextArg ABI_Tag)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg ABI_Tag))
-> NextArg a
-> Maybe (NextArg ABI_Tag)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SourceName -> ABI_Tag)
-> NextArg SourceName -> Maybe (NextArg ABI_Tag)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap SourceName -> ABI_Tag
ABITag

ctor_dtor_name :: AnyNext CtorDtor
ctor_dtor_name :: AnyNext CtorDtor
ctor_dtor_name = [NextArg a -> Maybe (NextArg CtorDtor)]
-> NextArg a -> Maybe (NextArg CtorDtor)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"C1" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
CompleteCtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"C2" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
BaseCtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"C3" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
CompleteAllocatingCtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"CI1" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> CtorDtor) -> NextArg Type_ -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> CtorDtor
CompleteInheritingCtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"CI2" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> CtorDtor) -> NextArg Type_ -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> CtorDtor
BaseInheritingCtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"D0" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
DeletingDtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"D1" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
CompleteDtor
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"D2" Next a a
-> (NextArg a -> Maybe (NextArg CtorDtor))
-> NextArg a
-> Maybe (NextArg CtorDtor)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> CtorDtor -> NextArg a -> Maybe (NextArg CtorDtor)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' CtorDtor
BaseDtor
                       ]

source_name :: AnyNext SourceName
source_name :: AnyNext SourceName
source_name = Next a Int
AnyNext Int
digits_num Next a Int
-> Next Int SourceName -> NextArg a -> Maybe (NextArg SourceName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next Int SourceName
identifier

identifier :: Next Int SourceName
identifier :: Next Int SourceName
identifier NextArg Int
i =
  let identChar :: Char -> Bool
identChar Char
x = Char -> Bool
isAlphaNum Char
x Bool -> Bool -> Bool
|| Char
x Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'_'
      (Text
nm, Text
ri) = Int -> Text -> (Text, Text)
T.splitAt (NextArg Int
i NextArg Int -> Getting Int (NextArg Int) Int -> Int
forall s a. s -> Getting a s a -> a
^. Getting Int (NextArg Int) Int
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (NextArg Int
i NextArg Int -> Getting Text (NextArg Int) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg Int) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp)
  in do Bool -> Maybe ()
require ((Char -> Bool) -> Text -> Bool
T.all Char -> Bool
identChar Text
nm)
        let (Int
idnt, Context
c') = Text -> Context -> (Int, Context)
contextFindOrAdd Text
nm (NextArg Int
i NextArg Int -> Getting Context (NextArg Int) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg Int) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext)
        NextArg SourceName -> Maybe (NextArg SourceName)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (NextArg SourceName -> Maybe (NextArg SourceName))
-> NextArg SourceName -> Maybe (NextArg SourceName)
forall a b. (a -> b) -> a -> b
$ NextArg Int
i
          NextArg Int -> (NextArg Int -> NextArg Int) -> NextArg Int
forall a b. a -> (a -> b) -> b
& (Text -> Identity Text) -> NextArg Int -> Identity (NextArg Int)
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp ((Text -> Identity Text) -> NextArg Int -> Identity (NextArg Int))
-> Text -> NextArg Int -> NextArg Int
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Text
ri
          NextArg Int
-> (NextArg Int -> NextArg SourceName) -> NextArg SourceName
forall a b. a -> (a -> b) -> b
& (Int -> Identity SourceName)
-> NextArg Int -> Identity (NextArg SourceName)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal ((Int -> Identity SourceName)
 -> NextArg Int -> Identity (NextArg SourceName))
-> SourceName -> NextArg Int -> NextArg SourceName
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Int -> SourceName
SrcName Int
idnt
          NextArg SourceName
-> (NextArg SourceName -> NextArg SourceName) -> NextArg SourceName
forall a b. a -> (a -> b) -> b
& (Context -> Identity Context)
-> NextArg SourceName -> Identity (NextArg SourceName)
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext ((Context -> Identity Context)
 -> NextArg SourceName -> Identity (NextArg SourceName))
-> Context -> NextArg SourceName -> NextArg SourceName
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Context
c'


unnamed_type_name :: AnyNext UnqualifiedName
unnamed_type_name :: AnyNext UnqualifiedName
unnamed_type_name = Text -> Next a a
forall a. Text -> Next a a
match Text
"Ut"
                    Next a a
-> (NextArg a -> Maybe (NextArg UnqualifiedName))
-> NextArg a
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Maybe Natural -> UnqualifiedName)
-> NextArg a -> Maybe (NextArg (Maybe Natural -> UnqualifiedName))
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' Maybe Natural -> UnqualifiedName
UnnamedTypeName
                    (NextArg a -> Maybe (NextArg (Maybe Natural -> UnqualifiedName)))
-> (NextArg (Maybe Natural -> UnqualifiedName)
    -> Maybe (NextArg UnqualifiedName))
-> NextArg a
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next (Maybe Natural -> UnqualifiedName) Int
-> Next
     (Maybe Natural -> UnqualifiedName)
     (Maybe Natural -> UnqualifiedName, Maybe Int)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next (Maybe Natural -> UnqualifiedName) Int
AnyNext Int
digits_num Next
  (Maybe Natural -> UnqualifiedName)
  (Maybe Natural -> UnqualifiedName, Maybe Int)
-> (NextArg (Maybe Natural -> UnqualifiedName, Maybe Int)
    -> Maybe (NextArg UnqualifiedName))
-> NextArg (Maybe Natural -> UnqualifiedName)
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Maybe Natural -> UnqualifiedName, Maybe Int)
 -> (Maybe Natural -> UnqualifiedName, Maybe Natural))
-> NextArg (Maybe Natural -> UnqualifiedName, Maybe Int)
-> Maybe
     (NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Maybe Int -> Maybe Natural)
-> (Maybe Natural -> UnqualifiedName, Maybe Int)
-> (Maybe Natural -> UnqualifiedName, Maybe Natural)
forall a b.
(a -> b)
-> (Maybe Natural -> UnqualifiedName, a)
-> (Maybe Natural -> UnqualifiedName, b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((Maybe Int -> Maybe Natural)
 -> (Maybe Natural -> UnqualifiedName, Maybe Int)
 -> (Maybe Natural -> UnqualifiedName, Maybe Natural))
-> (Maybe Int -> Maybe Natural)
-> (Maybe Natural -> UnqualifiedName, Maybe Int)
-> (Maybe Natural -> UnqualifiedName, Maybe Natural)
forall a b. (a -> b) -> a -> b
$ (Int -> Natural) -> Maybe Int -> Maybe Natural
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Int -> Natural
forall a. Enum a => Int -> a
toEnum)
                    (NextArg (Maybe Natural -> UnqualifiedName, Maybe Int)
 -> Maybe
      (NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural)))
-> (NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural)
    -> Maybe (NextArg UnqualifiedName))
-> NextArg (Maybe Natural -> UnqualifiedName, Maybe Int)
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural)
-> Maybe (NextArg UnqualifiedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                    (NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural)
 -> Maybe (NextArg UnqualifiedName))
-> (NextArg UnqualifiedName -> Maybe (NextArg UnqualifiedName))
-> NextArg (Maybe Natural -> UnqualifiedName, Maybe Natural)
-> Maybe (NextArg UnqualifiedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg UnqualifiedName -> Maybe (NextArg UnqualifiedName)
forall a. Text -> Next a a
match Text
"_"

-- | Parse the function argument (and return) types for a function.
--
-- At this point, all template argments that can be substituted have been made,
-- so any template arguments occurring in the arguments are ignored as T[n]_
-- replacements.

bare_function_type :: Bool -> Next FunctionName Encoding
bare_function_type :: Bool -> NextArg FunctionName -> Maybe (NextArg Encoding)
bare_function_type Bool
isStatic NextArg FunctionName
i =
  let constr :: FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
constr = if Bool
isStatic then FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
EncStaticFunc else FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
EncFunc in
  do NextArg (NonEmpty Type_)
tys <- Next FunctionName (NonEmpty Type_)
AnyNext (NonEmpty Type_)
types_ Next FunctionName (NonEmpty Type_)
-> Next FunctionName (NonEmpty Type_)
forall a b. (a -> b) -> a -> b
$ NextArg FunctionName
i NextArg FunctionName
-> (NextArg FunctionName -> NextArg FunctionName)
-> NextArg FunctionName
forall a b. a -> (a -> b) -> b
& (Bool -> Identity Bool)
-> NextArg FunctionName -> Identity (NextArg FunctionName)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock ((Bool -> Identity Bool)
 -> NextArg FunctionName -> Identity (NextArg FunctionName))
-> Bool -> NextArg FunctionName -> NextArg FunctionName
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
True
     -- Determine if the tys includes a function return type.  The rules are:
     --
     --  1. Template functions have return types encoded, with exceptions below.
     --  2. Function types not appearing as part of a function name mangling
     --     (e.g. parameters, pointer types, etc.) have return type encoded, with
     --     exceptions below.
     --  3. Non-template function names do not have return types encoded
     --
     -- Exceptions (for which return type is never included):
     --
     --  1. Constructors
     --  2. Destructors
     --  3. Conversion operator functions (e.g. operator int(..) )
     --
     let withRetType :: Maybe (NextArg Encoding)
withRetType = let (Type_
rty, Maybe (NonEmpty Type_)
argtys) = NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_))
forall a. NonEmpty a -> (a, Maybe (NonEmpty a))
NEL.uncons (NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_)))
-> NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_))
forall a b. (a -> b) -> a -> b
$ NextArg (NonEmpty Type_)
tys NextArg (NonEmpty Type_)
-> Getting
     (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
-> NonEmpty Type_
forall s a. s -> Getting a s a -> a
^. Getting
  (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                       in case Maybe (NonEmpty Type_)
argtys of
                            Just NonEmpty Type_
argtys' ->
                              NextArg (NonEmpty Type_) -> Encoding -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg (NonEmpty Type_)
tys (FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
constr (NextArg FunctionName
i NextArg FunctionName
-> Getting FunctionName (NextArg FunctionName) FunctionName
-> FunctionName
forall s a. s -> Getting a s a -> a
^. Getting FunctionName (NextArg FunctionName) FunctionName
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (Type_ -> Maybe Type_
forall a. a -> Maybe a
Just Type_
rty) NonEmpty Type_
argtys')
                            Maybe (NonEmpty Type_)
Nothing ->
                              Demangler -> String -> [String] -> Maybe (NextArg Encoding)
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"bare_function_type.withRetType"
                              [ String
"Function with rtype and no argtypes: "
                              , forall (saytag :: Symbol) a. Sayable saytag a => a -> String
sez @"error" (FunctionName -> Context -> WithContext FunctionName
forall a. a -> Context -> WithContext a
addContext (NextArg FunctionName
i NextArg FunctionName
-> Getting FunctionName (NextArg FunctionName) FunctionName
-> FunctionName
forall s a. s -> Getting a s a -> a
^. Getting FunctionName (NextArg FunctionName) FunctionName
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (NextArg FunctionName
i NextArg FunctionName
-> Getting Context (NextArg FunctionName) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg FunctionName) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext))
                              ]
     let noRetType :: Maybe (NextArg Encoding)
noRetType = (NonEmpty Type_ -> Encoding)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
constr (NextArg FunctionName
i NextArg FunctionName
-> Getting FunctionName (NextArg FunctionName) FunctionName
-> FunctionName
forall s a. s -> Getting a s a -> a
^. Getting FunctionName (NextArg FunctionName) FunctionName
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) Maybe Type_
forall a. Maybe a
Nothing) NextArg (NonEmpty Type_)
tys
     case NextArg FunctionName
i NextArg FunctionName
-> Getting FunctionName (NextArg FunctionName) FunctionName
-> FunctionName
forall s a. s -> Getting a s a -> a
^. Getting FunctionName (NextArg FunctionName) FunctionName
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal of
       FunctionName
         (UnscopedTemplateName
           (UnscopedName (UnScName Bool
_ (OperatorName (OpCast {}) [ABI_Tag]
_))) TemplateArgs
_) -> Maybe (NextArg Encoding)
noRetType
       FunctionName (UnscopedTemplateName {}) -> Maybe (NextArg Encoding)
withRetType
       FunctionName (NameNested (NestedTemplateName TemplatePrefix
pr TemplateArgs
_ [CVQualifier]
_ Maybe RefQualifier
_)) ->
         case TemplatePrefix
pr of
           NestedTemplate Prefix
_pfx NonEmpty UnqualifiedName
uqns | CtorDtorName {} <- NonEmpty UnqualifiedName -> UnqualifiedName
forall a. NonEmpty a -> a
NEL.last NonEmpty UnqualifiedName
uqns -> Maybe (NextArg Encoding)
noRetType
           TemplatePrefix
_ -> Maybe (NextArg Encoding)
withRetType
       FunctionName
_ ->
#ifdef MIN_VERSION_panic
            -- traceM ("bft what??! " <> show (i ^. nVal)) >>
#endif
            (NonEmpty Type_ -> Encoding)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg Encoding)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (FunctionName -> Maybe Type_ -> NonEmpty Type_ -> Encoding
constr (NextArg FunctionName
i NextArg FunctionName
-> Getting FunctionName (NextArg FunctionName) FunctionName
-> FunctionName
forall s a. s -> Getting a s a -> a
^. Getting FunctionName (NextArg FunctionName) FunctionName
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) Maybe Type_
forall a. Maybe a
Nothing) NextArg (NonEmpty Type_)
tys

-- | Called to return one or more types.  This is essentially the same as `some'
-- type_`, but also handles the case where there might be multiple types returned
-- at once by a Template Argument Pack.

types_ :: AnyNext (NEL.NonEmpty Type_)
types_ :: AnyNext (NonEmpty Type_)
types_ = AnyNext (NonEmpty Type_) -> Next a (NonEmpty (NonEmpty Type_))
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a (NonEmpty Type_)
AnyNext (NonEmpty Type_)
type_parser Next a (NonEmpty (NonEmpty Type_))
-> (NextArg (NonEmpty (NonEmpty Type_))
    -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty (NonEmpty Type_) -> NonEmpty Type_)
-> NextArg (NonEmpty (NonEmpty Type_))
-> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap NonEmpty (NonEmpty Type_) -> NonEmpty Type_
forall a. Semigroup a => NonEmpty a -> a
sconcat

-- | Called to parse a *single* type.  If multiple types are obtained (e.g. an
-- Template Argument Pack), return Nothing indicating a parse failure.

type_ :: AnyNext Type_
type_ :: AnyNext Type_
type_ = Next a (NonEmpty Type_)
AnyNext (NonEmpty Type_)
type_parser
        Next a (NonEmpty Type_)
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \NextArg (NonEmpty Type_)
i -> case NextArg (NonEmpty Type_)
i NextArg (NonEmpty Type_)
-> Getting
     (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
-> NonEmpty Type_
forall s a. s -> Getting a s a -> a
^. Getting
  (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal of
                    Type_
ty :| [] -> NextArg (NonEmpty Type_) -> Type_ -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg (NonEmpty Type_)
i Type_
ty
                    NonEmpty Type_
_ -> Demangler -> String -> [String] -> Maybe (NextArg Type_)
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"type_"
                         [ String
"Can only handle a type_parser return of one type"
                         , String
"to respond to a location expecting only one."
                         , String
"bad1: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> NonEmpty Type_ -> String
forall a. Show a => a -> String
show (NextArg (NonEmpty Type_)
iNextArg (NonEmpty Type_)
-> Getting
     (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
-> NonEmpty Type_
forall s a. s -> Getting a s a -> a
^.Getting
  (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)
                         , String
" rem: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> Text -> String
T.unpack (NextArg (NonEmpty Type_)
i NextArg (NonEmpty Type_)
-> Getting Text (NextArg (NonEmpty Type_)) Text -> Text
forall s a. s -> Getting a s a -> a
^. Getting Text (NextArg (NonEmpty Type_)) Text
forall a (f :: * -> *).
Functor f =>
(Text -> f Text) -> NextArg a -> f (NextArg a)
nInp)
                         ]


-- | Returns one or more types.  Normally this should only parse a single type
-- entry, but in the case of Template argument packs, there could actually be
-- multiple types returned.  This should be used as an internal function; callers
-- should use one of the types_ or type_ wrappers to indicate if they can handle
-- multiple types or not.

type_parser :: AnyNext (NEL.NonEmpty Type_)
type_parser :: AnyNext (NonEmpty Type_)
type_parser =
  [NextArg a -> Maybe (NextArg (NonEmpty Type_))]
-> NextArg a -> Maybe (NextArg (NonEmpty Type_))
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [
          -- Matches that are not type substitution candidates
          (BaseType -> NonEmpty Type_)
-> NextArg BaseType -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> [Type_] -> NonEmpty Type_
forall a. a -> [a] -> NonEmpty a
:|[]) (Type_ -> NonEmpty Type_)
-> (BaseType -> Type_) -> BaseType -> NonEmpty Type_
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BaseType -> Type_
BaseType) (NextArg BaseType -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg BaseType)
AnyNext BaseType
builtin_type

          -- Single element matches
        , [NextArg a -> Maybe (NextArg Type_)]
-> NextArg a -> Maybe (NextArg Type_)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
function_type
                , NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
class_enum_type
                , NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
array_type
                , NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
pointer_to_member_type
                , Next a TemplateArg
AnyNext TemplateArg
template_template_param Next a TemplateArg
-> Next TemplateArg TemplateArgs
-> Next a (TemplateArg, TemplateArgs)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next TemplateArg TemplateArgs
AnyNext TemplateArgs
template_args
                  Next a (TemplateArg, TemplateArgs)
-> (NextArg (TemplateArg, TemplateArgs) -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((TemplateArg, TemplateArgs) -> Type_)
-> NextArg (TemplateArg, TemplateArgs) -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((TemplateArg -> TemplateArgs -> Type_)
-> (TemplateArg, TemplateArgs) -> Type_
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry TemplateArg -> TemplateArgs -> Type_
Template)
                , Next a DeclType
AnyNext DeclType
decltype Next a DeclType
-> (NextArg DeclType -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (DeclType -> Type_) -> NextArg DeclType -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap DeclType -> Type_
DeclType_
                -- This one is tricky: it's recursive, but then binds the
                -- (possibly) multiple returned recursion types into a single
                -- type.
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"Dp" Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
types_ (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap NonEmpty Type_ -> Type_
Cpp11PackExpansion
                ]
          (NextArg a -> Maybe (NextArg Type_))
-> (NextArg Type_ -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next Type_ Type_
canSubstType
          Next Type_ Type_
-> (NextArg Type_ -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg Type_
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> NonEmpty Type_)
-> NextArg Type_ -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Type_ -> [Type_] -> NonEmpty Type_
forall a. a -> [a] -> NonEmpty a
:|[])

          -- Possibly multiple element matches (either direct or via recursion)
        , [NextArg a -> Maybe (NextArg (NonEmpty Type_))]
-> NextArg a -> Maybe (NextArg (NonEmpty Type_))
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
qualified_type
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"P" Next a a
-> (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
type_parser (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> NonEmpty Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type_ -> Type_
Pointer)
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"R" Next a a
-> (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
type_parser (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> NonEmpty Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type_ -> Type_
LValRef)
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"O" Next a a
-> (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
type_parser (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> NonEmpty Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type_ -> Type_
RValRef)
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"C" Next a a
-> (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
type_parser (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> NonEmpty Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type_ -> Type_
ComplexPair)
                , Text -> Next a a
forall a. Text -> Next a a
match Text
"G" Next a a
-> (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg (NonEmpty Type_))
AnyNext (NonEmpty Type_)
type_parser (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> NonEmpty Type_)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall a b. (a -> b) -> NonEmpty a -> NonEmpty b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Type_ -> Type_
Imaginary)
                , Next a TemplateArg
AnyNext TemplateArg
template_param
                  Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (\NextArg TemplateArg
i ->
                         let retType :: Type_ -> Maybe (NextArg (NonEmpty Type_))
retType Type_
t = NextArg TemplateArg
-> NonEmpty Type_ -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg TemplateArg
i (Type_
t Type_ -> [Type_] -> NonEmpty Type_
forall a. a -> [a] -> NonEmpty a
:| [])
                         in case NextArg TemplateArg
i NextArg TemplateArg
-> Getting TemplateArg (NextArg TemplateArg) TemplateArg
-> TemplateArg
forall s a. s -> Getting a s a -> a
^. Getting TemplateArg (NextArg TemplateArg) TemplateArg
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal of
                              TArgType Type_
t -> Type_ -> Maybe (NextArg (NonEmpty Type_))
retType Type_
t
                              TArgPack [] -> Type_ -> Maybe (NextArg (NonEmpty Type_))
retType (Type_ -> Maybe (NextArg (NonEmpty Type_)))
-> Type_ -> Maybe (NextArg (NonEmpty Type_))
forall a b. (a -> b) -> a -> b
$ BaseType -> Type_
BaseType BaseType
Ellipsis
                              TArgPack [TemplateArg]
tas ->
                                let each :: TemplateArg -> Type_
each = \case
                                      TArgType Type_
t -> Type_
t
                                      TemplateArg
_ -> Maybe Type_ -> Type_
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe Type_ -> Type_) -> Maybe Type_ -> Type_
forall a b. (a -> b) -> a -> b
$ Demangler -> String -> [String] -> Maybe Type_
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler
                                           String
"type_parser.template_param"
                                           [ String
"nested TArgPack members:"
                                           , [TemplateArg] -> String
forall a. Show a => a -> String
show [TemplateArg]
tas
                                           ]
                                in NextArg TemplateArg
-> NonEmpty Type_ -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg TemplateArg
i (NonEmpty Type_ -> Maybe (NextArg (NonEmpty Type_)))
-> Maybe (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< [Type_] -> Maybe (NonEmpty Type_)
forall a. [a] -> Maybe (NonEmpty a)
NEL.nonEmpty (TemplateArg -> Type_
each (TemplateArg -> Type_) -> [TemplateArg] -> [Type_]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [TemplateArg]
tas)
                              TemplateArg
o -> Demangler -> String -> [String] -> Maybe (NextArg (NonEmpty Type_))
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"type_parser.template_param"
                                   [ String
"bad template param ref in type:"
                                   , forall (saytag :: Symbol) a. Sayable saytag a => a -> String
sez @"debug" (TemplateArg -> Context -> WithContext TemplateArg
forall a. a -> Context -> WithContext a
addContext TemplateArg
o (NextArg TemplateArg
i NextArg TemplateArg
-> Getting Context (NextArg TemplateArg) Context -> Context
forall s a. s -> Getting a s a -> a
^. Getting Context (NextArg TemplateArg) Context
forall a (f :: * -> *).
Functor f =>
(Context -> f Context) -> NextArg a -> f (NextArg a)
nContext))
                                   , String
"raw: " String -> String -> String
forall a. Semigroup a => a -> a -> a
<> TemplateArg -> String
forall a. Show a => a -> String
show TemplateArg
o
                                   ]
                      )
                ]
          (NextArg a -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
canSubstTypes

          -- Substitutions, which are not recursively added as a substitution
          -- candidate
        , Next a Substitution'
AnyNext Substitution'
substitution
          Next a Substitution'
-> (NextArg Substitution' -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg a
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next Substitution Type_ -> Next Substitution' Type_
substituteType Next Substitution Type_
stdSubstToType
          Next Substitution' Type_
-> (NextArg Type_ -> Maybe (NextArg (NonEmpty Type_)))
-> NextArg Substitution'
-> Maybe (NextArg (NonEmpty Type_))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> NonEmpty Type_)
-> NextArg Type_ -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Type_ -> [Type_] -> NonEmpty Type_
forall a. a -> [a] -> NonEmpty a
:|[])
        ]


builtin_type :: AnyNext BaseType
builtin_type :: AnyNext BaseType
builtin_type =
  let parse :: (b, (Text, b, c)) -> NextArg a -> Maybe (NextArg b)
parse (b
t,(Text
m,b
_,c
_)) = Text -> Next a a
forall a. Text -> Next a a
match Text
m Next a a
-> (NextArg a -> Maybe (NextArg b))
-> NextArg a
-> Maybe (NextArg b)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> b -> NextArg a -> Maybe (NextArg b)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' b
t
  in [NextArg a -> Maybe (NextArg BaseType)]
-> NextArg a -> Maybe (NextArg BaseType)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum'
     (((BaseType, (Text, Text, Maybe Text))
-> NextArg a -> Maybe (NextArg BaseType)
forall {b} {b} {c} {a}.
(b, (Text, b, c)) -> NextArg a -> Maybe (NextArg b)
parse ((BaseType, (Text, Text, Maybe Text))
 -> NextArg a -> Maybe (NextArg BaseType))
-> [(BaseType, (Text, Text, Maybe Text))]
-> [NextArg a -> Maybe (NextArg BaseType)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(BaseType, (Text, Text, Maybe Text))]
builtinTypeTable)
       [NextArg a -> Maybe (NextArg BaseType)]
-> [NextArg a -> Maybe (NextArg BaseType)]
-> [NextArg a -> Maybe (NextArg BaseType)]
forall a. Semigroup a => a -> a -> a
<> [ Text -> Next a a
forall a. Text -> Next a a
match Text
"DF" Next a a
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> BaseType) -> NextArg Int -> Maybe (NextArg BaseType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> BaseType
FloatN  (Natural -> BaseType) -> (Int -> Natural) -> Int -> BaseType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural
forall a. Enum a => Int -> a
toEnum) (NextArg Int -> Maybe (NextArg BaseType))
-> (NextArg BaseType -> Maybe (NextArg BaseType))
-> NextArg Int
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg BaseType -> Maybe (NextArg BaseType)
forall a. Text -> Next a a
match Text
"_"
          , Text -> Next a a
forall a. Text -> Next a a
match Text
"DF" Next a a
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> BaseType) -> NextArg Int -> Maybe (NextArg BaseType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> BaseType
FloatNx (Natural -> BaseType) -> (Int -> Natural) -> Int -> BaseType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural
forall a. Enum a => Int -> a
toEnum) (NextArg Int -> Maybe (NextArg BaseType))
-> (NextArg BaseType -> Maybe (NextArg BaseType))
-> NextArg Int
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg BaseType -> Maybe (NextArg BaseType)
forall a. Text -> Next a a
match Text
"x"
          , Text -> Next a a
forall a. Text -> Next a a
match Text
"DB" Next a a
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> BaseType) -> NextArg Int -> Maybe (NextArg BaseType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> BaseType
SBitInt (Natural -> BaseType) -> (Int -> Natural) -> Int -> BaseType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural
forall a. Enum a => Int -> a
toEnum) (NextArg Int -> Maybe (NextArg BaseType))
-> (NextArg BaseType -> Maybe (NextArg BaseType))
-> NextArg Int
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg BaseType -> Maybe (NextArg BaseType)
forall a. Text -> Next a a
match Text
"_" -- TODO: or expression
          , Text -> Next a a
forall a. Text -> Next a a
match Text
"DU" Next a a
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> BaseType) -> NextArg Int -> Maybe (NextArg BaseType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> BaseType
UBitInt (Natural -> BaseType) -> (Int -> Natural) -> Int -> BaseType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural
forall a. Enum a => Int -> a
toEnum) (NextArg Int -> Maybe (NextArg BaseType))
-> (NextArg BaseType -> Maybe (NextArg BaseType))
-> NextArg Int
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg BaseType -> Maybe (NextArg BaseType)
forall a. Text -> Next a a
match Text
"_" -- TODO: or expression
          , Text -> Next a a
forall a. Text -> Next a a
match Text
"u" Next a a
-> (NextArg a -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg BaseType))
-> NextArg a
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next SourceName TemplateArgs
-> Next SourceName (SourceName, Maybe TemplateArgs)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next SourceName TemplateArgs
AnyNext TemplateArgs
template_args
            Next SourceName (SourceName, Maybe TemplateArgs)
-> (NextArg (SourceName, Maybe TemplateArgs)
    -> Maybe (NextArg BaseType))
-> NextArg SourceName
-> Maybe (NextArg BaseType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, Maybe TemplateArgs) -> BaseType)
-> NextArg (SourceName, Maybe TemplateArgs)
-> Maybe (NextArg BaseType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> Maybe TemplateArgs -> BaseType)
-> (SourceName, Maybe TemplateArgs) -> BaseType
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> Maybe TemplateArgs -> BaseType
VendorExtendedType)
          ]
     )

-- Returns potentially multiple types to support C++11 argument packs
qualified_type :: AnyNext (NEL.NonEmpty Type_)
qualified_type :: AnyNext (NonEmpty Type_)
qualified_type NextArg a
i = do NextArg [()]
eQ <- Next () () -> Next () [()]
forall a. Next () a -> Next () [a]
many' Next () ()
extended_qualifier Next () [()] -> Next () [()]
forall a b. (a -> b) -> a -> b
$ NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard NextArg a
i
                      NextArg [CVQualifier]
cQ <- Next [()] [CVQualifier]
AnyNext [CVQualifier]
cv_qualifiers NextArg [()]
eQ
                      -- Require some amount of production before recursion
                      Bool -> Maybe ()
require (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and [ [CVQualifier] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([CVQualifier] -> Bool) -> [CVQualifier] -> Bool
forall a b. (a -> b) -> a -> b
$ NextArg [CVQualifier]
cQ NextArg [CVQualifier]
-> Getting [CVQualifier] (NextArg [CVQualifier]) [CVQualifier]
-> [CVQualifier]
forall s a. s -> Getting a s a -> a
^. Getting [CVQualifier] (NextArg [CVQualifier]) [CVQualifier]
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                                          , [()] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([()] -> Bool) -> [()] -> Bool
forall a b. (a -> b) -> a -> b
$ NextArg [()]
eQ NextArg [()] -> Getting [()] (NextArg [()]) [()] -> [()]
forall s a. s -> Getting a s a -> a
^. Getting [()] (NextArg [()]) [()]
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                                          ]
                      NextArg (NonEmpty Type_)
tYs <- Next [CVQualifier] (NonEmpty Type_)
AnyNext (NonEmpty Type_)
type_parser NextArg [CVQualifier]
cQ
                      let eQv :: [()]
eQv = NextArg [()]
eQ NextArg [()] -> Getting [()] (NextArg [()]) [()] -> [()]
forall s a. s -> Getting a s a -> a
^. Getting [()] (NextArg [()]) [()]
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                      let cQv :: [CVQualifier]
cQv = NextArg [CVQualifier]
cQ NextArg [CVQualifier]
-> Getting [CVQualifier] (NextArg [CVQualifier]) [CVQualifier]
-> [CVQualifier]
forall s a. s -> Getting a s a -> a
^. Getting [CVQualifier] (NextArg [CVQualifier]) [CVQualifier]
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                      let qTy :: Type_ -> Type_
qTy = [()] -> [CVQualifier] -> Type_ -> Type_
QualifiedType [()]
eQv [CVQualifier]
cQv
                      NextArg (NonEmpty Type_)
-> NonEmpty Type_ -> Maybe (NextArg (NonEmpty Type_))
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg (NonEmpty Type_)
tYs (Type_ -> Type_
qTy (Type_ -> Type_) -> NonEmpty Type_ -> NonEmpty Type_
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (NextArg (NonEmpty Type_)
tYs NextArg (NonEmpty Type_)
-> Getting
     (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
-> NonEmpty Type_
forall s a. s -> Getting a s a -> a
^. Getting
  (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal))

extended_qualifier :: Next () ExtendedQualifier
extended_qualifier :: Next () ()
extended_qualifier = Text -> Next () ()
forall a. Text -> Next a a
match Text
"U" Next () () -> Next () () -> Next () ()
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> Next () ()
forall a b. String -> Next a b
tbd String
"extended_qualifier"

function_type :: AnyNext Type_
function_type :: AnyNext Type_
function_type NextArg a
i = do NextArg
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
f0 <- Next a [CVQualifier]
AnyNext [CVQualifier]
cv_qualifiers NextArg a
i
                           Maybe (NextArg [CVQualifier])
-> (NextArg [CVQualifier]
    -> Maybe (NextArg ([CVQualifier], Maybe ExceptionSpec)))
-> Maybe (NextArg ([CVQualifier], Maybe ExceptionSpec))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next [CVQualifier] ExceptionSpec
-> NextArg [CVQualifier]
-> Maybe (NextArg ([CVQualifier], Maybe ExceptionSpec))
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next [CVQualifier] ExceptionSpec
AnyNext ExceptionSpec
exception_spec
                           Maybe (NextArg ([CVQualifier], Maybe ExceptionSpec))
-> (NextArg ([CVQualifier], Maybe ExceptionSpec)
    -> Maybe
         (NextArg
            (([CVQualifier], Maybe ExceptionSpec),
             Maybe ([CVQualifier], Maybe ExceptionSpec))))
-> Maybe
     (NextArg
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec)))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next
  ([CVQualifier], Maybe ExceptionSpec)
  ([CVQualifier], Maybe ExceptionSpec)
-> NextArg ([CVQualifier], Maybe ExceptionSpec)
-> Maybe
     (NextArg
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec)))
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text
-> Next
     ([CVQualifier], Maybe ExceptionSpec)
     ([CVQualifier], Maybe ExceptionSpec)
forall a. Text -> Next a a
match Text
"Dx")
                     let (([CVQualifier]
cvq, Maybe ExceptionSpec
mb'exc), Maybe ([CVQualifier], Maybe ExceptionSpec)
mb'dx) = NextArg
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
f0 NextArg
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
-> Getting
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
     (NextArg
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec)))
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
-> (([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec))
forall s a. s -> Getting a s a -> a
^. Getting
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
  (NextArg
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     NextArg
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
f1 <- Text
-> Next
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
forall a. Text -> Next a a
match Text
"F" NextArg
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
f0 Maybe
  (NextArg
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> (NextArg
      (([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec))
    -> Maybe
         (NextArg
            ((([CVQualifier], Maybe ExceptionSpec),
              Maybe ([CVQualifier], Maybe ExceptionSpec)),
             Maybe
               (([CVQualifier], Maybe ExceptionSpec),
                Maybe ([CVQualifier], Maybe ExceptionSpec)))))
-> Maybe
     (NextArg
        ((([CVQualifier], Maybe ExceptionSpec),
          Maybe ([CVQualifier], Maybe ExceptionSpec)),
         Maybe
           (([CVQualifier], Maybe ExceptionSpec),
            Maybe ([CVQualifier], Maybe ExceptionSpec))))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
-> NextArg
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
-> Maybe
     (NextArg
        ((([CVQualifier], Maybe ExceptionSpec),
          Maybe ([CVQualifier], Maybe ExceptionSpec)),
         Maybe
           (([CVQualifier], Maybe ExceptionSpec),
            Maybe ([CVQualifier], Maybe ExceptionSpec))))
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text
-> Next
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
forall a. Text -> Next a a
match Text
"Y")
                     let isExternC :: Bool
isExternC = Maybe
  (([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec))
-> Bool
forall a. Maybe a -> Bool
isJust (Maybe
   (([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec))
 -> Bool)
-> Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
-> Bool
forall a b. (a -> b) -> a -> b
$ ((([CVQualifier], Maybe ExceptionSpec),
  Maybe ([CVQualifier], Maybe ExceptionSpec)),
 Maybe
   (([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
forall a b. (a, b) -> b
snd (((([CVQualifier], Maybe ExceptionSpec),
   Maybe ([CVQualifier], Maybe ExceptionSpec)),
  Maybe
    (([CVQualifier], Maybe ExceptionSpec),
     Maybe ([CVQualifier], Maybe ExceptionSpec)))
 -> Maybe
      (([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> ((([CVQualifier], Maybe ExceptionSpec),
     Maybe ([CVQualifier], Maybe ExceptionSpec)),
    Maybe
      (([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec))
forall a b. (a -> b) -> a -> b
$ NextArg
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
f1 NextArg
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> Getting
     ((([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)),
      Maybe
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec)))
     (NextArg
        ((([CVQualifier], Maybe ExceptionSpec),
          Maybe ([CVQualifier], Maybe ExceptionSpec)),
         Maybe
           (([CVQualifier], Maybe ExceptionSpec),
            Maybe ([CVQualifier], Maybe ExceptionSpec))))
     ((([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)),
      Maybe
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec)))
-> ((([CVQualifier], Maybe ExceptionSpec),
     Maybe ([CVQualifier], Maybe ExceptionSpec)),
    Maybe
      (([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)))
forall s a. s -> Getting a s a -> a
^. Getting
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
  (NextArg
     ((([CVQualifier], Maybe ExceptionSpec),
       Maybe ([CVQualifier], Maybe ExceptionSpec)),
      Maybe
        (([CVQualifier], Maybe ExceptionSpec),
         Maybe ([CVQualifier], Maybe ExceptionSpec))))
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     NextArg (NonEmpty Type_)
tys <- Next
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
  (NonEmpty Type_)
AnyNext (NonEmpty Type_)
types_ NextArg
  ((([CVQualifier], Maybe ExceptionSpec),
    Maybe ([CVQualifier], Maybe ExceptionSpec)),
   Maybe
     (([CVQualifier], Maybe ExceptionSpec),
      Maybe ([CVQualifier], Maybe ExceptionSpec)))
f1
                     let (Type_
rty, Maybe (NonEmpty Type_)
tyrem) = NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_))
forall a. NonEmpty a -> (a, Maybe (NonEmpty a))
NEL.uncons (NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_)))
-> NonEmpty Type_ -> (Type_, Maybe (NonEmpty Type_))
forall a b. (a -> b) -> a -> b
$ NextArg (NonEmpty Type_)
tys NextArg (NonEmpty Type_)
-> Getting
     (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
-> NonEmpty Type_
forall s a. s -> Getting a s a -> a
^. Getting
  (NonEmpty Type_) (NextArg (NonEmpty Type_)) (NonEmpty Type_)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal
                     NonEmpty Type_
argtys <- Maybe (NonEmpty Type_)
tyrem
                     NextArg (NonEmpty Type_, Maybe RefQualifier)
f2 <- Next (NonEmpty Type_) RefQualifier
-> Next (NonEmpty Type_) (NonEmpty Type_, Maybe RefQualifier)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next (NonEmpty Type_) RefQualifier
AnyNext RefQualifier
ref_qualifier NextArg (NonEmpty Type_)
tys
                           Maybe (NextArg (NonEmpty Type_, Maybe RefQualifier))
-> (NextArg (NonEmpty Type_, Maybe RefQualifier)
    -> Maybe (NextArg (NonEmpty Type_, Maybe RefQualifier)))
-> Maybe (NextArg (NonEmpty Type_, Maybe RefQualifier))
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text
-> NextArg (NonEmpty Type_, Maybe RefQualifier)
-> Maybe (NextArg (NonEmpty Type_, Maybe RefQualifier))
forall a. Text -> Next a a
match Text
"E"
                     let trnsct :: Transaction
trnsct = if Maybe ([CVQualifier], Maybe ExceptionSpec) -> Bool
forall a. Maybe a -> Bool
isJust Maybe ([CVQualifier], Maybe ExceptionSpec)
mb'dx
                                  then Transaction
TransactionSafe
                                  else Transaction
TransactionUnsafe
                     NextArg (NonEmpty Type_, Maybe RefQualifier)
-> Type_ -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg (NonEmpty Type_, Maybe RefQualifier)
f2 ([CVQualifier]
-> Maybe ExceptionSpec
-> Transaction
-> Bool
-> Type_
-> NonEmpty Type_
-> Maybe RefQualifier
-> Type_
Function [CVQualifier]
cvq Maybe ExceptionSpec
mb'exc Transaction
trnsct Bool
isExternC
                             Type_
rty NonEmpty Type_
argtys ((NonEmpty Type_, Maybe RefQualifier) -> Maybe RefQualifier
forall a b. (a, b) -> b
snd ((NonEmpty Type_, Maybe RefQualifier) -> Maybe RefQualifier)
-> (NonEmpty Type_, Maybe RefQualifier) -> Maybe RefQualifier
forall a b. (a -> b) -> a -> b
$ NextArg (NonEmpty Type_, Maybe RefQualifier)
f2 NextArg (NonEmpty Type_, Maybe RefQualifier)
-> Getting
     (NonEmpty Type_, Maybe RefQualifier)
     (NextArg (NonEmpty Type_, Maybe RefQualifier))
     (NonEmpty Type_, Maybe RefQualifier)
-> (NonEmpty Type_, Maybe RefQualifier)
forall s a. s -> Getting a s a -> a
^. Getting
  (NonEmpty Type_, Maybe RefQualifier)
  (NextArg (NonEmpty Type_, Maybe RefQualifier))
  (NonEmpty Type_, Maybe RefQualifier)
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal))

exception_spec :: AnyNext ExceptionSpec
exception_spec :: AnyNext ExceptionSpec
exception_spec = [NextArg a -> Maybe (NextArg ExceptionSpec)]
-> NextArg a -> Maybe (NextArg ExceptionSpec)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"Do" Next a a
-> (NextArg a -> Maybe (NextArg ExceptionSpec))
-> NextArg a
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ExceptionSpec -> NextArg a -> Maybe (NextArg ExceptionSpec)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' ExceptionSpec
NonThrowing
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"DO" Next a a
-> (NextArg a -> Maybe (NextArg ExceptionSpec))
-> NextArg a
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg ExceptionSpec))
-> NextArg a
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Expression Expression
forall a. Text -> Next a a
match Text
"E"
                         Next Expression Expression
-> (NextArg Expression -> Maybe (NextArg ExceptionSpec))
-> NextArg Expression
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> ExceptionSpec)
-> NextArg Expression -> Maybe (NextArg ExceptionSpec)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> ExceptionSpec
ComputedThrow
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"Dw" Next a a
-> (NextArg a -> Maybe (NextArg ExceptionSpec))
-> NextArg a
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a (NonEmpty Type_)
AnyNext (NonEmpty Type_)
types_ Next a (NonEmpty Type_)
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg ExceptionSpec))
-> NextArg a
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_))
forall a. Text -> Next a a
match Text
"E"
                         (NextArg (NonEmpty Type_) -> Maybe (NextArg (NonEmpty Type_)))
-> (NextArg (NonEmpty Type_) -> Maybe (NextArg ExceptionSpec))
-> NextArg (NonEmpty Type_)
-> Maybe (NextArg ExceptionSpec)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Type_ -> ExceptionSpec)
-> NextArg (NonEmpty Type_) -> Maybe (NextArg ExceptionSpec)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap NonEmpty Type_ -> ExceptionSpec
Throwing
                       ]

class_enum_type :: AnyNext Type_
class_enum_type :: AnyNext Type_
class_enum_type = [NextArg a -> Maybe (NextArg Type_)]
-> NextArg a -> Maybe (NextArg Type_)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ (Name -> Type_) -> NextArg Name -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> Type_
ClassUnionStructEnum (NextArg Name -> Maybe (NextArg Type_))
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg Name)
AnyNext Name
name
                        , Text -> Next a a
forall a. Text -> Next a a
match Text
"Ts" Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Name -> Type_) -> NextArg Name -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> Type_
ClassStruct (NextArg Name -> Maybe (NextArg Type_))
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg Name)
AnyNext Name
name
                        , Text -> Next a a
forall a. Text -> Next a a
match Text
"Tu" Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Name -> Type_) -> NextArg Name -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> Type_
Union (NextArg Name -> Maybe (NextArg Type_))
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg Name)
AnyNext Name
name
                        , Text -> Next a a
forall a. Text -> Next a a
match Text
"Te" Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Name -> Type_) -> NextArg Name -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Name -> Type_
Enum (NextArg Name -> Maybe (NextArg Type_))
-> (NextArg a -> Maybe (NextArg Name))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< NextArg a -> Maybe (NextArg Name)
AnyNext Name
name
                        ]

array_type :: AnyNext Type_
array_type :: AnyNext Type_
array_type = Text -> Next a a
forall a. Text -> Next a a
match Text
"A"
             Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg a -> Maybe (NextArg Type_)]
-> NextArg a -> Maybe (NextArg Type_)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"_" Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
type_ (NextArg a -> Maybe (NextArg Type_))
-> Next Type_ Type_ -> NextArg a -> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Type_) -> Next Type_ Type_
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (ArrayBound -> Type_ -> Type_
ArrayType ArrayBound
NoBounds)
                       , Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Int Int
forall a. Text -> Next a a
match Text
"_" Next Int Int
-> (NextArg Int -> Maybe (NextArg Type_)) -> Next Int (Int, Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg Int -> Maybe (NextArg Type_)
AnyNext Type_
type_
                         Next Int (Int, Type_)
-> (NextArg (Int, Type_) -> Maybe (NextArg Type_))
-> NextArg Int
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Int, Type_) -> Type_)
-> NextArg (Int, Type_) -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Int -> Type_ -> Type_) -> (Int, Type_) -> Type_
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (ArrayBound -> Type_ -> Type_
ArrayType (ArrayBound -> Type_ -> Type_)
-> (Int -> ArrayBound) -> Int -> Type_ -> Type_
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> ArrayBound
NumBound))
                       , Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Expression Expression
forall a. Text -> Next a a
match Text
"_" Next Expression Expression
-> (NextArg Expression -> Maybe (NextArg Type_))
-> Next Expression (Expression, Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg Expression -> Maybe (NextArg Type_)
AnyNext Type_
type_
                         Next Expression (Expression, Type_)
-> (NextArg (Expression, Type_) -> Maybe (NextArg Type_))
-> NextArg Expression
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Expression, Type_) -> Type_)
-> NextArg (Expression, Type_) -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Expression -> Type_ -> Type_) -> (Expression, Type_) -> Type_
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (ArrayBound -> Type_ -> Type_
ArrayType (ArrayBound -> Type_ -> Type_)
-> (Expression -> ArrayBound) -> Expression -> Type_ -> Type_
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Expression -> ArrayBound
ExprBound))
                       ]

pointer_to_member_type :: AnyNext Type_
pointer_to_member_type :: AnyNext Type_
pointer_to_member_type = Text -> Next a a
forall a. Text -> Next a a
match Text
"M"
                         Next a a
-> (NextArg a -> Maybe (NextArg Type_))
-> NextArg a
-> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Type_)
AnyNext Type_
type_ (NextArg a -> Maybe (NextArg Type_))
-> Next Type_ Type_ -> NextArg a -> Maybe (NextArg Type_)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Type_ -> Type_)
-> NextArg Type_ -> Maybe (NextArg (Type_ -> Type_))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> Type_ -> Type_
PointerToMember
                         (NextArg Type_ -> Maybe (NextArg (Type_ -> Type_)))
-> Next (Type_ -> Type_) Type_
-> Next Type_ (Type_ -> Type_, Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Type_ -> Type_) Type_
AnyNext Type_
type_ Next Type_ (Type_ -> Type_, Type_)
-> (NextArg (Type_ -> Type_, Type_) -> Maybe (NextArg Type_))
-> Next Type_ Type_
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Type_ -> Type_, Type_) -> Maybe (NextArg Type_)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply

function_encoding :: AnyNext Encoding
function_encoding :: AnyNext Encoding
function_encoding NextArg a
i = do NextArg Encoding
e <- Next a Encoding
AnyNext Encoding
encoding NextArg a
i
                         Bool -> Maybe ()
require (Bool -> Maybe ()) -> Bool -> Maybe ()
forall a b. (a -> b) -> a -> b
$ case NextArg Encoding
e NextArg Encoding
-> Getting Encoding (NextArg Encoding) Encoding -> Encoding
forall s a. s -> Getting a s a -> a
^. Getting Encoding (NextArg Encoding) Encoding
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal of
                                     EncFunc {} -> Bool
True
                                     EncStaticFunc {} -> Bool
True
                                     Encoding
_ -> Bool
False
                         Next Encoding Encoding
forall a. a -> Maybe a
forall (m :: * -> *) a. Monad m => a -> m a
return NextArg Encoding
e

discriminator :: Next a Discriminator
discriminator :: forall a. Next a Discriminator
discriminator = [NextArg a -> Maybe (NextArg Int)]
-> NextArg a -> Maybe (NextArg Int)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"_" Next a a
-> (NextArg a -> Maybe (NextArg Int))
-> NextArg a
-> Maybe (NextArg Int)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Int)
AnyNext Int
single_digit_num
                      , Text -> Next a a
forall a. Text -> Next a a
match Text
"__" Next a a
-> (NextArg a -> Maybe (NextArg Int))
-> NextArg a
-> Maybe (NextArg Int)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Int)
AnyNext Int
digits_num (NextArg a -> Maybe (NextArg Int))
-> Next Int Int -> NextArg a -> Maybe (NextArg Int)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Int Int
forall a. Text -> Next a a
match Text
"_"
                      ]
                (NextArg a -> Maybe (NextArg Int))
-> (NextArg Int -> Maybe (NextArg Discriminator))
-> NextArg a
-> Maybe (NextArg Discriminator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> Discriminator)
-> NextArg Int -> Maybe (NextArg Discriminator)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Natural -> Discriminator
Discriminator (Natural -> Discriminator)
-> (Int -> Natural) -> Int -> Discriminator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Natural
forall a. Enum a => Int -> a
toEnum)

template_prefix_and_args :: AnyNext (TemplatePrefix, Maybe TemplateArgs)
template_prefix_and_args :: AnyNext (TemplatePrefix, Maybe TemplateArgs)
template_prefix_and_args =
  [NextArg a -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))]
-> NextArg a
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ [NextArg a -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))]
-> NextArg a
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ \NextArg a
i -> do NextArg Prefix
p <- Next a Prefix
AnyNext Prefix
prefix NextArg a
i
                           (Prefix
tpr, Either UnqualifiedName TemplateArgs
entas) <- Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast (NextArg Prefix
p NextArg Prefix -> Getting Prefix (NextArg Prefix) Prefix -> Prefix
forall s a. s -> Getting a s a -> a
^. Getting Prefix (NextArg Prefix) Prefix
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)
                           (Prefix
rmnpval, Either UnqualifiedName TemplateArgs
ent) <- Prefix -> Maybe (Prefix, Either UnqualifiedName TemplateArgs)
prefixInitLast Prefix
tpr
                           case Either UnqualifiedName TemplateArgs
ent of
                             Right TemplateArgs
_ ->
                               Demangler
-> String
-> [String]
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"template_prefix_and_args"
                               [String
"Penultimate prefix must be an UnqualifiedName"]
                             Left UnqualifiedName
un ->
                               -- ultimate prefix entry must be template_args
                               case Either UnqualifiedName TemplateArgs
entas of
                                 Left UnqualifiedName
_ -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall a. Maybe a
Nothing
                                 Right TemplateArgs
tas ->
                                   let constr :: NonEmpty UnqualifiedName -> TemplatePrefix
constr = case Prefix
rmnpval of
                                                  Prefix
EmptyPrefix -> NonEmpty UnqualifiedName -> TemplatePrefix
GlobalTemplate
                                                  Prefix
p' -> Prefix -> NonEmpty UnqualifiedName -> TemplatePrefix
NestedTemplate Prefix
p'
                                   in NextArg Prefix
-> (TemplatePrefix, Maybe TemplateArgs)
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (f :: * -> *) a b.
Applicative f =>
NextArg a -> b -> f (NextArg b)
ret NextArg Prefix
p (NonEmpty UnqualifiedName -> TemplatePrefix
constr (UnqualifiedName
un UnqualifiedName -> [UnqualifiedName] -> NonEmpty UnqualifiedName
forall a. a -> [a] -> NonEmpty a
:| []), TemplateArgs -> Maybe TemplateArgs
forall a. a -> Maybe a
Just TemplateArgs
tas)
                   , Next a TemplateArg
AnyNext TemplateArg
template_param Next a TemplateArg
-> (NextArg TemplateArg
    -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs)))
-> NextArg a
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplateArg -> (TemplatePrefix, Maybe TemplateArgs))
-> NextArg TemplateArg
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((, Maybe TemplateArgs
forall a. Maybe a
Nothing) (TemplatePrefix -> (TemplatePrefix, Maybe TemplateArgs))
-> (TemplateArg -> TemplatePrefix)
-> TemplateArg
-> (TemplatePrefix, Maybe TemplateArgs)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TemplateArg -> TemplatePrefix
TemplateTemplateParam)
                   ]
           , Next a Substitution'
AnyNext Substitution'
substitution Next a Substitution'
-> (NextArg Substitution'
    -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs)))
-> NextArg a
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next Substitution TemplatePrefix
-> Next Substitution' TemplatePrefix
substituteTemplatePrefix
             (\NextArg Substitution
s -> Demangler -> String -> [String] -> Maybe (NextArg TemplatePrefix)
forall a b. a -> String -> [String] -> Maybe b
cannot Demangler
Demangler String
"template_prefix_and_args"
                    [ String
"Not a template prefix substitute:"
                    , Substitution -> String
forall a. Show a => a -> String
show (NextArg Substitution
s NextArg Substitution
-> Getting Substitution (NextArg Substitution) Substitution
-> Substitution
forall s a. s -> Getting a s a -> a
^. Getting Substitution (NextArg Substitution) Substitution
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)
                    ]
             )
             Next Substitution' TemplatePrefix
-> (NextArg TemplatePrefix
    -> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs)))
-> NextArg Substitution'
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplatePrefix -> (TemplatePrefix, Maybe TemplateArgs))
-> NextArg TemplatePrefix
-> Maybe (NextArg (TemplatePrefix, Maybe TemplateArgs))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (, Maybe TemplateArgs
forall a. Maybe a
Nothing)
           ]


template_template_param :: AnyNext TemplateParam
template_template_param :: AnyNext TemplateArg
template_template_param NextArg a
i = (Next a TemplateArg
AnyNext TemplateArg
template_param NextArg a
i Maybe (NextArg TemplateArg)
-> (NextArg TemplateArg -> Maybe (NextArg TemplateArg))
-> Maybe (NextArg TemplateArg)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg TemplateArg -> Maybe (NextArg TemplateArg)
canSubstTemplateParam)
                            Maybe (NextArg TemplateArg)
-> Maybe (NextArg TemplateArg) -> Maybe (NextArg TemplateArg)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Next a Substitution'
AnyNext Substitution'
substitution NextArg a
i Maybe (NextArg Substitution')
-> (NextArg Substitution' -> Maybe (NextArg TemplateArg))
-> Maybe (NextArg TemplateArg)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= String -> NextArg Substitution' -> Maybe (NextArg TemplateArg)
forall a b. String -> Next a b
tbd String
"ttp subs")

-- | Process a set of template args.
--
-- Note that only the *outermost* and *final* set of template args should be
-- candidates for substitution.
--
--   foo<bar<int> >              --->   [ bar<int> ]
--   foo<int>::bar<float, char>  --->  [ float, char ]
--
-- The nTmplSubsLatch and lTmplSubsLock form a two-phase state management: both
-- start as false and lock is one cycle after latch.  When locked, no new
-- template substitutions can be made.  Thus, recursion is handled by the first
-- (outermost) set of template parameters setting latch, which means that any
-- subsequent of (recursive) template parameters will set lock and therefore will
-- not update any template parameter substitution candidates.
--
-- The *final* set is handled by clearing the set of template parameter
-- substitution candidates any time this is entered and latch isn't set (latch is
-- cleared when each outer-level template parameter parsing is completed or has
-- not yet started).
--
-- One additional constraint is that template parameters are only substitution
-- candidates if encountered in the function "name" portion, but once function
-- arguments are processed, no more template argument candidates are added.  This
-- is accomplished by the argument processing setting the lock, and not doing any
-- clearing here when lock is set.

template_args :: AnyNext TemplateArgs
template_args :: AnyNext TemplateArgs
template_args = Text -> Next a a
forall a. Text -> Next a a
match Text
"I"
                Next a a
-> (NextArg a -> Maybe (NextArg TemplateArgs))
-> NextArg a
-> Maybe (NextArg TemplateArgs)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (\NextArg a
i -> do let latched :: Bool
latched = NextArg a
i NextArg a -> Getting Bool (NextArg a) Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool (NextArg a) Bool
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLatch
                                  locked :: Bool
locked = NextArg a
i NextArg a -> Getting Bool (NextArg a) Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool (NextArg a) Bool
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock
                                  lock :: Bool
lock = Bool
latched
                                  enter :: NextArg a -> NextArg a
enter = ((Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLatch ((Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a))
-> Bool -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
True)
                                          (NextArg a -> NextArg a)
-> (NextArg a -> NextArg a) -> NextArg a -> NextArg a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock ((Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a))
-> Bool -> NextArg a -> NextArg a
forall s t. ASetter s t Bool Bool -> Bool -> s -> t
||~ Bool
lock)
                                  i' :: NextArg a
i' = if Bool
latched Bool -> Bool -> Bool
|| Bool
locked
                                          -- reads: if outermost and not reading
                                          -- function arguments
                                       then NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& NextArg a -> NextArg a
enter
                                       else NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& NextArg a -> NextArg a
enter NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Seq TemplateArg -> Identity (Seq TemplateArg))
-> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Seq TemplateArg -> f (Seq TemplateArg))
-> NextArg a -> f (NextArg a)
nTmplSubs ((Seq TemplateArg -> Identity (Seq TemplateArg))
 -> NextArg a -> Identity (NextArg a))
-> Seq TemplateArg -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Seq TemplateArg
forall a. Monoid a => a
mempty
                              NextArg TemplateArgs
r <- AnyNext TemplateArg -> NextArg a -> Maybe (NextArg TemplateArgs)
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a TemplateArg
AnyNext TemplateArg
template_arg NextArg a
i'
                              NextArg TemplateArgs -> Maybe (NextArg TemplateArgs)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
                                (NextArg TemplateArgs -> Maybe (NextArg TemplateArgs))
-> NextArg TemplateArgs -> Maybe (NextArg TemplateArgs)
forall a b. (a -> b) -> a -> b
$ NextArg TemplateArgs
r
                                NextArg TemplateArgs
-> (NextArg TemplateArgs -> NextArg TemplateArgs)
-> NextArg TemplateArgs
forall a b. a -> (a -> b) -> b
& (Bool -> Identity Bool)
-> NextArg TemplateArgs -> Identity (NextArg TemplateArgs)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLatch ((Bool -> Identity Bool)
 -> NextArg TemplateArgs -> Identity (NextArg TemplateArgs))
-> Bool -> NextArg TemplateArgs -> NextArg TemplateArgs
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
latched
                                NextArg TemplateArgs
-> (NextArg TemplateArgs -> NextArg TemplateArgs)
-> NextArg TemplateArgs
forall a b. a -> (a -> b) -> b
& (Bool -> Identity Bool)
-> NextArg TemplateArgs -> Identity (NextArg TemplateArgs)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock ((Bool -> Identity Bool)
 -> NextArg TemplateArgs -> Identity (NextArg TemplateArgs))
-> Bool -> NextArg TemplateArgs -> NextArg TemplateArgs
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
locked
                    )
                (NextArg a -> Maybe (NextArg TemplateArgs))
-> (NextArg TemplateArgs -> Maybe (NextArg TemplateArgs))
-> NextArg a
-> Maybe (NextArg TemplateArgs)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg TemplateArgs -> Maybe (NextArg TemplateArgs)
forall a. Text -> Next a a
match Text
"E"

template_arg :: AnyNext TemplateArg
template_arg :: AnyNext TemplateArg
template_arg =
  -- n.b. must check expr_primary ('L') before type_ because type_ can be a class
  -- name, which can be a name, which can be an unqualified name, which can be a
  -- "[module_name] L ..."
  [NextArg a -> Maybe (NextArg TemplateArg)]
-> NextArg a -> Maybe (NextArg TemplateArg)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a ExprPrimary
AnyNext ExprPrimary
expr_primary Next a ExprPrimary
-> (NextArg ExprPrimary -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ExprPrimary -> TemplateArg)
-> NextArg ExprPrimary -> Maybe (NextArg TemplateArg)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ExprPrimary -> TemplateArg
TArgSimpleExpr (NextArg ExprPrimary -> Maybe (NextArg TemplateArg))
-> (NextArg TemplateArg -> Maybe (NextArg TemplateArg))
-> NextArg ExprPrimary
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg TemplateArg -> Maybe (NextArg TemplateArg)
canSubstTemplateArg
        , Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> TemplateArg)
-> NextArg Type_ -> Maybe (NextArg TemplateArg)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> TemplateArg
TArgType (NextArg Type_ -> Maybe (NextArg TemplateArg))
-> (NextArg TemplateArg -> Maybe (NextArg TemplateArg))
-> NextArg Type_
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg TemplateArg -> Maybe (NextArg TemplateArg)
canSubstTemplateArg
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"X" Next a a
-> (NextArg a -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Expression Expression
forall a. Text -> Next a a
match Text
"E" Next Expression Expression
-> (NextArg Expression -> Maybe (NextArg TemplateArg))
-> NextArg Expression
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> TemplateArg)
-> NextArg Expression -> Maybe (NextArg TemplateArg)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> TemplateArg
TArgExpr
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"J"
          Next a a
-> (NextArg a -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (\NextArg a
i -> do let locked :: Bool
locked = NextArg a
i NextArg a -> Getting Bool (NextArg a) Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool (NextArg a) Bool
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock
                        NextArg [TemplateArg]
r <- Next () TemplateArg -> Next () [TemplateArg]
forall a. Next () a -> Next () [a]
many' Next () TemplateArg
AnyNext TemplateArg
template_arg Next () [TemplateArg]
-> (NextArg a
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> NextArg a
-> Maybe (NextArg [TemplateArg])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard (NextArg a -> Maybe (NextArg [TemplateArg]))
-> NextArg a -> Maybe (NextArg [TemplateArg])
forall a b. (a -> b) -> a -> b
$ NextArg a
i NextArg a -> (NextArg a -> NextArg a) -> NextArg a
forall a b. a -> (a -> b) -> b
& (Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a)
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock ((Bool -> Identity Bool) -> NextArg a -> Identity (NextArg a))
-> Bool -> NextArg a -> NextArg a
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
True
                        NextArg [TemplateArg]
l <- Text -> Next [TemplateArg] [TemplateArg]
forall a. Text -> Next a a
match Text
"E" NextArg [TemplateArg]
r
                        ([TemplateArg] -> TemplateArg)
-> NextArg [TemplateArg] -> Maybe (NextArg TemplateArg)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [TemplateArg] -> TemplateArg
TArgPack (NextArg [TemplateArg] -> Maybe (NextArg TemplateArg))
-> NextArg [TemplateArg] -> Maybe (NextArg TemplateArg)
forall a b. (a -> b) -> a -> b
$ NextArg [TemplateArg]
l NextArg [TemplateArg]
-> (NextArg [TemplateArg] -> NextArg [TemplateArg])
-> NextArg [TemplateArg]
forall a b. a -> (a -> b) -> b
& (Bool -> Identity Bool)
-> NextArg [TemplateArg] -> Identity (NextArg [TemplateArg])
forall a (f :: * -> *).
Functor f =>
(Bool -> f Bool) -> NextArg a -> f (NextArg a)
nTmplSubsLock ((Bool -> Identity Bool)
 -> NextArg [TemplateArg] -> Identity (NextArg [TemplateArg]))
-> Bool -> NextArg [TemplateArg] -> NextArg [TemplateArg]
forall s t a b. ASetter s t a b -> b -> s -> t
.~ Bool
locked
              )
          (NextArg a -> Maybe (NextArg TemplateArg))
-> (NextArg TemplateArg -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg TemplateArg -> Maybe (NextArg TemplateArg)
canSubstTemplateArg
        ]

template_param :: AnyNext TemplateParam
template_param :: AnyNext TemplateArg
template_param =
  [NextArg a -> Maybe (NextArg (Maybe Int))]
-> NextArg a -> Maybe (NextArg (Maybe Int))
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"T_" Next a a
-> (NextArg a -> Maybe (NextArg (Maybe Int)))
-> NextArg a
-> Maybe (NextArg (Maybe Int))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Maybe Int -> NextArg a -> Maybe (NextArg (Maybe Int))
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' Maybe Int
forall a. Maybe a
Nothing
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"T" Next a a
-> (NextArg a -> Maybe (NextArg (Maybe Int)))
-> NextArg a
-> Maybe (NextArg (Maybe Int))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Int
AnyNext Int
digits_num Next a Int
-> (NextArg Int -> Maybe (NextArg (Maybe Int)))
-> NextArg a
-> Maybe (NextArg (Maybe Int))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> Maybe Int) -> NextArg Int -> Maybe (NextArg (Maybe Int))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Int -> Maybe Int
forall a. a -> Maybe a
Just (NextArg Int -> Maybe (NextArg (Maybe Int)))
-> (NextArg (Maybe Int) -> Maybe (NextArg (Maybe Int)))
-> NextArg Int
-> Maybe (NextArg (Maybe Int))
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg (Maybe Int) -> Maybe (NextArg (Maybe Int))
forall a. Text -> Next a a
match Text
"_"
        ]
  (NextArg a -> Maybe (NextArg (Maybe Int)))
-> (NextArg (Maybe Int) -> Maybe (NextArg TemplateArg))
-> NextArg a
-> Maybe (NextArg TemplateArg)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Maybe Int) -> Maybe (NextArg TemplateArg)
substituteTemplateParam

expression :: AnyNext Expression
expression :: AnyNext Expression
expression =
  let opMatch :: (Operator, (Arity, (Text, b)))
-> NextArg a -> Maybe (NextArg Expression)
opMatch (Operator
o,(Arity
Unary,(Text
t,b
_))) = Text -> Next a a
forall a. Text -> Next a a
match Text
t Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Operator -> Expression -> Expression
ExprUnary Operator
o)
      opMatch (Operator
o,(Arity
Binary,(Text
t,b
_))) = Text -> Next a a
forall a. Text -> Next a a
match Text
t Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression
                                   (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression -> Expression)
-> NextArg Expression -> Maybe (NextArg (Expression -> Expression))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Operator -> Expression -> Expression -> Expression
ExprBinary Operator
o) (NextArg Expression -> Maybe (NextArg (Expression -> Expression)))
-> Next (Expression -> Expression) Expression
-> Next Expression (Expression -> Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Expression -> Expression) Expression
AnyNext Expression
expression
                                   Next Expression (Expression -> Expression, Expression)
-> (NextArg (Expression -> Expression, Expression)
    -> Maybe (NextArg Expression))
-> Next Expression Expression
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Expression -> Expression, Expression)
-> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
      opMatch (Operator
o,(Arity
Trinary,(Text
t,b
_))) = Text -> Next a a
forall a. Text -> Next a a
match Text
t Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression
                                    (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression -> Expression -> Expression)
-> NextArg Expression
-> Maybe (NextArg (Expression -> Expression -> Expression))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Operator -> Expression -> Expression -> Expression -> Expression
ExprTrinary Operator
o) (NextArg Expression
 -> Maybe (NextArg (Expression -> Expression -> Expression)))
-> Next (Expression -> Expression -> Expression) Expression
-> Next
     Expression (Expression -> Expression -> Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Expression -> Expression -> Expression) Expression
AnyNext Expression
expression
                                    Next
  Expression (Expression -> Expression -> Expression, Expression)
-> (NextArg (Expression -> Expression -> Expression, Expression)
    -> Maybe (NextArg Expression))
-> Next Expression Expression
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Expression -> Expression -> Expression, Expression)
-> Maybe (NextArg (Expression -> Expression))
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply (NextArg (Expression -> Expression -> Expression, Expression)
 -> Maybe (NextArg (Expression -> Expression)))
-> Next (Expression -> Expression) Expression
-> Next
     (Expression -> Expression -> Expression, Expression)
     (Expression -> Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Expression -> Expression) Expression
AnyNext Expression
expression
                                    Next
  (Expression -> Expression -> Expression, Expression)
  (Expression -> Expression, Expression)
-> (NextArg (Expression -> Expression, Expression)
    -> Maybe (NextArg Expression))
-> NextArg (Expression -> Expression -> Expression, Expression)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Expression -> Expression, Expression)
-> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
      opMatch (Operator, (Arity, (Text, b)))
_ = Maybe (NextArg Expression)
-> NextArg a -> Maybe (NextArg Expression)
forall a b. a -> b -> a
const Maybe (NextArg Expression)
forall a. Maybe a
Nothing
      binary_op :: NextArg a -> Maybe (NextArg Operator)
binary_op = NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
operator_name
                  (NextArg a -> Maybe (NextArg Operator))
-> (NextArg Operator -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \NextArg Operator
i -> case Operator
-> [(Operator, (Arity, (Text, Text)))]
-> Maybe (Arity, (Text, Text))
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (NextArg Operator
iNextArg Operator
-> Getting Operator (NextArg Operator) Operator -> Operator
forall s a. s -> Getting a s a -> a
^.Getting Operator (NextArg Operator) Operator
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) [(Operator, (Arity, (Text, Text)))]
opTable of
                              Just (Arity
Binary, (Text, Text)
_) -> NextArg Operator -> Maybe (NextArg Operator)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NextArg Operator
i
                              Maybe (Arity, (Text, Text))
_ -> Maybe (NextArg Operator)
forall a. Maybe a
Nothing
      unary_op :: NextArg a -> Maybe (NextArg Operator)
unary_op = NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
operator_name
                  (NextArg a -> Maybe (NextArg Operator))
-> (NextArg Operator -> Maybe (NextArg Operator))
-> NextArg a
-> Maybe (NextArg Operator)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> \NextArg Operator
i -> case Operator
-> [(Operator, (Arity, (Text, Text)))]
-> Maybe (Arity, (Text, Text))
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup (NextArg Operator
iNextArg Operator
-> Getting Operator (NextArg Operator) Operator -> Operator
forall s a. s -> Getting a s a -> a
^.Getting Operator (NextArg Operator) Operator
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) [(Operator, (Arity, (Text, Text)))]
opTable of
                              Just (Arity
Unary, (Text, Text)
_) -> NextArg Operator -> Maybe (NextArg Operator)
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure NextArg Operator
i
                              Maybe (Arity, (Text, Text))
_ -> Maybe (NextArg Operator)
forall a. Maybe a
Nothing
      rmap2 :: (a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 = ((a, b) -> b) -> NextArg (a, b) -> Maybe (NextArg b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (((a, b) -> b) -> NextArg (a, b) -> Maybe (NextArg b))
-> ((a -> b -> b) -> (a, b) -> b)
-> (a -> b -> b)
-> NextArg (a, b)
-> Maybe (NextArg b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> b -> b) -> (a, b) -> b
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry
      isGS :: (a, Maybe a) -> Bool
isGS = Maybe a -> Bool
forall a. Maybe a -> Bool
isJust (Maybe a -> Bool)
-> ((a, Maybe a) -> Maybe a) -> (a, Maybe a) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Maybe a
forall a b. (a, b) -> b
snd
  in [NextArg a -> Maybe (NextArg Expression)]
-> NextArg a -> Maybe (NextArg Expression)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum'
     (((Operator, (Arity, (Text, Text)))
-> NextArg a -> Maybe (NextArg Expression)
forall {b} {a}.
(Operator, (Arity, (Text, b)))
-> NextArg a -> Maybe (NextArg Expression)
opMatch ((Operator, (Arity, (Text, Text)))
 -> NextArg a -> Maybe (NextArg Expression))
-> [(Operator, (Arity, (Text, Text)))]
-> [NextArg a -> Maybe (NextArg Expression)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Operator, (Arity, (Text, Text)))]
opTable)
      [NextArg a -> Maybe (NextArg Expression)]
-> [NextArg a -> Maybe (NextArg Expression)]
-> [NextArg a -> Maybe (NextArg Expression)]
forall a. Semigroup a => a -> a -> a
<>
      [ Text -> Next a a
forall a. Text -> Next a a
match Text
"pp_" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprPfxPlus
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"mm_" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprPfxMinus
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"cl" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> AnyNext Expression -> Next a (NonEmpty Expression)
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a Expression
AnyNext Expression
expression Next a (NonEmpty Expression)
-> (NextArg (NonEmpty Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (NonEmpty Expression -> Expression)
-> NextArg (NonEmpty Expression) -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap NonEmpty Expression -> Expression
ExprCall
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"cv" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_ -> Next Type_ Expression -> Next a (Type_, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Type_ Expression
AnyNext Expression
expression
        Next a (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (Type_, Expression) (Type_, Expression)
forall a. Text -> Next a a
match Text
"E"  -- n.b. missing from https://itanium-cxx-abi.github.io
        Next (Type_, Expression) (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg (Type_, Expression)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression -> Expression)
-> NextArg (Type_, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> Expression -> Expression
ExprConvert1
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"cv" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> Next Type_ Expression -> NextArg a -> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Type_ Type_
forall a. Text -> Next a a
match Text
"_" Next Type_ Type_
-> Next Type_ (NonEmpty Expression)
-> Next Type_ (Type_, NonEmpty Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> AnyNext Expression -> Next Type_ (NonEmpty Expression)
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a Expression
AnyNext Expression
expression
        Next Type_ (Type_, NonEmpty Expression)
-> (NextArg (Type_, NonEmpty Expression)
    -> Maybe (NextArg Expression))
-> Next Type_ Expression
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> NonEmpty Expression -> Expression)
-> NextArg (Type_, NonEmpty Expression)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> NonEmpty Expression -> Expression
ExprConvertSome
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"tl" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> Next Type_ [BracedExpression]
-> Next a (Type_, [BracedExpression])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () BracedExpression -> Next () [BracedExpression]
forall a. Next () a -> Next () [a]
many' Next () BracedExpression
AnyNext BracedExpression
braced_expression Next () [BracedExpression]
-> (NextArg Type_
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next Type_ [BracedExpression]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg Type_
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next a (Type_, [BracedExpression])
-> (NextArg (Type_, [BracedExpression])
    -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next (Type_, [BracedExpression]) (Type_, [BracedExpression])
forall a. Text -> Next a a
match Text
"E" Next (Type_, [BracedExpression]) (Type_, [BracedExpression])
-> (NextArg (Type_, [BracedExpression])
    -> Maybe (NextArg Expression))
-> NextArg (Type_, [BracedExpression])
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> [BracedExpression] -> Expression)
-> NextArg (Type_, [BracedExpression])
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> [BracedExpression] -> Expression
ExprConvertInit
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"il" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next () BracedExpression -> Next () [BracedExpression]
forall a. Next () a -> Next () [a]
many' Next () BracedExpression
AnyNext BracedExpression
braced_expression Next () [BracedExpression]
-> (NextArg a
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> NextArg a
-> Maybe (NextArg [BracedExpression])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard (NextArg a -> Maybe (NextArg [BracedExpression]))
-> (NextArg [BracedExpression] -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([BracedExpression] -> Expression)
-> NextArg [BracedExpression] -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [BracedExpression] -> Expression
ExprBracedInit
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"nw"
        Next (a, Maybe a) (a, Maybe a)
-> Next (a, Maybe a) [Expression]
-> Next (a, Maybe a) ((a, Maybe a), [Expression])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () Expression -> Next () [Expression]
forall a. Next () a -> Next () [a]
many' Next () Expression
AnyNext Expression
expression Next () [Expression]
-> (NextArg (a, Maybe a)
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next (a, Maybe a) [Expression]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg (a, Maybe a)
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next (a, Maybe a) ((a, Maybe a), [Expression])
-> (NextArg ((a, Maybe a), [Expression])
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next ((a, Maybe a), [Expression]) ((a, Maybe a), [Expression])
forall a. Text -> Next a a
match Text
"_" Next ((a, Maybe a), [Expression]) ((a, Maybe a), [Expression])
-> Next ((a, Maybe a), [Expression]) Type_
-> Next
     ((a, Maybe a), [Expression]) (((a, Maybe a), [Expression]), Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next ((a, Maybe a), [Expression]) Type_
AnyNext Type_
type_ Next
  ((a, Maybe a), [Expression]) (((a, Maybe a), [Expression]), Type_)
-> (NextArg (((a, Maybe a), [Expression]), Type_)
    -> Maybe (NextArg Expression))
-> NextArg ((a, Maybe a), [Expression])
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     (((a, Maybe a), [Expression]), Type_)
     (((a, Maybe a), [Expression]), Type_)
forall a. Text -> Next a a
match Text
"E"
        Next
  (((a, Maybe a), [Expression]), Type_)
  (((a, Maybe a), [Expression]), Type_)
-> (NextArg (((a, Maybe a), [Expression]), Type_)
    -> Maybe (NextArg Expression))
-> NextArg (((a, Maybe a), [Expression]), Type_)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (((a, Maybe a), [Expression]) -> Type_ -> Expression)
-> NextArg (((a, Maybe a), [Expression]), Type_)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 (((a, Maybe a) -> [Expression] -> Type_ -> Expression)
-> ((a, Maybe a), [Expression]) -> Type_ -> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (Bool -> [Expression] -> Type_ -> Expression
ExprNew (Bool -> [Expression] -> Type_ -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> [Expression]
-> Type_
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS))
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"nw" Next (a, Maybe a) (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((a, Maybe a)
 -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> NextArg (a, Maybe a)
-> Maybe
     (NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> [Expression] -> Type_ -> InitializerExpr -> Expression
ExprNewInit (Bool -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> [Expression]
-> Type_
-> InitializerExpr
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS)
        (NextArg (a, Maybe a)
 -> Maybe
      (NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression)))
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression)
     [Expression]
-> Next
     (a, Maybe a)
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () Expression -> Next () [Expression]
forall a. Next () a -> Next () [a]
many' Next () Expression
AnyNext Expression
expression Next () [Expression]
-> (NextArg
      ([Expression] -> Type_ -> InitializerExpr -> Expression)
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression)
     [Expression]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression)
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next
  (a, Maybe a)
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
-> (NextArg
      ([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression])
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
forall a. Text -> Next a a
match Text
"_" Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     Type_
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     (([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression]),
      Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  Type_
AnyNext Type_
type_ Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  (([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression]),
   Type_)
-> Next
     (([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression]),
      Type_)
     InitializerExpr
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     ((([Expression] -> Type_ -> InitializerExpr -> Expression,
        [Expression]),
       Type_),
      InitializerExpr)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next
  (([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression]),
   Type_)
  InitializerExpr
AnyNext InitializerExpr
initializer
        Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  ((([Expression] -> Type_ -> InitializerExpr -> Expression,
     [Expression]),
    Type_),
   InitializerExpr)
-> (NextArg
      ((([Expression] -> Type_ -> InitializerExpr -> Expression,
         [Expression]),
        Type_),
       InitializerExpr)
    -> Maybe (NextArg Expression))
-> NextArg
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression]),
  Type_)
 -> InitializerExpr -> Expression)
-> NextArg
     ((([Expression] -> Type_ -> InitializerExpr -> Expression,
        [Expression]),
       Type_),
      InitializerExpr)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 ((([Expression] -> Type_ -> InitializerExpr -> Expression,
  [Expression])
 -> Type_ -> InitializerExpr -> Expression)
-> (([Expression] -> Type_ -> InitializerExpr -> Expression,
     [Expression]),
    Type_)
-> InitializerExpr
-> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((([Expression] -> Type_ -> InitializerExpr -> Expression)
 -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> ([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression])
-> Type_
-> InitializerExpr
-> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ([Expression] -> Type_ -> InitializerExpr -> Expression)
-> [Expression] -> Type_ -> InitializerExpr -> Expression
forall a b. (a -> b) -> a -> b
($)))
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"na"
        Next (a, Maybe a) (a, Maybe a)
-> Next (a, Maybe a) [Expression]
-> Next (a, Maybe a) ((a, Maybe a), [Expression])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () Expression -> Next () [Expression]
forall a. Next () a -> Next () [a]
many' Next () Expression
AnyNext Expression
expression Next () [Expression]
-> (NextArg (a, Maybe a)
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next (a, Maybe a) [Expression]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg (a, Maybe a)
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next (a, Maybe a) ((a, Maybe a), [Expression])
-> (NextArg ((a, Maybe a), [Expression])
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next ((a, Maybe a), [Expression]) ((a, Maybe a), [Expression])
forall a. Text -> Next a a
match Text
"_" Next ((a, Maybe a), [Expression]) ((a, Maybe a), [Expression])
-> Next ((a, Maybe a), [Expression]) Type_
-> Next
     ((a, Maybe a), [Expression]) (((a, Maybe a), [Expression]), Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next ((a, Maybe a), [Expression]) Type_
AnyNext Type_
type_ Next
  ((a, Maybe a), [Expression]) (((a, Maybe a), [Expression]), Type_)
-> (NextArg (((a, Maybe a), [Expression]), Type_)
    -> Maybe (NextArg Expression))
-> NextArg ((a, Maybe a), [Expression])
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     (((a, Maybe a), [Expression]), Type_)
     (((a, Maybe a), [Expression]), Type_)
forall a. Text -> Next a a
match Text
"E"
        Next
  (((a, Maybe a), [Expression]), Type_)
  (((a, Maybe a), [Expression]), Type_)
-> (NextArg (((a, Maybe a), [Expression]), Type_)
    -> Maybe (NextArg Expression))
-> NextArg (((a, Maybe a), [Expression]), Type_)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (((a, Maybe a), [Expression]) -> Type_ -> Expression)
-> NextArg (((a, Maybe a), [Expression]), Type_)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 (((a, Maybe a) -> [Expression] -> Type_ -> Expression)
-> ((a, Maybe a), [Expression]) -> Type_ -> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (Bool -> [Expression] -> Type_ -> Expression
ExprNewArray (Bool -> [Expression] -> Type_ -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> [Expression]
-> Type_
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS))
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"na" Next (a, Maybe a) (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((a, Maybe a)
 -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> NextArg (a, Maybe a)
-> Maybe
     (NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool -> [Expression] -> Type_ -> InitializerExpr -> Expression
ExprNewInitArray (Bool -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> [Expression]
-> Type_
-> InitializerExpr
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS)
        (NextArg (a, Maybe a)
 -> Maybe
      (NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression)))
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression)
     [Expression]
-> Next
     (a, Maybe a)
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () Expression -> Next () [Expression]
forall a. Next () a -> Next () [a]
many' Next () Expression
AnyNext Expression
expression Next () [Expression]
-> (NextArg
      ([Expression] -> Type_ -> InitializerExpr -> Expression)
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression)
     [Expression]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg ([Expression] -> Type_ -> InitializerExpr -> Expression)
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next
  (a, Maybe a)
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
-> (NextArg
      ([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression])
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
forall a. Text -> Next a a
match Text
"_" Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     Type_
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     (([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression]),
      Type_)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  Type_
AnyNext Type_
type_ Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  (([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression]),
   Type_)
-> Next
     (([Expression] -> Type_ -> InitializerExpr -> Expression,
       [Expression]),
      Type_)
     InitializerExpr
-> Next
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
     ((([Expression] -> Type_ -> InitializerExpr -> Expression,
        [Expression]),
       Type_),
      InitializerExpr)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next
  (([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression]),
   Type_)
  InitializerExpr
AnyNext InitializerExpr
initializer
        Next
  ([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression])
  ((([Expression] -> Type_ -> InitializerExpr -> Expression,
     [Expression]),
    Type_),
   InitializerExpr)
-> (NextArg
      ((([Expression] -> Type_ -> InitializerExpr -> Expression,
         [Expression]),
        Type_),
       InitializerExpr)
    -> Maybe (NextArg Expression))
-> NextArg
     ([Expression] -> Type_ -> InitializerExpr -> Expression,
      [Expression])
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((([Expression] -> Type_ -> InitializerExpr -> Expression,
   [Expression]),
  Type_)
 -> InitializerExpr -> Expression)
-> NextArg
     ((([Expression] -> Type_ -> InitializerExpr -> Expression,
        [Expression]),
       Type_),
      InitializerExpr)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 ((([Expression] -> Type_ -> InitializerExpr -> Expression,
  [Expression])
 -> Type_ -> InitializerExpr -> Expression)
-> (([Expression] -> Type_ -> InitializerExpr -> Expression,
     [Expression]),
    Type_)
-> InitializerExpr
-> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((([Expression] -> Type_ -> InitializerExpr -> Expression)
 -> [Expression] -> Type_ -> InitializerExpr -> Expression)
-> ([Expression] -> Type_ -> InitializerExpr -> Expression,
    [Expression])
-> Type_
-> InitializerExpr
-> Expression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ([Expression] -> Type_ -> InitializerExpr -> Expression)
-> [Expression] -> Type_ -> InitializerExpr -> Expression
forall a b. (a -> b) -> a -> b
($)))
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"dl" Next (a, Maybe a) (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> Next (a, Maybe a) ((a, Maybe a), Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg (a, Maybe a) -> Maybe (NextArg Expression)
AnyNext Expression
expression
        Next (a, Maybe a) ((a, Maybe a), Expression)
-> (NextArg ((a, Maybe a), Expression)
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((a, Maybe a) -> Expression -> Expression)
-> NextArg ((a, Maybe a), Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 (Bool -> Expression -> Expression
ExprDel (Bool -> Expression -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> Expression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS)
      , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs") Next a (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"da" Next (a, Maybe a) (a, Maybe a)
-> (NextArg (a, Maybe a) -> Maybe (NextArg Expression))
-> Next (a, Maybe a) ((a, Maybe a), Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg (a, Maybe a) -> Maybe (NextArg Expression)
AnyNext Expression
expression
        Next (a, Maybe a) ((a, Maybe a), Expression)
-> (NextArg ((a, Maybe a), Expression)
    -> Maybe (NextArg Expression))
-> NextArg (a, Maybe a)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((a, Maybe a) -> Expression -> Expression)
-> NextArg ((a, Maybe a), Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 (Bool -> Expression -> Expression
ExprDelArray (Bool -> Expression -> Expression)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> Expression
-> Expression
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Bool
forall {a} {a}. (a, Maybe a) -> Bool
isGS)
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"dc" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_ -> Next Type_ Expression -> Next a (Type_, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Type_ Expression
AnyNext Expression
expression Next a (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression -> Expression)
-> NextArg (Type_, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> Expression -> Expression
ExprDynamicCast
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sc" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_ -> Next Type_ Expression -> Next a (Type_, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Type_ Expression
AnyNext Expression
expression Next a (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression -> Expression)
-> NextArg (Type_, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> Expression -> Expression
ExprStaticCast
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"cc" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_ -> Next Type_ Expression -> Next a (Type_, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Type_ Expression
AnyNext Expression
expression Next a (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression -> Expression)
-> NextArg (Type_, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> Expression -> Expression
ExprConstCast
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"rc" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_ -> Next Type_ Expression -> Next a (Type_, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Type_ Expression
AnyNext Expression
expression Next a (Type_, Expression)
-> (NextArg (Type_, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression -> Expression)
-> NextArg (Type_, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Type_ -> Expression -> Expression
ExprReinterpretCast
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"ti" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> Next Type_ Expression -> NextArg a -> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression) -> Next Type_ Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> Expression
ExprTypeIdType
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"te" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprTypeId
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"st" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> Next Type_ Expression -> NextArg a -> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression) -> Next Type_ Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> Expression
ExprSizeOfType
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sz" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprSizeOf
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"at" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Type_
AnyNext Type_
type_ Next a Type_
-> Next Type_ Expression -> NextArg a -> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Type_ -> Expression) -> Next Type_ Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> Expression
ExprAlignOfType
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"az" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprAlignOf
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"nx" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprNoException
      , Next a TemplateArg
AnyNext TemplateArg
template_param Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplateArg -> Expression)
-> NextArg TemplateArg -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap TemplateArg -> Expression
ExprTemplateParam
      , Next a FunctionParam
AnyNext FunctionParam
function_param Next a FunctionParam
-> (NextArg FunctionParam -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (FunctionParam -> Expression)
-> NextArg FunctionParam -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap FunctionParam -> Expression
ExprFunctionParam
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"dt" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression UnresolvedName
-> Next a (Expression, UnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Expression UnresolvedName
AnyNext UnresolvedName
unresolved_name Next a (Expression, UnresolvedName)
-> (NextArg (Expression, UnresolvedName)
    -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> UnresolvedName -> Expression)
-> NextArg (Expression, UnresolvedName)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Expression -> UnresolvedName -> Expression
ExprField
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"pt" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression UnresolvedName
-> Next a (Expression, UnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Expression UnresolvedName
AnyNext UnresolvedName
unresolved_name Next a (Expression, UnresolvedName)
-> (NextArg (Expression, UnresolvedName)
    -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> UnresolvedName -> Expression)
-> NextArg (Expression, UnresolvedName)
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Expression -> UnresolvedName -> Expression
ExprFieldPtr
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"ds" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression -> Next a (Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Expression Expression
AnyNext Expression
expression Next a (Expression, Expression)
-> (NextArg (Expression, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression -> Expression)
-> NextArg (Expression, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Expression -> Expression -> Expression
ExprFieldExpr
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sZ" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a TemplateArg
AnyNext TemplateArg
template_param Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (TemplateArg -> Expression)
-> NextArg TemplateArg -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap TemplateArg -> Expression
ExprSizeOfTmplParamPack
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sZ" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a FunctionParam
AnyNext FunctionParam
function_param Next a FunctionParam
-> (NextArg FunctionParam -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (FunctionParam -> Expression)
-> NextArg FunctionParam -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap FunctionParam -> Expression
ExprSizeOfFuncParamPack
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sP" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next () TemplateArg -> Next () [TemplateArg]
forall a. Next () a -> Next () [a]
many' Next () TemplateArg
AnyNext TemplateArg
template_arg Next () [TemplateArg]
-> (NextArg a
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> NextArg a
-> Maybe (NextArg [TemplateArg])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard (NextArg a -> Maybe (NextArg [TemplateArg]))
-> (NextArg [TemplateArg] -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next [TemplateArg] [TemplateArg]
forall a. Text -> Next a a
match Text
"E"
        Next [TemplateArg] [TemplateArg]
-> (NextArg [TemplateArg] -> Maybe (NextArg Expression))
-> NextArg [TemplateArg]
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([TemplateArg] -> Expression)
-> NextArg [TemplateArg] -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [TemplateArg] -> Expression
ExprSizeOfCapturedTmplParamPack
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"sp" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprPack
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"fl" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
unary_op (NextArg a -> Maybe (NextArg Operator))
-> Next Operator Expression -> Next a (Operator, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Operator Expression
AnyNext Expression
expression Next a (Operator, Expression)
-> (NextArg (Operator, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Operator -> Expression -> Expression)
-> NextArg (Operator, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Operator -> Expression -> Expression
ExprUnaryLeftFold
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"fr" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
unary_op (NextArg a -> Maybe (NextArg Operator))
-> Next Operator Expression -> Next a (Operator, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Operator Expression
AnyNext Expression
expression Next a (Operator, Expression)
-> (NextArg (Operator, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Operator -> Expression -> Expression)
-> NextArg (Operator, Expression) -> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Operator -> Expression -> Expression
ExprUnaryRightFold
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"fL" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
binary_op (NextArg a -> Maybe (NextArg Operator))
-> Next Operator Expression -> Next a (Operator, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Operator Expression
AnyNext Expression
expression Next a (Operator, Expression)
-> (NextArg (Operator, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Operator -> Expression -> Expression -> Expression)
-> NextArg (Operator, Expression)
-> Maybe (NextArg (Expression -> Expression))
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Operator -> Expression -> Expression -> Expression
ExprBinaryLeftFold
        (NextArg (Operator, Expression)
 -> Maybe (NextArg (Expression -> Expression)))
-> Next (Expression -> Expression) Expression
-> Next
     (Operator, Expression) (Expression -> Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Expression -> Expression) Expression
AnyNext Expression
expression Next (Operator, Expression) (Expression -> Expression, Expression)
-> (NextArg (Expression -> Expression, Expression)
    -> Maybe (NextArg Expression))
-> NextArg (Operator, Expression)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Expression -> Expression, Expression)
-> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"fR" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Operator)
AnyNext Operator
binary_op (NextArg a -> Maybe (NextArg Operator))
-> Next Operator Expression -> Next a (Operator, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Operator Expression
AnyNext Expression
expression Next a (Operator, Expression)
-> (NextArg (Operator, Expression) -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Operator -> Expression -> Expression -> Expression)
-> NextArg (Operator, Expression)
-> Maybe (NextArg (Expression -> Expression))
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 Operator -> Expression -> Expression -> Expression
ExprBinaryRightFold
        (NextArg (Operator, Expression)
 -> Maybe (NextArg (Expression -> Expression)))
-> Next (Expression -> Expression) Expression
-> Next
     (Operator, Expression) (Expression -> Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (Expression -> Expression) Expression
AnyNext Expression
expression Next (Operator, Expression) (Expression -> Expression, Expression)
-> (NextArg (Expression -> Expression, Expression)
    -> Maybe (NextArg Expression))
-> NextArg (Operator, Expression)
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Expression -> Expression, Expression)
-> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"tw" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg a -> Maybe (NextArg Expression)
AnyNext Expression
expression (NextArg a -> Maybe (NextArg Expression))
-> Next Expression Expression
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> Expression) -> Next Expression Expression
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> Expression
ExprThrow
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"tr" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Expression -> NextArg a -> Maybe (NextArg Expression)
forall (f :: * -> *) b a.
Applicative f =>
b -> NextArg a -> f (NextArg b)
ret' Expression
ExprReThrow
      , Text -> Next a a
forall a. Text -> Next a a
match Text
"u" Next a a
-> (NextArg a -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> Next SourceName [TemplateArg]
-> Next a (SourceName, [TemplateArg])
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next () TemplateArg -> Next () [TemplateArg]
forall a. Next () a -> Next () [a]
many' Next () TemplateArg
AnyNext TemplateArg
template_arg Next () [TemplateArg]
-> (NextArg SourceName
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> Next SourceName [TemplateArg]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg SourceName
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard
        Next a (SourceName, [TemplateArg])
-> (NextArg (SourceName, [TemplateArg])
    -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (SourceName -> [TemplateArg] -> Expression)
-> NextArg (SourceName, [TemplateArg])
-> Maybe (NextArg Expression)
forall {a} {b} {b}.
(a -> b -> b) -> NextArg (a, b) -> Maybe (NextArg b)
rmap2 SourceName -> [TemplateArg] -> Expression
ExprVendorExtended
      , Next a UnresolvedName
AnyNext UnresolvedName
unresolved_name Next a UnresolvedName
-> (NextArg UnresolvedName -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnresolvedName -> Expression)
-> NextArg UnresolvedName -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnresolvedName -> Expression
ExprUnresolvedName
      , Next a ExprPrimary
AnyNext ExprPrimary
expr_primary Next a ExprPrimary
-> (NextArg ExprPrimary -> Maybe (NextArg Expression))
-> NextArg a
-> Maybe (NextArg Expression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (ExprPrimary -> Expression)
-> NextArg ExprPrimary -> Maybe (NextArg Expression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ExprPrimary -> Expression
ExprPrim
      ])

expr_primary :: AnyNext ExprPrimary
expr_primary :: AnyNext ExprPrimary
expr_primary =
  let toFloat :: a -> a -> a
toFloat a
w a
f = String -> a
forall a. Read a => String -> a
read (a -> String
forall a. Show a => a -> String
show a
w String -> String -> String
forall a. Semigroup a => a -> a -> a
<> String
"." String -> String -> String
forall a. Semigroup a => a -> a -> a
<> a -> String
forall a. Show a => a -> String
show a
f)
      floatLit :: NextArg Type_ -> NextArg a -> a -> ExprPrimary
floatLit NextArg Type_
ty NextArg a
w a
p = Type_ -> Float -> ExprPrimary
FloatLit (NextArg Type_
ty NextArg Type_ -> Getting Type_ (NextArg Type_) Type_ -> Type_
forall s a. s -> Getting a s a -> a
^. Getting Type_ (NextArg Type_) Type_
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (Float -> ExprPrimary) -> Float -> ExprPrimary
forall a b. (a -> b) -> a -> b
$ a -> a -> Float
forall {a} {a} {a}. (Read a, Show a, Show a) => a -> a -> a
toFloat (NextArg a
w NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^.Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) a
p
      complexLit :: NextArg Type_
-> NextArg a -> NextArg a -> NextArg a -> a -> ExprPrimary
complexLit NextArg Type_
ty NextArg a
w NextArg a
p NextArg a
iw a
ip =
        Type_ -> Float -> Float -> ExprPrimary
ComplexFloatLit (NextArg Type_
ty NextArg Type_ -> Getting Type_ (NextArg Type_) Type_ -> Type_
forall s a. s -> Getting a s a -> a
^. Getting Type_ (NextArg Type_) Type_
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (a -> a -> Float
forall {a} {a} {a}. (Read a, Show a, Show a) => a -> a -> a
toFloat (NextArg a
w NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) (NextArg a
p NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)) (a -> a -> Float
forall {a} {a} {a}. (Read a, Show a, Show a) => a -> a -> a
toFloat (NextArg a
iw NextArg a -> Getting a (NextArg a) a -> a
forall s a. s -> Getting a s a -> a
^. Getting a (NextArg a) a
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal) a
ip)
      withType :: NextArg Type_ -> Maybe (NextArg ExprPrimary)
withType NextArg Type_
t = [Maybe (NextArg ExprPrimary)] -> Maybe (NextArg ExprPrimary)
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ do NextArg Int
d <- Next Type_ Int
AnyNext Int
digits_num NextArg Type_
t
                             [Maybe (NextArg ExprPrimary)] -> Maybe (NextArg ExprPrimary)
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ do NextArg Int
r <- Text -> Next Int Int
forall a. Text -> Next a a
match Text
"." NextArg Int
d Maybe (NextArg Int) -> Next Int Int -> Maybe (NextArg Int)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next Int Int
AnyNext Int
digits_num
                                       [Maybe (NextArg ExprPrimary)] -> Maybe (NextArg ExprPrimary)
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum [ do NextArg Int
i <- Text -> Next Int Int
forall a. Text -> Next a a
match Text
"_" NextArg Int
r
                                                      Maybe (NextArg Int) -> Next Int Int -> Maybe (NextArg Int)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next Int Int
AnyNext Int
digits_num
                                                      Maybe (NextArg Int) -> Next Int Int -> Maybe (NextArg Int)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> Next Int Int
forall a. Text -> Next a a
match Text
"."
                                                 NextArg Int
ir <- Next Int Int
AnyNext Int
digits_num NextArg Int
i
                                                 (Int -> ExprPrimary) -> NextArg Int -> Maybe (NextArg ExprPrimary)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (NextArg Type_
-> NextArg Int -> NextArg Int -> NextArg Int -> Int -> ExprPrimary
forall {a} {a} {a} {a}.
(Show a, Show a, Show a, Show a) =>
NextArg Type_
-> NextArg a -> NextArg a -> NextArg a -> a -> ExprPrimary
complexLit NextArg Type_
t NextArg Int
d NextArg Int
r NextArg Int
i) NextArg Int
ir
                                            , (Int -> ExprPrimary) -> NextArg Int -> Maybe (NextArg ExprPrimary)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (NextArg Type_ -> NextArg Int -> Int -> ExprPrimary
forall {a} {a}.
(Show a, Show a) =>
NextArg Type_ -> NextArg a -> a -> ExprPrimary
floatLit NextArg Type_
t NextArg Int
d) NextArg Int
r
                                            ]
                                  , (Int -> ExprPrimary) -> NextArg Int -> Maybe (NextArg ExprPrimary)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Type_ -> Int -> ExprPrimary
IntLit (NextArg Type_
t NextArg Type_ -> Getting Type_ (NextArg Type_) Type_ -> Type_
forall s a. s -> Getting a s a -> a
^. Getting Type_ (NextArg Type_) Type_
forall a b (f :: * -> *).
Functor f =>
(a -> f b) -> NextArg a -> f (NextArg b)
nVal)) NextArg Int
d
                                  ]
                        , (Type_ -> ExprPrimary)
-> NextArg Type_ -> Maybe (NextArg ExprPrimary)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Type_ -> ExprPrimary
DirectLit NextArg Type_
t
                        ]
  in
    Text -> Next a a
forall a. Text -> Next a a
match Text
"L"
    Next a a
-> (NextArg a -> Maybe (NextArg ExprPrimary))
-> NextArg a
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg a -> Maybe (NextArg ExprPrimary)]
-> NextArg a -> Maybe (NextArg ExprPrimary)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a Type_
AnyNext Type_
type_ Next a Type_
-> (NextArg Type_ -> Maybe (NextArg ExprPrimary))
-> NextArg a
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg Type_ -> Maybe (NextArg ExprPrimary)
withType (NextArg Type_ -> Maybe (NextArg ExprPrimary))
-> (NextArg ExprPrimary -> Maybe (NextArg ExprPrimary))
-> NextArg Type_
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> NextArg ExprPrimary -> Maybe (NextArg ExprPrimary)
forall a. Text -> Next a a
match Text
"E"
              , Text -> Next a a
forall a. Text -> Next a a
match Text
"_Z" Next a a
-> (NextArg a -> Maybe (NextArg ExprPrimary))
-> NextArg a
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Encoding
AnyNext Encoding
encoding Next a Encoding
-> (NextArg Encoding -> Maybe (NextArg ExprPrimary))
-> NextArg a
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next Encoding Encoding
forall a. Text -> Next a a
match Text
"E" Next Encoding Encoding
-> (NextArg Encoding -> Maybe (NextArg ExprPrimary))
-> NextArg Encoding
-> Maybe (NextArg ExprPrimary)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Encoding -> ExprPrimary)
-> NextArg Encoding -> Maybe (NextArg ExprPrimary)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Encoding -> ExprPrimary
ExternalNameLit
              ]

braced_expression :: AnyNext BracedExpression
braced_expression :: AnyNext BracedExpression
braced_expression = [NextArg a -> Maybe (NextArg BracedExpression)]
-> NextArg a -> Maybe (NextArg BracedExpression)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Expression -> BracedExpression)
-> NextArg Expression -> Maybe (NextArg BracedExpression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Expression -> BracedExpression
BracedExpr
                          , Text -> Next a a
forall a. Text -> Next a a
match Text
"di" Next a a
-> (NextArg a -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> Next SourceName BracedExpression
-> Next a (SourceName, BracedExpression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next SourceName BracedExpression
AnyNext BracedExpression
braced_expression
                            Next a (SourceName, BracedExpression)
-> (NextArg (SourceName, BracedExpression)
    -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, BracedExpression) -> BracedExpression)
-> NextArg (SourceName, BracedExpression)
-> Maybe (NextArg BracedExpression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> BracedExpression -> BracedExpression)
-> (SourceName, BracedExpression) -> BracedExpression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> BracedExpression -> BracedExpression
BracedFieldExpr)
                          , Text -> Next a a
forall a. Text -> Next a a
match Text
"dx" Next a a
-> (NextArg a -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> (NextArg Expression -> Maybe (NextArg BracedExpression))
-> Next a (Expression, BracedExpression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> NextArg Expression -> Maybe (NextArg BracedExpression)
AnyNext BracedExpression
braced_expression
                            Next a (Expression, BracedExpression)
-> (NextArg (Expression, BracedExpression)
    -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Expression, BracedExpression) -> BracedExpression)
-> NextArg (Expression, BracedExpression)
-> Maybe (NextArg BracedExpression)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Expression -> BracedExpression -> BracedExpression)
-> (Expression, BracedExpression) -> BracedExpression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expression -> BracedExpression -> BracedExpression
BracedIndexExpr)
                          , Text -> Next a a
forall a. Text -> Next a a
match Text
"dX" Next a a
-> (NextArg a -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Expression
AnyNext Expression
expression Next a Expression
-> Next Expression Expression -> Next a (Expression, Expression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Expression Expression
AnyNext Expression
expression
                            Next a (Expression, Expression)
-> (NextArg (Expression, Expression)
    -> Maybe (NextArg BracedExpression))
-> NextArg a
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Expression, Expression) -> BracedExpression -> BracedExpression)
-> NextArg (Expression, Expression)
-> Maybe (NextArg (BracedExpression -> BracedExpression))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Expression -> Expression -> BracedExpression -> BracedExpression)
-> (Expression, Expression) -> BracedExpression -> BracedExpression
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Expression -> Expression -> BracedExpression -> BracedExpression
BracedRangedExpr)
                            (NextArg (Expression, Expression)
 -> Maybe (NextArg (BracedExpression -> BracedExpression)))
-> Next (BracedExpression -> BracedExpression) BracedExpression
-> Next
     (Expression, Expression)
     (BracedExpression -> BracedExpression, BracedExpression)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (BracedExpression -> BracedExpression) BracedExpression
AnyNext BracedExpression
braced_expression Next
  (Expression, Expression)
  (BracedExpression -> BracedExpression, BracedExpression)
-> (NextArg
      (BracedExpression -> BracedExpression, BracedExpression)
    -> Maybe (NextArg BracedExpression))
-> NextArg (Expression, Expression)
-> Maybe (NextArg BracedExpression)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (BracedExpression -> BracedExpression, BracedExpression)
-> Maybe (NextArg BracedExpression)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                          ]

initializer :: AnyNext InitializerExpr
initializer :: AnyNext InitializerExpr
initializer = Text -> Next a a
forall a. Text -> Next a a
match Text
"pi" Next a a
-> (NextArg a -> Maybe (NextArg InitializerExpr))
-> NextArg a
-> Maybe (NextArg InitializerExpr)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next () Expression -> Next () [Expression]
forall a. Next () a -> Next () [a]
many' Next () Expression
AnyNext Expression
expression Next () [Expression]
-> (NextArg a
    -> (Text,
        ((),
         (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool))))))
-> NextArg a
-> Maybe (NextArg [Expression])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
forall a.
NextArg a
-> (Text,
    ((),
     (Context, (Seq SubsCandidate, (Seq TemplateArg, Bool, Bool)))))
rdiscard (NextArg a -> Maybe (NextArg [Expression]))
-> (NextArg [Expression] -> Maybe (NextArg InitializerExpr))
-> NextArg a
-> Maybe (NextArg InitializerExpr)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next [Expression] [Expression]
forall a. Text -> Next a a
match Text
"E"
              Next [Expression] [Expression]
-> (NextArg [Expression] -> Maybe (NextArg InitializerExpr))
-> NextArg [Expression]
-> Maybe (NextArg InitializerExpr)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([Expression] -> InitializerExpr)
-> NextArg [Expression] -> Maybe (NextArg InitializerExpr)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [Expression] -> InitializerExpr
Initializer

function_param :: AnyNext FunctionParam
function_param :: AnyNext FunctionParam
function_param = [NextArg a -> Maybe (NextArg FunctionParam)]
-> NextArg a -> Maybe (NextArg FunctionParam)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Text -> Next a a
forall a. Text -> Next a a
match Text
"fpT" Next a a
-> (NextArg a -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (a -> FunctionParam) -> NextArg a -> Maybe (NextArg FunctionParam)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (FunctionParam -> a -> FunctionParam
forall a b. a -> b -> a
const FunctionParam
FP_This)
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"fp" Next a a
-> (NextArg a -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a [CVQualifier]
AnyNext [CVQualifier]
cv_qualifiers Next a [CVQualifier]
-> (NextArg [CVQualifier] -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([CVQualifier] -> Natural -> FunctionParam)
-> NextArg [CVQualifier]
-> Maybe (NextArg (Natural -> FunctionParam))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [CVQualifier] -> Natural -> FunctionParam
FP_
                         (NextArg [CVQualifier]
 -> Maybe (NextArg (Natural -> FunctionParam)))
-> (NextArg (Natural -> FunctionParam)
    -> Maybe (NextArg FunctionParam))
-> NextArg [CVQualifier]
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text -> Next (Natural -> FunctionParam) (Natural -> FunctionParam)
forall a. Text -> Next a a
match Text
"_" Next (Natural -> FunctionParam) (Natural -> FunctionParam)
-> (NextArg (Natural -> FunctionParam)
    -> Maybe (NextArg FunctionParam))
-> NextArg (Natural -> FunctionParam)
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Natural -> FunctionParam) -> FunctionParam)
-> NextArg (Natural -> FunctionParam)
-> Maybe (NextArg FunctionParam)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Natural -> FunctionParam) -> Natural -> FunctionParam
forall a b. (a -> b) -> a -> b
$ Natural
1)
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"fp" Next a a
-> (NextArg a -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a [CVQualifier]
AnyNext [CVQualifier]
cv_qualifiers Next a [CVQualifier]
-> (NextArg [CVQualifier] -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ([CVQualifier] -> Natural -> FunctionParam)
-> NextArg [CVQualifier]
-> Maybe (NextArg (Natural -> FunctionParam))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap [CVQualifier] -> Natural -> FunctionParam
FP_
                         (NextArg [CVQualifier]
 -> Maybe (NextArg (Natural -> FunctionParam)))
-> Next (Natural -> FunctionParam) Natural
-> Next [CVQualifier] (Natural -> FunctionParam, Natural)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> (Next (Natural -> FunctionParam) Int
AnyNext Int
digits_num Next (Natural -> FunctionParam) Int
-> (NextArg Int -> Maybe (NextArg Natural))
-> Next (Natural -> FunctionParam) Natural
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Int -> Natural) -> NextArg Int -> Maybe (NextArg Natural)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Int -> Natural
forall a. Enum a => Int -> a
toEnum (Int -> Natural) -> (Int -> Int) -> Int -> Natural
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
2)))
                         Next [CVQualifier] (Natural -> FunctionParam, Natural)
-> (NextArg (Natural -> FunctionParam, Natural)
    -> Maybe (NextArg FunctionParam))
-> NextArg [CVQualifier]
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     (Natural -> FunctionParam, Natural)
     (Natural -> FunctionParam, Natural)
forall a. Text -> Next a a
match Text
"_" Next
  (Natural -> FunctionParam, Natural)
  (Natural -> FunctionParam, Natural)
-> (NextArg (Natural -> FunctionParam, Natural)
    -> Maybe (NextArg FunctionParam))
-> NextArg (Natural -> FunctionParam, Natural)
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (Natural -> FunctionParam, Natural)
-> Maybe (NextArg FunctionParam)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
                       , Text -> Next a a
forall a. Text -> Next a a
match Text
"fL" Next a a
-> (NextArg a -> Maybe (NextArg FunctionParam))
-> NextArg a
-> Maybe (NextArg FunctionParam)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> String -> NextArg a -> Maybe (NextArg FunctionParam)
forall a b. String -> Next a b
tbd String
"function param l"
                       ]

unresolved_name :: AnyNext UnresolvedName
unresolved_name :: AnyNext UnresolvedName
unresolved_name =
  [NextArg a -> Maybe (NextArg UnresolvedName)]
-> NextArg a -> Maybe (NextArg UnresolvedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs")
          Next a (a, Maybe a)
-> Next (a, Maybe a) BaseUnresolvedName
-> Next a ((a, Maybe a), BaseUnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (a, Maybe a) BaseUnresolvedName
AnyNext BaseUnresolvedName
base_unresolved_name
          Next a ((a, Maybe a), BaseUnresolvedName)
-> (NextArg ((a, Maybe a), BaseUnresolvedName)
    -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (((a, Maybe a), BaseUnresolvedName) -> UnresolvedName)
-> NextArg ((a, Maybe a), BaseUnresolvedName)
-> Maybe (NextArg UnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (((a, Maybe a) -> BaseUnresolvedName -> UnresolvedName)
-> ((a, Maybe a), BaseUnresolvedName) -> UnresolvedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (Bool -> BaseUnresolvedName -> UnresolvedName
URN_Base (Bool -> BaseUnresolvedName -> UnresolvedName)
-> ((a, Maybe a) -> Bool)
-> (a, Maybe a)
-> BaseUnresolvedName
-> UnresolvedName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe a -> Bool
forall a. Maybe a -> Bool
isJust (Maybe a -> Bool)
-> ((a, Maybe a) -> Maybe a) -> (a, Maybe a) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Maybe a
forall a b. (a, b) -> b
snd))
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"sr" Next a a
-> (NextArg a -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a UnresolvedType
AnyNext UnresolvedType
unresolved_type Next a UnresolvedType
-> Next UnresolvedType BaseUnresolvedName
-> Next a (UnresolvedType, BaseUnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next UnresolvedType BaseUnresolvedName
AnyNext BaseUnresolvedName
base_unresolved_name
          Next a (UnresolvedType, BaseUnresolvedName)
-> (NextArg (UnresolvedType, BaseUnresolvedName)
    -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((UnresolvedType, BaseUnresolvedName) -> UnresolvedName)
-> NextArg (UnresolvedType, BaseUnresolvedName)
-> Maybe (NextArg UnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((UnresolvedType -> BaseUnresolvedName -> UnresolvedName)
-> (UnresolvedType, BaseUnresolvedName) -> UnresolvedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry UnresolvedType -> BaseUnresolvedName -> UnresolvedName
URNScopedRef)
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"srN" Next a a
-> (NextArg a -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a UnresolvedType
AnyNext UnresolvedType
unresolved_type Next a UnresolvedType
-> (NextArg UnresolvedType -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnresolvedType
 -> UnresolvedQualifierLevels
 -> BaseUnresolvedName
 -> UnresolvedName)
-> NextArg UnresolvedType
-> Maybe
     (NextArg
        (UnresolvedQualifierLevels
         -> BaseUnresolvedName -> UnresolvedName))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnresolvedType
-> UnresolvedQualifierLevels
-> BaseUnresolvedName
-> UnresolvedName
URNSubScopedRef
          (NextArg UnresolvedType
 -> Maybe
      (NextArg
         (UnresolvedQualifierLevels
          -> BaseUnresolvedName -> UnresolvedName)))
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName)
     UnresolvedQualifierLevels
-> Next
     UnresolvedType
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> AnyNext UnresolvedQualifierLevel
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName)
     UnresolvedQualifierLevels
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a UnresolvedQualifierLevel
AnyNext UnresolvedQualifierLevel
unresolved_qualifier_level Next
  UnresolvedType
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> (NextArg
      (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
       UnresolvedQualifierLevels)
    -> Maybe (NextArg UnresolvedName))
-> NextArg UnresolvedType
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
forall a. Text -> Next a a
match Text
"E" Next
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> (NextArg
      (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
       UnresolvedQualifierLevels)
    -> Maybe (NextArg UnresolvedName))
-> NextArg
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> Maybe (NextArg (BaseUnresolvedName -> UnresolvedName))
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
          (NextArg
   (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
    UnresolvedQualifierLevels)
 -> Maybe (NextArg (BaseUnresolvedName -> UnresolvedName)))
-> Next (BaseUnresolvedName -> UnresolvedName) BaseUnresolvedName
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
     (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (BaseUnresolvedName -> UnresolvedName) BaseUnresolvedName
AnyNext BaseUnresolvedName
base_unresolved_name Next
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
  (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
-> (NextArg
      (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
    -> Maybe (NextArg UnresolvedName))
-> NextArg
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
-> Maybe (NextArg UnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
        , Next a a -> Next a (a, Maybe a)
forall a b. Next a b -> Next a (a, Maybe b)
optional' (Text -> Next a a
forall a. Text -> Next a a
match Text
"gs")
          Next a (a, Maybe a)
-> Next (a, Maybe a) (a, Maybe a)
-> Next a ((a, Maybe a), (a, Maybe a))
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Text -> Next (a, Maybe a) (a, Maybe a)
forall a. Text -> Next a a
match Text
"sr" Next a ((a, Maybe a), (a, Maybe a))
-> (NextArg ((a, Maybe a), (a, Maybe a))
    -> Maybe (NextArg UnresolvedName))
-> NextArg a
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (((a, Maybe a), (a, Maybe a))
 -> UnresolvedQualifierLevels
 -> BaseUnresolvedName
 -> UnresolvedName)
-> NextArg ((a, Maybe a), (a, Maybe a))
-> Maybe
     (NextArg
        (UnresolvedQualifierLevels
         -> BaseUnresolvedName -> UnresolvedName))
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap (Bool
-> UnresolvedQualifierLevels
-> BaseUnresolvedName
-> UnresolvedName
URNQualRef (Bool
 -> UnresolvedQualifierLevels
 -> BaseUnresolvedName
 -> UnresolvedName)
-> (((a, Maybe a), (a, Maybe a)) -> Bool)
-> ((a, Maybe a), (a, Maybe a))
-> UnresolvedQualifierLevels
-> BaseUnresolvedName
-> UnresolvedName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe a -> Bool
forall a. Maybe a -> Bool
isJust (Maybe a -> Bool)
-> (((a, Maybe a), (a, Maybe a)) -> Maybe a)
-> ((a, Maybe a), (a, Maybe a))
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a, Maybe a) -> Maybe a
forall a b. (a, b) -> b
snd ((a, Maybe a) -> Maybe a)
-> (((a, Maybe a), (a, Maybe a)) -> (a, Maybe a))
-> ((a, Maybe a), (a, Maybe a))
-> Maybe a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((a, Maybe a), (a, Maybe a)) -> (a, Maybe a)
forall a b. (a, b) -> a
fst)
          (NextArg ((a, Maybe a), (a, Maybe a))
 -> Maybe
      (NextArg
         (UnresolvedQualifierLevels
          -> BaseUnresolvedName -> UnresolvedName)))
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName)
     UnresolvedQualifierLevels
-> Next
     ((a, Maybe a), (a, Maybe a))
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> AnyNext UnresolvedQualifierLevel
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName)
     UnresolvedQualifierLevels
forall a b. AnyNext a -> Next b (NonEmpty a)
some' Next a UnresolvedQualifierLevel
AnyNext UnresolvedQualifierLevel
unresolved_qualifier_level Next
  ((a, Maybe a), (a, Maybe a))
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> (NextArg
      (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
       UnresolvedQualifierLevels)
    -> Maybe (NextArg UnresolvedName))
-> NextArg ((a, Maybe a), (a, Maybe a))
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Text
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
forall a. Text -> Next a a
match Text
"E" Next
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> (NextArg
      (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
       UnresolvedQualifierLevels)
    -> Maybe (NextArg UnresolvedName))
-> NextArg
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
-> Maybe (NextArg (BaseUnresolvedName -> UnresolvedName))
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
          (NextArg
   (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
    UnresolvedQualifierLevels)
 -> Maybe (NextArg (BaseUnresolvedName -> UnresolvedName)))
-> Next (BaseUnresolvedName -> UnresolvedName) BaseUnresolvedName
-> Next
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
     (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next (BaseUnresolvedName -> UnresolvedName) BaseUnresolvedName
AnyNext BaseUnresolvedName
base_unresolved_name Next
  (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
   UnresolvedQualifierLevels)
  (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
-> (NextArg
      (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
    -> Maybe (NextArg UnresolvedName))
-> NextArg
     (UnresolvedQualifierLevels -> BaseUnresolvedName -> UnresolvedName,
      UnresolvedQualifierLevels)
-> Maybe (NextArg UnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> NextArg (BaseUnresolvedName -> UnresolvedName, BaseUnresolvedName)
-> Maybe (NextArg UnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
NextArg (a -> b, a) -> f (NextArg b)
rapply
        ]

base_unresolved_name :: AnyNext BaseUnresolvedName
base_unresolved_name :: AnyNext BaseUnresolvedName
base_unresolved_name =
  [NextArg a -> Maybe (NextArg BaseUnresolvedName)]
-> NextArg a -> Maybe (NextArg BaseUnresolvedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next SourceName TemplateArgs
-> Next SourceName (SourceName, Maybe TemplateArgs)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next SourceName TemplateArgs
AnyNext TemplateArgs
template_args Next SourceName (SourceName, Maybe TemplateArgs)
-> (NextArg (SourceName, Maybe TemplateArgs)
    -> Maybe (NextArg BaseUnresolvedName))
-> NextArg SourceName
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, Maybe TemplateArgs) -> BaseUnresolvedName)
-> NextArg (SourceName, Maybe TemplateArgs)
-> Maybe (NextArg BaseUnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> Maybe TemplateArgs -> BaseUnresolvedName)
-> (SourceName, Maybe TemplateArgs) -> BaseUnresolvedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> Maybe TemplateArgs -> BaseUnresolvedName
BUName)
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"on" Next a a
-> (NextArg a -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Operator
AnyNext Operator
operator_name Next a Operator
-> Next Operator TemplateArgs -> Next a (Operator, TemplateArgs)
forall a b c. Next a b -> Next b c -> Next a (b, c)
>&=> Next Operator TemplateArgs
AnyNext TemplateArgs
template_args
          Next a (Operator, TemplateArgs)
-> (NextArg (Operator, TemplateArgs)
    -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((Operator, TemplateArgs) -> BaseUnresolvedName)
-> NextArg (Operator, TemplateArgs)
-> Maybe (NextArg BaseUnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((Operator -> TemplateArgs -> BaseUnresolvedName)
-> (Operator, TemplateArgs) -> BaseUnresolvedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Operator -> TemplateArgs -> BaseUnresolvedName
BUOnOperatorT)
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"on" Next a a
-> (NextArg a -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next a Operator
AnyNext Operator
operator_name Next a Operator
-> (NextArg Operator -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (Operator -> BaseUnresolvedName)
-> NextArg Operator -> Maybe (NextArg BaseUnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap Operator -> BaseUnresolvedName
BUOnOperator
        , Text -> Next a a
forall a. Text -> Next a a
match Text
"dn" Next a a
-> (NextArg a -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> [NextArg a -> Maybe (NextArg BaseUnresolvedName)]
-> NextArg a -> Maybe (NextArg BaseUnresolvedName)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a UnresolvedType
AnyNext UnresolvedType
unresolved_type
                                 Next a UnresolvedType
-> Next UnresolvedType BaseUnresolvedName
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (UnresolvedType -> BaseUnresolvedName)
-> Next UnresolvedType BaseUnresolvedName
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap UnresolvedType -> BaseUnresolvedName
BUDestructorUnresolvedType
                               , Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg BaseUnresolvedName))
-> NextArg a
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next SourceName TemplateArgs
-> Next SourceName (SourceName, Maybe TemplateArgs)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next SourceName TemplateArgs
AnyNext TemplateArgs
template_args
                                 Next SourceName (SourceName, Maybe TemplateArgs)
-> (NextArg (SourceName, Maybe TemplateArgs)
    -> Maybe (NextArg BaseUnresolvedName))
-> NextArg SourceName
-> Maybe (NextArg BaseUnresolvedName)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, Maybe TemplateArgs) -> BaseUnresolvedName)
-> NextArg (SourceName, Maybe TemplateArgs)
-> Maybe (NextArg BaseUnresolvedName)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> Maybe TemplateArgs -> BaseUnresolvedName)
-> (SourceName, Maybe TemplateArgs) -> BaseUnresolvedName
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> Maybe TemplateArgs -> BaseUnresolvedName
BUDestructorSimpleId)
                               ]
        ]

unresolved_type :: AnyNext UnresolvedType
unresolved_type :: AnyNext UnresolvedType
unresolved_type NextArg a
i =
  ([NextArg a -> Maybe (NextArg UnresolvedType)]
-> NextArg a -> Maybe (NextArg UnresolvedType)
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Functor t, Alternative f) =>
t (a -> f b) -> a -> f b
asum' [ Next a TemplateArg
AnyNext TemplateArg
template_param Next a TemplateArg
-> (NextArg TemplateArg -> Maybe (NextArg UnresolvedType))
-> NextArg a
-> Maybe (NextArg UnresolvedType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next TemplateArg TemplateArgs
-> Next TemplateArg (TemplateArg, Maybe TemplateArgs)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next TemplateArg TemplateArgs
AnyNext TemplateArgs
template_args Next TemplateArg (TemplateArg, Maybe TemplateArgs)
-> (NextArg (TemplateArg, Maybe TemplateArgs)
    -> Maybe (NextArg UnresolvedType))
-> NextArg TemplateArg
-> Maybe (NextArg UnresolvedType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((TemplateArg, Maybe TemplateArgs) -> UnresolvedType)
-> NextArg (TemplateArg, Maybe TemplateArgs)
-> Maybe (NextArg UnresolvedType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((TemplateArg -> Maybe TemplateArgs -> UnresolvedType)
-> (TemplateArg, Maybe TemplateArgs) -> UnresolvedType
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry TemplateArg -> Maybe TemplateArgs -> UnresolvedType
URTTemplate)
         , Next a DeclType
AnyNext DeclType
decltype Next a DeclType
-> (NextArg DeclType -> Maybe (NextArg UnresolvedType))
-> NextArg a
-> Maybe (NextArg UnresolvedType)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> (DeclType -> UnresolvedType)
-> NextArg DeclType -> Maybe (NextArg UnresolvedType)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap DeclType -> UnresolvedType
URTDeclType
         ]
    NextArg a
i Maybe (NextArg UnresolvedType)
-> (NextArg UnresolvedType -> Maybe (NextArg UnresolvedType))
-> Maybe (NextArg UnresolvedType)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= NextArg UnresolvedType -> Maybe (NextArg UnresolvedType)
canSubstUnresolvedType)
  Maybe (NextArg UnresolvedType)
-> Maybe (NextArg UnresolvedType) -> Maybe (NextArg UnresolvedType)
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Next a Substitution'
AnyNext Substitution'
substitution NextArg a
i
       Maybe (NextArg Substitution')
-> (NextArg Substitution' -> Maybe (NextArg UnresolvedType))
-> Maybe (NextArg UnresolvedType)
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Next Substitution UnresolvedType
-> NextArg Substitution' -> Maybe (NextArg UnresolvedType)
substituteUnresolvedType (String -> Next Substitution UnresolvedType
forall a b. String -> Next a b
tbd String
"substituteUnresolvedType"))

unresolved_qualifier_level :: AnyNext UnresolvedQualifierLevel
unresolved_qualifier_level :: AnyNext UnresolvedQualifierLevel
unresolved_qualifier_level =
  Next a SourceName
AnyNext SourceName
source_name Next a SourceName
-> (NextArg SourceName -> Maybe (NextArg UnresolvedQualifierLevel))
-> NextArg a
-> Maybe (NextArg UnresolvedQualifierLevel)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> Next SourceName TemplateArgs
-> Next SourceName (SourceName, Maybe TemplateArgs)
forall a b. Next a b -> Next a (a, Maybe b)
optional' Next SourceName TemplateArgs
AnyNext TemplateArgs
template_args Next SourceName (SourceName, Maybe TemplateArgs)
-> (NextArg (SourceName, Maybe TemplateArgs)
    -> Maybe (NextArg UnresolvedQualifierLevel))
-> NextArg SourceName
-> Maybe (NextArg UnresolvedQualifierLevel)
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> ((SourceName, Maybe TemplateArgs) -> UnresolvedQualifierLevel)
-> NextArg (SourceName, Maybe TemplateArgs)
-> Maybe (NextArg UnresolvedQualifierLevel)
forall (f :: * -> *) a b.
Applicative f =>
(a -> b) -> NextArg a -> f (NextArg b)
rmap ((SourceName -> Maybe TemplateArgs -> UnresolvedQualifierLevel)
-> (SourceName, Maybe TemplateArgs) -> UnresolvedQualifierLevel
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry SourceName -> Maybe TemplateArgs -> UnresolvedQualifierLevel
URQL)