packages feed

hydra-scala 0.17.2 → 0.17.3

raw patch · 4 files changed

+60/−59 lines, 4 filesdep ~hydra-jvmdep ~hydra-kernelPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-jvm, hydra-kernel

API changes (from Hackage documentation)

Files

hydra-scala.cabal view
@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:           hydra-scala-version:        0.17.2+version:        0.17.3 synopsis:       Hydra's Scala coder: emit Scala source from Hydra modules description:    Hydra is an implementation of the LambdaGraph data model, which takes advantage of an isomorphism between labeled hypergraphs and typed lambda calculus: in Hydra, "graphs are programs, and programs are graphs". Scala support for Hydra category:       Data@@ -40,7 +40,7 @@   build-depends:       base >=4.19.0 && <4.22     , containers >=0.6.7 && <0.8-    , hydra-jvm ==0.17.2-    , hydra-kernel ==0.17.2+    , hydra-jvm ==0.17.3+    , hydra-kernel ==0.17.3     , scientific >=0.3.7 && <0.4   default-language: Haskell2010
src/main/haskell/Hydra/Scala/Coder.hs view
@@ -33,6 +33,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Math as Math import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings@@ -113,9 +114,8 @@           typeDefs = Pairs.first partitioned           termDefs = Pairs.second partitioned           nsName = Packaging.unModuleName (Packaging.moduleName mod)-          pname =-                  Syntax.NameData {-                    Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." nsName)))}+          pname = Syntax.NameData {+                Syntax.nameDataValue = (Syntax.PredefString (Strings.join "." (Strings.splitOn "." nsName)))}           pref = Syntax.RefDataName pname       in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g td) typeDefs) (\typeDeclStats -> Eithers.bind (Eithers.mapList (\td -> encodeTermDefinition cx g td) termDefs) (\termDeclStats -> Eithers.bind (findImports cx g mod) (\imports -> Right (Syntax.Pkg {         Syntax.pkgName = pname,@@ -191,12 +191,12 @@           nonSelfVars = Lists.filter (\vv -> Logic.not (Equality.equal vv inVar)) outVars           safeNonSelfVars =                   Lists.filter (\vv -> Logic.and (Logic.not (Sets.member vv directInputVars)) (Logic.not (Equality.equal (Just vv) codVar))) nonSelfVars-      in (Logic.ifElse (Logic.and (Equality.gte selfRefCount 2) (Logic.not (Lists.null safeNonSelfVars))) (Lists.foldl (\s -> \vv -> Maps.insert vv inVar s) subst safeNonSelfVars) subst)+      in (Logic.ifElse (Logic.and (Ordering.gte selfRefCount 2) (Logic.not (Lists.null safeNonSelfVars))) (Lists.foldl (\s -> \vv -> Maps.insert vv inVar s) subst safeNonSelfVars) subst)  -- | Drop N domain types from a function type, returning the remaining type dropDomains :: Int -> Core.Type -> Core.Type dropDomains n t =-    Logic.ifElse (Equality.lte n 0) t (case (Strip.deannotateType t) of+    Logic.ifElse (Ordering.lte n 0) t (case (Strip.deannotateType t) of       Core.TypeFunction v0 -> dropDomains (Math.sub n 1) (Core.functionTypeCodomain v0)       Core.TypeForall v0 -> dropDomains n (Core.forallTypeBody v0)       _ -> t)@@ -221,17 +221,16 @@                     Core.TypeUnit -> True                     Core.TypeRecord v0 -> Equality.equal (Lists.length v0) 0                     _ -> False)-          shortTypeName =-                  Optionals.fromOptional "x" (Lists.maybeLast (Strings.splitOn "." (Optionals.cases sn "x" (\n -> Core.unName n))))+          shortTypeName = Optionals.withDefault "x" (Lists.last (Strings.splitOn "." (Optionals.cases sn "x" (\n -> Core.unName n))))           lamParamSuffix =                   case (Strip.deannotateAndDetypeTerm fterm) of                     Core.TermLambda v0 ->                       let rawName = Core.unName (Core.lambdaParameter v0)                           safeName = Strings.fromList (Lists.map (\c -> Logic.ifElse (Equality.equal c 39) 95 c) (Strings.toList rawName))-                      in (Strings.cat2 "_" safeName)+                      in (Strings.concat2 "_" safeName)                     _ -> ""           v =-                  Core.Name (Strings.cat [+                  Core.Name (Strings.concat [                     "v_",                     shortTypeName,                     "_",@@ -260,11 +259,11 @@        let doms = extractDomains typ           paramNames = extractParams term-          paramCount = Math.min (Lists.length paramNames) (Lists.length doms)+          paramCount = Ordering.min (Lists.length paramNames) (Lists.length doms)           cod = dropDomains paramCount typ           zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)           freeTypeVars =-                  Lists.nub (Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Variables.freeVariablesInTypeOrdered typ))+                  Lists.distinct (Lists.filter (\v -> Logic.not (Lists.member 46 (Strings.toList (Core.unName v)))) (Variables.freeVariablesInTypeOrdered typ))           tparams = Lists.map (\tv -> Utils.stparam tv) freeTypeVars           letBindings = extractLetBindings term           gWithTypeVars =@@ -310,7 +309,7 @@                     Optionals.bind rawMdom (\dom ->                       let freeVars = Variables.freeVariablesInType dom                           unqualifiedFreeVars =-                                  Sets.fromList (Lists.filter (\n -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName n)))) (Sets.toList freeVars))+                                  Sets.fromList (Lists.filter (\n -> Logic.not (Lists.member 46 (Strings.toList (Core.unName n)))) (Sets.toList freeVars))                           unresolvedVars = Sets.difference unqualifiedFreeVars (Graph.graphTypeVariables g)                       in (Logic.ifElse (Sets.null unresolvedVars) (Just dom) Nothing))         in (Eithers.bind (encodeTerm cx g body) (\sbody -> Eithers.bind (Optionals.cases mdom (findSdom cx g meta) (\dom -> Eithers.bind (encodeType cx g dom) (\sdom -> Right (Just sdom)))) (\sdom -> Right (Utils.slambda v sbody sdom))))@@ -410,10 +409,10 @@ encodeLocalDef cx g outerTypeVars lname term typ =        let freeTypeVars =-              Lists.filter (\v -> Logic.and (Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Logic.not (Sets.member v outerTypeVars))) (Sets.toList (Variables.freeVariablesInType typ))+              Lists.filter (\v -> Logic.and (Logic.not (Lists.member 46 (Strings.toList (Core.unName v)))) (Logic.not (Sets.member v outerTypeVars))) (Sets.toList (Variables.freeVariablesInType typ))           doms = extractDomains typ           paramNames = extractParams term-          paramCount = Math.min (Lists.length paramNames) (Lists.length doms)+          paramCount = Ordering.min (Lists.length paramNames) (Lists.length doms)           cod = dropDomains paramCount typ           zippedParams = Lists.zip (Lists.take paramCount paramNames) (Lists.take paramCount doms)           letBindings = extractLetBindings term@@ -550,7 +549,7 @@               parts = Strings.splitOn "." fullName               numParts = Lists.length parts               escaped =-                      Logic.ifElse (Equality.lte numParts 1) (Utils.scalaEscapeName fullName) (Logic.ifElse (Equality.equal numParts 2) (Strings.cat2 (Optionals.fromOptional fullName (Lists.maybeHead parts)) (Strings.cat2 "." (Utils.scalaEscapeName localName))) (Strings.intercalate "." (Lists.concat2 (Lists.take (Math.sub numParts 1) parts) [+                      Logic.ifElse (Ordering.lte numParts 1) (Utils.scalaEscapeName fullName) (Logic.ifElse (Equality.equal numParts 2) (Strings.concat2 (Optionals.withDefault fullName (Lists.head parts)) (Strings.concat2 "." (Utils.scalaEscapeName localName))) (Strings.join "." (Lists.concat2 (Lists.take (Math.sub numParts 1) parts) [                         Utils.scalaEscapeName localName])))           in (Right (Utils.sname escaped))         Core.TermAnnotated v0 -> encodeTerm cx g (Core.annotatedTermBody v0)@@ -588,7 +587,7 @@                       _ -> False                     _ -> False           freeTypeVarsInTyp =-                  Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ_))+                  Lists.filter (\v -> Logic.not (Lists.member 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ_))       in (Logic.ifElse isFunctionType (encodeComplexTermDef cx g lname term typ_) (Logic.ifElse (Lists.null freeTypeVarsInTyp) (Eithers.bind (encodeType cx g typ_) (\stype -> Eithers.bind (encodeTerm cx g term) (\rhs -> Right (Syntax.StatDefn (Syntax.DefnVal (Syntax.ValDefn {         Syntax.valDefnMods = [           Syntax.ModLazy],@@ -705,7 +704,7 @@           Syntax.lambdaTypeTpe = sbody}))))       Core.TypeVariable v0 ->         let rawName = Core.unName v0-            typeName = Logic.ifElse (Lists.elem 46 (Strings.toList rawName)) rawName (Formatting.capitalize rawName)+            typeName = Logic.ifElse (Lists.member 46 (Strings.toList rawName)) rawName (Formatting.capitalize rawName)         in (Right (Syntax.TypeVar (Syntax.VarType {           Syntax.varTypeName = Syntax.NameType {             Syntax.nameTypeValue = typeName}})))@@ -723,7 +722,7 @@           dname = Syntax.NameData {                 Syntax.nameDataValue = (Syntax.PredefString lname)}           freeVars =-                  Lists.filter (\v -> Logic.not (Lists.elem 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))+                  Lists.filter (\v -> Logic.not (Lists.member 46 (Strings.toList (Core.unName v)))) (Sets.toList (Variables.freeVariablesInType typ))           tparams =                   Lists.map (\_v ->                     let vn = Formatting.capitalize (Core.unName _v)@@ -1043,8 +1042,8 @@ findSelfRefVar :: (Eq t0, Ord t0) => (M.Map t0 [t0] -> Maybe t0) findSelfRefVar grouped = -      let selfRefs = Lists.filter (\entry -> Lists.elem (Pairs.first entry) (Pairs.second entry)) (Maps.toList grouped)-      in (Optionals.map (\entry -> Pairs.first entry) (Lists.maybeHead selfRefs))+      let selfRefs = Lists.filter (\entry -> Lists.member (Pairs.first entry) (Pairs.second entry)) (Maps.toList grouped)+      in (Optionals.map (\entry -> Pairs.first entry) (Lists.head selfRefs))  -- | Group a list of pairs into a map keyed by first component (#589) groupPairsByFirst :: Ord t0 => ([(t0, t1)] -> M.Map t0 [t1])@@ -1072,7 +1071,7 @@ -- | Peel up to n curried domain types off a function type (#589) peelDomainTypes :: Int -> Core.Type -> ([Core.Type], Core.Type) peelDomainTypes n t =-    Logic.ifElse (Equality.lte n 0) ([], t) (case (Strip.deannotateType t) of+    Logic.ifElse (Ordering.lte n 0) ([], t) (case (Strip.deannotateType t) of       Core.TypeFunction v0 ->         let rest = peelDomainTypes (Math.sub n 1) (Core.functionTypeCodomain v0)         in (Lists.cons (Core.functionTypeDomain v0) (Pairs.first rest), (Pairs.second rest))@@ -1086,7 +1085,7 @@ -- | Unify every co-occurring var onto inVar when inVar is its own accumulator output (#589) selfRefSubstitutionProcessGroup :: (Eq t0, Ord t0) => (M.Map t0 t0 -> t0 -> [t0] -> M.Map t0 t0) selfRefSubstitutionProcessGroup subst inVar outVars =-    Logic.ifElse (Lists.elem inVar outVars) (Lists.foldl (\s -> \vv -> Logic.ifElse (Equality.equal vv inVar) s (Maps.insert vv inVar s)) subst outVars) subst+    Logic.ifElse (Lists.member inVar outVars) (Lists.foldl (\s -> \vv -> Logic.ifElse (Equality.equal vv inVar) s (Maps.insert vv inVar s)) subst outVars) subst  -- | Strip wrap eliminations from terms (newtypes are erased in Scala) stripWrapEliminations :: Core.Term -> Core.Term@@ -1148,7 +1147,7 @@       Syntax.importImporters = [         Syntax.Importer {           Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {-            Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),+            Syntax.nameDataValue = (Syntax.PredefString (Strings.join "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),           Syntax.importerImportees = [             Syntax.ImporteeWildcard]}]})) @@ -1159,7 +1158,7 @@       Syntax.importImporters = [         Syntax.Importer {           Syntax.importerRef = (Syntax.RefDataName (Syntax.NameData {-            Syntax.nameDataValue = (Syntax.PredefString (Strings.intercalate "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),+            Syntax.nameDataValue = (Syntax.PredefString (Strings.join "." (Strings.splitOn "." (Packaging.unModuleName ns))))})),           Syntax.importerImportees = []}]}))  -- | Convert a type parameter to a type variable reference
src/main/haskell/Hydra/Scala/Serde.hs view
@@ -24,6 +24,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Math as Math import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing@@ -65,7 +66,7 @@           body = Syntax.functionDataBody f           bodyExpr = termToExpr body           bodyLen = Serialization.expressionLength bodyExpr-      in (Logic.ifElse (Equality.gt bodyLen 60) (Serialization.noSep [+      in (Logic.ifElse (Ordering.gt bodyLen 60) (Serialization.noSep [         Serialization.parenListAdaptive (Lists.map dataParamToExpr params),         (Serialization.cst " =>\n  "),         bodyExpr]) (Serialization.spaceSep [@@ -83,7 +84,7 @@        let name = Syntax.paramDataName dp           stype = Syntax.paramDataDecltpe dp-      in (Serialization.noSep (Optionals.cat [+      in (Serialization.noSep (Optionals.givens [         Optionals.pure (nameToExpr name),         (Optionals.map (\t -> Serialization.spaceSep [           Serialization.cst ":",@@ -122,7 +123,7 @@                       (typeToExpr t)]) scod             paramssExprs = Lists.map (\ps -> Serialization.parenListAdaptive (Lists.map dataParamToExpr ps)) paramss             nameAndParams =-                    Serialization.noSep (Optionals.cat (Lists.concat [+                    Serialization.noSep (Optionals.givens (Lists.concat [                       [                         Optionals.pure (dataNameToExpr name)],                       [@@ -137,7 +138,7 @@                       nameAndParams,                       (Serialization.cst "=")]             bodyLen = Serialization.expressionLength bodyExpr-        in (Logic.ifElse (Equality.gt bodyLen 80) (Serialization.noSep [+        in (Logic.ifElse (Ordering.gt bodyLen 80) (Serialization.noSep [           defSig,           (Serialization.cst "\n  "),           bodyExpr]) (Serialization.spaceSep [@@ -147,7 +148,7 @@         let name = Syntax.typeDefnName v0             tparams = Syntax.typeDefnTparams v0             body = Syntax.typeDefnBody v0-        in (Serialization.spaceSep (Optionals.cat [+        in (Serialization.spaceSep (Optionals.givens [           Optionals.pure (Serialization.cst "type"),           (Optionals.pure (typeNameToExpr name)),           (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams)))),@@ -159,14 +160,14 @@             typ = Syntax.valDefnDecltpe v0             rhs = Syntax.valDefnRhs v0             nameStr =-                    Optionals.fromOptional "" (Optionals.map (\firstPat ->+                    Optionals.withDefault "" (Optionals.map (\firstPat ->                       let patName =                               case firstPat of                                 Syntax.PatVar v1 -> Syntax.varPatName v1-                      in (Syntax.unPredefString (Syntax.nameDataValue patName))) (Lists.maybeHead pats))+                      in (Syntax.unPredefString (Syntax.nameDataValue patName))) (Lists.head pats))             nameAndType =                     Optionals.cases typ (Serialization.cst nameStr) (\t -> Serialization.spaceSep [-                      Serialization.cst (Strings.cat2 nameStr ":"),+                      Serialization.cst (Strings.concat2 nameStr ":"),                       (typeToExpr t)])             valKeyword = Logic.ifElse (Lists.null mods) "val" "lazy val"         in (Serialization.spaceSep [@@ -185,7 +186,7 @@             paramsExpr =                     Logic.ifElse (Lists.null paramss) Nothing (Optionals.pure (Serialization.parenListAdaptive (Lists.map dataParamToExpr (Lists.concat paramss))))             nameAndParams =-                    Serialization.noSep (Optionals.cat [+                    Serialization.noSep (Optionals.givens [                       Optionals.pure (typeNameToExpr name),                       tparamsExpr,                       paramsExpr])@@ -202,7 +203,7 @@             enumHeader =                     Serialization.spaceSep [                       Serialization.cst "enum",-                      (Serialization.noSep (Optionals.cat [+                      (Serialization.noSep (Optionals.givens [                         Optionals.pure (typeNameToExpr name),                         (Logic.ifElse (Lists.null tparams) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map typeParamToExpr tparams))))])),                       (Serialization.cst ":")]@@ -266,12 +267,12 @@                   case ref of                     Syntax.RefDataName v0 -> Syntax.unPredefString (Syntax.nameDataValue v0)           forImportees =-                  Logic.ifElse (Lists.null importees) (Serialization.cst "") (Logic.ifElse (Equality.equal (Lists.length importees) 1) (Optionals.fromOptional (Serialization.cst "") (Optionals.map (\firstImp -> Serialization.noSep [+                  Logic.ifElse (Lists.null importees) (Serialization.cst "") (Logic.ifElse (Equality.equal (Lists.length importees) 1) (Optionals.withDefault (Serialization.cst "") (Optionals.map (\firstImp -> Serialization.noSep [                     Serialization.cst ".",                     case firstImp of                       Syntax.ImporteeWildcard -> Serialization.cst "*"                       Syntax.ImporteeName v0 -> Serialization.cst (case (Syntax.nameImporteeName v0) of-                        Syntax.NameValue v1 -> v1)]) (Lists.maybeHead importees))) (Serialization.noSep [+                        Syntax.NameValue v1 -> v1)]) (Lists.head importees))) (Serialization.noSep [                     Serialization.cst ".",                     (Serialization.curlyBracesList Nothing Serialization.inlineStyle (Lists.map (\it -> case it of                       Syntax.ImporteeWildcard -> Serialization.cst "*"@@ -292,15 +293,15 @@ litToExpr lit =     case lit of       Syntax.LitBoolean v0 -> Serialization.cst (Logic.ifElse v0 "true" "false")-      Syntax.LitByte v0 -> Serialization.cst (Strings.cat2 (Literals.showInt8 v0) ".toByte")-      Syntax.LitShort v0 -> Serialization.cst (Strings.cat2 (Literals.showInt16 v0) ".toShort")+      Syntax.LitByte v0 -> Serialization.cst (Strings.concat2 (Literals.showInt8 v0) ".toByte")+      Syntax.LitShort v0 -> Serialization.cst (Strings.concat2 (Literals.showInt16 v0) ".toShort")       Syntax.LitInt v0 -> Serialization.cst (Literals.showInt32 v0)-      Syntax.LitLong v0 -> Serialization.cst (Strings.cat2 (Literals.showInt64 v0) "L")+      Syntax.LitLong v0 -> Serialization.cst (Strings.concat2 (Literals.showInt64 v0) "L")       Syntax.LitFloat v0 -> Serialization.cst (scalaFloatLiteralText "Float" "f" (Literals.showFloat32 v0))       Syntax.LitDouble v0 -> Serialization.cst (scalaFloatLiteralText "Double" "" (Literals.showFloat64 v0))       Syntax.LitUnit -> Serialization.cst "()"-      Syntax.LitString v0 -> Serialization.cst (Strings.cat2 "\"" (Strings.cat2 (Serde.escapeJavaString v0) "\""))-      Syntax.LitBytes v0 -> Serialization.cst (Strings.cat2 "Array[Byte](" (Strings.cat2 (Strings.intercalate ", " (Lists.map (\b -> Strings.cat2 (Literals.showInt32 b) ".toByte") v0)) ")"))+      Syntax.LitString v0 -> Serialization.cst (Strings.concat2 "\"" (Strings.concat2 (Serde.escapeJavaString v0) "\""))+      Syntax.LitBytes v0 -> Serialization.cst (Strings.concat2 "Array[Byte](" (Strings.concat2 (Strings.join ", " (Lists.map (\b -> Strings.concat2 (Literals.showInt32 b) ".toByte") v0)) ")"))       _ -> Serialization.cst "TODO:literal"  -- | The match operator@@ -364,7 +365,7 @@  scalaFloatLiteralText :: String -> String -> String -> String scalaFloatLiteralText prefix suffix s =-    Logic.ifElse (Equality.equal s "NaN") (Strings.cat2 prefix ".NaN") (Logic.ifElse (Equality.equal s "Infinity") (Strings.cat2 prefix ".PositiveInfinity") (Logic.ifElse (Equality.equal s "-Infinity") (Strings.cat2 prefix ".NegativeInfinity") (Strings.cat2 s suffix)))+    Logic.ifElse (Equality.equal s "NaN") (Strings.concat2 prefix ".NaN") (Logic.ifElse (Equality.equal s "Infinity") (Strings.concat2 prefix ".PositiveInfinity") (Logic.ifElse (Equality.equal s "-Infinity") (Strings.concat2 prefix ".NegativeInfinity") (Strings.concat2 s suffix)))  -- | Convert a statement to an expression statToExpr :: Syntax.Stat -> Ast.Expr@@ -425,7 +426,7 @@           (Serialization.bracketList Serialization.inlineStyle (Lists.map typeToExpr args))])       Syntax.TypeFunction v0 ->         let cod = Syntax.functionTypeRes v0-            dom = Optionals.fromOptional cod (Lists.maybeHead (Syntax.functionTypeParams v0))+            dom = Optionals.withDefault cod (Lists.head (Syntax.functionTypeParams v0))         in (Serialization.ifx functionArrowOp (typeToExpr dom) (typeToExpr cod))       Syntax.TypeLambda v0 ->         let params = Syntax.lambdaTypeTparams v0
src/main/haskell/Hydra/Scala/Utils.hs view
@@ -23,6 +23,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Math as Math import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Ordering as Ordering import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Names as Names@@ -59,7 +60,7 @@ -- | Qualify a union field name, optionally prefixing with the Scala type name qualifyUnionFieldName :: String -> Maybe Core.Name -> Core.Name -> String qualifyUnionFieldName dlft sname fname =-    Strings.cat2 (Optionals.cases sname dlft (\n -> Strings.cat2 (scalaTypeName True n) ".")) (scalaEscapeName (Core.unName fname))+    Strings.concat2 (Optionals.cases sname dlft (\n -> Strings.concat2 (scalaTypeName True n) ".")) (scalaEscapeName (Core.unName fname))  -- | Apply a Scala data expression to a list of arguments sapply :: Syntax.Data -> [Syntax.Data] -> Syntax.Data@@ -75,16 +76,16 @@       let typeToStr = \t -> typeToString t           typeStrings = Lists.map typeToStr typeArgs           typeArgStr =-                  Strings.cat [+                  Strings.concat [                     "[",-                    (Strings.intercalate ", " typeStrings),+                    (Strings.join ", " typeStrings),                     "]"]       in case fun of         Syntax.DataRef v0 -> case v0 of           Syntax.RefDataName v1 ->             let nameStr = Syntax.nameDataValue v1                 rawName = Syntax.unPredefString nameStr-            in (sname (Strings.cat2 rawName typeArgStr))+            in (sname (Strings.concat2 rawName typeArgStr))           Syntax.RefDataSelect v1 ->             let qual = Syntax.selectDataQual v1                 selName = Syntax.selectDataName v1@@ -93,7 +94,7 @@             in (Syntax.DataRef (Syntax.RefDataSelect (Syntax.SelectData {               Syntax.selectDataQual = qual,               Syntax.selectDataName = Syntax.NameData {-                Syntax.nameDataValue = (Syntax.PredefString (Strings.cat2 rawName typeArgStr))}})))+                Syntax.nameDataValue = (Syntax.PredefString (Strings.concat2 rawName typeArgStr))}})))           _ -> fun         _ -> fun) @@ -119,8 +120,8 @@           sanitized2 = Logic.ifElse (Equality.equal sanitized "_") "_x" sanitized           sanitized3 = Logic.ifElse (Equality.equal sanitized2 "toString") "toString_" sanitized2           needsBackticks =-                  Logic.or (Sets.member sanitized3 scalaReservedWords) (Logic.and (Equality.gt (Strings.length sanitized3) 0) (Equality.equal (Optionals.fromOptional 0 (Strings.maybeCharAt (Math.sub (Strings.length sanitized3) 1) sanitized3)) 95))-      in (Logic.ifElse needsBackticks (Strings.cat [+                  Logic.or (Sets.member sanitized3 scalaReservedWords) (Logic.and (Ordering.gt (Strings.length sanitized3) 0) (Equality.equal (Optionals.withDefault 0 (Strings.charAt (Math.sub (Strings.length sanitized3) 1) sanitized3)) 95))+      in (Logic.ifElse needsBackticks (Strings.concat [         "`",         sanitized3,         "`"]) sanitized3)@@ -156,9 +157,9 @@ sprim name =        let qname = Names.qualifyName name-          prefix = Packaging.unModuleName (Optionals.fromOptional (Packaging.ModuleName "") (Util.qualifiedNameModuleName qname))+          prefix = Packaging.unModuleName (Optionals.withDefault (Packaging.ModuleName "") (Util.qualifiedNameModuleName qname))           local = scalaEscapeName (Util.qualifiedNameLocal qname)-      in (sname (Strings.cat2 (Strings.cat2 prefix ".") local))+      in (sname (Strings.concat2 (Strings.concat2 prefix ".") local))  -- | Apply a Scala type to a list of type arguments stapply :: Syntax.Type -> [Syntax.Type] -> Syntax.Type@@ -217,17 +218,17 @@       Syntax.TypeFunction v0 ->         let params = Lists.map typeToString (Syntax.functionTypeParams v0)             res = typeToString (Syntax.functionTypeRes v0)-        in (Strings.cat [+        in (Strings.concat [           "(",-          (Strings.intercalate ", " params),+          (Strings.join ", " params),           ") => ",           res])       Syntax.TypeApply v0 ->         let base = typeToString (Syntax.applyTypeTpe v0)             argStrs = Lists.map typeToString (Syntax.applyTypeArgs v0)-        in (Strings.cat [+        in (Strings.concat [           base,           "[",-          (Strings.intercalate ", " argStrs),+          (Strings.join ", " argStrs),           "]"])       _ -> "Any"