hydra-0.15.0: src/main/haskell/Hydra/Eval/Lib/Maps.hs

-- Note: this is an automatically generated file. Do not edit.
-- | Evaluation-level implementations of Map functions for the Hydra interpreter.

module Hydra.Eval.Lib.Maps where
import qualified Hydra.Core as Core
import qualified Hydra.Errors as Errors
import qualified Hydra.Lib.Lists as Lists
import qualified Hydra.Lib.Maps as Maps
import qualified Hydra.Lib.Pairs as Pairs
import qualified Hydra.Show.Core as ShowCore
import Prelude hiding  (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum)
import qualified Data.Scientific as Sci
-- | Interpreter-friendly alter for Map terms.
alter :: t0 -> t1 -> Core.Term -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
alter cx g funTerm keyTerm mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let currentVal = Maps.lookup keyTerm v0
            newVal =
                    Core.TermApplication (Core.Application {
                      Core.applicationFunction = funTerm,
                      Core.applicationArgument = (Core.TermMaybe currentVal)})
        in (Right (Core.TermApplication (Core.Application {
          Core.applicationFunction = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermApplication (Core.Application {
              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maybes.maybe")),
              Core.applicationArgument = (Core.TermApplication (Core.Application {
                Core.applicationFunction = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.delete")),
                  Core.applicationArgument = keyTerm})),
                Core.applicationArgument = mapTerm}))})),
            Core.applicationArgument = (Core.TermLambda (Core.Lambda {
              Core.lambdaParameter = (Core.Name "newV"),
              Core.lambdaDomain = Nothing,
              Core.lambdaBody = (Core.TermApplication (Core.Application {
                Core.applicationFunction = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermApplication (Core.Application {
                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.insert")),
                    Core.applicationArgument = keyTerm})),
                  Core.applicationArgument = (Core.TermVariable (Core.Name "newV"))})),
                Core.applicationArgument = mapTerm}))}))})),
          Core.applicationArgument = newVal})))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))
-- | Interpreter-friendly bimap for Map terms.
bimap :: t0 -> t1 -> Core.Term -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
bimap cx g keyFun valFun mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let pairs = Maps.toList v0
        in (Right (Core.TermMap (Maps.fromList (Lists.map (\p ->
          let k = Pairs.first p
              v = Pairs.second p
          in (Core.TermApplication (Core.Application {
            Core.applicationFunction = keyFun,
            Core.applicationArgument = k}), (Core.TermApplication (Core.Application {
            Core.applicationFunction = valFun,
            Core.applicationArgument = v})))) pairs))))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))
-- | Interpreter-friendly filter for Map terms.
filter :: t0 -> t1 -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
filter cx g valPred mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let pairs = Maps.toList v0
        in (Right (Core.TermApplication (Core.Application {
          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),
          Core.applicationArgument = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat")),
            Core.applicationArgument = (Core.TermList (Lists.map (\p ->
              let v = Pairs.second p
              in (Core.TermApplication (Core.Application {
                Core.applicationFunction = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermApplication (Core.Application {
                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),
                    Core.applicationArgument = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = valPred,
                      Core.applicationArgument = v}))})),
                  Core.applicationArgument = (Core.TermList (Lists.pure (Core.TermPair (Pairs.first p, v))))})),
                Core.applicationArgument = (Core.TermList [])}))) pairs))}))})))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))
-- | Interpreter-friendly filterWithKey for Map terms.
filterWithKey :: t0 -> t1 -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
filterWithKey cx g pred mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let pairs = Maps.toList v0
        in (Right (Core.TermApplication (Core.Application {
          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.fromList")),
          Core.applicationArgument = (Core.TermApplication (Core.Application {
            Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.lists.concat")),
            Core.applicationArgument = (Core.TermList (Lists.map (\p ->
              let k = Pairs.first p
                  v = Pairs.second p
              in (Core.TermApplication (Core.Application {
                Core.applicationFunction = (Core.TermApplication (Core.Application {
                  Core.applicationFunction = (Core.TermApplication (Core.Application {
                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.logic.ifElse")),
                    Core.applicationArgument = (Core.TermApplication (Core.Application {
                      Core.applicationFunction = (Core.TermApplication (Core.Application {
                        Core.applicationFunction = pred,
                        Core.applicationArgument = k})),
                      Core.applicationArgument = v}))})),
                  Core.applicationArgument = (Core.TermList (Lists.pure (Core.TermPair (k, v))))})),
                Core.applicationArgument = (Core.TermList [])}))) pairs))}))})))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))
-- | Interpreter-friendly findWithDefault for Map terms.
findWithDefault :: t0 -> t1 -> Core.Term -> Core.Term -> Core.Term -> Either t2 Core.Term
findWithDefault cx g defaultTerm keyTerm mapTerm =
    Right (Core.TermApplication (Core.Application {
      Core.applicationFunction = (Core.TermApplication (Core.Application {
        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maybes.fromMaybe")),
        Core.applicationArgument = defaultTerm})),
      Core.applicationArgument = (Core.TermApplication (Core.Application {
        Core.applicationFunction = (Core.TermApplication (Core.Application {
          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.maps.lookup")),
          Core.applicationArgument = keyTerm})),
        Core.applicationArgument = mapTerm}))}))
-- | Interpreter-friendly map for Map terms.
map :: t0 -> t1 -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
map cx g valFun mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let pairs = Maps.toList v0
        in (Right (Core.TermMap (Maps.fromList (Lists.map (\p ->
          let k = Pairs.first p
              v = Pairs.second p
          in (k, (Core.TermApplication (Core.Application {
            Core.applicationFunction = valFun,
            Core.applicationArgument = v})))) pairs))))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))
-- | Interpreter-friendly mapKeys for Map terms.
mapKeys :: t0 -> t1 -> Core.Term -> Core.Term -> Either Errors.Error Core.Term
mapKeys cx g keyFun mapTerm =
    case mapTerm of
      Core.TermMap v0 ->
        let pairs = Maps.toList v0
        in (Right (Core.TermMap (Maps.fromList (Lists.map (\p ->
          let k = Pairs.first p
              v = Pairs.second p
          in (Core.TermApplication (Core.Application {
            Core.applicationFunction = keyFun,
            Core.applicationArgument = k}), v)) pairs))))
      _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {
        Errors.unexpectedShapeErrorExpected = "map value",
        Errors.unexpectedShapeErrorActual = (ShowCore.term mapTerm)})))