diff --git a/hydra-scala.cabal b/hydra-scala.cabal --- a/hydra-scala.cabal +++ b/hydra-scala.cabal @@ -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 diff --git a/src/main/haskell/Hydra/Scala/Coder.hs b/src/main/haskell/Hydra/Scala/Coder.hs --- a/src/main/haskell/Hydra/Scala/Coder.hs +++ b/src/main/haskell/Hydra/Scala/Coder.hs @@ -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 diff --git a/src/main/haskell/Hydra/Scala/Serde.hs b/src/main/haskell/Hydra/Scala/Serde.hs --- a/src/main/haskell/Hydra/Scala/Serde.hs +++ b/src/main/haskell/Hydra/Scala/Serde.hs @@ -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 diff --git a/src/main/haskell/Hydra/Scala/Utils.hs b/src/main/haskell/Hydra/Scala/Utils.hs --- a/src/main/haskell/Hydra/Scala/Utils.hs +++ b/src/main/haskell/Hydra/Scala/Utils.hs @@ -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"