symantic-parser-0.2.0.20210703: test/Golden/Splice/G1.expected.txt

\(input :: inp) ->
  let !(#
         init,
         readMore,
         readNext
         #) =
          let _ = "cursorOf"
           in let next
                    ( t@( Data.Text.Internal.Text
                            arr
                            off
                            unconsumed
                          )
                      ) =
                      let !( Data.Text.Unsafe.Iter
                               c
                               d
                             ) = Data.Text.Unsafe.iter t 0
                       in (#
                            c,
                            Data.Text.Internal.Text arr (off GHC.Num.+ d) (unconsumed GHC.Num.- d)
                          #)
                  more
                    ( Data.Text.Internal.Text
                        _
                        _
                        unconsumed
                      ) = unconsumed GHC.Classes.> 0
               in (# input, more, next #)
      finalRet = \_farInp _farExp v _inp -> Data.Either.Right v
      finalRaise ::
        forall b.
        Symantic.Parser.Machine.Generate.Catcher
          inp
          b = \(!exn) _failInp (!farInp) (!farExp) ->
          Data.Either.Left
            Symantic.Parser.Machine.Generate.ParsingError
              { Symantic.Parser.Machine.Generate.parsingErrorOffset = Symantic.Parser.Machine.Input.offset farInp,
                Symantic.Parser.Machine.Generate.parsingErrorException = exn,
                Symantic.Parser.Machine.Generate.parsingErrorUnexpected =
                  if readMore farInp
                    then
                      GHC.Maybe.Just
                        ( let (#
                                c,
                                _
                                #) = readNext farInp
                           in c
                        )
                    else GHC.Maybe.Nothing,
                Symantic.Parser.Machine.Generate.parsingErrorExpecting = farExp
              }
   in let inputToken = Data.Proxy.Proxy :: Data.Proxy.Proxy (Symantic.Parser.Machine.Input.InputToken inp)
       in let
           in let readFail = finalRaise
               in if readMore init
                    then
                      let !(# c, cs #) = readNext init
                       in if (GHC.Classes.==) 'a' c
                            then
                              let _ = "resume"
                               in finalRet
                                    init
                                    Data.Set.Internal.empty
                                    ( let _ = "resume.genCode"
                                       in GHC.Show.show 'a'
                                    )
                                    cs
                            else
                              let _ = "checkToken.else"
                               in let failExp =
                                        Data.Set.Internal.Bin
                                          1
                                          ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                              ( case inputToken of
                                                  (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureToken 'a'
                                              )
                                          )
                                          Data.Set.Internal.Tip
                                          Data.Set.Internal.Tip
                                   in let (#
                                            farInp,
                                            farExp
                                            #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of
                                              GHC.Types.LT ->
                                                (#
                                                  init,
                                                  failExp
                                                #)
                                              GHC.Types.EQ ->
                                                (#
                                                  init,
                                                  failExp GHC.Base.<> Data.Set.Internal.empty
                                                #)
                                              GHC.Types.GT ->
                                                (#
                                                  init,
                                                  Data.Set.Internal.empty
                                                #)
                                       in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp
                    else
                      let _ = "checkHorizon.else"
                       in let failExp =
                                Data.Set.Internal.Bin
                                  1
                                  ( Symantic.Parser.Grammar.Combinators.SomeFailure
                                      ( case inputToken of
                                          (Data.Proxy.Proxy :: Data.Proxy.Proxy tok') -> Symantic.Parser.Grammar.Combinators.FailureHorizon @tok' 1
                                      )
                                  )
                                  Data.Set.Internal.Tip
                                  Data.Set.Internal.Tip
                           in let (#
                                    farInp,
                                    farExp
                                    #) = case (GHC.Classes.compare `Data.Function.on` Symantic.Parser.Machine.Input.offset) init init of
                                      GHC.Types.LT ->
                                        (#
                                          init,
                                          failExp
                                        #)
                                      GHC.Types.EQ ->
                                        (#
                                          init,
                                          failExp GHC.Base.<> Data.Set.Internal.empty
                                        #)
                                      GHC.Types.GT ->
                                        (#
                                          init,
                                          Data.Set.Internal.empty
                                        #)
                               in finalRaise Symantic.Parser.Grammar.Combinators.ExceptionFailure init farInp farExp