packages feed

hydra-ext 0.17.5 → 0.17.6

raw patch · 57 files changed

+323/−160 lines, 57 filesdep ~hydra-kerneldep ~hydra-rdfPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hydra-kernel, hydra-rdf

API changes (from Hackage documentation)

Files

CHANGELOG.md view
@@ -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<map>` -> 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 `<run>/<path>.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
hydra-ext.cabal view
@@ -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
src/main/haskell/Hydra/Atlas.hs view
@@ -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
src/main/haskell/Hydra/Avro/Coder.hs view
@@ -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_)
src/main/haskell/Hydra/Avro/Encoder.hs view
@@ -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 @@               _ -> "<key>"             _ -> "<key>",           (termToJsonValue v))) (Maps.toList v0))-      Core.TermRecord v0 -> Logic.ifElse (Lists.null (Core.recordFields v0)) Model.ValueNull (Model.ValueString "<record>")+      Core.TermRecord v0 -> Logic.ifElse (Lists.isEmpty (Core.recordFields v0)) Model.ValueNull (Model.ValueString "<record>")       _ -> Model.ValueString "<term>"  -- | Generate a default name for an anonymous type
src/main/haskell/Hydra/Avro/Environment.hs view
@@ -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
src/main/haskell/Hydra/Avro/Language.hs view
@@ -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
src/main/haskell/Hydra/Avro/Schema.hs view
@@ -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
src/main/haskell/Hydra/Avro/SchemaJson.hs view
@@ -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]
src/main/haskell/Hydra/Avro/Testing.hs view
@@ -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
src/main/haskell/Hydra/Azure/Dtld.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Coder.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Environment.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Language.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Names.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Serde.hs view
@@ -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)),
src/main/haskell/Hydra/Cpp/Syntax.hs view
@@ -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
src/main/haskell/Hydra/Cpp/Utils.hs view
@@ -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
src/main/haskell/Hydra/Csharp/Language.hs view
@@ -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
src/main/haskell/Hydra/Csharp/Syntax.hs view
@@ -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).
src/main/haskell/Hydra/Datalog/Syntax.hs view
@@ -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
src/main/haskell/Hydra/Delta/Parquet.hs view
@@ -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.
src/main/haskell/Hydra/Geojson/Model.hs view
@@ -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
src/main/haskell/Hydra/Graphql/Coder.hs view
@@ -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))))))))))
src/main/haskell/Hydra/Graphql/Language.hs view
@@ -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
src/main/haskell/Hydra/Graphql/Serde.hs view
@@ -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)])
src/main/haskell/Hydra/Graphql/Syntax.hs view
@@ -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.
src/main/haskell/Hydra/Iana/Linkrelations.hs view
@@ -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
src/main/haskell/Hydra/Json/Schema/Coder.hs view
@@ -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 [
src/main/haskell/Hydra/Json/Schema/Language.hs view
@@ -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
src/main/haskell/Hydra/Json/Schema/Model.hs view
@@ -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
src/main/haskell/Hydra/Json/Schema/Serde.hs view
@@ -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 ->
src/main/haskell/Hydra/Kusto/Kql.hs view
@@ -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
src/main/haskell/Hydra/Osv/Schema.hs view
@@ -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
src/main/haskell/Hydra/Parquet/Format.hs view
@@ -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
src/main/haskell/Hydra/Pegasus/Coder.hs view
@@ -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
src/main/haskell/Hydra/Pegasus/Language.hs view
@@ -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)
src/main/haskell/Hydra/Pegasus/Pdl.hs view
@@ -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
src/main/haskell/Hydra/Pegasus/Serde.hs view
@@ -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)])
src/main/haskell/Hydra/Protobuf/Any.hs view
@@ -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
src/main/haskell/Hydra/Protobuf/Coder.hs view
@@ -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
src/main/haskell/Hydra/Protobuf/Environment.hs view
@@ -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
src/main/haskell/Hydra/Protobuf/Language.hs view
@@ -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
src/main/haskell/Hydra/Protobuf/Proto3.hs view
@@ -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
src/main/haskell/Hydra/Protobuf/Serde.hs view
@@ -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,
src/main/haskell/Hydra/Protobuf/SourceContext.hs view
@@ -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.
src/main/haskell/Hydra/Rust/Coder.hs view
@@ -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]))))
src/main/haskell/Hydra/Rust/Language.hs view
@@ -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
src/main/haskell/Hydra/Rust/Operators.hs view
@@ -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 (+=)
src/main/haskell/Hydra/Rust/Serde.hs view
@@ -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,           "{",
src/main/haskell/Hydra/Rust/Syntax.hs view
@@ -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
src/main/haskell/Hydra/Sql/Syntax.hs view
@@ -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
src/main/haskell/Hydra/Stac/Items.hs view
@@ -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
src/main/haskell/Hydra/Workflow.hs view
@@ -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
src/main/haskell/Hydra/Yaml/Coder.hs view
@@ -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))))),
src/main/haskell/Hydra/Yaml/Language.hs view
@@ -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
src/main/haskell/Hydra/Yaml/Serde.hs view
@@ -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 ->