diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,168 @@ --- +## [0.17.6] - 2026-08-30 + +Point release on the 0.17.x line, and the last backward-incompatible batch before the 1.0 surface +freeze. Five kernel-surface changes land together as the "0.17 breaking batch": +`null` becomes `isEmpty`, `read*`/`show*` become `parse*`/`print*`, `TypeScheme.constraints` and +`TypeVariableConstraints.classes` change shape, and the constructor primitives are finalized. +Alongside them, a genuine soundness gap in type inference is fixed — class constraints now propagate +through function-domain positions — and the cold-seed path is rebuilt on the Java host so that +breaking core-type changes are no longer structurally impossible to bootstrap. + +**Backward-incompatible.** All five surface changes below alter the published kernel. Code written +against 0.17.5 must be updated: + +- **[#682]** `hydra.lib.{lists,sets,maps,strings}.null` -> `.isEmpty`. +- **[#691]** the `read*`/`show*` family -> `parse*`/`print*`. +- **[#683]** `TypeScheme.constraints`: `optional` -> plain `map`. +- **[#685]** `TypeVariableConstraints.classes`: `list` -> `set`. +- **[#687]** constructor primitives finalized: `lists.pure` is removed; `optionals.given`, + `eithers.left`/`right` and `pairs.pair` are added. + +[#682]: https://github.com/CategoricalData/hydra/issues/682 +[#683]: https://github.com/CategoricalData/hydra/issues/683 +[#685]: https://github.com/CategoricalData/hydra/issues/685 +[#687]: https://github.com/CategoricalData/hydra/issues/687 +[#691]: https://github.com/CategoricalData/hydra/issues/691 + +### Highlights + +- **Class constraints propagate through contravariant positions** + ([#702](https://github.com/CategoricalData/hydra/issues/702)): inference silently dropped a class + constraint when the constrained type variable was bound through the **domain** (input) position of a + higher-order function argument, while transferring it correctly in output positions — a real soundness + gap in the type checker. It had been papered over twice by freezing `encodeMap`/`encodeSet` to + monomorphic `Int`. Both freezes and the [#554](https://github.com/CategoricalData/hydra/issues/554) + `toPrimitive` stopgap are now removed, the definitions re-polymorphized, and a domain-position + regression test added. A `sets.filter` overlay lands across Java, Python, Scala, TypeScript and the + Lisp dialects as its first consumer. +- **Cold-seed rebuilt on the Java host** + ([#703](https://github.com/CategoricalData/hydra/issues/703)): CI's cold-seed steps compiled HEAD's + kernel `Types` source against the *published* Hackage `hydra-kernel`, which is sound only for additive + changes and structurally impossible for any breaking core-type-shape change — the root of a recurring + red-CI class (#500, #608, #617, #417, #683). The Haskell cold-seeder (`ColdSeedMain`, `typesmods/`, + Check-2) is deleted and replaced by a data-driven Java-host schema-walking seed + (`seed-dist-haskell.sh`), which decodes `dist/json` and emits Haskell text without ever linking + HEAD types against a published kernel. +- **`hydra.paths` completed** ([#716](https://github.com/CategoricalData/hydra/issues/716)): + the step unions are realigned with the `hydra.core` term and type grammars — missing variants + added (`annotatedAnnotation`, `eitherLeft`/`eitherRight`, `effect`), undirected steps given a + direction, and variants named after retired constructors renamed. `hydra.print.paths` is rewritten + as serialization-only (printers, parsers and a round-trip law), and the graph view moves to a new + `hydra.shredding` module (`shredGraph`/`shredTerm`/`shredSchema`), which the Graphviz coder now + consumes. +- **`hydra.lib.ordering` is genuinely structural on every host** + ([#718](https://github.com/CategoricalData/hydra/issues/718)): the Java, Python and Scala overlay + implementations fell back to comparing *printed strings* for non-literal and mixed-variant terms, + contradicting the normative `ordering-and-equality.md` (records field-by-field in declaration + order, unions by declared-variant order then payload, wrappers by wrapped value, decimals by + numeric value then scale — with no print-based fallback anywhere). All three are now structural; + Java delegates to the generated `compareTo`. +- **Bash driver-layer audit** ([#714](https://github.com/CategoricalData/hydra/issues/714)): + a prerequisite to the remaining #416 promotion. Six dead build scripts superseded by + `transform-json-to-target.sh` are deleted, and the #608 oil-and-water and #540 header-idempotency + regression harnesses are wired into `test-regressions.sh`. + +- **Backward-compatibility and deprecation policy** + ([#676](https://github.com/CategoricalData/hydra/issues/676)): adds the normative spec chapter defining + what "compatible" means after 1.0 — the additivity calculus, the deprecation/rename mechanism, and + enforcement. `LifecycleInfo.deprecatedSince` moves from defined-but-unused to populated on **32** + kernel primitives slated for 0.18 deprecation, via a new `deprecatedSince` DSL helper. +- **Effect-sequencing contract specified and tested** + ([#675](https://github.com/CategoricalData/hydra/issues/675)): `hydra.lib.effects` carries a sequencing + contract — effects composed in a specified order, exactly once each, with `bind`'s continuation deferred + until the prior effect has run. On the lazy Haskell host this falls out of the evaluation model; on the + eight eager hosts it depended entirely on each hand-written interpreter. The obligations are now written + into `effects.md` and backed by ordering-observation tests for `bind`/`foldList`/`mapList`/`mapOptional`. +- **Non-GC memory-discipline investigation** + ([#678](https://github.com/CategoricalData/hydra/issues/678)): Hydra's data model says nothing about + allocation, freeing, or ownership, which is what gates Swift, Rust, C++ and C as runtime hosts. This + investigation delivers per-language verdicts plus leak-free proof-of-concept implementations — Rust + (`Box` structural ownership), C++ (`unique_ptr` + arena) and C (arena), all ASan/LSan-clean on + construct-and-drop of a recursive `Term` — and an airtight analysis of Swift's class-forcing requirement. +- **Build system promotion continues** ([#416](https://github.com/CategoricalData/hydra/issues/416)): + adds `hydra.build.Registry`, which models per-language build identity as data (name / coder package / + family) with per-script scope lists. `syncMatrix` and `langExpansion` are rewired onto it, and the + hardcoded language lists in the test and bench scripts are retired in favour of a generated + `languages.json`. Later in the cycle: `publishsets.reverseDepClosure` and + `publishsets.requiresCoders` promote reverse-dependency propagation and per-package coder-loading + into data, an `expected-libraries.json` artifact lets the Common Lisp and Emacs Lisp harnesses + fail fast on a missing `hydra.lib`, and a host-independent `apply-assembly-plan.sh` executor + (with a conformance test) takes over the Java `assemble-distribution` Step 0. +- **Serialization specification chapter** + ([#674](https://github.com/CategoricalData/hydra/issues/674)): documents serializability, the + encode/decode contract, and the round-trip law; `isSerializable` now forbids `void` + ([#690](https://github.com/CategoricalData/hydra/issues/690)), and `hydra.lib.functions.absurd` is added + as the void eliminator ([#684](https://github.com/CategoricalData/hydra/issues/684)). + +### Bug fixes + +- **Hoisting silently produced terms with free variables** + ([#717](https://github.com/CategoricalData/hydra/issues/717)): + `augmentBindingsWithNewFreeVars` returned a binding *unchanged* when a captured variable had no + type in the context, yielding a top-level binding with free variables — a term valid before + hoisting and invalid after, produced with no error. It is now total and fails loudly, per the + kernel's fail-immediately rule. +- **TypeScript `div`/`mod` used truncating semantics** + ([#677](https://github.com/CategoricalData/hydra/issues/677)): corrected to floor/Knuth division via + shared bigint helpers, with an `Optional` codomain; the dead `maybeDiv`/`maybeMod` are deleted and an + emitted-path test added. +- **Overlay lag behind the `null` -> `isEmpty` rename** + ([#682](https://github.com/CategoricalData/hydra/issues/682)): the Java, Python, Scala, TypeScript and + Lisp overlays each kept a stale spelling (`isEmpty_`, a half-renamed Python `null` impl, and Lisp + camelCase where the coder emits snake_case), breaking generation until reconciled. +- **`check-haskell-def-completeness` could not resolve qualified assembly references** + ([#683](https://github.com/CategoricalData/hydra/issues/683)), surfaced once the #703 cold-clone path + began reaching the check. +- **Void-typed definitions leaked into DSL-ref generation** + ([#684](https://github.com/CategoricalData/hydra/issues/684)): `absurd` and friends are now excluded + across all hosts. +- **Scheme bootstrap loader gaps** ([#641](https://github.com/CategoricalData/hydra/issues/641)): + missing `functions.scm`/`ordering.scm` in the native-lib load list, missing defaults in the def-module + load list, and a guile-only import allowlist. +- **Bootstrap diff detail was swallowed** ([#671](https://github.com/CategoricalData/hydra/issues/671)): + now persisted to `/.diff`, with `compare_output`'s return value no longer discarded. + Separately, `compare_output` mis-derived the `src/main` vs `src/test` root per file + ([#706](https://github.com/CategoricalData/hydra/issues/706)). +- **Nested duplicate output path** ([#664](https://github.com/CategoricalData/hydra/issues/664)) from + `hydra-kernel` being hardcoded into `defaultOutput`. +- **Bootstrap codegen exceptions hid their stack traces** + ([#707](https://github.com/CategoricalData/hydra/issues/707)) in `bootstrap.ts`. + +### Release tooling + +- `bin/check-release-env.sh` ([#704](https://github.com/CategoricalData/hydra/issues/704)) adds a + publish-time toolchain preflight, after JDK- and twine-version problems cost real time at 0.17.5. +- The TypeScript head's node floor is lowered to `^18.0.0 || >=20.0.0`, the true vitest constraint + ([#708](https://github.com/CategoricalData/hydra/issues/708)). +- Hydra does not create GitHub Releases; the detached `.asc` signature stays in `release-artifacts/` + until [#441](https://github.com/CategoricalData/hydra/issues/441) + ([#508](https://github.com/CategoricalData/hydra/issues/508)). + +### Known issues + +- The `hostOverrides` shim is pinned to `{java: local, python: local}` for the duration of the breaking + batch, since the new kernel surface is by definition absent from published 0.17.5. It must be retired + once 0.17.6 is visible in Maven Central and PyPI + ([#508](https://github.com/CategoricalData/hydra/issues/508)). +- **`hydra-ext` does not ship to Maven Central for Java**, as in 0.17.4 and 0.17.5: the Java coder's + visitor-pattern inner interface still collides with an enclosing type named `Visitor` + ([#643](https://github.com/CategoricalData/hydra/issues/643)), so the package does not compile for + that target. It publishes to Hackage and PyPI as usual. +- The breaking batch leaves three deliberate 0.18 tails, each separately tracked: + `effects.pure` is retained provisionally pending a name decision + ([#688](https://github.com/CategoricalData/hydra/issues/688)); the `printable` type class that would + promote the print/parse convention into enforced dispatch awaits + [#497](https://github.com/CategoricalData/hydra/issues/497); and the literal conversion lattice is + gated on [#129](https://github.com/CategoricalData/hydra/issues/129) via + [#689](https://github.com/CategoricalData/hydra/issues/689). Anticipated `TypeClassConstraint` + variants remain open as [#686](https://github.com/CategoricalData/hydra/issues/686) — the `set` + element type must stay orderable as variants are added. + +--- + ## [0.17.5] - 2026-08-19 Point release on the 0.17.x line. Two language-surface changes lead: sum-type eliminators unify on diff --git a/hydra-ext.cabal b/hydra-ext.cabal --- a/hydra-ext.cabal +++ b/hydra-ext.cabal @@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.38.1. +-- This file has been generated from package.yaml by hpack version 0.39.1. -- -- see: https://github.com/sol/hpack name: hydra-ext -version: 0.17.5 +version: 0.17.6 synopsis: Hydra extensions: additional coders and schema integrations 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". Various extensions to Hydra category: Data @@ -90,7 +90,7 @@ base >=4.19.0 && <4.22 , bytestring >=0.11.5 && <0.13 , containers >=0.6.7 && <0.8 - , hydra-kernel ==0.17.5 - , hydra-rdf ==0.17.5 + , hydra-kernel ==0.17.6 + , hydra-rdf ==0.17.6 , scientific >=0.3.7 && <0.4 default-language: Haskell2010 diff --git a/src/main/haskell/Hydra/Atlas.hs b/src/main/haskell/Hydra/Atlas.hs --- a/src/main/haskell/Hydra/Atlas.hs +++ b/src/main/haskell/Hydra/Atlas.hs @@ -8,7 +8,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Xml.Schema as Schema -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Int as I import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Avro/Coder.hs b/src/main/haskell/Hydra/Avro/Coder.hs --- a/src/main/haskell/Hydra/Avro/Coder.hs +++ b/src/main/haskell/Hydra/Avro/Coder.hs @@ -49,7 +49,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -138,7 +138,7 @@ Schema.SchemaNamed v0 -> let ns = Schema.namedNamespace v0 manns = namedAnnotationsToCore v0 - ann = Logic.ifElse (Maps.null manns) Nothing (Just manns) + ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) lastNs = Environment.avroEnvironmentNamespace env0 nextNs = Optionals.match ns lastNs (\s -> Just s) env1 = @@ -325,7 +325,7 @@ Schema.PrimitiveNull -> True _ -> False _ -> False - hasNull = Logic.not (Lists.null (Lists.filter isNull schemas)) + hasNull = Logic.not (Lists.isEmpty (Lists.filter isNull schemas)) nonNulls = Lists.filter (\s -> Logic.not (isNull s)) schemas forOptional = \s -> Eithers.bind (avroHydraAdapter cx s env0) (\adEnv -> @@ -425,7 +425,7 @@ findAvroPrimaryKeyField cx qname avroFields = let keys = Optionals.givens (Lists.map (\f -> primaryKeyE cx f) avroFields) - in (Logic.ifElse (Lists.null keys) (Right Nothing) (Logic.ifElse (Equality.equal (Lists.length keys) 1) (Right (Lists.head keys)) (err cx (Strings.concat2 "multiple primary key fields for " (showQname qname))))) + in (Logic.ifElse (Lists.isEmpty keys) (Right Nothing) (Logic.ifElse (Equality.equal (Lists.length keys) 1) (Right (Lists.head keys)) (err cx (Strings.concat2 "multiple primary key fields for " (showQname qname))))) -- | Extract a foreign key annotation from a field, if present foreignKeyE :: t0 -> Schema.Field -> Either Errors.Error (Maybe Environment.AvroForeignKey) @@ -446,7 +446,7 @@ case v of Model.ValueBoolean v0 -> Right (Logic.ifElse v0 "true" "false") Model.ValueString v0 -> Right v0 - Model.ValueNumber v0 -> Right (Literals.showDecimal v0) + Model.ValueNumber v0 -> Right (Literals.printDecimal v0) _ -> unexpectedE cx "string, number, or boolean" "other" -- | Extract named type annotations and convert them to core Name/Term pairs @@ -460,7 +460,7 @@ -- | Look up an optional string attribute in a JSON object map optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe String)) optStringE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.pure s) (expectStringE cx v)) + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) -- | Parse a dotted Avro name into a qualified name parseAvroName :: Maybe String -> String -> Environment.AvroQualifiedName @@ -485,7 +485,7 @@ prepareField cx env f = let manns = fieldAnnotationsToCore f - ann = Logic.ifElse (Maps.null manns) Nothing (Just manns) + ann = Logic.ifElse (Maps.isEmpty manns) Nothing (Just manns) in (Eithers.bind (foreignKeyE cx f) (\fk -> Eithers.bind (Optionals.match fk (avroHydraAdapter cx (Schema.fieldType f) env) (\fkVal -> let fkName = Environment.avroForeignKeyTypeName fkVal fkConstr = Environment.avroForeignKeyConstructor fkVal @@ -616,15 +616,15 @@ Core.TypeLiteral v0 -> case v0 of Core.LiteralTypeBoolean -> readAndWrap (\x -> Literals.parseBoolean x) (\b -> Core.LiteralBoolean b) Core.LiteralTypeInteger v1 -> case v1 of - Core.IntegerTypeBigint -> readAndWrap (\x -> Literals.readBigint x) (\i -> Core.LiteralInteger (Core.IntegerValueBigint i)) - Core.IntegerTypeInt8 -> readAndWrap (\x -> Literals.readInt8 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt8 i)) - Core.IntegerTypeInt16 -> readAndWrap (\x -> Literals.readInt16 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt16 i)) - Core.IntegerTypeInt32 -> readAndWrap (\x -> Literals.readInt32 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt32 i)) - Core.IntegerTypeInt64 -> readAndWrap (\x -> Literals.readInt64 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt64 i)) - Core.IntegerTypeUint8 -> readAndWrap (\x -> Literals.readUint8 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint8 i)) - Core.IntegerTypeUint16 -> readAndWrap (\x -> Literals.readUint16 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint16 i)) - Core.IntegerTypeUint32 -> readAndWrap (\x -> Literals.readUint32 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint32 i)) - Core.IntegerTypeUint64 -> readAndWrap (\x -> Literals.readUint64 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint64 i)) + Core.IntegerTypeBigint -> readAndWrap (\x -> Literals.parseBigint x) (\i -> Core.LiteralInteger (Core.IntegerValueBigint i)) + Core.IntegerTypeInt8 -> readAndWrap (\x -> Literals.parseInt8 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt8 i)) + Core.IntegerTypeInt16 -> readAndWrap (\x -> Literals.parseInt16 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt16 i)) + Core.IntegerTypeInt32 -> readAndWrap (\x -> Literals.parseInt32 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt32 i)) + Core.IntegerTypeInt64 -> readAndWrap (\x -> Literals.parseInt64 x) (\i -> Core.LiteralInteger (Core.IntegerValueInt64 i)) + Core.IntegerTypeUint8 -> readAndWrap (\x -> Literals.parseUint8 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint8 i)) + Core.IntegerTypeUint16 -> readAndWrap (\x -> Literals.parseUint16 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint16 i)) + Core.IntegerTypeUint32 -> readAndWrap (\x -> Literals.parseUint32 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint32 i)) + Core.IntegerTypeUint64 -> readAndWrap (\x -> Literals.parseUint64 x) (\i -> Core.LiteralInteger (Core.IntegerValueUint64 i)) Core.LiteralTypeString -> Right (Core.TermLiteral (Core.LiteralString s)) _ -> unexpectedE cx "literal type" "other literal type" _ -> unexpectedE cx "literal type" "other" @@ -636,15 +636,15 @@ Core.TermLiteral v0 -> case v0 of Core.LiteralBoolean v1 -> Right (Literals.printBoolean v1) Core.LiteralInteger v1 -> Right (case v1 of - Core.IntegerValueBigint v2 -> Literals.showBigint v2 - Core.IntegerValueInt8 v2 -> Literals.showInt8 v2 - Core.IntegerValueInt16 v2 -> Literals.showInt16 v2 - Core.IntegerValueInt32 v2 -> Literals.showInt32 v2 - Core.IntegerValueInt64 v2 -> Literals.showInt64 v2 - Core.IntegerValueUint8 v2 -> Literals.showUint8 v2 - Core.IntegerValueUint16 v2 -> Literals.showUint16 v2 - Core.IntegerValueUint32 v2 -> Literals.showUint32 v2 - Core.IntegerValueUint64 v2 -> Literals.showUint64 v2) + Core.IntegerValueBigint v2 -> Literals.printBigint v2 + Core.IntegerValueInt8 v2 -> Literals.printInt8 v2 + Core.IntegerValueInt16 v2 -> Literals.printInt16 v2 + Core.IntegerValueInt32 v2 -> Literals.printInt32 v2 + Core.IntegerValueInt64 v2 -> Literals.printInt64 v2 + Core.IntegerValueUint8 v2 -> Literals.printUint8 v2 + Core.IntegerValueUint16 v2 -> Literals.printUint16 v2 + Core.IntegerValueUint32 v2 -> Literals.printUint32 v2 + Core.IntegerValueUint64 v2 -> Literals.printUint64 v2) Core.LiteralString v1 -> Right v1 _ -> unexpectedE cx "boolean, integer, or string" "other literal" Core.TermOptional v0 -> Optionals.match v0 (unexpectedE cx "literal value" "Nothing") (\term_ -> termToStringE cx term_) diff --git a/src/main/haskell/Hydra/Avro/Encoder.hs b/src/main/haskell/Hydra/Avro/Encoder.hs --- a/src/main/haskell/Hydra/Avro/Encoder.hs +++ b/src/main/haskell/Hydra/Avro/Encoder.hs @@ -48,7 +48,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -519,7 +519,7 @@ _ -> "" _ -> "", (termToJsonValue v))) (Maps.toList v0)) - Core.TermRecord v0 -> Logic.ifElse (Lists.null (Core.recordFields v0)) Model.ValueNull (Model.ValueString "") + Core.TermRecord v0 -> Logic.ifElse (Lists.isEmpty (Core.recordFields v0)) Model.ValueNull (Model.ValueString "") _ -> Model.ValueString "" -- | Generate a default name for an anonymous type diff --git a/src/main/haskell/Hydra/Avro/Environment.hs b/src/main/haskell/Hydra/Avro/Environment.hs --- a/src/main/haskell/Hydra/Avro/Environment.hs +++ b/src/main/haskell/Hydra/Avro/Environment.hs @@ -9,7 +9,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Errors as Errors import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Avro/Language.hs b/src/main/haskell/Hydra/Avro/Language.hs --- a/src/main/haskell/Hydra/Avro/Language.hs +++ b/src/main/haskell/Hydra/Avro/Language.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Language constraints for Apache Avro diff --git a/src/main/haskell/Hydra/Avro/Schema.hs b/src/main/haskell/Hydra/Avro/Schema.hs --- a/src/main/haskell/Hydra/Avro/Schema.hs +++ b/src/main/haskell/Hydra/Avro/Schema.hs @@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Avro/SchemaJson.hs b/src/main/haskell/Hydra/Avro/SchemaJson.hs --- a/src/main/haskell/Hydra/Avro/SchemaJson.hs +++ b/src/main/haskell/Hydra/Avro/SchemaJson.hs @@ -45,7 +45,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -178,7 +178,7 @@ -- | Decode aliases from a JSON object map decodeAliases :: t0 -> M.Map String Model.Value -> Either t1 (Maybe [String]) decodeAliases cx m = - Eithers.bind (optArrayE cx avroAliases m) (\mArr -> Optionals.match mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.pure strs) (Eithers.mapList (expectStringE cx) arr))) + Eithers.bind (optArrayE cx avroAliases m) (\mArr -> Optionals.match mArr (Right Nothing) (\arr -> Eithers.map (\strs -> Optionals.given strs) (Eithers.mapList (expectStringE cx) arr))) -- | Decode an Avro array schema from a JSON object map decodeArraySchema :: t0 -> M.Map String Model.Value -> Either Errors.Error Schema.Schema @@ -424,12 +424,12 @@ Maps.fromList (Optionals.givens (Lists.map (\entry -> let k = Pairs.first entry v = Pairs.second entry - in (Logic.ifElse (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 k)) 64) (Optionals.pure (Strings.fromList (Lists.drop 1 (Strings.toList k)), v)) Nothing)) (Maps.toList m))) + in (Logic.ifElse (Equality.equal (Optionals.withDefault 0 (Strings.charAt 0 k)) 64) (Optionals.given (Strings.fromList (Lists.drop 1 (Strings.toList k)), v)) Nothing)) (Maps.toList m))) -- | Look up an optional array attribute in a JSON object map optArrayE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe [Model.Value])) optArrayE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\a -> Optionals.pure a) (expectArrayE cx v)) + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\a -> Optionals.given a) (expectArrayE cx v)) -- | Look up an optional attribute in a JSON object map optE :: Ord t0 => (t0 -> M.Map t0 t1 -> Maybe t1) @@ -438,7 +438,7 @@ -- | Look up an optional string attribute in a JSON object map optStringE :: Ord t1 => (t0 -> t1 -> M.Map t1 Model.Value -> Either t2 (Maybe String)) optStringE cx fname m = - Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.pure s) (expectStringE cx v)) + Optionals.match (Maps.lookup fname m) (Right Nothing) (\v -> Eithers.map (\s -> Optionals.given s) (expectStringE cx v)) -- | Look up a required array attribute in a JSON object map requireArrayE :: t0 -> String -> M.Map String Model.Value -> Either Errors.Error [Model.Value] diff --git a/src/main/haskell/Hydra/Avro/Testing.hs b/src/main/haskell/Hydra/Avro/Testing.hs --- a/src/main/haskell/Hydra/Avro/Testing.hs +++ b/src/main/haskell/Hydra/Avro/Testing.hs @@ -7,7 +7,7 @@ import qualified Hydra.Avro.Schema as Schema import qualified Hydra.Core as Core import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A test case for the bidirectional Avro coder diff --git a/src/main/haskell/Hydra/Azure/Dtld.hs b/src/main/haskell/Hydra/Azure/Dtld.hs --- a/src/main/haskell/Hydra/Azure/Dtld.hs +++ b/src/main/haskell/Hydra/Azure/Dtld.hs @@ -10,7 +10,7 @@ module Hydra.Azure.Dtld where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Cpp/Coder.hs b/src/main/haskell/Hydra/Cpp/Coder.hs --- a/src/main/haskell/Hydra/Cpp/Coder.hs +++ b/src/main/haskell/Hydra/Cpp/Coder.hs @@ -59,7 +59,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -172,7 +172,7 @@ -- | Create a constructor function body: default if no params, empty compound otherwise createConstructorBody :: [t0] -> Syntax.FunctionBody createConstructorBody params = - Logic.ifElse (Lists.null params) Syntax.FunctionBodyDefault (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [])) + Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault (Syntax.FunctionBodyCompound (Syntax.CompoundStatement [])) -- | Create a function call expression createFunctionCallExpr :: String -> [Syntax.Expression] -> Syntax.Expression diff --git a/src/main/haskell/Hydra/Cpp/Environment.hs b/src/main/haskell/Hydra/Cpp/Environment.hs --- a/src/main/haskell/Hydra/Cpp/Environment.hs +++ b/src/main/haskell/Hydra/Cpp/Environment.hs @@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Packaging as Packaging import qualified Hydra.Util as Util -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Cpp/Language.hs b/src/main/haskell/Hydra/Cpp/Language.hs --- a/src/main/haskell/Hydra/Cpp/Language.hs +++ b/src/main/haskell/Hydra/Cpp/Language.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Cpp/Names.hs b/src/main/haskell/Hydra/Cpp/Names.hs --- a/src/main/haskell/Hydra/Cpp/Names.hs +++ b/src/main/haskell/Hydra/Cpp/Names.hs @@ -46,7 +46,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Get the C++ class name from a Hydra Name diff --git a/src/main/haskell/Hydra/Cpp/Serde.hs b/src/main/haskell/Hydra/Cpp/Serde.hs --- a/src/main/haskell/Hydra/Cpp/Serde.hs +++ b/src/main/haskell/Hydra/Cpp/Serde.hs @@ -41,7 +41,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Convert an access specifier to an expression @@ -237,7 +237,7 @@ [ classKeyToExpr key, (Serialization.cst name)], - (Logic.ifElse (Lists.null inheritance) [] [ + (Logic.ifElse (Lists.isEmpty inheritance) [] [ Serialization.cst ":", (Serialization.commaSep Serialization.inlineStyle (Lists.map baseSpecifierToExpr inheritance))])])) @@ -284,7 +284,7 @@ Just (Serialization.noSep [ Serialization.cst name, (Serialization.parenListAdaptive (Lists.map parameterToExpr params))]), - (Logic.ifElse (Lists.null inits) Nothing (Just (Serialization.spaceSep [ + (Logic.ifElse (Lists.isEmpty inits) Nothing (Just (Serialization.spaceSep [ Serialization.cst ":", (Serialization.commaSep Serialization.inlineStyle (Lists.map memInitializerToExpr inits))]))), (Just (functionBodyToExpr body))])) @@ -606,7 +606,7 @@ integerLiteralToExpr :: Syntax.IntegerLiteral -> Ast.Expr integerLiteralToExpr i = case i of - Syntax.IntegerLiteralDecimal v0 -> Serialization.cst (Literals.showBigint v0) + Syntax.IntegerLiteralDecimal v0 -> Serialization.cst (Literals.printBigint v0) Syntax.IntegerLiteralHexadecimal v0 -> Serialization.cst (Strings.concat2 "0x" v0) Syntax.IntegerLiteralOctal v0 -> Serialization.cst (Strings.concat2 "0" v0) Syntax.IntegerLiteralBinary v0 -> Serialization.cst (Strings.concat2 "0b" v0) @@ -654,7 +654,7 @@ body = Syntax.lambdaExpressionBody le in (Serialization.spaceSep [ captureListToExpr captures, - (Logic.ifElse (Lists.null params) (Serialization.parens (Serialization.cst "")) (Serialization.parenListAdaptive (Lists.map parameterToExpr params))), + (Logic.ifElse (Lists.isEmpty params) (Serialization.parens (Serialization.cst "")) (Serialization.parenListAdaptive (Lists.map parameterToExpr params))), (Optionals.match retType (Serialization.cst "") (\t -> Serialization.spaceSep [ Serialization.cst "->", (typeExpressionToExpr t)])), @@ -702,7 +702,7 @@ in (Serialization.spaceSep (Lists.concat [ [ Serialization.cst "#line", - (Serialization.cst (Literals.showInt32 lineNumber))], + (Serialization.cst (Literals.printInt32 lineNumber))], (Optionals.match filename [] (\f -> [ Serialization.cst (Strings.concat [ "\"", @@ -714,7 +714,7 @@ literalToExpr l = case l of Syntax.LiteralInteger v0 -> integerLiteralToExpr v0 - Syntax.LiteralFloating v0 -> Serialization.cst (Literals.showFloat64 (Syntax.unFloatingLiteral v0)) + Syntax.LiteralFloating v0 -> Serialization.cst (Literals.printFloat64 (Syntax.unFloatingLiteral v0)) Syntax.LiteralCharacter v0 -> Serialization.cst (Strings.concat [ "'", (Syntax.unCharacterLiteral v0), @@ -1001,7 +1001,7 @@ let preps = Syntax.programPreprocessorDirectives prog includes = Syntax.programIncludes prog decls = Syntax.programDeclarations prog - separate = \sep -> \defs -> Logic.ifElse (Lists.null defs) Nothing (Just (sep defs)) + separate = \sep -> \defs -> Logic.ifElse (Lists.isEmpty defs) Nothing (Just (sep defs)) in (Serialization.doubleNewlineSep (Optionals.givens [ separate Serialization.newlineSep (Lists.map preprocessorDirectiveToExpr preps), (separate Serialization.newlineSep (Lists.map includeDirectiveToExpr includes)), diff --git a/src/main/haskell/Hydra/Cpp/Syntax.hs b/src/main/haskell/Hydra/Cpp/Syntax.hs --- a/src/main/haskell/Hydra/Cpp/Syntax.hs +++ b/src/main/haskell/Hydra/Cpp/Syntax.hs @@ -5,7 +5,7 @@ module Hydra.Cpp.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A C++ member or base-class access specifier: public, protected, or private diff --git a/src/main/haskell/Hydra/Cpp/Utils.hs b/src/main/haskell/Hydra/Cpp/Utils.hs --- a/src/main/haskell/Hydra/Cpp/Utils.hs +++ b/src/main/haskell/Hydra/Cpp/Utils.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Create a const reference parameter @@ -119,7 +119,7 @@ -- | Create a constructor body (default if no params, empty otherwise) createConstructorBody :: [t0] -> Syntax.FunctionBody -createConstructorBody params = Logic.ifElse (Lists.null params) Syntax.FunctionBodyDefault emptyFunctionBody +createConstructorBody params = Logic.ifElse (Lists.isEmpty params) Syntax.FunctionBodyDefault emptyFunctionBody -- | Create an enum access expression createEnumAccessExpr :: String -> String -> Syntax.Expression diff --git a/src/main/haskell/Hydra/Csharp/Language.hs b/src/main/haskell/Hydra/Csharp/Language.hs --- a/src/main/haskell/Hydra/Csharp/Language.hs +++ b/src/main/haskell/Hydra/Csharp/Language.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Csharp/Syntax.hs b/src/main/haskell/Hydra/Csharp/Syntax.hs --- a/src/main/haskell/Hydra/Csharp/Syntax.hs +++ b/src/main/haskell/Hydra/Csharp/Syntax.hs @@ -6,7 +6,7 @@ module Hydra.Csharp.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | The body of a property or indexer accessor: a block, an expression, or empty (abstract). diff --git a/src/main/haskell/Hydra/Datalog/Syntax.hs b/src/main/haskell/Hydra/Datalog/Syntax.hs --- a/src/main/haskell/Hydra/Datalog/Syntax.hs +++ b/src/main/haskell/Hydra/Datalog/Syntax.hs @@ -5,7 +5,7 @@ module Hydra.Datalog.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A relation applied to a list of terms diff --git a/src/main/haskell/Hydra/Delta/Parquet.hs b/src/main/haskell/Hydra/Delta/Parquet.hs --- a/src/main/haskell/Hydra/Delta/Parquet.hs +++ b/src/main/haskell/Hydra/Delta/Parquet.hs @@ -5,7 +5,7 @@ module Hydra.Delta.Parquet where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Represent array data type. diff --git a/src/main/haskell/Hydra/Geojson/Model.hs b/src/main/haskell/Hydra/Geojson/Model.hs --- a/src/main/haskell/Hydra/Geojson/Model.hs +++ b/src/main/haskell/Hydra/Geojson/Model.hs @@ -6,7 +6,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Graphql/Coder.hs b/src/main/haskell/Hydra/Graphql/Coder.hs --- a/src/main/haskell/Hydra/Graphql/Coder.hs +++ b/src/main/haskell/Hydra/Graphql/Coder.hs @@ -54,7 +54,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -240,7 +240,7 @@ ns_, (Logic.ifElse (Equality.equal ns_ modNs) "" (Strings.concat2 (Formatting.sanitizeWithUnderscores Sets.empty (Packaging.unModuleName ns_)) "_")))) namespaces))) (Packaging.moduleName mod) typeDefs filePath = Names.moduleNameToFilePath Util.CaseConventionCamel (File.FileExtension "graphql") (Packaging.moduleName mod) - in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g prefixes td) typeDefs) (\gtdefs -> Right (Maps.fromList (Lists.pure ( + in (Eithers.bind (Eithers.mapList (\td -> encodeTypeDefinition cx g prefixes td) typeDefs) (\gtdefs -> Right (Maps.fromList (Lists.singleton ( filePath, (Serialization.printExpr (Serialization.parenthesize (Serde.documentToExpr (Syntax.Document (Lists.map (\gtdef -> Syntax.DefinitionTypeSystem (Syntax.TypeSystemDefinitionOrExtensionDefinition (Syntax.TypeSystemDefinitionType gtdef))) gtdefs)))))))))) diff --git a/src/main/haskell/Hydra/Graphql/Language.hs b/src/main/haskell/Hydra/Graphql/Language.hs --- a/src/main/haskell/Hydra/Graphql/Language.hs +++ b/src/main/haskell/Hydra/Graphql/Language.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Graphql/Serde.hs b/src/main/haskell/Hydra/Graphql/Serde.hs --- a/src/main/haskell/Hydra/Graphql/Serde.hs +++ b/src/main/haskell/Hydra/Graphql/Serde.hs @@ -37,7 +37,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Convert a GraphQL definition to an expression @@ -183,4 +183,4 @@ withDescription mdesc expr = Serialization.newlineSep (Optionals.givens [ Optionals.map descriptionToExpr mdesc, - (Optionals.pure expr)]) + (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Graphql/Syntax.hs b/src/main/haskell/Hydra/Graphql/Syntax.hs --- a/src/main/haskell/Hydra/Graphql/Syntax.hs +++ b/src/main/haskell/Hydra/Graphql/Syntax.hs @@ -6,7 +6,7 @@ module Hydra.Graphql.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A GraphQL field alias, immediately followed by a colon. diff --git a/src/main/haskell/Hydra/Iana/Linkrelations.hs b/src/main/haskell/Hydra/Iana/Linkrelations.hs --- a/src/main/haskell/Hydra/Iana/Linkrelations.hs +++ b/src/main/haskell/Hydra/Iana/Linkrelations.hs @@ -5,7 +5,7 @@ module Hydra.Iana.Linkrelations where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | An IANA link relation type diff --git a/src/main/haskell/Hydra/Json/Schema/Coder.hs b/src/main/haskell/Hydra/Json/Schema/Coder.hs --- a/src/main/haskell/Hydra/Json/Schema/Coder.hs +++ b/src/main/haskell/Hydra/Json/Schema/Coder.hs @@ -55,7 +55,7 @@ import qualified Hydra.Validation as Validation import qualified Hydra.Variables as Variables import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M import qualified Data.Set as S @@ -107,8 +107,9 @@ reqs = Lists.foldl (\acc -> \f -> Logic.ifElse (isRequiredField f) (Lists.concat2 acc [ SchemaModel.Keyword (Core.unName (Core.fieldTypeName f))]) acc) [] fields - reqRes = Logic.ifElse (Lists.null reqs) [] [ - SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired reqs)] + reqRes = + Logic.ifElse (Lists.isEmpty reqs) [] [ + SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionRequired reqs)] addPropsRes = [ SchemaModel.RestrictionObject (SchemaModel.ObjectRestrictionAdditionalProperties (SchemaModel.AdditionalItemsAny False))] @@ -130,7 +131,7 @@ let isSimple = \f -> Predicates.isUnitType (Strip.deannotateType (Core.fieldTypeType f)) simple = Lists.filter isSimple fields nonsimple = Lists.filter (\f -> Logic.not (isSimple f)) fields - in (Logic.ifElse (Lists.null simple) (encodeRecordOrUnion cx g optional True fields) (Eithers.bind (encodeRecordOrUnion cx g False True nonsimple) (\recRes -> + in (Logic.ifElse (Lists.isEmpty simple) (encodeRecordOrUnion cx g optional True fields) (Eithers.bind (encodeRecordOrUnion cx g False True nonsimple) (\recRes -> let names = Lists.map (\f -> Core.unName (Core.fieldTypeName f)) simple simpleSchema = SchemaModel.Schema [ diff --git a/src/main/haskell/Hydra/Json/Schema/Language.hs b/src/main/haskell/Hydra/Json/Schema/Language.hs --- a/src/main/haskell/Hydra/Json/Schema/Language.hs +++ b/src/main/haskell/Hydra/Json/Schema/Language.hs @@ -35,7 +35,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Language constraints for JSON Schema diff --git a/src/main/haskell/Hydra/Json/Schema/Model.hs b/src/main/haskell/Hydra/Json/Schema/Model.hs --- a/src/main/haskell/Hydra/Json/Schema/Model.hs +++ b/src/main/haskell/Hydra/Json/Schema/Model.hs @@ -6,7 +6,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Json/Schema/Serde.hs b/src/main/haskell/Hydra/Json/Schema/Serde.hs --- a/src/main/haskell/Hydra/Json/Schema/Serde.hs +++ b/src/main/haskell/Hydra/Json/Schema/Serde.hs @@ -41,7 +41,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -92,7 +92,7 @@ restMap = fromObject (toObject [ (keyId, (Optionals.map (\i -> Model.ValueString i) mid)), - (keySchema, (Optionals.pure (Model.ValueString "http://json-schema.org/2020-12/schema"))), + (keySchema, (Optionals.given (Model.ValueString "http://json-schema.org/2020-12/schema"))), ( keyDefinitions, (Optionals.map (\mp -> Model.ValueObject (Lists.map (\p -> diff --git a/src/main/haskell/Hydra/Kusto/Kql.hs b/src/main/haskell/Hydra/Kusto/Kql.hs --- a/src/main/haskell/Hydra/Kusto/Kql.hs +++ b/src/main/haskell/Hydra/Kusto/Kql.hs @@ -5,7 +5,7 @@ module Hydra.Kusto.Kql where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Int as I diff --git a/src/main/haskell/Hydra/Osv/Schema.hs b/src/main/haskell/Hydra/Osv/Schema.hs --- a/src/main/haskell/Hydra/Osv/Schema.hs +++ b/src/main/haskell/Hydra/Osv/Schema.hs @@ -5,7 +5,7 @@ module Hydra.Osv.Schema where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A person or entity credited with discovering, fixing, or reporting a vulnerability diff --git a/src/main/haskell/Hydra/Parquet/Format.hs b/src/main/haskell/Hydra/Parquet/Format.hs --- a/src/main/haskell/Hydra/Parquet/Format.hs +++ b/src/main/haskell/Hydra/Parquet/Format.hs @@ -6,7 +6,7 @@ module Hydra.Parquet.Format where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.ByteString as B import qualified Data.Int as I diff --git a/src/main/haskell/Hydra/Pegasus/Coder.hs b/src/main/haskell/Hydra/Pegasus/Coder.hs --- a/src/main/haskell/Hydra/Pegasus/Coder.hs +++ b/src/main/haskell/Hydra/Pegasus/Coder.hs @@ -56,7 +56,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -80,7 +80,7 @@ encode :: t0 -> Graph.Graph -> M.Map Packaging.ModuleName String -> Core.Type -> Either Errors.Error Pdl.Schema encode cx g aliases t = case (Strip.deannotateType t) of - Core.TypeRecord v0 -> Logic.ifElse (Lists.null v0) (encode cx g aliases (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))) (Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintCore.type_ t))))) res)) + Core.TypeRecord v0 -> Logic.ifElse (Lists.isEmpty v0) (encode cx g aliases (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32))) (Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintCore.type_ t))))) res)) _ -> Eithers.bind (encodeType cx g aliases t) (\res -> Eithers.either (\schema -> Right schema) (\_ -> Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "type resolved to an unsupported nested named schema: " (PrintCore.type_ t))))) res) -- | Encode a Hydra field type as a PDL enum field, converting the name to upper snake case diff --git a/src/main/haskell/Hydra/Pegasus/Language.hs b/src/main/haskell/Hydra/Pegasus/Language.hs --- a/src/main/haskell/Hydra/Pegasus/Language.hs +++ b/src/main/haskell/Hydra/Pegasus/Language.hs @@ -35,7 +35,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Language constraints for LinkedIn Pegasus (PDL) diff --git a/src/main/haskell/Hydra/Pegasus/Pdl.hs b/src/main/haskell/Hydra/Pegasus/Pdl.hs --- a/src/main/haskell/Hydra/Pegasus/Pdl.hs +++ b/src/main/haskell/Hydra/Pegasus/Pdl.hs @@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Json.Model as Model -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Annotations which can be applied to record fields, aliased union members, enum symbols, or named schemas diff --git a/src/main/haskell/Hydra/Pegasus/Serde.hs b/src/main/haskell/Hydra/Pegasus/Serde.hs --- a/src/main/haskell/Hydra/Pegasus/Serde.hs +++ b/src/main/haskell/Hydra/Pegasus/Serde.hs @@ -40,7 +40,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Convert PDL annotations to an optional expression (doc comment) @@ -112,7 +112,7 @@ parts = Optionals.givens [ Optionals.map (\n -> Pdl.unNamespace n) ns, - (Optionals.pure name)] + (Optionals.given name)] in (Serialization.cst (Strings.join "." parts)) -- | Convert a record field to an expression @@ -124,9 +124,9 @@ optional = Pdl.recordFieldOptional rf anns = Pdl.recordFieldAnnotations rf in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ - Optionals.pure (Serialization.cst (Strings.concat2 name ":")), - (Logic.ifElse optional (Optionals.pure (Serialization.cst "optional")) Nothing), - (Optionals.pure (schemaToExpr schema))]))) + Optionals.given (Serialization.cst (Strings.concat2 name ":")), + (Logic.ifElse optional (Optionals.given (Serialization.cst "optional")) Nothing), + (Optionals.given (schemaToExpr schema))]))) -- | Convert a schema file to an expression schemaFileToExpr :: Pdl.SchemaFile -> Ast.Expr @@ -137,7 +137,7 @@ imports = Pdl.schemaFileImports sf schemas = Pdl.schemaFileSchemas sf namespaceSec = - Optionals.pure (Serialization.spaceSep [ + Optionals.given (Serialization.spaceSep [ Serialization.cst "namespace", (Serialization.cst ns)]) packageSec = @@ -145,8 +145,8 @@ Serialization.cst "package", (Serialization.cst (Pdl.unPackage p))]) pkg importsSec = - Logic.ifElse (Lists.null imports) Nothing (Optionals.pure (Serialization.newlineSep (Lists.map importToExpr imports))) - schemaSecs = Lists.map (\s -> Optionals.pure (namedSchemaToExpr s)) schemas + Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) + schemaSecs = Lists.map (\s -> Optionals.given (namedSchemaToExpr s)) schemas in (Serialization.doubleNewlineSep (Optionals.givens (Lists.concat [ [ namespaceSec, @@ -183,11 +183,11 @@ anns = Pdl.unionMemberAnnotations um in (withAnnotations anns (Serialization.spaceSep (Optionals.givens [ Optionals.map (\fn -> Serialization.cst (Strings.concat2 (Pdl.unFieldName fn) ":")) alias, - (Optionals.pure (schemaToExpr schema))]))) + (Optionals.given (schemaToExpr schema))]))) -- | Prepend annotations (doc comment) to an expression withAnnotations :: Pdl.Annotations -> Ast.Expr -> Ast.Expr withAnnotations anns expr = Serialization.newlineSep (Optionals.givens [ annotationsToExpr anns, - (Optionals.pure expr)]) + (Optionals.given expr)]) diff --git a/src/main/haskell/Hydra/Protobuf/Any.hs b/src/main/haskell/Hydra/Protobuf/Any.hs --- a/src/main/haskell/Hydra/Protobuf/Any.hs +++ b/src/main/haskell/Hydra/Protobuf/Any.hs @@ -5,7 +5,7 @@ module Hydra.Protobuf.Any where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.ByteString as B diff --git a/src/main/haskell/Hydra/Protobuf/Coder.hs b/src/main/haskell/Hydra/Protobuf/Coder.hs --- a/src/main/haskell/Hydra/Protobuf/Coder.hs +++ b/src/main/haskell/Hydra/Protobuf/Coder.hs @@ -64,7 +64,7 @@ import qualified Hydra.Validation as Validation import qualified Hydra.Variables as Variables import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Protobuf/Environment.hs b/src/main/haskell/Hydra/Protobuf/Environment.hs --- a/src/main/haskell/Hydra/Protobuf/Environment.hs +++ b/src/main/haskell/Hydra/Protobuf/Environment.hs @@ -6,7 +6,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Typing as Typing -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | State threaded through Protobuf encoding: inference context plus field-index counter diff --git a/src/main/haskell/Hydra/Protobuf/Language.hs b/src/main/haskell/Hydra/Protobuf/Language.hs --- a/src/main/haskell/Hydra/Protobuf/Language.hs +++ b/src/main/haskell/Hydra/Protobuf/Language.hs @@ -37,7 +37,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Protobuf/Proto3.hs b/src/main/haskell/Hydra/Protobuf/Proto3.hs --- a/src/main/haskell/Hydra/Protobuf/Proto3.hs +++ b/src/main/haskell/Hydra/Protobuf/Proto3.hs @@ -5,7 +5,7 @@ module Hydra.Protobuf.Proto3 where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | A top-level Protobuf definition, either an enum or a message type diff --git a/src/main/haskell/Hydra/Protobuf/Serde.hs b/src/main/haskell/Hydra/Protobuf/Serde.hs --- a/src/main/haskell/Hydra/Protobuf/Serde.hs +++ b/src/main/haskell/Hydra/Protobuf/Serde.hs @@ -42,7 +42,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Convert a definition to an expression @@ -82,7 +82,7 @@ in (optDesc False options (semi (Serialization.spaceSep [ Serialization.cst (Proto3.unEnumValueName name), (Serialization.cst "="), - (Serialization.cst (Literals.showInt32 number))]))) + (Serialization.cst (Literals.printInt32 number))]))) -- | Filter out internal options (those whose names start with underscore) excludeInternalOptions :: [Proto3.Option] -> [Proto3.Option] @@ -105,7 +105,7 @@ fieldOptionsToExpr opts0 = let opts = excludeInternalOptions opts0 - in (Logic.ifElse (Lists.null opts) Nothing (Optionals.pure (Serialization.bracketList Serialization.inlineStyle (Lists.map fieldOptionToExpr opts)))) + in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.bracketList Serialization.inlineStyle (Lists.map fieldOptionToExpr opts)))) -- | Convert a field to an expression fieldToExpr :: Proto3.Field -> Ast.Expr @@ -124,22 +124,22 @@ let kt = Proto3.mapTypeKeys v0 vt = Proto3.mapTypeValues v0 in (semi (Serialization.spaceSep (Optionals.givens [ - Optionals.pure (fieldTypeToExpr typ), - (Optionals.pure (Serialization.cst (Proto3.unFieldName name))), - (Optionals.pure (Serialization.cst "=")), - (Optionals.pure (Serialization.cst (Literals.showInt32 num))), + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), (fieldOptionsToExpr options)]))) Proto3.FieldTypeRepeated _ -> semi (Serialization.spaceSep (Optionals.givens [ - Optionals.pure (fieldTypeToExpr typ), - (Optionals.pure (Serialization.cst (Proto3.unFieldName name))), - (Optionals.pure (Serialization.cst "=")), - (Optionals.pure (Serialization.cst (Literals.showInt32 num))), + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), (fieldOptionsToExpr options)])) Proto3.FieldTypeSimple _ -> semi (Serialization.spaceSep (Optionals.givens [ - Optionals.pure (fieldTypeToExpr typ), - (Optionals.pure (Serialization.cst (Proto3.unFieldName name))), - (Optionals.pure (Serialization.cst "=")), - (Optionals.pure (Serialization.cst (Literals.showInt32 num))), + Optionals.given (fieldTypeToExpr typ), + (Optionals.given (Serialization.cst (Proto3.unFieldName name))), + (Optionals.given (Serialization.cst "=")), + (Optionals.given (Serialization.cst (Literals.printInt32 num))), (fieldOptionsToExpr options)])))) -- | Convert a field type to an expression @@ -177,7 +177,7 @@ fileOptionsToExpr opts0 = let opts = excludeInternalOptions opts0 - in (Logic.ifElse (Lists.null opts) Nothing (Optionals.pure (Serialization.newlineSep (Lists.map fileOptionToExpr opts)))) + in (Logic.ifElse (Lists.isEmpty opts) Nothing (Optionals.given (Serialization.newlineSep (Lists.map fileOptionToExpr opts)))) -- | Convert a file reference to an import expression importToExpr :: Proto3.FileReference -> Ast.Expr @@ -234,17 +234,17 @@ defs = Proto3.protoFileTypes pf options = Proto3.protoFileOptions pf headerSec = - Optionals.pure (Serialization.newlineSep [ + Optionals.given (Serialization.newlineSep [ semi (Serialization.cst "syntax = \"proto3\""), (semi (Serialization.spaceSep [ Serialization.cst "package", (Serialization.cst (Proto3.unPackageName pkg))]))]) importsSec = - Logic.ifElse (Lists.null imports) Nothing (Optionals.pure (Serialization.newlineSep (Lists.map importToExpr imports))) + Logic.ifElse (Lists.isEmpty imports) Nothing (Optionals.given (Serialization.newlineSep (Lists.map importToExpr imports))) options1 = Lists.filter (\opt -> Logic.not (Equality.equal (Proto3.optionName opt) "_description")) options optionsSec = fileOptionsToExpr options1 defsSec = - Logic.ifElse (Lists.null defs) Nothing (Optionals.pure (Serialization.doubleNewlineSep (Lists.map definitionToExpr defs))) + Logic.ifElse (Lists.isEmpty defs) Nothing (Optionals.given (Serialization.doubleNewlineSep (Lists.map definitionToExpr defs))) in (optDesc True options (Serialization.doubleNewlineSep (Optionals.givens [ headerSec, importsSec, diff --git a/src/main/haskell/Hydra/Protobuf/SourceContext.hs b/src/main/haskell/Hydra/Protobuf/SourceContext.hs --- a/src/main/haskell/Hydra/Protobuf/SourceContext.hs +++ b/src/main/haskell/Hydra/Protobuf/SourceContext.hs @@ -5,7 +5,7 @@ module Hydra.Protobuf.SourceContext where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | `SourceContext` represents information about the source of a protobuf element, like the file in which it is defined. diff --git a/src/main/haskell/Hydra/Rust/Coder.hs b/src/main/haskell/Hydra/Rust/Coder.hs --- a/src/main/haskell/Hydra/Rust/Coder.hs +++ b/src/main/haskell/Hydra/Rust/Coder.hs @@ -54,7 +54,7 @@ import qualified Hydra.Validation as Validation import qualified Hydra.Variables as Variables import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M @@ -68,7 +68,7 @@ isUnit = case dtyp of Core.TypeUnit -> True - Core.TypeRecord v0 -> Lists.null v0 + Core.TypeRecord v0 -> Lists.isEmpty v0 _ -> False in (Logic.ifElse isUnit (Right (Syntax.EnumVariant { Syntax.enumVariantName = (Formatting.capitalize fname), @@ -235,7 +235,7 @@ isUnit = case dterm of Core.TermUnit -> True - Core.TermRecord v1 -> Lists.null (Core.recordFields v1) + Core.TermRecord v1 -> Lists.isEmpty (Core.recordFields v1) _ -> False in (Logic.ifElse isUnit (Right (rustExprPath (Strings.concat2 (Strings.concat2 tname "::") fname))) (Eithers.bind (encodeTerm cx g fterm) (\sval -> Right (rustCall (rustExprPath (Strings.concat2 (Strings.concat2 tname "::") fname)) [ sval])))) diff --git a/src/main/haskell/Hydra/Rust/Language.hs b/src/main/haskell/Hydra/Rust/Language.hs --- a/src/main/haskell/Hydra/Rust/Language.hs +++ b/src/main/haskell/Hydra/Rust/Language.hs @@ -36,7 +36,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Set as S diff --git a/src/main/haskell/Hydra/Rust/Operators.hs b/src/main/haskell/Hydra/Rust/Operators.hs --- a/src/main/haskell/Hydra/Rust/Operators.hs +++ b/src/main/haskell/Hydra/Rust/Operators.hs @@ -34,7 +34,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Add-assign operator (+=) diff --git a/src/main/haskell/Hydra/Rust/Serde.hs b/src/main/haskell/Hydra/Rust/Serde.hs --- a/src/main/haskell/Hydra/Rust/Serde.hs +++ b/src/main/haskell/Hydra/Rust/Serde.hs @@ -44,7 +44,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Serialize an array expression @@ -243,7 +243,7 @@ -- | Serialize derive macros to an attribute expression derivesToExpr :: [String] -> Maybe Ast.Expr derivesToExpr derives = - Logic.ifElse (Lists.null derives) Nothing (Just (Serialization.cst (Strings.concat [ + Logic.ifElse (Lists.isEmpty derives) Nothing (Just (Serialization.cst (Strings.concat [ "#[derive(", (Strings.join ", " derives), ")]"]))) @@ -391,7 +391,7 @@ let val = Syntax.floatLiteralValue fl suf = Syntax.floatLiteralSuffix fl - valStr = Literals.showFloat64 val + valStr = Literals.printFloat64 val sufStr = Optionals.match suf "" (\s -> s) in (Serialization.cst (Strings.concat2 valStr sufStr)) @@ -510,14 +510,14 @@ let name = Syntax.genericParamName gp bounds = Syntax.genericParamBounds gp - in (Logic.ifElse (Lists.null bounds) (Serialization.cst name) (Serialization.spaceSep [ + in (Logic.ifElse (Lists.isEmpty bounds) (Serialization.cst name) (Serialization.spaceSep [ Serialization.cst (Strings.concat2 name ":"), (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) bounds)))])) -- | Serialize a list of generic parameters genericParamsToExpr :: [Syntax.GenericParam] -> Maybe Ast.Expr genericParamsToExpr gps = - Logic.ifElse (Lists.null gps) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map genericParamToExpr gps))) + Logic.ifElse (Lists.isEmpty gps) Nothing (Just (Serialization.angleBracesList Serialization.inlineStyle (Lists.map genericParamToExpr gps))) -- | Serialize an identifier pattern identifierPatternToExpr :: Syntax.IdentifierPattern -> Ast.Expr @@ -655,7 +655,7 @@ let val = Syntax.integerLiteralValue il suf = Syntax.integerLiteralSuffix il - valStr = Literals.showBigint val + valStr = Literals.printBigint val sufStr = Optionals.match suf "" (\s -> s) in (Serialization.cst (Strings.concat2 valStr sufStr)) @@ -732,11 +732,11 @@ Syntax.LiteralByteString _ -> Serialization.cst "b\"...\"" Syntax.LiteralChar v0 -> Serialization.cst (Strings.concat [ "'", - (Literals.showUint32 v0), + (Literals.printUint32 v0), "'"]) Syntax.LiteralByte v0 -> Serialization.cst (Strings.concat [ "b'", - (Literals.showUint8 v0), + (Literals.printUint8 v0), "'"]) Syntax.LiteralBool v0 -> Serialization.cst (Logic.ifElse v0 "true" "false") @@ -816,7 +816,7 @@ turbo = Syntax.methodCallExprTurbofish m args = Syntax.methodCallExprArgs m turboPart = - Logic.ifElse (Lists.null turbo) "" (Strings.concat [ + Logic.ifElse (Lists.isEmpty turbo) "" (Strings.concat [ "::<", (Strings.join ", " (Lists.map (\t -> Serialization.printExpr (typeToExpr t)) turbo)), ">"]) @@ -1108,7 +1108,7 @@ unsafeKw = Logic.ifElse isUnsafe (Just (Serialization.cst "unsafe")) Nothing genericsExpr = genericParamsToExpr generics superPart = - Logic.ifElse (Lists.null supers) Nothing (Just (Serialization.spaceSep [ + Logic.ifElse (Lists.isEmpty supers) Nothing (Just (Serialization.spaceSep [ Serialization.cst ":", (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) supers)))])) wherePart = Optionals.match whereC Nothing (\w -> Just (whereClauseToExpr w)) @@ -1172,7 +1172,7 @@ bounds = Syntax.traitTypeBounds t def = Syntax.traitTypeDefault t boundsPart = - Logic.ifElse (Lists.null bounds) Nothing (Just (Serialization.spaceSep [ + Logic.ifElse (Lists.isEmpty bounds) Nothing (Just (Serialization.spaceSep [ Serialization.cst ":", (Serialization.cst (Strings.join " + " (Lists.map (\b -> Serialization.printExpr (typeParamBoundToExpr b)) bounds)))])) defPart = @@ -1195,7 +1195,7 @@ in (Serialization.cst (Strings.concat [ Serialization.printExpr (expressionToExpr tuple), ".", - (Literals.showInt32 idx)])) + (Literals.printInt32 idx)])) -- | Serialize a tuple struct pattern tupleStructPatternToExpr :: Syntax.TupleStructPattern -> Ast.Expr @@ -1341,7 +1341,7 @@ Syntax.UseTreeGroup v0 -> let prefix = Syntax.useGroupPrefix v0 trees = Syntax.useGroupTrees v0 - prefixStr = Logic.ifElse (Lists.null prefix) "" (Strings.concat2 (Strings.join "::" prefix) "::") + prefixStr = Logic.ifElse (Lists.isEmpty prefix) "" (Strings.concat2 (Strings.join "::" prefix) "::") in (Serialization.cst (Strings.concat [ prefixStr, "{", diff --git a/src/main/haskell/Hydra/Rust/Syntax.hs b/src/main/haskell/Hydra/Rust/Syntax.hs --- a/src/main/haskell/Hydra/Rust/Syntax.hs +++ b/src/main/haskell/Hydra/Rust/Syntax.hs @@ -5,7 +5,7 @@ module Hydra.Rust.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.ByteString as B import qualified Data.Int as I diff --git a/src/main/haskell/Hydra/Sql/Syntax.hs b/src/main/haskell/Hydra/Sql/Syntax.hs --- a/src/main/haskell/Hydra/Sql/Syntax.hs +++ b/src/main/haskell/Hydra/Sql/Syntax.hs @@ -5,7 +5,7 @@ module Hydra.Sql.Syntax where import qualified Hydra.Core as Core -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | An approximate (floating-point) numeric literal, such as 1.5E10 diff --git a/src/main/haskell/Hydra/Stac/Items.hs b/src/main/haskell/Hydra/Stac/Items.hs --- a/src/main/haskell/Hydra/Stac/Items.hs +++ b/src/main/haskell/Hydra/Stac/Items.hs @@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Geojson.Model as Model import qualified Hydra.Iana.Linkrelations as Linkrelations -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci import qualified Data.Map as M diff --git a/src/main/haskell/Hydra/Workflow.hs b/src/main/haskell/Hydra/Workflow.hs --- a/src/main/haskell/Hydra/Workflow.hs +++ b/src/main/haskell/Hydra/Workflow.hs @@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Graph as Graph import qualified Hydra.Packaging as Packaging -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | The specification of a Hydra schema, provided as a set of modules and a distinguished type diff --git a/src/main/haskell/Hydra/Yaml/Coder.hs b/src/main/haskell/Hydra/Yaml/Coder.hs --- a/src/main/haskell/Hydra/Yaml/Coder.hs +++ b/src/main/haskell/Hydra/Yaml/Coder.hs @@ -49,7 +49,7 @@ import qualified Hydra.Variants as Variants import qualified Hydra.Yaml.Language as Language import qualified Hydra.Yaml.Model as YamlModel -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Decode a YAML value to a record term @@ -145,7 +145,7 @@ case f of Core.FloatValueFloat32 v1 -> LibLiterals.float32ToFloat64 v1 Core.FloatValueFloat64 v1 -> v1 - shown = LibLiterals.showFloat64 bf + shown = LibLiterals.printFloat64 bf in (Logic.ifElse (requiresYamlStringSentinel shown) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat [ "YAML cannot represent float value: ", shown])))) (Right (YamlModel.ScalarFloat bf))))), diff --git a/src/main/haskell/Hydra/Yaml/Language.hs b/src/main/haskell/Hydra/Yaml/Language.hs --- a/src/main/haskell/Hydra/Yaml/Language.hs +++ b/src/main/haskell/Hydra/Yaml/Language.hs @@ -35,7 +35,7 @@ import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Language constraints for YAML diff --git a/src/main/haskell/Hydra/Yaml/Serde.hs b/src/main/haskell/Hydra/Yaml/Serde.hs --- a/src/main/haskell/Hydra/Yaml/Serde.hs +++ b/src/main/haskell/Hydra/Yaml/Serde.hs @@ -45,7 +45,7 @@ import qualified Hydra.Validation as Validation import qualified Hydra.Variants as Variants import qualified Hydra.Yaml.Model as YamlModel -import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, map, pure, sum) +import Prelude hiding (Enum, Ordering, decodeFloat, encodeFloat, fail, lines, map, pure, sum, unlines) import qualified Data.Scientific as Sci -- | Escape single quotes by doubling them @@ -72,7 +72,7 @@ -- | Indent all lines of a string by 2 spaces indentString :: String -> String indentString s = - Strings.concat (Lists.map (\line -> Logic.ifElse (Strings.null line) "" (Strings.concat [ + Strings.concat (Lists.map (\line -> Logic.ifElse (Strings.isEmpty line) "" (Strings.concat [ " ", line, "\n"])) (Formatting.lines s)) @@ -85,11 +85,11 @@ parts = Lists.span (\c -> Logic.not (Equality.equal c dotCode)) chars before = Pairs.first parts afterWithDot = Pairs.second parts - in (Logic.ifElse (Lists.null before) False (Logic.ifElse (Lists.null afterWithDot) False ( + in (Logic.ifElse (Lists.isEmpty before) False (Logic.ifElse (Lists.isEmpty afterWithDot) False ( let after = Lists.drop 1 afterWithDot - in (Logic.ifElse (Lists.null after) False ( + in (Logic.ifElse (Lists.isEmpty after) False ( let isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) - in (Logic.and (Lists.null (Lists.filter (\c -> Logic.not (isDigitFn c)) before)) (Lists.null (Lists.filter (\c -> Logic.not (isDigitFn c)) after)))))))) + in (Logic.and (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) before)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) after)))))))) -- | Check if a string looks like a number looksLikeNumber :: String -> Bool @@ -101,16 +101,16 @@ tailCh = Pairs.second p rest = Logic.ifElse (Equality.equal firstCh 45) tailCh chars isDigitFn = \c -> Logic.and (Ordering.gte c 48) (Ordering.lte c 57) - allDigits = Logic.and (Logic.not (Lists.null rest)) (Lists.null (Lists.filter (\c -> Logic.not (isDigitFn c)) rest)) + allDigits = Logic.and (Logic.not (Lists.isEmpty rest)) (Lists.isEmpty (Lists.filter (\c -> Logic.not (isDigitFn c)) rest)) in (Logic.ifElse allDigits True (isDecimalString rest))) (Lists.uncons chars))) -- | Check if a string needs quoting in YAML needsQuoting :: String -> Bool needsQuoting s = - Logic.ifElse (Strings.null s) True (Logic.ifElse (Lists.member s yamlReservedWords) True (Logic.ifElse (looksLikeNumber s) True ( + Logic.ifElse (Strings.isEmpty s) True (Logic.ifElse (Lists.member s yamlReservedWords) True (Logic.ifElse (looksLikeNumber s) True ( let chars = Strings.toList s specials = Strings.toList yamlSpecialChars - hasSpecial = Logic.not (Lists.null (Lists.filter (\c -> Lists.member c specials) chars)) + hasSpecial = Logic.not (Lists.isEmpty (Lists.filter (\c -> Lists.member c specials) chars)) in (Logic.ifElse hasSpecial True (hasLeadingTrailingSpace s))))) -- | Write a mapping entry in block style @@ -125,7 +125,7 @@ ": ", (writeScalar v0), "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.null v0) (Strings.concat [ + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ writeNodeInline key, ": []\n"]) (Strings.concat [ writeNodeInline key, @@ -150,7 +150,7 @@ ": ", (writeScalar v0), "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.null v0) (Strings.concat [ + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) (Strings.concat [ writeNodeInline key, ": []\n"]) (Strings.concat [ writeNodeInline key, @@ -168,7 +168,7 @@ writeNode node = case node of YamlModel.NodeScalar v0 -> Strings.concat2 (writeScalar v0) "\n" - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.null v0) "[]\n" (Strings.concat (Lists.map (\item -> writeSequenceItem item) v0)) + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "[]\n" (Strings.concat (Lists.map (\item -> writeSequenceItem item) v0)) YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "{}\n" (Strings.concat (Lists.map (\e -> writeMappingEntry e) (Maps.toList v0))) -- | Write a node inline (for use as a mapping key) @@ -196,9 +196,9 @@ writeScalar s = case s of YamlModel.ScalarBool v0 -> Logic.ifElse v0 "true" "false" - YamlModel.ScalarDecimal v0 -> Literals.showDecimal v0 - YamlModel.ScalarFloat v0 -> Literals.showFloat64 v0 - YamlModel.ScalarInt v0 -> Literals.showBigint v0 + YamlModel.ScalarDecimal v0 -> Literals.printDecimal v0 + YamlModel.ScalarFloat v0 -> Literals.printFloat64 v0 + YamlModel.ScalarInt v0 -> Literals.printBigint v0 YamlModel.ScalarNull -> "null" YamlModel.ScalarStr v0 -> writeString v0 @@ -210,7 +210,7 @@ "- ", (writeScalar v0), "\n"] - YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.null v0) "- []\n" (Strings.concat2 "-\n" (indentString (writeNode node))) + YamlModel.NodeSequence v0 -> Logic.ifElse (Lists.isEmpty v0) "- []\n" (Strings.concat2 "-\n" (indentString (writeNode node))) YamlModel.NodeMapping v0 -> Logic.ifElse (Equality.equal (Maps.size v0) 0) "- {}\n" ( let entries = Maps.toList v0 in (Optionals.withDefault "" (Optionals.map (\p ->