{-# 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
import Debug.Trace
#endif
demangle1 :: Text -> Result
demangle1 :: Text -> Result
demangle1 Text
s = Text -> Context -> Result
demangle Text
s Context
newDemangling
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 :: 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
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
(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
]
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)
]
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 [
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
]
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' [
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
]
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
"_"
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
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
#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
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
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)
]
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' [
(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
, [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_
, 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
:|[])
, [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
, 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
"_"
, 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
"_"
, 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)
]
)
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
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 ->
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")
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
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 =
[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"
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)