packages feed

hydra-kernel 0.17.4 → 0.17.5

raw patch · 266 files changed

+1203/−859 lines, 266 filesdep +unixPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: unix

API changes (from Hackage documentation)

- Hydra.Dsl.Lib.Optionals: cases :: TypedTerm (Maybe x) -> TypedTerm y -> TypedTerm (x -> y) -> TypedTerm y
- Hydra.Dsl.Lib.Strings: lines :: TypedTerm String -> TypedTerm [String]
- Hydra.Dsl.Lib.Strings: unlines :: TypedTerm [String] -> TypedTerm String
- Hydra.Lib.Optionals: cases :: PrimitiveDefinition
- Hydra.Lib.Strings: lines :: PrimitiveDefinition
- Hydra.Lib.Strings: unlines :: PrimitiveDefinition
- Hydra.Overlay.Haskell.Lib.Files: utcToTimespec :: UTCTime -> Timespec
- Hydra.Overlay.Haskell.Lib.Optionals: cases :: Maybe a -> b -> (a -> b) -> b
- Hydra.Overlay.Haskell.Lib.Strings: lines :: String -> [String]
- Hydra.Overlay.Haskell.Lib.Strings: unlines :: [String] -> String
+ Hydra.Classes: classIsSatisfiedByType :: Name -> Type -> Bool
+ Hydra.Constants: fieldNameValue :: String
+ Hydra.Dsl.Constants: fieldNameValue :: TypedTerm String
+ Hydra.Dsl.Formatting: lines :: TypedTerm String -> TypedTerm [String]
+ Hydra.Dsl.Formatting: unlines :: TypedTerm [String] -> TypedTerm String
+ Hydra.Dsl.Lib.Files: createSymlink :: TypedTerm FilePath -> TypedTerm FilePath -> TypedTerm (IO (Either FileError ()))
+ Hydra.Dsl.Lib.Files: readSymlink :: TypedTerm FilePath -> TypedTerm (IO (Either FileError FilePath))
+ Hydra.Dsl.Lib.Optionals: match :: TypedTerm (Maybe x) -> TypedTerm y -> TypedTerm (x -> y) -> TypedTerm y
+ Hydra.Dsl.Rewriting: wrapTermToRecord :: TypedTerm Name -> TypedTerm Term -> TypedTerm Term
+ Hydra.Dsl.Rewriting: wrapTypeToRecord :: TypedTerm Type -> TypedTerm Type
+ Hydra.Formatting: lines :: String -> [String]
+ Hydra.Formatting: unlines :: [String] -> String
+ Hydra.Inference: dischargeClassConstraints :: InferenceContext -> TypeSubst -> Map Name TypeVariableConstraints -> Either Error ()
+ Hydra.Lib.Files: createSymlink :: PrimitiveDefinition
+ Hydra.Lib.Files: readSymlink :: PrimitiveDefinition
+ Hydra.Lib.Optionals: match :: PrimitiveDefinition
+ Hydra.Overlay.Haskell.Lib.Files: createSymlink :: FilePath -> FilePath -> IO (Either FileError ())
+ Hydra.Overlay.Haskell.Lib.Files: epochToTimespec :: EpochTime -> Timespec
+ Hydra.Overlay.Haskell.Lib.Files: posixFileType :: FileStatus -> FileType
+ Hydra.Overlay.Haskell.Lib.Files: readSymlink :: FilePath -> IO (Either FileError FilePath)
+ Hydra.Overlay.Haskell.Lib.Optionals: match :: Maybe a -> b -> (a -> b) -> b
+ Hydra.Parsers: manyLoop :: Parser t0 -> [Int] -> [t0] -> ParseResult [t0]
+ Hydra.Rewriting: wrapTermToRecord :: Name -> Term -> Term
+ Hydra.Rewriting: wrapTypeToRecord :: Type -> Type
- Hydra.Dsl.Lib.Files: status :: TypedTerm FilePath -> TypedTerm (IO (Either FileError FileStatus))
+ Hydra.Dsl.Lib.Files: status :: TypedTerm Bool -> TypedTerm FilePath -> TypedTerm (IO (Either FileError FileStatus))
- Hydra.Dsl.Parsing: parseError :: TypedTerm String -> TypedTerm String -> TypedTerm ParseError
+ Hydra.Dsl.Parsing: parseError :: TypedTerm String -> TypedTerm [Int] -> TypedTerm ParseError
- Hydra.Dsl.Parsing: parseErrorRemainder :: TypedTerm ParseError -> TypedTerm String
+ Hydra.Dsl.Parsing: parseErrorRemainder :: TypedTerm ParseError -> TypedTerm [Int]
- Hydra.Dsl.Parsing: parseErrorWithRemainder :: TypedTerm ParseError -> TypedTerm String -> TypedTerm ParseError
+ Hydra.Dsl.Parsing: parseErrorWithRemainder :: TypedTerm ParseError -> TypedTerm [Int] -> TypedTerm ParseError
- Hydra.Dsl.Parsing: parseSuccess :: TypedTerm a -> TypedTerm String -> TypedTerm (ParseSuccess a)
+ Hydra.Dsl.Parsing: parseSuccess :: TypedTerm a -> TypedTerm [Int] -> TypedTerm (ParseSuccess a)
- Hydra.Dsl.Parsing: parseSuccessRemainder :: TypedTerm (ParseSuccess a) -> TypedTerm String
+ Hydra.Dsl.Parsing: parseSuccessRemainder :: TypedTerm (ParseSuccess a) -> TypedTerm [Int]
- Hydra.Dsl.Parsing: parseSuccessWithRemainder :: TypedTerm (ParseSuccess a) -> TypedTerm String -> TypedTerm (ParseSuccess a)
+ Hydra.Dsl.Parsing: parseSuccessWithRemainder :: TypedTerm (ParseSuccess a) -> TypedTerm [Int] -> TypedTerm (ParseSuccess a)
- Hydra.Dsl.Parsing: parser :: TypedTerm (String -> ParseResult a) -> TypedTerm (Parser a)
+ Hydra.Dsl.Parsing: parser :: TypedTerm ([Int] -> ParseResult a) -> TypedTerm (Parser a)
- Hydra.Dsl.Parsing: unParser :: TypedTerm (Parser a) -> TypedTerm (String -> ParseResult a)
+ Hydra.Dsl.Parsing: unParser :: TypedTerm (Parser a) -> TypedTerm ([Int] -> ParseResult a)
- Hydra.Overlay.Haskell.Dsl.Typed.Phantoms: cases :: Name -> TypedTerm a -> Maybe (TypedTerm b) -> [Field] -> TypedTerm b
+ Hydra.Overlay.Haskell.Dsl.Typed.Phantoms: cases :: AsName n => n -> Maybe (TypedTerm b) -> [Field] -> TypedTerm (a -> b)
- Hydra.Overlay.Haskell.Dsl.Typed.Phantoms: match :: AsName n => n -> Maybe (TypedTerm b) -> [Field] -> TypedTerm (a -> b)
+ Hydra.Overlay.Haskell.Dsl.Typed.Phantoms: match :: AsName n => n -> TypedTerm a -> Maybe (TypedTerm b) -> [Field] -> TypedTerm b
- Hydra.Overlay.Haskell.Lib.Files: status :: FilePath -> IO (Either FileError FileStatus)
+ Hydra.Overlay.Haskell.Lib.Files: status :: Bool -> FilePath -> IO (Either FileError FileStatus)
- Hydra.Overlay.Haskell.Lib.Math: range :: Enum a => a -> a -> [a]
+ Hydra.Overlay.Haskell.Lib.Math: range :: (Enum a, Ord a) => a -> a -> [a]
- Hydra.Parsing: ParseError :: String -> String -> ParseError
+ Hydra.Parsing: ParseError :: String -> [Int] -> ParseError
- Hydra.Parsing: ParseSuccess :: a -> String -> ParseSuccess a
+ Hydra.Parsing: ParseSuccess :: a -> [Int] -> ParseSuccess a
- Hydra.Parsing: Parser :: (String -> ParseResult a) -> Parser a
+ Hydra.Parsing: Parser :: ([Int] -> ParseResult a) -> Parser a
- Hydra.Parsing: [parseErrorRemainder] :: ParseError -> String
+ Hydra.Parsing: [parseErrorRemainder] :: ParseError -> [Int]
- Hydra.Parsing: [parseSuccessRemainder] :: ParseSuccess a -> String
+ Hydra.Parsing: [parseSuccessRemainder] :: ParseSuccess a -> [Int]
- Hydra.Parsing: [unParser] :: Parser a -> String -> ParseResult a
+ Hydra.Parsing: [unParser] :: Parser a -> [Int] -> ParseResult a

Files

CHANGELOG.md view
@@ -15,6 +15,131 @@  --- +## [0.17.5] - 2026-08-19++Point release on the 0.17.x line. Two language-surface changes lead: sum-type eliminators unify on+`match` (scrutinee-first), and the primitive set is tentatively finalized — `strings.lines`/`unlines`+are removed in favour of `hydra.formatting` term helpers. A symlink-aware filesystem family lands+across all ten hosts, and Hydra's own build system continues its migration into Hydra.++**Backward-incompatible.** The `cases` -> `match` rename and the `strings.lines`/`unlines` removal+both change the published kernel surface. Code written against 0.17.4 that uses `Optionals.cases`+or `strings.lines`/`strings.unlines` must be updated.++### Highlights++- **Sum-type eliminators unify on `match`** ([#615](https://github.com/CategoricalData/hydra/issues/615)):+  the `cases`/`match` helper pair is flipped to a single scrutinee-first `match` convention across the+  Haskell, Java, Python, and Scala DSLs, the `optionals.cases` -> `optionals.match` kernel primitive,+  and the corresponding implementations in TypeScript and all four Lisp dialects.+- **Primitive set tentatively finalized** ([#417](https://github.com/CategoricalData/hydra/issues/417)):+  `strings.lines` and `strings.unlines` are removed as primitives; their semantics are preserved as+  `hydra.formatting.lines`/`unlines` term helpers, with overlay implementations dropped across all ten+  hosts and callers repointed.+- **Symlink-aware filesystem primitives** ([#666](https://github.com/CategoricalData/hydra/issues/666)):+  `status(followLinks)`, `createSymlink`, and `readSymlink` land with native implementations for every+  host — Haskell, Java, Python, Scala, TypeScript, Clojure, Common Lisp, Scheme, and Emacs Lisp.+- **Build system promotion continues** ([#416](https://github.com/CategoricalData/hydra/issues/416)):+  adds `hydra.build.walk` extension-glob helpers (`extensionOf`/`filterByExtension`/`matchesExtension`)+  and `hydra.build.comparereportlogic`, a set of pure snapshot-compare decision helpers.++### Bug fixes++- **`math.range` was inclusive of both bounds** ([#647](https://github.com/CategoricalData/hydra/issues/647)),+  silently fabricating an extra element in index arithmetic.+- **Java coder TCO-`cases` codegen** dropped enclosing-method type parameters from union-variant casts+  (found via [#666](https://github.com/CategoricalData/hydra/issues/666)).+- **`ShaclRdf` promoted to a DSL module** ([#652](https://github.com/CategoricalData/hydra/issues/652))+  so the SHACL pipeline works outside Haskell.+- **Cold-seed shim portability**: the R22 bootstrap shim used GNU-only `\+` and `\b`, which fail under+  BSD `sed` on macOS ([#417](https://github.com/CategoricalData/hydra/issues/417)).+- **Bootstrap Haskell target missing `unix`**: the demo's static `package.yaml` was not updated when+  `System.Posix.Files` entered the kernel overlay, breaking every `*-to-haskell` bootstrap cell+  ([#670](https://github.com/CategoricalData/hydra/issues/670)).+- **Bootstrap comparison scored Scala and TypeScript cells as passing without comparing anything**:+  `compare_output`'s target switch was missing both languages, so the baseline path was malformed,+  every file counted as "no baseline found", and a zero-file comparison reported `pass`. A Scala or+  TypeScript *target* cell could never fail ([#671](https://github.com/CategoricalData/hydra/issues/671)).++### Known issues++- A pre-#630 post-generation text pass rewrites `hydra.lib.<sub>` -> `hydra.overlay.<lang>.lib.<sub>`+  in generated **doc comments** as well as code, because its quote-prefix guard does not recognize+  mid-sentence prose references. Affects two kernel doc strings in `src/main`+  (`hydra.error.system`, `hydra.error.packaging`) plus ~20 generated docstrings in the test tree;+  cosmetic only, no behavioral impact. Tracked as part of+  [#633](https://github.com/CategoricalData/hydra/issues/633).+- Bootstrap comparison diff detail is not persisted to the run directory+  ([#671](https://github.com/CategoricalData/hydra/issues/671)).++---++## [0.17.4] - 2026-08-09++Point release on the 0.17.x line. Fixes an inference bug that mis-typed generated Java and Python for+`readFile`, adds the `divide` primitive, and restores `hydra-ext` to the published package set. Release+validation also surfaced a family of pre-existing cross-host code-generation defects — none of which the+per-host CI jobs can catch, because only the bootstrap exercises one host generating *another*.++### Highlights++- **Output-only nominal generalization fixed** ([#637](https://github.com/CategoricalData/hydra/issues/637),+  with [#638](https://github.com/CategoricalData/hydra/issues/638) /+  [#639](https://github.com/CategoricalData/hydra/issues/639) /+  [#640](https://github.com/CategoricalData/hydra/issues/640)): a nominal type appearing only in the+  *output* position of a primitive's signature was generalized to a free type variable instead of resolving+  as nominal, mis-typing the generated Java and Python for `readFile`. Also widens universe closure and adds+  a `kernelTypeUniverse` helper, an effect DSL builder, and `effects`/`files`/`text`/`system` lib wrappers.+- **`divide` primitive** ([#317](https://github.com/CategoricalData/hydra/issues/317)): now present in the+  published kernel. This also clears the cold-clone dangle, since a cold seed against published 0.17.4+  resolves `DefMath.divide`.+- **`hydra-ext` republished** ([#636](https://github.com/CategoricalData/hydra/issues/636)): back in the+  published set after its absence from 0.17.1–0.17.3, shipping to Hackage and PyPI.++### Bug fixes++- **Overlay-lib redirection skipped for the Haskell target**+  ([#630](https://github.com/CategoricalData/hydra/issues/630)):+  the Java, Python, Scheme, Clojure and Common Lisp heads resolved the overlay lib directory using an+  all-lowercase path and did not lower-case the names they scanned. Haskell's overlay tree is capitalized+  (`Hydra/Overlay/Haskell/Lib/`), so every `hydra.lib.*` redirect silently failed and the generated Haskell+  imported `Hydra.Lib.*` instead of `Hydra.Overlay.Haskell.Lib.*`, producing hundreds of type errors. The+  defect was invisible on case-sensitive filesystems, where the failed directory check falls back to a+  hard-coded list that happens to be correct. The Python head carried *two* independent copies of this scan;+  only the one in `generation.py` feeds the Haskell coder.+- **Lisp-as-host bootstrap** ([#520](https://github.com/CategoricalData/hydra/issues/520),+  [#630](https://github.com/CategoricalData/hydra/issues/630)): the four Lisp head decode drivers called+  `from_json` with a stale 4-argument signature, and the Lisp bootstrap-driver coders were not pre-bound with+  `overlaySubs`.+- **Python-as-host dropped the `Graph` argument** ([#630](https://github.com/CategoricalData/hydra/issues/630)):+  `overlaySubs` was not threaded into the Python head's `write_*` wrappers.+- **Clojure `resolve-coder` and `decimal-to-float32`**+  ([#630](https://github.com/CategoricalData/hydra/issues/630)): a stray parenthesis closed a `case` early,+  making an unsupported-default block run unconditionally; and `(float (.doubleValue ...))` threw on+  `Float.MAX_VALUE`, now saturating via `(.floatValue (bigdec x))`.+- **Cold-seeder failed on macOS** ([#630](https://github.com/CategoricalData/hydra/issues/630)): the #376+  cold seeder used a bare `sed -i -e`, which is GNU-only and aborts immediately under BSD `sed`.++### Release engineering++- **Review checkpoint before Maven Central publishes**+  ([#591](https://github.com/CategoricalData/hydra/issues/591)): `HYDRA_JAVA_PUBLISH_HOLD=1` uploads the+  aggregated Java deployment as `USER_MANAGED`, so it validates and then holds for review instead of+  publishing automatically. This mirrors `HYDRA_SCALA_PUBLISH_HOLD` and makes an upload reversible — a held+  deployment can be dropped, whereas an automatic one cannot be undone.++### Known issues++- **`hydra-ext` is not published to Maven Central**+  ([#643](https://github.com/CategoricalData/hydra/issues/643)): it does not compile for the Java target,+  because the visitor-pattern inner interface the Java coder emits collides with the enclosing `Visitor`+  type in `hydra.cpp.syntax`. Only Java is affected; the Python coder emits sibling classes rather than+  nested ones. ext ships to Hackage and PyPI at 0.17.4 and is expected to rejoin the Java set once fixed.+- **TypeScript no longer self-hosts**+  ([#642](https://github.com/CategoricalData/hydra/issues/642)): the TypeScript host's JSON decoder fails to+  decode most of the kernel, so `typescript-as-host` code generation is broken. No published artifact is+  affected — `dist/typescript` is generated by the Haskell host and passes its test suite.+ ## [0.17.3] - 2026-08-01  Point release on the 0.17.x line, focused on **release-artifact integrity**. The 0.17.2 release shipped
hydra-kernel.cabal view
@@ -1,11 +1,11 @@ cabal-version: 1.12 --- This file has been generated from package.yaml by hpack version 0.39.1.+-- This file has been generated from package.yaml by hpack version 0.38.1. -- -- see: https://github.com/sol/hpack  name:           hydra-kernel-version:        0.17.4+version:        0.17.5 synopsis:       The Hydra kernel: core types, terms, inference, and DSL runtime 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". This package is the Hydra kernel: the core type and term model, type inference, the term rewriting and reduction engine, the primitive library, and the DSL runtime — the code that must be present in every Hydra implementation. The convenient entry point is the Hydra.Kernel module, which re-exports the kernel's collision-free surface. category:       Data@@ -347,4 +347,5 @@     , split >=0.2.3 && <0.3     , text >=2.0.2 && <2.2     , time >=1.12.0 && <1.13+    , unix >=2.8.0 && <2.9   default-language: Haskell2010
src/main/haskell/Hydra/Adapt.hs view
@@ -62,7 +62,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@@ -99,7 +99,7 @@         in (Eithers.bind (Eithers.mapList adaptBinding els0) (\adaptedTerms ->           let els1Raw = Lists.concat (Lists.map Environment.termAsBindings adaptedTerms)               processBinding =-                      \el -> Eithers.bind (Rewriting.rewriteTermM (adaptNestedTypes constraints litmap) (Core.bindingTerm el)) (\newTerm -> Eithers.bind (Optionals.cases (Core.bindingTypeScheme el) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedType -> Right (Core.Binding {+                      \el -> Eithers.bind (Rewriting.rewriteTermM (adaptNestedTypes constraints litmap) (Core.bindingTerm el)) (\newTerm -> Eithers.bind (Optionals.match (Core.bindingTypeScheme el) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedType -> Right (Core.Binding {                         Core.bindingName = (Core.bindingName el),                         Core.bindingTerm = newTerm,                         Core.bindingTypeScheme = adaptedType})))@@ -164,7 +164,7 @@ adaptLambdaDomains :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either Errors.Error Core.Term) -> t0 -> Either Errors.Error Core.Term adaptLambdaDomains constraints litmap recurse term =     Eithers.bind (recurse term) (\rewritten -> case rewritten of-      Core.TermLambda v0 -> Eithers.bind (Optionals.cases (Core.lambdaDomain v0) (Right Nothing) (\dom -> Eithers.bind (adaptType constraints litmap dom) (\dom1 -> Right (Just dom1)))) (\adaptedDomain -> Right (Core.TermLambda (Core.Lambda {+      Core.TermLambda v0 -> Eithers.bind (Optionals.match (Core.lambdaDomain v0) (Right Nothing) (\dom -> Eithers.bind (adaptType constraints litmap dom) (\dom1 -> Right (Just dom1)))) (\adaptedDomain -> Right (Core.TermLambda (Core.Lambda {         Core.lambdaParameter = (Core.lambdaParameter v0),         Core.lambdaDomain = adaptedDomain,         Core.lambdaBody = (Core.lambdaBody v0)})))@@ -210,13 +210,13 @@ adaptLiteralTypesMap :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType adaptLiteralTypesMap constraints = -      let tryType = \lt -> Optionals.cases (adaptLiteralType constraints lt) Nothing (\lt2 -> Just (lt, lt2))+      let tryType = \lt -> Optionals.match (adaptLiteralType constraints lt) Nothing (\lt2 -> Just (lt, lt2))       in (Maps.fromList (Optionals.givens (Lists.map tryType Reflect.literalTypes)))  -- | Adapt a literal value using the given language constraints adaptLiteralValue :: Ord t0 => (M.Map t0 Core.LiteralType -> t0 -> Core.Literal -> Core.Literal) adaptLiteralValue litmap lt l =-    Optionals.cases (Maps.lookup lt litmap) (Core.LiteralString (PrintCore.literal l)) (\lt2 -> adaptLiteral lt2 l)+    Optionals.match (Maps.lookup lt litmap) (Core.LiteralString (PrintCore.literal l)) (\lt2 -> adaptLiteral lt2 l)  -- | Rewrite callback for adapting nested let binding TypeSchemes in a term adaptNestedTypes :: Coders.LanguageConstraints -> M.Map Core.LiteralType Core.LiteralType -> (t0 -> Either Errors.Error Core.Term) -> t0 -> Either Errors.Error Core.Term@@ -224,7 +224,7 @@     Eithers.bind (recurse term) (\rewritten -> case rewritten of       Core.TermLet v0 ->         let adaptB =-                \b -> Eithers.bind (Optionals.cases (Core.bindingTypeScheme b) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedBType -> Right (Core.Binding {+                \b -> Eithers.bind (Optionals.match (Core.bindingTypeScheme b) (Right Nothing) (\ts -> Eithers.bind (adaptTypeScheme constraints litmap ts) (\ts1 -> Right (Just ts1)))) (\adaptedBType -> Right (Core.Binding {                   Core.bindingName = (Core.bindingName b),                   Core.bindingTerm = (Core.bindingTerm b),                   Core.bindingTypeScheme = adaptedBType}))@@ -266,7 +266,7 @@                     forUnsupported =                             \term ->                               let tryAlts =-                                      \alts -> Optionals.cases (Lists.uncons alts) (Right Nothing) (\uc -> Eithers.bind (tryTerm (Pairs.first uc)) (\mterm -> Optionals.cases mterm (tryAlts (Pairs.second uc)) (\t -> Right (Just t))))+                                      \alts -> Optionals.match (Lists.uncons alts) (Right Nothing) (\uc -> Eithers.bind (tryTerm (Pairs.first uc)) (\mterm -> Optionals.match mterm (tryAlts (Pairs.second uc)) (\t -> Right (Just t))))                               in (Eithers.bind (termAlternatives cx graph term) (\alts0 -> tryAlts alts0))                     tryTerm =                             \term ->@@ -278,7 +278,7 @@                     Core.typeApplicationTermBody = (Core.typeApplicationTermBody v0),                     Core.typeApplicationTermType = atyp})))                   Core.TermTypeLambda _ -> Right term1-                  _ -> Eithers.bind (tryTerm term1) (\mterm -> Optionals.cases mterm (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "no alternatives for term: " (PrintCore.term term1))))) (\term2 -> Right term2))))+                  _ -> Eithers.bind (tryTerm term1) (\mterm -> Optionals.match mterm (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "no alternatives for term: " (PrintCore.term term1))))) (\term2 -> Right term2))))       in (Rewriting.rewriteTermM rewrite term0)  -- | Adapt a term using the constraints of a given language@@ -311,12 +311,12 @@        let forSupported =               \typ -> case typ of-                Core.TypeLiteral v0 -> Logic.ifElse (literalTypeSupported constraints v0) (Just typ) (Optionals.cases (Maps.lookup v0 litmap) (Just (Core.TypeLiteral Core.LiteralTypeString)) (\lt2 -> Just (Core.TypeLiteral lt2)))+                Core.TypeLiteral v0 -> Logic.ifElse (literalTypeSupported constraints v0) (Just typ) (Optionals.match (Maps.lookup v0 litmap) (Just (Core.TypeLiteral Core.LiteralTypeString)) (\lt2 -> Just (Core.TypeLiteral lt2)))                 _ -> Just typ           forUnsupported =                   \typ ->                     let tryAlts =-                            \alts -> Optionals.bind (Lists.uncons alts) (\uc -> Optionals.cases (tryType (Pairs.first uc)) (tryAlts (Pairs.second uc)) (\t -> Just t))+                            \alts -> Optionals.bind (Lists.uncons alts) (\uc -> Optionals.match (tryType (Pairs.first uc)) (tryAlts (Pairs.second uc)) (\t -> Just t))                         alts0 = typeAlternatives typ                     in (tryAlts alts0)           tryType =@@ -324,7 +324,7 @@                     let supportedVariant = Sets.member (Reflect.typeVariant typ) (Coders.languageConstraintsTypeVariants constraints)                     in (Logic.ifElse supportedVariant (forSupported typ) (forUnsupported typ))           rewrite =-                  \recurse -> \typ -> Eithers.bind (recurse typ) (\type1 -> Optionals.cases (tryType type1) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "no alternatives for type: " (PrintCore.type_ typ))))) (\type2 -> Right type2))+                  \recurse -> \typ -> Eithers.bind (recurse typ) (\type1 -> Optionals.match (tryType type1) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "no alternatives for type: " (PrintCore.type_ typ))))) (\type2 -> Right type2))       in (Rewriting.rewriteTypeM rewrite type0)  -- | Adapt a type using the constraints of a given language@@ -359,7 +359,7 @@        let namespacesSet = Sets.fromList namespaces           isParentBinding =-                  \b -> Optionals.cases (Names.moduleNameOf (Core.bindingName b)) False (\ns -> Sets.member ns namespacesSet)+                  \b -> Optionals.match (Names.moduleNameOf (Core.bindingName b)) False (\ns -> Sets.member ns namespacesSet)           hoistCases =                   \bindings ->                     let stripped =@@ -389,7 +389,7 @@           qualifyUntyped =                   \b ->                     let nm = Core.unName (Core.bindingName b)-                    in (Optionals.cases (Names.moduleNameOf (Core.bindingName b)) (Strings.concat2 "(no module) " nm) (\ns -> Strings.concat [+                    in (Optionals.match (Names.moduleNameOf (Core.bindingName b)) (Strings.concat2 "(no module) " nm) (\ns -> Strings.concat [                       Packaging.unModuleName ns,                       " :: ",                       nm]))@@ -444,11 +444,11 @@                         let t1 = peelOne t                             t2 = peelOne t1                             t3 = peelOne t2-                        in (Optionals.cases (extractAnn t) (Optionals.cases (extractAnn t1) (Optionals.cases (extractAnn t2) (extractAnn t3) (\a -> Just a)) (\a -> Just a)) (\a -> Just a))+                        in (Optionals.match (extractAnn t) (Optionals.match (extractAnn t1) (Optionals.match (extractAnn t2) (extractAnn t3) (\a -> Just a)) (\a -> Just a)) (\a -> Just a))               originalAnnotations =-                      Maps.fromList (Optionals.givens (Lists.map (\b -> Optionals.cases (findAnn (Core.bindingTerm b)) Nothing (\ann -> Just (Core.bindingName b, ann))) originalBindings))+                      Maps.fromList (Optionals.givens (Lists.map (\b -> Optionals.match (findAnn (Core.bindingTerm b)) Nothing (\ann -> Just (Core.bindingName b, ann))) originalBindings))               reattachAnnotation =-                      \b -> Optionals.cases (Maps.lookup (Core.bindingName b) originalAnnotations) b (\ann -> Core.Binding {+                      \b -> Optionals.match (Maps.lookup (Core.bindingName b) originalAnnotations) b (\ann -> Core.Binding {                         Core.bindingName = (Core.bindingName b),                         Core.bindingTerm = case (Core.bindingTerm b) of                           Core.TermAnnotated v0 -> Core.TermAnnotated (Core.AnnotatedTerm {@@ -466,15 +466,15 @@                         Packaging.termDefinitionSignature = (Just (Scoping.typeSchemeToTermSignature ts)),                         Packaging.termDefinitionBody = (Core.bindingTerm el)}) (Core.bindingTypeScheme el)               selectedElements =-                      Lists.filter (\el -> Optionals.cases (Names.moduleNameOf (Core.bindingName el)) False (\ns -> Sets.member ns namespacesSet)) bins5+                      Lists.filter (\el -> Optionals.match (Names.moduleNameOf (Core.bindingName el)) False (\ns -> Sets.member ns namespacesSet)) bins5               elementsByNamespace =-                      Lists.foldl (\acc -> \el -> Optionals.cases (Names.moduleNameOf (Core.bindingName el)) acc (\ns ->-                        let existing = Optionals.cases (Maps.lookup ns acc) [] Functions.identity+                      Lists.foldl (\acc -> \el -> Optionals.match (Names.moduleNameOf (Core.bindingName el)) acc (\ns ->+                        let existing = Optionals.match (Maps.lookup ns acc) [] Functions.identity                         in (Maps.insert ns (Lists.concat2 existing [                           el]) acc))) Maps.empty selectedElements               defsGrouped =                       Lists.map (\ns ->-                        let elsForNs = Optionals.cases (Maps.lookup ns elementsByNamespace) [] Functions.identity+                        let elsForNs = Optionals.match (Maps.lookup ns elementsByNamespace) [] Functions.identity                         in (Optionals.givens (Lists.map toDef elsForNs))) namespaces               g = Lexical.buildGraph bins5 Maps.empty (Graph.graphPrimitives adapted)           in (Right (@@ -762,7 +762,7 @@         in (Right [           term2])       Core.TermOptional v0 -> Right [-        Core.TermList (Optionals.cases v0 [] (\term2 -> [+        Core.TermList (Optionals.match v0 [] (\term2 -> [           term2]))]       Core.TermTypeLambda v0 ->         let term2 = Core.typeLambdaBody v0
src/main/haskell/Hydra/Analysis.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.Set as S @@ -103,7 +103,7 @@     case (Strip.deannotateTerm t) of       Core.TermLambda v0 -> Logic.ifElse argMode (         let v = Core.lambdaParameter v0-            dom = Optionals.cases (Core.lambdaDomain v0) (Core.TypeVariable (Core.Name "_")) (\x_ -> x_)+            dom = Optionals.match (Core.lambdaDomain v0) (Core.TypeVariable (Core.Name "_")) (\x_ -> x_)             body = Core.lambdaBody v0             newEnv = setTC (Scoping.extendGraphForLambda (getTC gEnv) v0) gEnv         in (analyzeFunctionTermWithGather cx forBinding getTC setTC argMode newEnv tparams (Lists.cons v args) bindings (Lists.cons dom doms) tapps body)) (analyzeFunctionTermWithFinish cx getTC gEnv tparams args bindings doms tapps t)@@ -145,7 +145,7 @@                     deannotatedTerm = Strip.deannotateTerm term                     dataNames = Dependencies.termDependencyNames binds withPrims withNoms term                     schemaNames =-                            Logic.ifElse withSchema (Optionals.cases (Core.bindingTypeScheme el) Sets.empty (\ts -> Dependencies.typeDependencyNames True (Core.typeSchemeBody ts))) Sets.empty+                            Logic.ifElse withSchema (Optionals.match (Core.bindingTypeScheme el) Sets.empty (\ts -> Dependencies.typeDependencyNames True (Core.typeSchemeBody ts))) Sets.empty                 in (Logic.ifElse (Predicates.isEncodedType deannotatedTerm) (Eithers.map (\typ -> Sets.unions [                   dataNames,                   schemaNames,@@ -251,7 +251,7 @@                   dflt = Core.caseStatementDefault v1                   branchesOk =                           Lists.foldl (\ok -> \field -> Logic.and ok (isTailRecursiveInTailPosition funcName (Core.caseAlternativeHandler field))) True cases_-                  dfltOk = Optionals.cases dflt True (\d -> isTailRecursiveInTailPosition funcName d)+                  dfltOk = Optionals.match dflt True (\d -> isTailRecursiveInTailPosition funcName d)                   argsOk = Lists.foldl (\ok -> \arg -> Logic.and ok (Variables.isFreeVariableInTerm funcName arg)) True gatherArgs               in (Logic.and (Logic.and branchesOk dfltOk) argsOk)             _ -> Variables.isFreeVariableInTerm funcName term
src/main/haskell/Hydra/Annotations.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 import qualified Data.Set as S@@ -59,7 +59,7 @@ aggregateAnnotations getValue getX getAnns t =        let toPairs =-              \rest -> \t2 -> Optionals.cases (getValue t2) rest (\yy -> toPairs (Lists.cons (Maps.toList (getAnns yy)) rest) (getX yy))+              \rest -> \t2 -> Optionals.match (getValue t2) rest (\yy -> toPairs (Lists.cons (Maps.toList (getAnns yy)) rest) (getX yy))       in (Maps.fromList (Lists.concat (toPairs [] t)))  -- | Extract comments/description from a Binding@@ -95,7 +95,7 @@ -- | Get description from annotations map (Either version) getDescription :: t0 -> Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.Error (Maybe String) getDescription cx graph anns =-    Optionals.cases (Maps.lookup (Core.Name "description") anns) (Right Nothing) (\term -> Eithers.map Optionals.pure (ExtractCore.string graph term))+    Optionals.match (Maps.lookup (Core.Name "description") anns) (Right Nothing) (\term -> Eithers.map Optionals.pure (ExtractCore.string graph term))  -- | Get a term annotation getTermAnnotation :: Core.Name -> Core.Term -> Maybe Core.Term@@ -115,7 +115,7 @@ -- | Get type from annotations getType :: Graph.Graph -> M.Map Core.Name Core.Term -> Either Errors.DecodingError (Maybe Core.Type) getType graph anns =-    Optionals.cases (Maps.lookup Constants.keyType anns) (Right Nothing) (\dat -> Eithers.map Optionals.pure (DecodeCore.type_ graph dat))+    Optionals.match (Maps.lookup Constants.keyType anns) (Right Nothing) (\dat -> Eithers.map Optionals.pure (DecodeCore.type_ graph dat))  -- | Get a type annotation getTypeAnnotation :: Core.Name -> Core.Type -> Maybe Core.Term@@ -126,7 +126,7 @@ getTypeClasses cx graph term =        let decodeName = \term2 -> Eithers.bimap (\de -> Errors.ErrorDecoding de) (\x -> x) (DecodeCore.name graph term2)-      in (Optionals.cases (getTermAnnotation Constants.keyClasses term) (Right Maps.empty) (\term2 -> ExtractCore.map decodeName (ExtractCore.setOf decodeName graph) graph term2))+      in (Optionals.match (getTermAnnotation Constants.keyClasses term) (Right Maps.empty) (\term2 -> ExtractCore.map decodeName (ExtractCore.setOf decodeName graph) graph term2))  -- | Get type description (Either version) getTypeDescription :: t0 -> Graph.Graph -> Core.Type -> Either Errors.Error (Maybe String)@@ -146,7 +146,7 @@        let isFlaggedAsFirstClassType =               Optionals.withDefault False (Optionals.map (\_ -> True) (getTermAnnotation Constants.keyFirstClassType (Core.bindingTerm el)))-      in (Optionals.cases (Core.bindingTypeScheme el) False (\ts -> Logic.and (Equality.equal ts (Core.TypeScheme {+      in (Optionals.match (Core.bindingTypeScheme el) False (\ts -> Logic.and (Equality.equal ts (Core.TypeScheme {         Core.typeSchemeVariables = [],         Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.Type")),         Core.typeSchemeConstraints = Nothing})) (Logic.not isFlaggedAsFirstClassType)))
src/main/haskell/Hydra/Arity.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  -- | Find the arity (expected number of arguments) of a primitive constant or function
src/main/haskell/Hydra/Ast.hs view
@@ -5,7 +5,7 @@ module Hydra.Ast 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  -- | Operator associativity
src/main/haskell/Hydra/Checking.hs view
@@ -59,7 +59,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@@ -67,7 +67,7 @@ -- | True if every element of the list is equal to every other element (vacuously true for the empty list) allEqual :: Eq t0 => ([t0] -> Bool) allEqual els =-    Optionals.cases (Lists.uncons els) True (\uc ->+    Optionals.match (Lists.uncons els) True (\uc ->       let h = Pairs.first uc           t = Pairs.second uc       in (Lists.foldl (\b -> \x -> Logic.and b (Equality.equal x h)) True t))@@ -75,7 +75,7 @@ -- | Apply type arguments to a type, substituting forall-bound variables. Paper: inference.tex, 'Checking the witness' (consuming the pending-type-argument stack). applyTypeArgumentsToType :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> Core.Type -> Either Errors.Error Core.Type applyTypeArgumentsToType cx tx typeArgs t =-    Optionals.cases (Lists.uncons typeArgs) (Right t) (\uc ->+    Optionals.match (Lists.uncons typeArgs) (Right t) (\uc ->       let ah = Pairs.first uc           at = Pairs.second uc       in case t of@@ -132,7 +132,7 @@                                 \b ->                                   let bterm = Core.bindingTerm b                                       newVars =-                                              Optionals.cases (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))+                                              Optionals.match (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))                                       newTrace = Lists.cons (Core.unName (Core.bindingName b)) trace                                   in (checkRecursive newVars newTrace (Just b) bterm)                         in (Eithers.bind (Eithers.mapList forBinding (Core.letBindings v0)) (\_ -> recurse (Core.letBody v0)))@@ -150,7 +150,7 @@               Left (Errors.ErrorChecking (Checking.CheckingErrorUnequalTypes (Checking.UnequalTypesError {                 Checking.unequalTypesErrorTypes = types,                 Checking.unequalTypesErrorDescription = desc})))-      in (Logic.ifElse (typesAllEffectivelyEqual tx types) (Optionals.cases (Lists.head types) unequalErr (\t -> Right t)) unequalErr)+      in (Logic.ifElse (typesAllEffectivelyEqual tx types) (Optionals.match (Lists.head types) unequalErr (\t -> Right t)) unequalErr)  -- | Sanity-check a type substitution arising from unification. Specifically, check that schema types have not been inappropriately unified with type variables inferred from terms. Paper: inference.tex, 'Checking the witness' (always-on invariant: a substitution may not bind a type name as if it were an inference variable). checkTypeSubst :: t0 -> Graph.Graph -> Typing.TypeSubst -> Either Errors.Error Typing.TypeSubst@@ -166,7 +166,7 @@                     Core.TypeWrap _ -> True                     _ -> False           badVars =-                  Sets.fromList (Lists.filter (\v -> Optionals.cases (Lexical.dereferenceSchemaType v (Graph.graphSchemaTypes tx)) False isNominal) (Sets.toList suspectVars))+                  Sets.fromList (Lists.filter (\v -> Optionals.match (Lexical.dereferenceSchemaType v (Graph.graphSchemaTypes tx)) False isNominal) (Sets.toList suspectVars))           badPairs = Lists.filter (\p -> Sets.member (Pairs.first p) badVars) (Maps.toList s)           printPair =                   \p -> Strings.concat2 (Strings.concat2 (Core.unName (Pairs.first p)) " --> ") (PrintCore.type_ (Pairs.second p))@@ -274,11 +274,11 @@        let tname = Core.caseStatementTypeName cs           dflt = Core.caseStatementDefault cs-          cases = Core.caseStatementCases cs-          cterms = Lists.map Core.caseAlternativeHandler cases+          match = Core.caseStatementCases cs+          cterms = Lists.map Core.caseAlternativeHandler match       in (Eithers.bind (Eithers.mapOptional (\e -> typeOf cx tx [] e) dflt) (\dfltResult ->         let tdflt = Optionals.map Pairs.first dfltResult-            cx2 = Optionals.cases dfltResult cx Pairs.second+            cx2 = Optionals.match dfltResult cx Pairs.second             foldResult =                     Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->                       let types = Pairs.first accR@@ -316,9 +316,9 @@                     Checking.typeArityMismatchErrorExpectedArity = 2,                     Checking.typeArityMismatchErrorActualArity = n,                     Checking.typeArityMismatchErrorTypeArguments = typeArgs})))-      in (Optionals.cases (Lists.uncons typeArgs) arityErr (\uc0 ->+      in (Optionals.match (Lists.uncons typeArgs) arityErr (\uc0 ->         let ta0 = Pairs.first uc0-        in (Optionals.cases (Lists.uncons (Pairs.second uc0)) arityErr (\uc1 ->+        in (Optionals.match (Lists.uncons (Pairs.second uc0)) arityErr (\uc1 ->           let ta1 = Pairs.first uc1           in (Logic.ifElse (Equality.equal n 2) (Eithers.either (\leftTerm -> Eithers.bind (typeOf cx tx [] leftTerm) (\result ->             let leftType = Pairs.first result@@ -358,7 +358,7 @@       let v = Core.lambdaParameter l           mdom = Core.lambdaDomain l           body = Core.lambdaBody l-      in (Eithers.bind (Optionals.cases mdom (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLambda (Checking.UntypedLambdaError {+      in (Eithers.bind (Optionals.match mdom (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLambda (Checking.UntypedLambdaError {       })))) (\dom ->         let types2 = Maps.insert v (Scoping.fTypeToTypeScheme dom) (Graph.graphBoundTypes tx)         in (Eithers.bind (typeOf cx (Graph.Graph {@@ -389,7 +389,7 @@           body = Core.letBody letTerm           bnames = Lists.map Core.bindingName bs           bindingType =-                  \b -> Optionals.cases (Core.bindingTypeScheme b) (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLetBinding (Checking.UntypedLetBindingError {+                  \b -> Optionals.match (Core.bindingTypeScheme b) (Left (Errors.ErrorChecking (Checking.CheckingErrorUntypedLetBinding (Checking.UntypedLetBindingError {                     Checking.untypedLetBindingErrorBinding = b})))) (\ts -> Right (Scoping.typeSchemeToFType ts))           btypesResult =                   Lists.foldl (\acc -> \b -> Eithers.bind acc (\accR ->@@ -422,7 +422,7 @@                 Checking.typeArityMismatchErrorExpectedArity = 1,                 Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),                 Checking.typeArityMismatchErrorTypeArguments = typeArgs})))-      in (Logic.ifElse (Lists.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.cases (Lists.head typeArgs) listArityErr (\ta0 -> Right (Core.TypeList ta0, cx))) listArityErr) (+      in (Logic.ifElse (Lists.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.match (Lists.head typeArgs) listArityErr (\ta0 -> Right (Core.TypeList ta0, cx))) listArityErr) (         let foldResult =                 Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->                   let types = Pairs.first accR@@ -455,9 +455,9 @@                 Checking.typeArityMismatchErrorExpectedArity = 2,                 Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),                 Checking.typeArityMismatchErrorTypeArguments = typeArgs})))-      in (Logic.ifElse (Maps.null m) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 2) (Optionals.cases (Lists.uncons typeArgs) mapArityErr (\uc0 ->+      in (Logic.ifElse (Maps.null m) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 2) (Optionals.match (Lists.uncons typeArgs) mapArityErr (\uc0 ->         let ta0 = Pairs.first uc0-        in (Optionals.cases (Lists.uncons (Pairs.second uc0)) mapArityErr (\uc1 ->+        in (Optionals.match (Lists.uncons (Pairs.second uc0)) mapArityErr (\uc1 ->           let ta1 = Pairs.first uc1           in (Right (             Core.TypeMap (Core.MapType {@@ -505,14 +505,14 @@                               Checking.typeArityMismatchErrorExpectedArity = 1,                               Checking.typeArityMismatchErrorActualArity = n,                               Checking.typeArityMismatchErrorTypeArguments = typeArgs})))-                in (Logic.ifElse (Equality.equal n 1) (Optionals.cases (Lists.head typeArgs) maybeArityErr (\ta0 -> Right (Core.TypeOptional ta0, cx))) maybeArityErr)+                in (Logic.ifElse (Equality.equal n 1) (Optionals.match (Lists.head typeArgs) maybeArityErr (\ta0 -> Right (Core.TypeOptional ta0, cx))) maybeArityErr)           forJust =                   \term -> Eithers.bind (typeOf cx tx [] term) (\tResult ->                     let termType = Pairs.first tResult                         cx2 = Pairs.second tResult                         t = Core.TypeOptional termType                     in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2))))-      in (Optionals.cases mt forNothing forJust)+      in (Optionals.match mt forNothing forJust)  -- | Reconstruct the type of a pair (Either/InferenceContext version). Paper: inference.tex, rule Pair (checking side). typeOfPair :: Typing.InferenceContext -> Graph.Graph -> [Core.Type] -> (Core.Term, Core.Term) -> Either Errors.Error (Core.Type, Typing.InferenceContext)@@ -546,7 +546,7 @@        let rawTs =               Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))-      in (Optionals.cases rawTs (Left (Errors.ErrorUndefinedTermVariable (ErrorCore.UndefinedTermVariableError {+      in (Optionals.match rawTs (Left (Errors.ErrorUndefinedTermVariable (ErrorCore.UndefinedTermVariableError {         ErrorCore.undefinedTermVariableErrorLocation = (Paths.SubtermPath []),         ErrorCore.undefinedTermVariableErrorName = name}))) (\tsRaw ->         let instResult = Resolution.instantiateTypeScheme cx tsRaw@@ -603,7 +603,7 @@                 Checking.typeArityMismatchErrorExpectedArity = 1,                 Checking.typeArityMismatchErrorActualArity = (Lists.length typeArgs),                 Checking.typeArityMismatchErrorTypeArguments = typeArgs})))-      in (Logic.ifElse (Sets.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.cases (Lists.head typeArgs) setArityErr (\ta0 -> Right (Core.TypeSet ta0, cx))) setArityErr) (+      in (Logic.ifElse (Sets.null els) (Logic.ifElse (Equality.equal (Lists.length typeArgs) 1) (Optionals.match (Lists.head typeArgs) setArityErr (\ta0 -> Right (Core.TypeSet ta0, cx))) setArityErr) (         let foldResult =                 Lists.foldl (\acc -> \term -> Eithers.bind acc (\accR ->                   let types = Pairs.first accR@@ -688,7 +688,7 @@                 in (Eithers.bind (applyTypeArgumentsToType cx2 tx typeArgs t) (\applied -> Right (applied, cx2)))           primScheme =                   Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))-      in (Optionals.cases primScheme (Optionals.cases (Maps.lookup name (Graph.graphBoundTypes tx)) (Left (Errors.ErrorUntypedTermVariable (ErrorCore.UntypedTermVariableError {+      in (Optionals.match primScheme (Optionals.match (Maps.lookup name (Graph.graphBoundTypes tx)) (Left (Errors.ErrorUntypedTermVariable (ErrorCore.UntypedTermVariableError {         ErrorCore.untypedTermVariableErrorLocation = (Paths.SubtermPath []),         ErrorCore.untypedTermVariableErrorName = name}))) forScheme) forScheme)
src/main/haskell/Hydra/Classes.hs view
@@ -17,12 +17,15 @@ import qualified Hydra.File as File import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model+import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality+import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing import qualified Hydra.Paths as Paths import qualified Hydra.Query as Query import qualified Hydra.Regex as Regex import qualified Hydra.Relational as Relational+import qualified Hydra.Strip as Strip import qualified Hydra.System as System import qualified Hydra.Tabular as Tabular import qualified Hydra.Testing as Testing@@ -33,8 +36,26 @@ 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++-- | Check whether a type is an instance of a constraint class, by the class's short name.+classIsSatisfiedByType :: Core.Name -> Core.Type -> Bool+classIsSatisfiedByType className typ =++      let isIntegerLiteral =+              case (Strip.deannotateType typ) of+                Core.TypeLiteral v0 -> case v0 of+                  Core.LiteralTypeInteger _ -> True+                  _ -> False+                _ -> False+          isFloatLiteral =+                  case (Strip.deannotateType typ) of+                    Core.TypeLiteral v0 -> case v0 of+                      Core.LiteralTypeFloat _ -> True+                      _ -> False+                    _ -> False+      in (Logic.ifElse (Equality.equal className (Core.Name "equality")) True (Logic.ifElse (Equality.equal className (Core.Name "ordering")) True (Logic.ifElse (Equality.equal className (Core.Name "numeric")) (Logic.or isIntegerLiteral isFloatLiteral) (Logic.ifElse (Equality.equal className (Core.Name "integral")) isIntegerLiteral (Logic.ifElse (Equality.equal className (Core.Name "fractional")) isFloatLiteral False)))))  -- | The equality type class: instances support structural equality. equality :: Typing.TypeClass
src/main/haskell/Hydra/Codegen.hs view
@@ -25,6 +25,7 @@ import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Inference as Inference import qualified Hydra.Json.Decode as Decode@@ -64,7 +65,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 import qualified Data.Set as S@@ -96,7 +97,7 @@                     (hexDigit (Optionals.withDefault 0 (Math.div b 16))),                     (hexDigit (Optionals.withDefault 0 (Math.mod b 16)))]           go =-                  \inStr -> \esc -> \bytes -> Optionals.cases (Lists.uncons bytes) [] (\uc ->+                  \inStr -> \esc -> \bytes -> Optionals.match (Lists.uncons bytes) [] (\uc ->                     let b = Pairs.first uc                         bs = Pairs.second uc                     in (Logic.ifElse esc (Lists.cons b (go inStr False bs)) (Logic.ifElse (Logic.and (Equality.equal b 92) inStr) (Lists.cons b (go inStr True bs)) (Logic.ifElse (Equality.equal b 34) (Lists.cons b (go (Logic.not inStr) False bs)) (Logic.ifElse (Logic.and inStr (Ordering.lt b 32)) (Lists.concat2 (escapeToUnicode b) (go inStr False bs)) (Lists.cons b (go inStr False bs)))))))@@ -116,7 +117,7 @@ formatTermBinding binding =        let name = Core.unName (Core.bindingName binding)-          typeStr = Optionals.cases (Core.bindingTypeScheme binding) "?" (\scheme -> PrintCore.typeScheme scheme)+          typeStr = Optionals.match (Core.bindingTypeScheme binding) "?" (\scheme -> PrintCore.typeScheme scheme)       in (Strings.concat2 (Strings.concat2 (Strings.concat2 "  " name) " : ") typeStr)  -- | Format a type binding for the lexicon@@ -175,7 +176,7 @@       in (Eithers.bind (Eithers.mapList (\b -> formatTypeBinding graph b) sortedTypes) (\typeLines ->         let termLines = Lists.map (\b -> formatTermBinding b) sortedTerms             primitiveLines = Lists.map (\p -> formatPrimitive p) sortedPrimitives-        in (Right (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "Primitives:\n" (Strings.unlines primitiveLines)) "\nTypes:\n") (Strings.unlines typeLines)) "\nTerms:\n") (Strings.unlines termLines)))))+        in (Right (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "Primitives:\n" (Formatting.unlines primitiveLines)) "\nTypes:\n") (Formatting.unlines typeLines)) "\nTerms:\n") (Formatting.unlines termLines)))))  -- | Pure core of code generation: given a coder, language, infer flag, bootstrap graph, universe, and modules to generate, produce a list of (filePath, content) pairs. Emission flags doExpand/doHoistCaseStatements/doHoistPolymorphicLetBindings are derived from the absence of the matching LanguageFeature in lang.supportedFeatures: a target that lacks partialApplication needs eta expansion (doExpand=true), and so on. generateSourceFiles :: Ord t0 => ((Packaging.Module -> [Packaging.Definition] -> Typing.InferenceContext -> Graph.Graph -> Either Errors.Error (M.Map t0 t1)) -> Coders.Language -> Bool -> Graph.Graph -> [Packaging.Module] -> [Packaging.Module] -> Typing.InferenceContext -> Either Errors.Error [(t0, t1)])@@ -588,7 +589,7 @@                   \pending -> \visited -> Logic.ifElse (Sets.null pending) visited (                     let newVisited = Sets.union visited pending                         nextDeps =-                                Sets.fromList (Lists.concat (Lists.map (\nsv -> Optionals.cases (Maps.lookup nsv nsMap) [] (\depMod -> getDeps depMod)) (Sets.toList pending)))+                                Sets.fromList (Lists.concat (Lists.map (\nsv -> Optionals.match (Maps.lookup nsv nsMap) [] (\depMod -> getDeps depMod)) (Sets.toList pending)))                         newPending = Sets.difference nextDeps newVisited                     in (go newPending newVisited))       in (go initialDeps Sets.empty)
src/main/haskell/Hydra/Coders.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Graph as Graph import qualified Hydra.Util as Util 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/Constants.hs view
@@ -33,8 +33,12 @@ 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++-- | The conventional field name used when normalizing a wrapped (newtype) value to a single-field record+fieldNameValue :: String+fieldNameValue = "value"  -- | The name used for ignored variables ignoredVariable :: String
src/main/haskell/Hydra/Core.hs view
@@ -4,7 +4,7 @@  module Hydra.Core where -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/Decode/Ast.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.ast.Associativity@@ -34,7 +34,7 @@                       (Core.Name "left", (\input -> Eithers.map (\t -> Ast.AssociativityLeft) (ExtractCore.decodeUnit cx input))),                       (Core.Name "right", (\input -> Eithers.map (\t -> Ast.AssociativityRight) (ExtractCore.decodeUnit cx input))),                       (Core.Name "both", (\input -> Eithers.map (\t -> Ast.AssociativityBoth) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -102,7 +102,7 @@                       (Core.Name "op", (\input -> Eithers.map (\t -> Ast.ExprOp t) (opExpr cx input))),                       (Core.Name "brackets", (\input -> Eithers.map (\t -> Ast.ExprBrackets t) (bracketExpr cx input))),                       (Core.Name "seq", (\input -> Eithers.map (\t -> Ast.ExprSeq t) (seqExpr cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -132,7 +132,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -241,7 +241,7 @@                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),                       (Core.Name "doubleBreak", (\input -> Eithers.map (\t -> Ast.WsDoubleBreak) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Coders.hs view
@@ -21,7 +21,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.coders.CaseConventions@@ -55,7 +55,7 @@                     Maps.fromList [                       (Core.Name "encode", (\input -> Eithers.map (\t -> Coders.CoderDirectionEncode) (ExtractCore.decodeUnit cx input))),                       (Core.Name "decode", (\input -> Eithers.map (\t -> Coders.CoderDirectionDecode) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -80,7 +80,7 @@                       (                         Core.Name "nestedPolymorphicLetBindings",                         (\input -> Eithers.map (\t -> Coders.LanguageFeatureNestedPolymorphicLetBindings) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -109,7 +109,7 @@                     Maps.fromList [                       (Core.Name "pre", (\input -> Eithers.map (\t -> Coders.TraversalOrderPre) (ExtractCore.decodeUnit cx input))),                       (Core.Name "post", (\input -> Eithers.map (\t -> Coders.TraversalOrderPost) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Core.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.core.AnnotatedTerm@@ -142,7 +142,7 @@                     Maps.fromList [                       (Core.Name "float32", (\input -> Eithers.map (\t -> Core.FloatTypeFloat32) (ExtractCore.decodeUnit cx input))),                       (Core.Name "float64", (\input -> Eithers.map (\t -> Core.FloatTypeFloat64) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -176,7 +176,7 @@                               _ -> Left (Errors.DecodingError "expected float64 value")                             _ -> Left (Errors.DecodingError "expected float64 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -234,7 +234,7 @@                       (Core.Name "uint16", (\input -> Eithers.map (\t -> Core.IntegerTypeUint16) (ExtractCore.decodeUnit cx input))),                       (Core.Name "uint32", (\input -> Eithers.map (\t -> Core.IntegerTypeUint32) (ExtractCore.decodeUnit cx input))),                       (Core.Name "uint64", (\input -> Eithers.map (\t -> Core.IntegerTypeUint64) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -331,7 +331,7 @@                               _ -> Left (Errors.DecodingError "expected uint64 value")                             _ -> Left (Errors.DecodingError "expected uint64 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -400,7 +400,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -422,7 +422,7 @@                       (Core.Name "float", (\input -> Eithers.map (\t -> Core.LiteralTypeFloat t) (floatType cx input))),                       (Core.Name "integer", (\input -> Eithers.map (\t -> Core.LiteralTypeInteger t) (integerType cx input))),                       (Core.Name "string", (\input -> Eithers.map (\t -> Core.LiteralTypeString) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -514,7 +514,7 @@                       (Core.Name "unwrap", (\input -> Eithers.map (\t -> Core.TermUnwrap t) (name cx input))),                       (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TermVariable t) (name cx input))),                       (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TermWrap t) (wrappedTerm cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -548,7 +548,7 @@                       (Core.Name "variable", (\input -> Eithers.map (\t -> Core.TypeVariable t) (name cx input))),                       (Core.Name "void", (\input -> Eithers.map (\t -> Core.TypeVoid) (ExtractCore.decodeUnit cx input))),                       (Core.Name "wrap", (\input -> Eithers.map (\t -> Core.TypeWrap t) (type_ cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -576,7 +576,7 @@             variantMap =                     Maps.fromList [                       (Core.Name "simple", (\input -> Eithers.map (\t -> Core.TypeClassConstraintSimple t) (name cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Docs.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.docs.DocSegment@@ -38,7 +38,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Error/Checking.hs view
@@ -20,7 +20,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.error.checking.CheckingError@@ -70,7 +70,7 @@                       (                         Core.Name "untypedTermVariable",                         (\input -> Eithers.map (\t -> Checking.CheckingErrorUntypedTermVariable t) (untypedTermVariableCheckingError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Error/Core.hs view
@@ -19,7 +19,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.error.core.ConstantConditionError@@ -210,7 +210,7 @@                       (                         Core.Name "typeMismatch",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidLiteralErrorTypeMismatch t) (literalTypeMismatchError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -316,7 +316,7 @@                       (                         Core.Name "untypedTermVariable",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTermErrorUntypedTermVariable t) (untypedTermVariableError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -374,7 +374,7 @@                       (                         Core.Name "voidInNonBottomPosition",                         (\input -> Eithers.map (\t -> ErrorCore.InvalidTypeErrorVoidInNonBottomPosition t) (voidInNonBottomPositionError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Error/File.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.error.file.FileError@@ -51,7 +51,7 @@                       (                         Core.Name "permissionDenied",                         (\input -> Eithers.map (\t -> ErrorFile.FileErrorPermissionDenied t) (DecodeFile.filePath cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Error/Packaging.hs view
@@ -19,7 +19,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.error.packaging.ConflictingModuleNameError@@ -133,7 +133,7 @@                       (                         Core.Name "missingDocumentation",                         (\input -> Eithers.map (\t -> ErrorPackaging.InvalidModuleErrorMissingDocumentation t) (missingDocumentationError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -174,7 +174,7 @@                       (                         Core.Name "undeclaredDependency",                         (\input -> Eithers.map (\t -> ErrorPackaging.InvalidPackageErrorUndeclaredDependency t) (undeclaredDependencyError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Error/System.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.error.system.SystemError@@ -47,7 +47,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Errors.hs view
@@ -21,7 +21,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.errors.DecodingError@@ -80,7 +80,7 @@                         Core.Name "unexpectedTypeVariant",                         (\input -> Eithers.map (\t -> Errors.ErrorUnexpectedTypeVariant t) (ErrorCore.unexpectedTypeVariantError cx input))),                       (Core.Name "unification", (\input -> Eithers.map (\t -> Errors.ErrorUnification t) (unificationError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -115,7 +115,7 @@                       (                         Core.Name "unexpectedShape",                         (\input -> Eithers.map (\t -> Errors.ExtractionErrorUnexpectedShape t) (unexpectedShapeError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -136,7 +136,7 @@                       (                         Core.Name "unification",                         (\input -> Eithers.map (\t -> Errors.InferenceErrorUnification t) (unificationInferenceError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -256,7 +256,7 @@                       (                         Core.Name "unexpectedShape",                         (\input -> Eithers.map (\t -> Errors.ResolutionErrorUnexpectedShape t) (unexpectedShapeError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/File.hs view
@@ -18,7 +18,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.file.FileExtension@@ -80,7 +80,7 @@                       (Core.Name "regular", (\input -> Eithers.map (\t -> File.FileTypeRegular) (ExtractCore.decodeUnit cx input))),                       (Core.Name "link", (\input -> Eithers.map (\t -> File.FileTypeLink) (ExtractCore.decodeUnit cx input))),                       (Core.Name "socket", (\input -> Eithers.map (\t -> File.FileTypeSocket) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Json/Model.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.json.model.Value@@ -60,7 +60,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Packaging.hs view
@@ -18,7 +18,7 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.packaging.Definition@@ -34,7 +34,7 @@                       (Core.Name "primitive", (\input -> Eithers.map (\t -> Packaging.DefinitionPrimitive t) (primitiveDefinition cx input))),                       (Core.Name "term", (\input -> Eithers.map (\t -> Packaging.DefinitionTerm t) (termDefinition cx input))),                       (Core.Name "type", (\input -> Eithers.map (\t -> Packaging.DefinitionType t) (typeDefinition cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -55,7 +55,7 @@                         (\input -> Eithers.map (\t -> Packaging.DefinitionReferencePrimitive t) (DecodeCore.name cx input))),                       (Core.Name "term", (\input -> Eithers.map (\t -> Packaging.DefinitionReferenceTerm t) (DecodeCore.name cx input))),                       (Core.Name "type", (\input -> Eithers.map (\t -> Packaging.DefinitionReferenceType t) (DecodeCore.name cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -75,7 +75,7 @@                       (Core.Name "runtime", (\input -> Eithers.map (\t -> Packaging.DependencyScopeRuntime) (ExtractCore.decodeUnit cx input))),                       (Core.Name "test", (\input -> Eithers.map (\t -> Packaging.DependencyScopeTest) (ExtractCore.decodeUnit cx input))),                       (Core.Name "tool", (\input -> Eithers.map (\t -> Packaging.DependencyScopeTool) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -131,7 +131,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -303,7 +303,7 @@                       (Core.Name "exact", (\input -> Eithers.map (\t -> Packaging.VersionSpecifierExact t) (version cx input))),                       (Core.Name "atLeast", (\input -> Eithers.map (\t -> Packaging.VersionSpecifierAtLeast t) (version cx input))),                       (Core.Name "range", (\input -> Eithers.map (\t -> Packaging.VersionSpecifierRange t) (versionRange cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Parsing.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Parsing as Parsing import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.parsing.ParseError@@ -30,11 +30,13 @@           Core.TermLiteral v1 -> case v1 of             Core.LiteralString v2 -> Right v2             _ -> Left (Errors.DecodingError "expected string literal")-          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_message -> Eithers.bind (ExtractCore.requireField "remainder" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_message -> Eithers.bind (ExtractCore.requireField "remainder" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of           Core.TermLiteral v1 -> case v1 of-            Core.LiteralString v2 -> Right v2-            _ -> Left (Errors.DecodingError "expected string literal")-          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseError {+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_remainder -> Right (Parsing.ParseError {           Parsing.parseErrorMessage = field_message,           Parsing.parseErrorRemainder = field_remainder}))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.parsing.ParseError")) (ExtractCore.stripWithDecodingError cx raw)@@ -51,7 +53,7 @@                     Maps.fromList [                       (Core.Name "success", (\input -> Eithers.map (\t -> Parsing.ParseResultSuccess t) (parseSuccess a cx input))),                       (Core.Name "failure", (\input -> Eithers.map (\t -> Parsing.ParseResultFailure t) (parseError cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -63,11 +65,13 @@     Eithers.either (\err -> Left err) (\stripped -> case stripped of       Core.TermRecord v0 ->         let fieldMap = ExtractCore.toFieldMap v0-        in (Eithers.bind (ExtractCore.requireField "value" a fieldMap cx) (\field_value -> Eithers.bind (ExtractCore.requireField "remainder" (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of+        in (Eithers.bind (ExtractCore.requireField "value" a fieldMap cx) (\field_value -> Eithers.bind (ExtractCore.requireField "remainder" (ExtractCore.decodeList (\cx2 -> \raw2 -> Eithers.either (\err -> Left err) (\stripped2 -> case stripped2 of           Core.TermLiteral v1 -> case v1 of-            Core.LiteralString v2 -> Right v2-            _ -> Left (Errors.DecodingError "expected string literal")-          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2)) fieldMap cx) (\field_remainder -> Right (Parsing.ParseSuccess {+            Core.LiteralInteger v2 -> case v2 of+              Core.IntegerValueInt32 v3 -> Right v3+              _ -> Left (Errors.DecodingError "expected int32 value")+            _ -> Left (Errors.DecodingError "expected int32 literal")+          _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx2 raw2))) fieldMap cx) (\field_remainder -> Right (Parsing.ParseSuccess {           Parsing.parseSuccessValue = field_value,           Parsing.parseSuccessRemainder = field_remainder}))))       _ -> Left (Errors.DecodingError "expected a record of type hydra.parsing.ParseSuccess")) (ExtractCore.stripWithDecodingError cx raw)
src/main/haskell/Hydra/Decode/Paths.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.paths.SubtermEdge@@ -158,7 +158,7 @@                         Core.Name "injectionTerm",                         (\input -> Eithers.map (\t -> Paths.SubtermStepInjectionTerm) (ExtractCore.decodeUnit cx input))),                       (Core.Name "wrappedTerm", (\input -> Eithers.map (\t -> Paths.SubtermStepWrappedTerm) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -254,7 +254,7 @@                       (Core.Name "setElement", (\input -> Eithers.map (\t -> Paths.SubtypeStepSetElement) (ExtractCore.decodeUnit cx input))),                       (Core.Name "unionField", (\input -> Eithers.map (\t -> Paths.SubtypeStepUnionField t) (DecodeCore.name cx input))),                       (Core.Name "wrappedType", (\input -> Eithers.map (\t -> Paths.SubtypeStepWrappedType) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Query.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Query as Query import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.query.ComparisonConstraint@@ -46,7 +46,7 @@                       (                         Core.Name "greaterThanOrEqual",                         (\input -> Eithers.map (\t -> Query.ComparisonConstraintGreaterThanOrEqual) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -88,7 +88,7 @@                       (Core.Name "term", (\input -> Eithers.map (\t -> Query.NodeTerm t) (DecodeCore.term cx input))),                       (Core.Name "variable", (\input -> Eithers.map (\t -> Query.NodeVariable t) (variable cx input))),                       (Core.Name "wildcard", (\input -> Eithers.map (\t -> Query.NodeWildcard) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -107,7 +107,7 @@                       (Core.Name "step", (\input -> Eithers.map (\t -> Query.PathStep t) (step cx input))),                       (Core.Name "regex", (\input -> Eithers.map (\t -> Query.PathRegex t) (regexSequence cx input))),                       (Core.Name "inverse", (\input -> Eithers.map (\t -> Query.PathInverse t) (path cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -143,7 +143,7 @@                         Core.Name "disjunction",                         (\input -> Eithers.map (\t -> Query.PatternDisjunction t) (ExtractCore.decodeList pattern cx input))),                       (Core.Name "graph", (\input -> Eithers.map (\t -> Query.PatternGraph t) (graphPattern cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -229,7 +229,7 @@                             _ -> Left (Errors.DecodingError "expected int32 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),                       (Core.Name "range", (\input -> Eithers.map (\t -> Query.RegexQuantifierRange t) (range cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -259,7 +259,7 @@                       (Core.Name "edge", (\input -> Eithers.map (\t -> Query.StepEdge t) (edge cx input))),                       (Core.Name "project", (\input -> Eithers.map (\t -> Query.StepProject t) (DecodeCore.projection cx input))),                       (Core.Name "compare", (\input -> Eithers.map (\t -> Query.StepCompare t) (comparisonConstraint cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Regex.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Regex as Regex import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.regex.Alternation@@ -48,7 +48,7 @@                       (Core.Name "anchorEnd", (\input -> Eithers.map (\t -> Regex.AtomAnchorEnd) (ExtractCore.decodeUnit cx input))),                       (Core.Name "group", (\input -> Eithers.map (\t -> Regex.AtomGroup t) (alternation cx input))),                       (Core.Name "class", (\input -> Eithers.map (\t -> Regex.AtomClass t) (characterClass cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -112,7 +112,7 @@                             _ -> Left (Errors.DecodingError "expected int32 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),                       (Core.Name "range", (\input -> Eithers.map (\t -> Regex.ClassItemRange t) (characterRange cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -162,7 +162,7 @@                             _ -> Left (Errors.DecodingError "expected int32 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input)))),                       (Core.Name "range", (\input -> Eithers.map (\t -> Regex.QuantifierRange_ t) (quantifierRange cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Relational.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Relational as Relational import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.relational.ColumnName
src/main/haskell/Hydra/Decode/System.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.System as System 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  -- | Decoder for hydra.system.Command
src/main/haskell/Hydra/Decode/Tabular.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Tabular as Tabular 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  -- | Decoder for hydra.tabular.ColumnType
src/main/haskell/Hydra/Decode/Testing.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Testing as Testing 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  -- | Decoder for hydra.testing.Tag
src/main/haskell/Hydra/Decode/Time.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Time as Time 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  -- | Decoder for hydra.time.Timespec
src/main/haskell/Hydra/Decode/Topology.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Topology as Topology 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/Decode/Typed.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Typed as Typed 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  -- | Decoder for hydra.typed.TypedBinding
src/main/haskell/Hydra/Decode/Typing.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Typing as Typing 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  -- | Decoder for hydra.typing.FunctionStructure
src/main/haskell/Hydra/Decode/Util.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Rewriting as Rewriting 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  -- | Decoder for hydra.util.CaseConvention@@ -34,7 +34,7 @@                       (Core.Name "pascal", (\input -> Eithers.map (\t -> Util.CaseConventionPascal) (ExtractCore.decodeUnit cx input))),                       (Core.Name "lowerSnake", (\input -> Eithers.map (\t -> Util.CaseConventionLowerSnake) (ExtractCore.decodeUnit cx input))),                       (Core.Name "upperSnake", (\input -> Eithers.map (\t -> Util.CaseConventionUpperSnake) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -53,7 +53,7 @@                       (Core.Name "lessThan", (\input -> Eithers.map (\t -> Util.ComparisonLessThan) (ExtractCore.decodeUnit cx input))),                       (Core.Name "equalTo", (\input -> Eithers.map (\t -> Util.ComparisonEqualTo) (ExtractCore.decodeUnit cx input))),                       (Core.Name "greaterThan", (\input -> Eithers.map (\t -> Util.ComparisonGreaterThan) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -90,7 +90,7 @@                               _ -> Left (Errors.DecodingError "expected int32 value")                             _ -> Left (Errors.DecodingError "expected int32 literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Validation.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Util as Util import qualified Hydra.Validation as Validation-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  -- | Decoder for hydra.validation.ValidationProfile
src/main/haskell/Hydra/Decode/Variants.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Util as Util 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  -- | Decoder for hydra.variants.LiteralVariant@@ -36,7 +36,7 @@                       (Core.Name "float", (\input -> Eithers.map (\t -> Variants.LiteralVariantFloat) (ExtractCore.decodeUnit cx input))),                       (Core.Name "integer", (\input -> Eithers.map (\t -> Variants.LiteralVariantInteger) (ExtractCore.decodeUnit cx input))),                       (Core.Name "string", (\input -> Eithers.map (\t -> Variants.LiteralVariantString) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -77,7 +77,7 @@                       (Core.Name "unwrap", (\input -> Eithers.map (\t -> Variants.TermVariantUnwrap) (ExtractCore.decodeUnit cx input))),                       (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TermVariantVariable) (ExtractCore.decodeUnit cx input))),                       (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TermVariantWrap) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -113,7 +113,7 @@                       (Core.Name "variable", (\input -> Eithers.map (\t -> Variants.TypeVariantVariable) (ExtractCore.decodeUnit cx input))),                       (Core.Name "void", (\input -> Eithers.map (\t -> Variants.TypeVariantVoid) (ExtractCore.decodeUnit cx input))),                       (Core.Name "wrap", (\input -> Eithers.map (\t -> Variants.TypeVariantWrap) (ExtractCore.decodeUnit cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decode/Yaml/Model.hs view
@@ -17,7 +17,7 @@ import qualified Hydra.Rewriting as Rewriting import qualified Hydra.Util as Util import qualified Hydra.Yaml.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  -- | Decoder for hydra.yaml.model.Node@@ -33,7 +33,7 @@                       (Core.Name "mapping", (\input -> Eithers.map (\t -> Model.NodeMapping t) (ExtractCore.decodeMap node node cx input))),                       (Core.Name "scalar", (\input -> Eithers.map (\t -> Model.NodeScalar t) (scalar cx input))),                       (Core.Name "sequence", (\input -> Eithers.map (\t -> Model.NodeSequence t) (ExtractCore.decodeList node cx input)))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))@@ -89,7 +89,7 @@                             Core.LiteralString v2 -> Right v2                             _ -> Left (Errors.DecodingError "expected string literal")                           _ -> Left (Errors.DecodingError "expected literal")) (ExtractCore.stripWithDecodingError cx input))))]-        in (Optionals.cases (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [+        in (Optionals.match (Maps.lookup fname variantMap) (Left (Errors.DecodingError (Strings.concat [           "no such field ",           (Core.unName fname),           " in union"]))) (\f -> f fterm))
src/main/haskell/Hydra/Decoding.hs view
@@ -51,7 +51,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  -- | Collect forall type variable names from a type@@ -1939,7 +1939,7 @@                                 Core.applicationFunction = (Core.TermApplication (Core.Application {                                   Core.applicationFunction = (Core.TermTypeApplication (Core.TypeApplicationTerm {                                     Core.typeApplicationTermBody = (Core.TermTypeApplication (Core.TypeApplicationTerm {-                                      Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                                      Core.typeApplicationTermBody = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                                       Core.typeApplicationTermType = variantFnType})),                                     Core.typeApplicationTermType = (Core.TypeEither (Core.EitherType {                                       Core.eitherTypeLeft = decErrType,
src/main/haskell/Hydra/Dependencies.hs view
@@ -53,7 +53,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@@ -154,7 +154,7 @@               \recurse -> \typ2 ->                 let afterRecurse =                         \tr -> case tr of-                          Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 schema) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "No such type in schema: " (Core.unName v0))))) (inlineType schema)+                          Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 schema) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "No such type in schema: " (Core.unName v0))))) (inlineType schema)                           _ -> Right tr                 in (Eithers.bind (recurse typ2) (\tr -> afterRecurse tr))       in (Rewriting.rewriteTypeM f typ)@@ -235,7 +235,7 @@                               \ts ->                                 let t = Core.typeSchemeBody ts                                 in (Logic.ifElse (Lists.null (Core.typeSchemeVariables ts)) (forMono t) typ)-                  in (Optionals.cases (Maps.lookup v0 types) typ (\ts -> forTypeScheme ts))+                  in (Optionals.match (Maps.lookup v0 types) typ (\ts -> forTypeScheme ts))                 Core.TypeWrap _ -> typ                 _ -> recurse typ       in (Rewriting.rewriteType rewrite typ0)
src/main/haskell/Hydra/Differentiation.hs view
@@ -40,7 +40,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  -- | Differentiate a binary primitive application given both arguments and their derivatives@@ -202,7 +202,7 @@         let func = Core.applicationFunction v0             arg = Core.applicationArgument v0         in case func of-          Core.TermVariable v1 -> Optionals.cases (primitiveDerivative v1) (differentiateTerm dx (Core.TermApplication (Core.Application {+          Core.TermVariable v1 -> Optionals.match (primitiveDerivative v1) (differentiateTerm dx (Core.TermApplication (Core.Application {             Core.applicationFunction = func,             Core.applicationArgument = arg}))) (\derivTerm -> Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {
src/main/haskell/Hydra/Docs.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core 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  -- | A segment of a documentation string, either a raw text fragment or an inline entity reference. Documentation strings are parsed into a sequence of DocSegments for host-specific rendering.
src/main/haskell/Hydra/Dsl/Analysis.hs view
@@ -87,7 +87,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.Set as S
src/main/haskell/Hydra/Dsl/Annotations.hs view
@@ -73,7 +73,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 import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Arity.hs view
@@ -62,7 +62,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  -- | DSL reference to hydra.arity.primitiveArity
src/main/haskell/Hydra/Dsl/Ast.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Encode.Ast as EncodeAst import qualified Hydra.Typed as Typed-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  -- | DSL name token for hydra.ast.Associativity
src/main/haskell/Hydra/Dsl/Checking.hs view
@@ -88,7 +88,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/Dsl/Coders.hs view
@@ -20,7 +20,7 @@ import qualified Hydra.Typed as Typed import qualified Hydra.Util as Util 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/Dsl/Constants.hs view
@@ -62,8 +62,12 @@ 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++-- | DSL reference to hydra.constants.fieldNameValue+fieldNameValue :: Typed.TypedTerm String+fieldNameValue = Typed.TypedTerm (Core.TermVariable (Core.Name "hydra.constants.fieldNameValue"))  -- | DSL reference to hydra.constants.ignoredVariable ignoredVariable :: Typed.TypedTerm String
src/main/haskell/Hydra/Dsl/Core.hs view
@@ -8,7 +8,7 @@ import qualified Hydra.Decode.Core as DecodeCore import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Typed as Typed-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/Dsl/Dependencies.hs view
@@ -78,7 +78,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/Dsl/Docs.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Encode.Docs as EncodeDocs import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed-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  -- | DSL name token for hydra.docs.DocSegment
src/main/haskell/Hydra/Dsl/Environment.hs view
@@ -74,7 +74,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
src/main/haskell/Hydra/Dsl/Error/Checking.hs view
@@ -16,7 +16,7 @@ import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing 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/Dsl/Error/Core.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed 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  -- | DSL constructor for hydra.error.core.ConstantConditionError
src/main/haskell/Hydra/Dsl/Error/File.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Error.File as ErrorFile import qualified Hydra.File as File import qualified Hydra.Typed as Typed-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  -- | DSL injection for the alreadyExists variant of hydra.error.file.FileError
src/main/haskell/Hydra/Dsl/Error/Packaging.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed 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  -- | DSL constructor for hydra.error.packaging.ConflictingModuleNameError
src/main/haskell/Hydra/Dsl/Error/System.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Error.System as System import qualified Hydra.File as File import qualified Hydra.Typed as Typed-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  -- | DSL injection for the commandNotFound variant of hydra.error.system.SystemError
src/main/haskell/Hydra/Dsl/Errors.hs view
@@ -20,7 +20,7 @@ import qualified Hydra.Typed as Typed import qualified Hydra.Typing as Typing 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  -- | DSL constructor for the hydra.errors.DecodingError wrapper
src/main/haskell/Hydra/Dsl/Extract/Json.hs view
@@ -64,7 +64,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
src/main/haskell/Hydra/Dsl/File.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.File as File import qualified Hydra.Time as Time import qualified Hydra.Typed as Typed-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/Dsl/Formatting.hs view
@@ -62,7 +62,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 @@ -142,6 +142,13 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.javaStyleComment")),       Core.applicationArgument = (Typed.unTypedTerm arg0)})) +-- | DSL reference to hydra.formatting.lines+lines :: Typed.TypedTerm String -> Typed.TypedTerm [String]+lines arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.lines")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))+ -- | DSL reference to hydra.formatting.mapFirstLetter mapFirstLetter :: Typed.TypedTerm (String -> String) -> Typed.TypedTerm String -> Typed.TypedTerm String mapFirstLetter arg0 arg1 =@@ -188,6 +195,13 @@ stripLeadingAndTrailingWhitespace arg0 =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.stripLeadingAndTrailingWhitespace")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.formatting.unlines+unlines :: Typed.TypedTerm [String] -> Typed.TypedTerm String+unlines arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.formatting.unlines")),       Core.applicationArgument = (Typed.unTypedTerm arg0)}))  -- | DSL reference to hydra.formatting.withCharacterAliases
src/main/haskell/Hydra/Dsl/Graph.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed 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 import qualified Data.Map as M import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Json/Bootstrap.hs view
@@ -28,7 +28,7 @@ import qualified Hydra.Typing as Typing import qualified Hydra.Util as Util 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
src/main/haskell/Hydra/Dsl/Json/Decode.hs view
@@ -70,7 +70,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
src/main/haskell/Hydra/Dsl/Json/Decoding.hs view
@@ -62,7 +62,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
src/main/haskell/Hydra/Dsl/Json/Encode.hs view
@@ -70,7 +70,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
src/main/haskell/Hydra/Dsl/Json/Model.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Json.Model as EncodeJsonModel import qualified Hydra.Json.Model as Model import qualified Hydra.Typed as Typed-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  -- | DSL injection for the array variant of hydra.json.model.Value
src/main/haskell/Hydra/Dsl/Json/Parser.hs view
@@ -63,7 +63,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  -- | DSL reference to hydra.json.parser.digit
src/main/haskell/Hydra/Dsl/Json/Writer.hs view
@@ -64,7 +64,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  -- | DSL reference to hydra.json.writer.colonOp
src/main/haskell/Hydra/Dsl/Json/Yaml/Decode.hs view
@@ -66,7 +66,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 import qualified Data.Map as M
src/main/haskell/Hydra/Dsl/Json/Yaml/Encode.hs view
@@ -66,7 +66,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 import qualified Data.Map as M
src/main/haskell/Hydra/Dsl/Lexical.hs view
@@ -68,7 +68,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 import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Lib/Chars.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.chars.isAlpha
src/main/haskell/Hydra/Dsl/Lib/Defaults.hs view
@@ -8,6 +8,7 @@ import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Lib.Eithers as Eithers import qualified Hydra.Dsl.Lib.Equality as Equality+import qualified Hydra.Dsl.Lib.Functions as Functions import qualified Hydra.Dsl.Lib.Lists as Lists import qualified Hydra.Dsl.Lib.Logic as Logic import qualified Hydra.Dsl.Lib.Maps as Maps@@ -17,7 +18,7 @@ import qualified Hydra.Dsl.Lib.Sets as Sets import qualified Hydra.Lib.Defaults as Defaults import qualified Hydra.Typed as Typed-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/Dsl/Lib/Effects.hs view
@@ -61,7 +61,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/Dsl/Lib/Eithers.hs view
@@ -61,7 +61,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/Dsl/Lib/Equality.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.equality.equal
src/main/haskell/Hydra/Dsl/Lib/Files.hs view
@@ -61,7 +61,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.ByteString as B @@ -94,6 +94,15 @@         Core.applicationArgument = (Typed.unTypedTerm recursive)})),       Core.applicationArgument = (Typed.unTypedTerm path)})) +-- | DSL reference to hydra.lib.files.createSymlink+createSymlink :: Typed.TypedTerm File.FilePath -> Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError ()))+createSymlink target link =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.files.createSymlink")),+        Core.applicationArgument = (Typed.unTypedTerm target)})),+      Core.applicationArgument = (Typed.unTypedTerm link)}))+ -- | DSL reference to hydra.lib.files.exists exists :: Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError Bool)) exists path =@@ -115,6 +124,13 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.files.readFile")),       Core.applicationArgument = (Typed.unTypedTerm path)})) +-- | DSL reference to hydra.lib.files.readSymlink+readSymlink :: Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError File.FilePath))+readSymlink path =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.files.readSymlink")),+      Core.applicationArgument = (Typed.unTypedTerm path)}))+ -- | DSL reference to hydra.lib.files.removeDirectory removeDirectory :: Typed.TypedTerm Bool -> Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError ())) removeDirectory recursive path =@@ -141,10 +157,12 @@       Core.applicationArgument = (Typed.unTypedTerm destination)}))  -- | DSL reference to hydra.lib.files.status-status :: Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError File.FileStatus))-status path =+status :: Typed.TypedTerm Bool -> Typed.TypedTerm File.FilePath -> Typed.TypedTerm (IO (Either ErrorFile.FileError File.FileStatus))+status followLinks path =     Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.files.status")),+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.files.status")),+        Core.applicationArgument = (Typed.unTypedTerm followLinks)})),       Core.applicationArgument = (Typed.unTypedTerm path)}))  -- | DSL reference to hydra.lib.files.writeFile
src/main/haskell/Hydra/Dsl/Lib/Functions.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.functions.compose
src/main/haskell/Hydra/Dsl/Lib/Lists.hs view
@@ -61,7 +61,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/Dsl/Lib/Literals.hs view
@@ -61,7 +61,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.ByteString as B import qualified Data.Int as I
src/main/haskell/Hydra/Dsl/Lib/Logic.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.logic.and
src/main/haskell/Hydra/Dsl/Lib/Maps.hs view
@@ -61,7 +61,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
src/main/haskell/Hydra/Dsl/Lib/Math.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.math.abs
src/main/haskell/Hydra/Dsl/Lib/Optionals.hs view
@@ -61,7 +61,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 @@ -83,17 +83,6 @@         Core.applicationArgument = (Typed.unTypedTerm m)})),       Core.applicationArgument = (Typed.unTypedTerm f)})) --- | DSL reference to hydra.lib.optionals.cases-cases :: Typed.TypedTerm (Maybe x) -> Typed.TypedTerm y -> Typed.TypedTerm (x -> y) -> Typed.TypedTerm y-cases m def f =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermApplication (Core.Application {-        Core.applicationFunction = (Core.TermApplication (Core.Application {-          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),-          Core.applicationArgument = (Typed.unTypedTerm m)})),-        Core.applicationArgument = (Typed.unTypedTerm def)})),-      Core.applicationArgument = (Typed.unTypedTerm f)}))- -- | DSL reference to hydra.lib.optionals.compose compose :: Typed.TypedTerm (x -> Maybe y) -> Typed.TypedTerm (y -> Maybe z) -> Typed.TypedTerm x -> Typed.TypedTerm (Maybe z) compose f g x =@@ -172,6 +161,17 @@         Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.mapSet")),         Core.applicationArgument = (Typed.unTypedTerm f)})),       Core.applicationArgument = (Typed.unTypedTerm s)}))++-- | DSL reference to hydra.lib.optionals.match+match :: Typed.TypedTerm (Maybe x) -> Typed.TypedTerm y -> Typed.TypedTerm (x -> y) -> Typed.TypedTerm y+match m def f =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermApplication (Core.Application {+          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),+          Core.applicationArgument = (Typed.unTypedTerm m)})),+        Core.applicationArgument = (Typed.unTypedTerm def)})),+      Core.applicationArgument = (Typed.unTypedTerm f)}))  -- | DSL reference to hydra.lib.optionals.pure pure :: Typed.TypedTerm x -> Typed.TypedTerm (Maybe x)
src/main/haskell/Hydra/Dsl/Lib/Ordering.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.ordering.compare
src/main/haskell/Hydra/Dsl/Lib/Pairs.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.pairs.bimap
src/main/haskell/Hydra/Dsl/Lib/Regex.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.regex.find
src/main/haskell/Hydra/Dsl/Lib/Sets.hs view
@@ -61,7 +61,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/Dsl/Lib/Strings.hs view
@@ -61,7 +61,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  -- | DSL reference to hydra.lib.strings.charAt@@ -112,13 +112,6 @@       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.length")),       Core.applicationArgument = (Typed.unTypedTerm s)})) --- | DSL reference to hydra.lib.strings.lines-lines :: Typed.TypedTerm String -> Typed.TypedTerm [String]-lines s =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.lines")),-      Core.applicationArgument = (Typed.unTypedTerm s)}))- -- | DSL reference to hydra.lib.strings.null null :: Typed.TypedTerm String -> Typed.TypedTerm Bool null s =@@ -155,10 +148,3 @@     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.toUpper")),       Core.applicationArgument = (Typed.unTypedTerm s)}))---- | DSL reference to hydra.lib.strings.unlines-unlines :: Typed.TypedTerm [String] -> Typed.TypedTerm String-unlines xs =-    Typed.TypedTerm (Core.TermApplication (Core.Application {-      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.strings.unlines")),-      Core.applicationArgument = (Typed.unTypedTerm xs)}))
src/main/haskell/Hydra/Dsl/Lib/System.hs view
@@ -61,7 +61,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.ByteString as B import qualified Data.Map as M
src/main/haskell/Hydra/Dsl/Lib/Text.hs view
@@ -61,7 +61,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.ByteString as B
src/main/haskell/Hydra/Dsl/Names.hs view
@@ -68,7 +68,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 import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Packaging.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed 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  -- | DSL name token for hydra.packaging.Definition
src/main/haskell/Hydra/Dsl/Parsing.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Graph as Graph import qualified Hydra.Parsing as Parsing import qualified Hydra.Typed as Typed-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  -- | DSL composition builder for the decoder of hydra.parsing.ParseResult@@ -58,7 +58,7 @@       Core.applicationArgument = (Typed.unTypedTerm a)}))  -- | DSL constructor for hydra.parsing.ParseError-parseError :: Typed.TypedTerm String -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError+parseError :: Typed.TypedTerm String -> Typed.TypedTerm [Int] -> Typed.TypedTerm Parsing.ParseError parseError message remainder =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),@@ -84,7 +84,7 @@ parseErrorParseError = Typed.TypedName (Core.Name "hydra.parsing.ParseError")  -- | DSL accessor for the remainder field of hydra.parsing.ParseError-parseErrorRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String+parseErrorRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm [Int] parseErrorRemainder x =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermProject (Core.Projection {@@ -110,7 +110,7 @@             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL updater for the remainder field of hydra.parsing.ParseError-parseErrorWithRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm String -> Typed.TypedTerm Parsing.ParseError+parseErrorWithRemainder :: Typed.TypedTerm Parsing.ParseError -> Typed.TypedTerm [Int] -> Typed.TypedTerm Parsing.ParseError parseErrorWithRemainder original newVal =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.parsing.ParseError"),@@ -149,7 +149,7 @@         Core.fieldTerm = (Typed.unTypedTerm x)}}))  -- | DSL constructor for hydra.parsing.ParseSuccess-parseSuccess :: Typed.TypedTerm a -> Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseSuccess a)+parseSuccess :: Typed.TypedTerm a -> Typed.TypedTerm [Int] -> Typed.TypedTerm (Parsing.ParseSuccess a) parseSuccess value remainder =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),@@ -166,7 +166,7 @@ parseSuccessParseSuccess = Typed.TypedName (Core.Name "hydra.parsing.ParseSuccess")  -- | DSL accessor for the remainder field of hydra.parsing.ParseSuccess-parseSuccessRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String+parseSuccessRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm [Int] parseSuccessRemainder x =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermProject (Core.Projection {@@ -184,7 +184,7 @@       Core.applicationArgument = (Typed.unTypedTerm x)}))  -- | DSL updater for the remainder field of hydra.parsing.ParseSuccess-parseSuccessWithRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm String -> Typed.TypedTerm (Parsing.ParseSuccess a)+parseSuccessWithRemainder :: Typed.TypedTerm (Parsing.ParseSuccess a) -> Typed.TypedTerm [Int] -> Typed.TypedTerm (Parsing.ParseSuccess a) parseSuccessWithRemainder original newVal =     Typed.TypedTerm (Core.TermRecord (Core.Record {       Core.recordTypeName = (Core.Name "hydra.parsing.ParseSuccess"),@@ -218,7 +218,7 @@             Core.applicationArgument = (Typed.unTypedTerm original)}))}]}))  -- | DSL constructor for the hydra.parsing.Parser wrapper-parser :: Typed.TypedTerm (String -> Parsing.ParseResult a) -> Typed.TypedTerm (Parsing.Parser a)+parser :: Typed.TypedTerm ([Int] -> Parsing.ParseResult a) -> Typed.TypedTerm (Parsing.Parser a) parser x =     Typed.TypedTerm (Core.TermWrap (Core.WrappedTerm {       Core.wrappedTermTypeName = (Core.Name "hydra.parsing.Parser"),@@ -229,7 +229,7 @@ parserParser = Typed.TypedName (Core.Name "hydra.parsing.Parser")  -- | DSL accessor for the body of hydra.parsing.Parser-unParser :: Typed.TypedTerm (Parsing.Parser a) -> Typed.TypedTerm (String -> Parsing.ParseResult a)+unParser :: Typed.TypedTerm (Parsing.Parser a) -> Typed.TypedTerm ([Int] -> Parsing.ParseResult a) unParser x =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermUnwrap (Core.Name "hydra.parsing.Parser")),
src/main/haskell/Hydra/Dsl/Paths.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Paths as EncodePaths import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed-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  -- | DSL constructor for hydra.paths.SubtermEdge
src/main/haskell/Hydra/Dsl/Predicates.hs view
@@ -76,7 +76,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
src/main/haskell/Hydra/Dsl/Print/Docs.hs view
@@ -63,7 +63,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  -- | DSL reference to hydra.print.docs.definitionReference
src/main/haskell/Hydra/Dsl/Query.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Query as EncodeQuery import qualified Hydra.Query as Query import qualified Hydra.Typed as Typed-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  -- | DSL name token for hydra.query.ComparisonConstraint
src/main/haskell/Hydra/Dsl/Reduction.hs view
@@ -85,7 +85,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  -- | DSL reference to hydra.reduction.alphaConvert
src/main/haskell/Hydra/Dsl/Refs.hs view
@@ -64,7 +64,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 import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Regex.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Regex as EncodeRegex import qualified Hydra.Regex as Regex import qualified Hydra.Typed as Typed-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  -- | DSL injection for the anchorEnd variant of hydra.regex.Atom
src/main/haskell/Hydra/Dsl/Relational.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Graph as Graph import qualified Hydra.Relational as Relational import qualified Hydra.Typed as Typed-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/Dsl/Resolution.hs view
@@ -74,7 +74,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
src/main/haskell/Hydra/Dsl/Rewriting.hs view
@@ -6,10 +6,12 @@  import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs import qualified Hydra.Dsl.Ast as DslAst import qualified Hydra.Dsl.Coders as DslCoders+import qualified Hydra.Dsl.Constants as DslConstants import qualified Hydra.Dsl.Core as DslCore import qualified Hydra.Dsl.Docs as DslDocs import qualified Hydra.Dsl.Error.Checking as ErrorChecking@@ -64,7 +66,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  -- | DSL reference to hydra.rewriting.applyInsideTypeLambdasAndAnnotations@@ -260,4 +262,20 @@ subtypes arg0 =     Typed.TypedTerm (Core.TermApplication (Core.Application {       Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.subtypes")),+      Core.applicationArgument = (Typed.unTypedTerm arg0)}))++-- | DSL reference to hydra.rewriting.wrapTermToRecord+wrapTermToRecord :: Typed.TypedTerm Core.Name -> Typed.TypedTerm Core.Term -> Typed.TypedTerm Core.Term+wrapTermToRecord arg0 arg1 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermApplication (Core.Application {+        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.wrapTermToRecord")),+        Core.applicationArgument = (Typed.unTypedTerm arg0)})),+      Core.applicationArgument = (Typed.unTypedTerm arg1)}))++-- | DSL reference to hydra.rewriting.wrapTypeToRecord+wrapTypeToRecord :: Typed.TypedTerm Core.Type -> Typed.TypedTerm Core.Type+wrapTypeToRecord arg0 =+    Typed.TypedTerm (Core.TermApplication (Core.Application {+      Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.rewriting.wrapTypeToRecord")),       Core.applicationArgument = (Typed.unTypedTerm arg0)}))
src/main/haskell/Hydra/Dsl/Scoping.hs view
@@ -62,7 +62,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  -- | DSL reference to hydra.scoping.extendGraphForLambda
src/main/haskell/Hydra/Dsl/Serialization.hs view
@@ -19,6 +19,7 @@ import qualified Hydra.Dsl.Error.System as DslErrorSystem import qualified Hydra.Dsl.Errors as DslErrors import qualified Hydra.Dsl.File as DslFile+import qualified Hydra.Dsl.Formatting as DslFormatting import qualified Hydra.Dsl.Graph as DslGraph import qualified Hydra.Dsl.Json.Model as JsonModel import qualified Hydra.Dsl.Packaging as DslPackaging@@ -43,6 +44,7 @@ import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model import qualified Hydra.Packaging as Packaging@@ -62,7 +64,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  -- | DSL reference to hydra.serialization.angleBraces
src/main/haskell/Hydra/Dsl/Sorting.hs view
@@ -64,7 +64,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 import qualified Data.Set as S
src/main/haskell/Hydra/Dsl/Strip.hs view
@@ -64,7 +64,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  -- | DSL reference to hydra.strip.deannotateAndDetypeTerm
src/main/haskell/Hydra/Dsl/System.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.File as File import qualified Hydra.System as System import qualified Hydra.Typed as Typed-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.Map as M
src/main/haskell/Hydra/Dsl/Tabular.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Relational as Relational import qualified Hydra.Tabular as Tabular import qualified Hydra.Typed as Typed-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  -- | DSL constructor for hydra.tabular.ColumnType
src/main/haskell/Hydra/Dsl/Test/Transform.hs view
@@ -66,7 +66,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  -- | DSL reference to hydra.test.transform.addGenerationPrefix
src/main/haskell/Hydra/Dsl/Test/Utils.hs view
@@ -66,7 +66,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  -- | DSL reference to hydra.test.utils.inferTerm
src/main/haskell/Hydra/Dsl/Testing.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Testing as EncodeTesting import qualified Hydra.Testing as Testing import qualified Hydra.Typed as Typed-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  -- | DSL constructor for hydra.testing.EffectfulTestCase
src/main/haskell/Hydra/Dsl/Time.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Time as EncodeTime import qualified Hydra.Time as Time import qualified Hydra.Typed as Typed-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/Dsl/Topology.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Graph as Graph import qualified Hydra.Topology as Topology import qualified Hydra.Typed as Typed-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/Dsl/Typing.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Typed as Typed 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 import qualified Data.Map as M
src/main/haskell/Hydra/Dsl/Util.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Packaging as Packaging import qualified Hydra.Typed as Typed 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/Dsl/Validation.hs view
@@ -14,7 +14,7 @@ import qualified Hydra.Graph as Graph import qualified Hydra.Typed as Typed import qualified Hydra.Validation as Validation-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/Dsl/Variables.hs view
@@ -66,7 +66,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/Dsl/Variants.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Variants as EncodeVariants import qualified Hydra.Typed as Typed 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  -- | DSL injection for the binary variant of hydra.variants.LiteralVariant
src/main/haskell/Hydra/Dsl/Yaml/Model.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Yaml.Model as EncodeYamlModel import qualified Hydra.Typed as Typed import qualified Hydra.Yaml.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/Dsls.hs view
@@ -51,7 +51,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  -- | Collect forall type variable names from a type@@ -611,7 +611,7 @@ generateRefBindings d =     case d of       Packaging.DefinitionType _ -> Right []-      Packaging.DefinitionTerm v0 -> Optionals.cases (Packaging.termDefinitionSignature v0) (Right []) (\sig -> Right [+      Packaging.DefinitionTerm v0 -> Optionals.match (Packaging.termDefinitionSignature v0) (Right []) (\sig -> Right [         generateSignatureRef (Packaging.termDefinitionName v0) sig])       Packaging.DefinitionPrimitive v0 -> Right [         generateSignatureRef (Packaging.primitiveDefinitionName v0) (Packaging.primitiveDefinitionSignature v0)]@@ -877,7 +877,7 @@ isDslEligibleBinding cx graph b =        let ns = Names.moduleNameOf (Core.bindingName b)-      in (Logic.ifElse (Equality.equal (Optionals.cases ns "" Packaging.unModuleName) "hydra.typed") (Right Nothing) (Right (Just b)))+      in (Logic.ifElse (Equality.equal (Optionals.match ns "" Packaging.unModuleName) "hydra.typed") (Right Nothing) (Right (Just b)))  -- | Build the nominal result type with type applications for forall variables nominalResultType :: Core.Name -> Core.Type -> Core.Type
src/main/haskell/Hydra/Encode/Ast.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals-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  -- | Encoder for hydra.ast.Associativity
src/main/haskell/Hydra/Encode/Coders.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Encode.File as File import qualified Hydra.Encode.Util as Util import qualified Hydra.Encode.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  -- | Encoder for hydra.coders.CaseConventions
src/main/haskell/Hydra/Encode/Core.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets-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  -- | Encoder for hydra.core.AnnotatedTerm
src/main/haskell/Hydra/Encode/Docs.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs import qualified Hydra.Encode.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  -- | Encoder for hydra.docs.DocSegment
src/main/haskell/Hydra/Encode/Error/Checking.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Error.Checking as Checking import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets-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  -- | Encoder for hydra.error.checking.CheckingError
src/main/haskell/Hydra/Encode/Error/Core.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Encode.Variants as Variants import qualified Hydra.Error.Core as ErrorCore import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists-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  -- | Encoder for hydra.error.core.ConstantConditionError
src/main/haskell/Hydra/Encode/Error/File.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.File as EncodeFile import qualified Hydra.Error.File as ErrorFile-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  -- | Encoder for hydra.error.file.FileError
src/main/haskell/Hydra/Encode/Error/Packaging.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Encode.Packaging as EncodePackaging import qualified Hydra.Encode.Util as Util import qualified Hydra.Error.Packaging as ErrorPackaging-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  -- | Encoder for hydra.error.packaging.ConflictingModuleNameError
src/main/haskell/Hydra/Encode/Error/System.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.File as File import qualified Hydra.Error.System as System-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  -- | Encoder for hydra.error.system.SystemError
src/main/haskell/Hydra/Encode/Errors.hs view
@@ -12,7 +12,7 @@ import qualified Hydra.Encode.Typing as Typing import qualified Hydra.Encode.Variants as Variants import qualified Hydra.Errors as Errors-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  -- | Encoder for hydra.errors.DecodingError
src/main/haskell/Hydra/Encode/File.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Encode.Time as Time import qualified Hydra.File as File import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals-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  -- | Encoder for hydra.file.FileExtension
src/main/haskell/Hydra/Encode/Json/Model.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Json.Model as Model import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs-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  -- | Encoder for hydra.json.model.Value
src/main/haskell/Hydra/Encode/Packaging.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals 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  -- | Encoder for hydra.packaging.Definition
src/main/haskell/Hydra/Encode/Parsing.hs view
@@ -6,8 +6,9 @@  import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore+import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Parsing as Parsing-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  -- | Encoder for hydra.parsing.ParseError@@ -21,7 +22,7 @@           Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseErrorMessage x))},         Core.Field {           Core.fieldName = (Core.Name "remainder"),-          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseErrorRemainder x))}]})+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) xs)) (Parsing.parseErrorRemainder x))}]})  -- | Encoder for hydra.parsing.ParseResult parseResult :: (a -> Core.Term) -> Parsing.ParseResult a -> Core.Term@@ -49,4 +50,4 @@           Core.fieldTerm = (a (Parsing.parseSuccessValue x))},         Core.Field {           Core.fieldName = (Core.Name "remainder"),-          Core.fieldTerm = ((\x2 -> Core.TermLiteral (Core.LiteralString x2)) (Parsing.parseSuccessRemainder x))}]})+          Core.fieldTerm = ((\xs -> Core.TermList (Lists.map (\x2 -> Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt32 x2))) xs)) (Parsing.parseSuccessRemainder x))}]})
src/main/haskell/Hydra/Encode/Paths.hs view
@@ -8,7 +8,7 @@ import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Paths as Paths-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  -- | Encoder for hydra.paths.SubtermEdge
src/main/haskell/Hydra/Encode/Query.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals import qualified Hydra.Query as Query-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  -- | Encoder for hydra.query.ComparisonConstraint
src/main/haskell/Hydra/Encode/Regex.hs view
@@ -8,7 +8,7 @@ import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Regex as Regex-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  -- | Encoder for hydra.regex.Alternation
src/main/haskell/Hydra/Encode/Relational.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Relational as Relational-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  -- | Encoder for hydra.relational.ColumnName
src/main/haskell/Hydra/Encode/System.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals import qualified Hydra.System as System-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  -- | Encoder for hydra.system.Command
src/main/haskell/Hydra/Encode/Tabular.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals import qualified Hydra.Tabular as Tabular-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  -- | Encoder for hydra.tabular.ColumnType
src/main/haskell/Hydra/Encode/Testing.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Testing as Testing-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  -- | Encoder for hydra.testing.Tag
src/main/haskell/Hydra/Encode/Time.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Time as Time-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  -- | Encoder for hydra.time.Timespec
src/main/haskell/Hydra/Encode/Topology.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Topology as Topology-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/Encode/Typed.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore import qualified Hydra.Typed as Typed-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  -- | Encoder for hydra.typed.TypedBinding
src/main/haskell/Hydra/Encode/Typing.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals 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  -- | Encoder for hydra.typing.FunctionStructure
src/main/haskell/Hydra/Encode/Util.hs view
@@ -11,7 +11,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs 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  -- | Encoder for hydra.util.CaseConvention
src/main/haskell/Hydra/Encode/Validation.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Sets as Sets import qualified Hydra.Validation as Validation-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  -- | Encoder for hydra.validation.ValidationProfile
src/main/haskell/Hydra/Encode/Variants.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Encode.Core as EncodeCore 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  -- | Encoder for hydra.variants.LiteralVariant
src/main/haskell/Hydra/Encode/Yaml/Model.hs view
@@ -9,7 +9,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Maps as Maps import qualified Hydra.Yaml.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  -- | Encoder for hydra.yaml.model.Node
src/main/haskell/Hydra/Encoding.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  -- | Transform a type binding into an encoder binding
src/main/haskell/Hydra/Environment.hs view
@@ -48,14 +48,14 @@ 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  -- | Convert a definition to a typed term definitionAsTypeApplicationTerm :: Core.Binding -> Either Errors.Error Core.TypeApplicationTerm definitionAsTypeApplicationTerm el =-    Optionals.cases (Core.bindingTypeScheme el) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+    Optionals.match (Core.bindingTypeScheme el) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {       Errors.unexpectedShapeErrorExpected = "typed binding",       Errors.unexpectedShapeErrorActual = "untyped binding"})))) (\ts -> Right (Core.TypeApplicationTerm {       Core.typeApplicationTermBody = (Core.bindingTerm el),@@ -139,7 +139,7 @@                               Core.TermRecord v0 -> Logic.ifElse (Equality.equal (Core.recordTypeName v0) (Core.Name "hydra.core.TypeScheme")) (Eithers.map Optionals.pure (decodeTypeScheme (Core.bindingTerm el))) (Right Nothing)                               Core.TermInject v0 -> Logic.ifElse (Equality.equal (Core.injectionTypeName v0) (Core.Name "hydra.core.Type")) (Eithers.map (\decoded -> Just (toTypeScheme [] decoded)) (decodeType (Core.bindingTerm el))) (Right Nothing)                               _ -> Right Nothing-                    in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme el) (Eithers.map (\typ -> Just (Scoping.fTypeToTypeScheme typ)) (decodeType (Core.bindingTerm el))) (\ts -> Logic.ifElse (Equality.equal ts (Core.TypeScheme {+                    in (Eithers.bind (Optionals.match (Core.bindingTypeScheme el) (Eithers.map (\typ -> Just (Scoping.fTypeToTypeScheme typ)) (decodeType (Core.bindingTerm el))) (\ts -> Logic.ifElse (Equality.equal ts (Core.TypeScheme {                       Core.typeSchemeVariables = [],                       Core.typeSchemeBody = (Core.TypeVariable (Core.Name "hydra.core.TypeScheme")),                       Core.typeSchemeConstraints = Nothing})) (Eithers.map Optionals.pure (decodeTypeScheme (Core.bindingTerm el))) (Logic.ifElse (Equality.equal ts (Core.TypeScheme {
src/main/haskell/Hydra/Error/Checking.hs view
@@ -8,7 +8,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Typing as Typing 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/Error/Core.hs view
@@ -7,7 +7,7 @@ import qualified Hydra.Core as Core import qualified Hydra.Paths as Paths 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  -- | An application of ifElse where the condition is a literal boolean, creating a dead branch (optional)
src/main/haskell/Hydra/Error/File.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.File as File-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 recoverable file-system error
src/main/haskell/Hydra/Error/Packaging.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  -- | A module name which, when mapped to a target language's directory or package structure, conflicts with another module's mapped name. For example, hydra.foo.bar and hydra.fooBar might both map to the same directory in a case-insensitive filesystem.
src/main/haskell/Hydra/Error/System.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.File as File-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 recoverable failure to launch a process or to perform a hydra.lib.system system call, named after the POSIX errno values the host reports. A child that launches successfully and then exits non-zero is not a SystemError; it is a ProcessResult with a non-zero exitCode
src/main/haskell/Hydra/Errors.hs view
@@ -10,7 +10,7 @@ import qualified Hydra.Paths as Paths import qualified Hydra.Typing as Typing 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  -- | An error that occurred during decoding of a term
src/main/haskell/Hydra/Extract/Core.hs view
@@ -47,7 +47,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.ByteString as B import qualified Data.Int as I@@ -195,7 +195,7 @@                   Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {                     Errors.unexpectedShapeErrorExpected = (Strings.concat2 "field " (Core.unName fname)),                     Errors.unexpectedShapeErrorActual = "no matching field"})))-      in (Logic.ifElse (Lists.null matchingFields) noMatchErr (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.cases (Lists.head matchingFields) noMatchErr (\mf -> Eithers.bind (Lexical.stripAndDereferenceTerm graph (Core.fieldTerm mf)) (\stripped -> mapping stripped))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      in (Logic.ifElse (Lists.null matchingFields) noMatchErr (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.match (Lists.head matchingFields) noMatchErr (\mf -> Eithers.bind (Lexical.stripAndDereferenceTerm graph (Core.fieldTerm mf)) (\stripped -> mapping stripped))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "single field",         Errors.unexpectedShapeErrorActual = (Strings.concat2 "multiple fields named " (Core.unName fname))})))))) @@ -358,7 +358,7 @@             noBindingErr =                     Left (Errors.ErrorExtraction (Errors.ExtractionErrorNoSuchBinding (Errors.NoSuchBindingError {                       Errors.noSuchBindingErrorName = name})))-        in (Logic.ifElse (Lists.null matchingBindings) noBindingErr (Logic.ifElse (Equality.equal (Lists.length matchingBindings) 1) (Optionals.cases (Lists.head matchingBindings) noBindingErr (\b -> Right (Core.bindingTerm b))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleBindings (Errors.MultipleBindingsError {+        in (Logic.ifElse (Lists.null matchingBindings) noBindingErr (Logic.ifElse (Equality.equal (Lists.length matchingBindings) 1) (Optionals.match (Lists.head matchingBindings) noBindingErr (\b -> Right (Core.bindingTerm b))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleBindings (Errors.MultipleBindingsError {           Errors.multipleBindingsErrorName = name}))))))))  -- | Extract a list of terms from a term@@ -434,7 +434,7 @@ optionalTerm :: (Core.Term -> Either Errors.Error t0) -> Graph.Graph -> Core.Term -> Either Errors.Error (Maybe t0) optionalTerm f graph term0 =     Eithers.bind (Lexical.stripAndDereferenceTerm graph term0) (\term -> case term of-      Core.TermOptional v0 -> Optionals.cases v0 (Right Nothing) (\t -> Eithers.map Optionals.pure (f t))+      Core.TermOptional v0 -> Optionals.match v0 (Right Nothing) (\t -> Eithers.map Optionals.pure (f t))       _ -> Left (Errors.ErrorExtraction (Errors.ExtractionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "optional value",         Errors.unexpectedShapeErrorActual = (PrintCore.term term)}))))@@ -480,7 +480,7 @@ -- | Require a field from a record's field map and decode it requireField :: String -> (t0 -> t1 -> Either Errors.DecodingError t2) -> M.Map Core.Name t1 -> t0 -> Either Errors.DecodingError t2 requireField fieldName decoder fieldMap g =-    Optionals.cases (Maps.lookup (Core.Name fieldName) fieldMap) (Left (Errors.DecodingError (Strings.concat [+    Optionals.match (Maps.lookup (Core.Name fieldName) fieldMap) (Left (Errors.DecodingError (Strings.concat [       "missing field ",       fieldName,       " in record"]))) (\fieldTerm -> decoder g fieldTerm)
src/main/haskell/Hydra/Extract/Json.hs view
@@ -38,7 +38,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 @@ -76,16 +76,16 @@  -- | Look up an optional array field in a JSON object optArray :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe [Model.Value]))-optArray fname m = Optionals.cases (opt fname m) (Right Nothing) (\a -> Eithers.map (\x -> Just x) (expectArray a))+optArray fname m = Optionals.match (opt fname m) (Right Nothing) (\a -> Eithers.map (\x -> Just x) (expectArray a))  -- | Look up an optional string field in a JSON object optString :: Ord t0 => (t0 -> M.Map t0 Model.Value -> Either String (Maybe String))-optString fname m = Optionals.cases (opt fname m) (Right Nothing) (\s -> Eithers.map (\x -> Just x) (expectString s))+optString fname m = Optionals.match (opt fname m) (Right Nothing) (\s -> Eithers.map (\x -> Just x) (expectString s))  -- | Look up a required field in a JSON object, failing if not found require :: String -> M.Map String t0 -> Either String t0 require fname m =-    Optionals.cases (Maps.lookup fname m) (Left (Strings.concat [+    Optionals.match (Maps.lookup fname m) (Left (Strings.concat [       "required attribute ",       (showValue (Model.ValueString fname)),       " not found"])) (\value -> Right value)
src/main/haskell/Hydra/Extract/Util.hs view
@@ -38,7 +38,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  -- | Extract a comparison from a term
src/main/haskell/Hydra/File.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.Time as Time-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/Formatting.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 import qualified Data.Set as S @@ -110,12 +110,19 @@ indentLines s =        let indent = \l -> Strings.concat2 "    " l-      in (Strings.unlines (Lists.map indent (Strings.lines s)))+      in (unlines (Lists.map indent (lines s)))  -- | Format a string as a Java-style block comment javaStyleComment :: String -> String javaStyleComment s = Strings.concat2 (Strings.concat2 (Strings.concat2 "/**\n" " * ") s) "\n */" +-- | Split a string into lines on newline (U+000A); a trailing newline is consumed without producing an empty trailing element, and the empty string yields the empty list.+lines :: String -> [String]+lines s =+    Logic.ifElse (Strings.null s) [] (+      let parts = Strings.splitOn "\n" s+      in (Optionals.withDefault parts (Optionals.map (\lst -> Logic.ifElse (Strings.null lst) (Optionals.withDefault parts (Lists.init parts)) parts) (Lists.last parts))))+ -- | A helper which maps the first letter of a string to another string mapFirstLetter :: (String -> String) -> String -> String mapFirstLetter mapping s =@@ -147,7 +154,7 @@       in (Logic.ifElse (Strings.null stripped) "" (         let lastIdx = Math.sub (Strings.length stripped) 1             appended = Strings.concat2 stripped "."-        in (Optionals.cases (Strings.charAt lastIdx stripped) appended (\lastChar -> Logic.ifElse (Equality.equal lastChar 46) stripped appended))))+        in (Optionals.match (Strings.charAt lastIdx stripped) appended (\lastChar -> Logic.ifElse (Equality.equal lastChar 46) stripped appended))))  -- | Sanitize a string by replacing non-alphanumeric characters and escaping reserved words sanitizeWithUnderscores :: S.Set String -> String -> String@@ -165,6 +172,10 @@ stripLeadingAndTrailingWhitespace :: String -> String stripLeadingAndTrailingWhitespace s =     Strings.fromList (Lists.dropWhile Chars.isSpace (Lists.reverse (Lists.dropWhile Chars.isSpace (Lists.reverse (Strings.toList s)))))++-- | Join a list of strings with newlines (U+000A), appending a newline after each element including the last; the empty list yields the empty string.+unlines :: [String] -> String+unlines xs = Strings.concat (Lists.map (\l -> Strings.concat2 l "\n") xs)  -- | Replace special characters with their alphanumeric aliases withCharacterAliases :: String -> String
src/main/haskell/Hydra/Graph.hs view
@@ -8,7 +8,7 @@ import qualified Hydra.Errors as Errors import qualified Hydra.Packaging as Packaging 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 import qualified Data.Map as M import qualified Data.Set as S
src/main/haskell/Hydra/Hoisting.hs view
@@ -53,7 +53,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.Set as S @@ -97,12 +97,12 @@ -- | Check if a binding has a polymorphic type (non-empty list of type scheme variables) bindingIsPolymorphic :: Core.Binding -> Bool bindingIsPolymorphic binding =-    Optionals.cases (Core.bindingTypeScheme binding) False (\ts -> Logic.not (Lists.null (Core.typeSchemeVariables ts)))+    Optionals.match (Core.bindingTypeScheme binding) False (\ts -> Logic.not (Lists.null (Core.typeSchemeVariables ts)))  -- | Check if a binding's type uses any type variables from the given Graph. Returns True if the free type variables in the binding's type intersect with the type variables in scope (graphTypeVariables). bindingUsesContextTypeVars :: Graph.Graph -> Core.Binding -> Bool bindingUsesContextTypeVars cx binding =-    Optionals.cases (Core.bindingTypeScheme binding) False (\ts ->+    Optionals.match (Core.bindingTypeScheme binding) False (\ts ->       let freeInType = Variables.freeVariablesInType (Core.typeSchemeBody ts)           contextTypeVars = Graph.graphTypeVariables cx       in (Logic.not (Sets.null (Sets.intersection freeInType contextTypeVars))))@@ -177,7 +177,7 @@                     capturedTermVarTypes =                             Lists.map (\typ -> Strip.deannotateTypeParameters typ) (Optionals.givens (Lists.map Pairs.second capturedTermVarTypePairs))                     freeInBindingType =-                            Optionals.cases (Core.bindingTypeScheme b) Sets.empty (\ts -> Variables.freeVariablesInType (Core.typeSchemeBody ts))+                            Optionals.match (Core.bindingTypeScheme b) Sets.empty (\ts -> Variables.freeVariablesInType (Core.typeSchemeBody ts))                     freeInCapturedVarTypes = Sets.unions (Lists.map (\t -> Variables.freeVariablesInType t) capturedTermVarTypes)                     capturedTypeVars =                             Sets.toList (Sets.intersection (Graph.graphTypeVariables cx) (Sets.union freeInBindingType freeInCapturedVarTypes))@@ -200,7 +200,7 @@                     termWithTypeLambdas =                             Lists.foldl (\t -> \v -> Core.TermTypeLambda (Core.TypeLambda {                               Core.typeLambdaParameter = v,-                              Core.typeLambdaBody = t})) termWithLambdas (Lists.reverse (Optionals.cases newTypeScheme [] Core.typeSchemeVariables))+                              Core.typeLambdaBody = t})) termWithLambdas (Lists.reverse (Optionals.match newTypeScheme [] Core.typeSchemeVariables))                     withTypeApps =                             Lists.foldl (\t -> \v -> Core.TermTypeApplication (Core.TypeApplicationTerm {                               Core.typeApplicationTermBody = t,@@ -235,7 +235,7 @@                             keepUs = Pairs.second partitionPair                             hoistedBindingNames = Lists.map Core.bindingName hoistUs                             polyLetVariables =-                                    Sets.fromList (Lists.filter (\v -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v (Graph.graphBoundTypes cx))) False Resolution.fTypeIsPolymorphic) (Sets.toList (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx))))+                                    Sets.fromList (Lists.filter (\v -> Optionals.match (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v (Graph.graphBoundTypes cx))) False Resolution.fTypeIsPolymorphic) (Sets.toList (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx))))                             boundTermVariables =                                     Sets.union (Graph.graphLambdaVariables cx) (Sets.difference (Sets.fromList (Maps.keys (Graph.graphBoundTerms cx))) (Graph.graphLambdaVariables cx))                             freeVariablesInEachBinding =@@ -248,7 +248,7 @@                             bindingsWithCapturedVars =                                     Lists.map (\b -> (                                       b,-                                      (Optionals.cases (Maps.lookup (Core.bindingName b) capturedVarsMap) [] (\vars -> Sets.toList (Sets.difference vars polyLetVariables))))) hoistUs+                                      (Optionals.match (Maps.lookup (Core.bindingName b) capturedVarsMap) [] (\vars -> Sets.toList (Sets.difference vars polyLetVariables))))) hoistUs                             hoistPairsAndNames = Lists.foldl (hoistOne prefix cx) ([], alreadyUsedNames) bindingsWithCapturedVars                             hoistPairs = Lists.reverse (Pairs.first hoistPairsAndNames)                             hoistedBindings = Lists.map Pairs.first hoistPairs@@ -259,7 +259,7 @@                             isCacheable =                                     \name ->                                       let multiRef = Ordering.gte (countVarOccurrences name body) 2-                                          isPoly = Optionals.cases (Maps.lookup name hoistBindingMap) False (\b -> bindingIsPolymorphic b)+                                          isPoly = Optionals.match (Maps.lookup name hoistBindingMap) False (\b -> bindingIsPolymorphic b)                                       in (Logic.and multiRef (Logic.not isPoly))                             singleRefPairs = Lists.filter (\p -> Logic.not (isCacheable (Pairs.first p))) hoistNameReplacementPairs                             multiRefPairs = Lists.filter (\p -> isCacheable (Pairs.first p)) hoistNameReplacementPairs@@ -268,7 +268,7 @@                             bodySubst = Substitution.substituteInTerm bodyOnlySubst body                             cacheBindings =                                     Lists.map (\p ->-                                      let origType = Optionals.cases (Maps.lookup (Pairs.first p) hoistBindingMap) Nothing (\b -> Core.bindingTypeScheme b)+                                      let origType = Optionals.match (Maps.lookup (Pairs.first p) hoistBindingMap) Nothing (\b -> Core.bindingTypeScheme b)                                       in Core.Binding {                                         Core.bindingName = (Pairs.first p),                                         Core.bindingTerm = (Pairs.second p),@@ -419,7 +419,7 @@                         bodyPathPrefix = Lists.concat2 path [                               Paths.SubtermStepLetBody]                         firstBindingName =-                                Optionals.cases (Lists.head bindings) "body" (\b -> Strings.join "_" (Strings.splitOn "." (Core.unName (Core.bindingName b))))+                                Optionals.match (Lists.head bindings) "body" (\b -> Strings.join "_" (Strings.splitOn "." (Core.unName (Core.bindingName b))))                         bodyPrefix = Strings.concat2 firstBindingName "_body"                         bodyResult = processImmediateSubterm cx 1 bodyPrefix bodyPathPrefix body                         newBody = Pairs.second bodyResult@@ -473,10 +473,10 @@ normalizePathForHoisting path =        let go =-              \remaining -> Optionals.cases (Lists.uncons remaining) remaining (\uc1 ->+              \remaining -> Optionals.match (Lists.uncons remaining) remaining (\uc1 ->                 let first = Pairs.first uc1                     afterFirst = Pairs.second uc1-                in (Optionals.cases (Lists.uncons afterFirst) remaining (\uc2 ->+                in (Optionals.match (Lists.uncons afterFirst) remaining (\uc2 ->                   let second = Pairs.first uc2                       rest = Pairs.second uc2                   in (Logic.ifElse (Logic.and (isApplicationFunction first) (isLambdaBody second)) (Lists.cons Paths.SubtermStepLetBody (go rest)) (Lists.cons first (go afterFirst))))))
src/main/haskell/Hydra/Inference.hs view
@@ -7,6 +7,7 @@ import qualified Hydra.Annotations as Annotations import qualified Hydra.Ast as Ast import qualified Hydra.Checking as Checking+import qualified Hydra.Classes as Classes import qualified Hydra.Coders as Coders import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs@@ -61,7 +62,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@@ -69,7 +70,7 @@ -- | Return the element at the given index, or Left(Other) with the given description if out of range atOrFail :: Int -> String -> [t0] -> Either Errors.Error t0 atOrFail i desc xs =-    Optionals.cases (Lists.at i xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "atOrFail: " desc)))) (\x -> Right x)+    Optionals.match (Lists.at i xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "atOrFail: " desc)))) (\x -> Right x)  -- | Unify type constraints and check the substitution bindConstraints :: Typing.InferenceContext -> Graph.Graph -> [Typing.TypeConstraint] -> Either Errors.Error Typing.TypeSubst@@ -90,7 +91,7 @@                               \b ->                                 let bname = Core.bindingName b                                     bterm = Core.bindingTerm b-                                in (Optionals.cases (Core.bindingTypeScheme b) (Core.Binding {+                                in (Optionals.match (Core.bindingTypeScheme b) (Core.Binding {                                   Core.bindingName = bname,                                   Core.bindingTerm = (bindUnboundTypeVariables cx bterm),                                   Core.bindingTypeScheme = Nothing}) (\ts ->@@ -127,6 +128,31 @@       Core.typeApplicationTermBody = t,       Core.typeApplicationTermType = (Core.TypeVariable v)})) body tvars +-- | Check that every constrained type variable's final resolved type is an instance of each class it was constrained to.+dischargeClassConstraints :: Typing.InferenceContext -> Typing.TypeSubst -> M.Map Core.Name Core.TypeVariableConstraints -> Either Errors.Error ()+dischargeClassConstraints fcx subst constraints =++      let substMap = Typing.unTypeSubst subst+          checkOne =+                  \pair ->+                    let varName = Pairs.first pair+                        varConstraints = Pairs.second pair+                    in (Optionals.match (Maps.lookup varName substMap) (Right ()) (\resolvedType ->+                      let checkClass =+                              \classConstraint ->+                                let className =+                                        case classConstraint of+                                          Core.TypeClassConstraintSimple v0 -> v0+                                in (Logic.ifElse (Classes.classIsSatisfiedByType className resolvedType) (Right ()) (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {+                                  Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx))),+                                  Errors.otherInferenceErrorMessage = (Strings.concat [+                                    "Type ",+                                    (PrintCore.type_ resolvedType),+                                    " does not satisfy constraint ",+                                    (Core.unName className)])})))))+                      in (Eithers.bind (Eithers.mapList checkClass (Core.typeVariableConstraintsClasses varConstraints)) (\_ -> Right ()))))+      in (Eithers.bind (Eithers.mapList checkOne (Maps.toList constraints)) (\_ -> Right ()))+ -- | Add (term variable, type scheme) pairs to the graph's bound types extendContext :: [(Core.Name, Core.TypeScheme)] -> Graph.Graph -> Graph.Graph extendContext pairs cx =@@ -188,7 +214,7 @@ -- | Return the first element of a list, or Left(Other) with the given description if the list is empty headOrFail :: String -> [t0] -> Either Errors.Error t0 headOrFail desc xs =-    Optionals.cases (Lists.head xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "headOrFail: " desc)))) (\x -> Right x)+    Optionals.match (Lists.head xs) (Left (Errors.ErrorOther (Errors.OtherError (Strings.concat2 "headOrFail: " desc)))) (\x -> Right x)  -- | Infer types for all elements in a graph, using the provided ordered bindings. Returns both the inferred graph and the ordered inferred bindings. Paper: inference.tex, the SCC treatment of cycles (section introduction); the whole graph is one mutually recursive let. inferGraphTypes :: Typing.InferenceContext -> [Core.Binding] -> Graph.Graph -> Either Errors.Error ((Graph.Graph, [Core.Binding]), Typing.InferenceContext)@@ -219,11 +245,11 @@       in (Eithers.bind (inferTypeOfTerm fcx g0 (Core.TermLet let0) "graph term") (\result ->         let fcx2 = Typing.inferenceResultContext result             term = Typing.inferenceResultTerm result-        in (Eithers.bind (finalizeInferredTerm fcx2 g0 term) (\finalized -> case finalized of+        in (Eithers.bind (dischargeClassConstraints fcx2 (Typing.inferenceResultSubst result) (Typing.inferenceResultClassConstraints result)) (\_ -> Eithers.bind (finalizeInferredTerm fcx2 g0 term) (\finalized -> case finalized of           Core.TermLet v0 -> Right (fromLetTerm v0, fcx2)           Core.TermVariable _ -> Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {             Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),-            Errors.otherInferenceErrorMessage = "Expected inferred graph as let term"})))))))+            Errors.otherInferenceErrorMessage = "Expected inferred graph as let term"}))))))))  -- | Infer the type of a term in a given inference context inferInGraphContext :: Typing.InferenceContext -> Graph.Graph -> Core.Term -> Either Errors.Error Typing.InferenceResult@@ -236,7 +262,7 @@ inferMany fcx cx pairs =        let emptyResult = Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)-      in (Optionals.cases (Lists.uncons pairs) emptyResult (\pairsUc ->+      in (Optionals.match (Lists.uncons pairs) emptyResult (\pairsUc ->         let headPair = Pairs.first pairsUc             tl = Pairs.second pairsUc             e = Pairs.first headPair@@ -276,19 +302,19 @@                 Core.letBody = (Core.TermLiteral (Core.LiteralString "ignoredBody"))})       in (Eithers.bind (inferTypeOfTerm fcx cx letTerm "infer type of term") (\result ->         let fcx2 = Typing.inferenceResultContext result-        in (Eithers.bind (finalizeInferredTerm fcx2 cx (Typing.inferenceResultTerm result)) (\finalized -> Eithers.bind (ExtractCore.let_ cx finalized) (\letResult ->+        in (Eithers.bind (dischargeClassConstraints fcx2 (Typing.inferenceResultSubst result) (Typing.inferenceResultClassConstraints result)) (\_ -> Eithers.bind (finalizeInferredTerm fcx2 cx (Typing.inferenceResultTerm result)) (\finalized -> Eithers.bind (ExtractCore.let_ cx finalized) (\letResult ->           let bindings = Core.letBindings letResult           in (Logic.ifElse (Equality.equal 1 (Lists.length bindings)) (Eithers.bind (headOrFail "inferTypeOf: single binding expected" bindings) (\binding ->             let term1 = Core.bindingTerm binding                 mts = Core.bindingTypeScheme binding-            in (Optionals.cases mts (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {+            in (Optionals.match mts (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {               Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),               Errors.otherInferenceErrorMessage = "Expected a type scheme"})))) (\ts -> Right ((term1, ts), fcx2))))) (Left (Errors.ErrorInference (Errors.InferenceErrorOther (Errors.OtherInferenceError {             Errors.otherInferenceErrorPath = (Paths.SubtermPath (Lists.reverse (Typing.inferenceContextTrace fcx2))),             Errors.otherInferenceErrorMessage = (Strings.concat [               "Expected a single binding with a type scheme, but got: ",               (Literals.showInt32 (Lists.length bindings)),-              " bindings"])}))))))))))+              " bindings"])})))))))))))  -- | Infer the type of an annotated term (Either version). Paper: inference.tex, rule Ann. inferTypeOfAnnotatedTerm :: Typing.InferenceContext -> Graph.Graph -> Core.AnnotatedTerm -> Either Errors.Error Typing.InferenceResult@@ -366,8 +392,8 @@        let tname = Core.caseStatementTypeName caseStmt           dflt = Core.caseStatementDefault caseStmt-          cases = Core.caseStatementCases caseStmt-          fnames = Lists.map Core.caseAlternativeName cases+          match = Core.caseStatementCases caseStmt+          fnames = Lists.map Core.caseAlternativeName match       in (Eithers.bind (Resolution.requireSchemaType fcx (Graph.graphSchemaTypes cx) tname) (\stRp ->         let schemaType = Pairs.first stRp             fcx2 = Pairs.second stRp@@ -387,7 +413,7 @@                 "case ",                 (Core.unName tname),                 ".",-                (Core.unName (Core.caseAlternativeName f))]))) cases)) (\caseRp ->+                (Core.unName (Core.caseAlternativeName f))]))) match)) (\caseRp ->               let caseResults = Pairs.first caseRp                   fcx4 = Pairs.second caseRp                   iterms = Pairs.first caseResults@@ -677,7 +703,7 @@               constraintsWithS2 = Substitution.substInClassConstraints s2 inferredConstraints               composedSubst = Substitution.composeTypeSubst s1 s2               originalBindingConstraints =-                      Lists.foldl (\acc -> \b -> Optionals.cases (Core.bindingTypeScheme b) acc (\ts -> Optionals.cases (Core.typeSchemeConstraints ts) acc (\c -> mergeClassConstraints acc c))) Maps.empty bins0+                      Lists.foldl (\acc -> \b -> Optionals.match (Core.bindingTypeScheme b) acc (\ts -> Optionals.match (Core.typeSchemeConstraints ts) acc (\c -> mergeClassConstraints acc c))) Maps.empty bins0               originalConstraintsSubst = Substitution.substInClassConstraints composedSubst originalBindingConstraints               allInferredConstraints = mergeClassConstraints constraintsWithS2 originalConstraintsSubst               mergedConstraints = mergeClassConstraints (Graph.graphClassConstraints g2base) allInferredConstraints@@ -807,7 +833,7 @@ inferTypeOfOptional fcx cx m =        let trmCons = \terms -> Core.TermOptional (Lists.head terms)-      in (inferTypeOfCollection fcx cx (\x -> Core.TypeOptional x) trmCons "optional element" Sets.empty (Optionals.cases m [] Lists.singleton))+      in (inferTypeOfCollection fcx cx (\x -> Core.TypeOptional x) trmCons "optional element" Sets.empty (Optionals.match m [] Lists.singleton))  -- | Infer the type of a pair (Either version). Paper: inference.tex, rule Pair. inferTypeOfPair :: Typing.InferenceContext -> Graph.Graph -> (Core.Term, Core.Term) -> Either Errors.Error Typing.InferenceResult@@ -969,7 +995,7 @@ -- | Infer the type of a variable (Either version). Paper: inference.tex, rule Var (elaboration form), with rule Prim as the primitive-namespace fallback. inferTypeOfVariable :: Typing.InferenceContext -> Graph.Graph -> Core.Name -> Either Errors.Error Typing.InferenceResult inferTypeOfVariable fcx cx name =-    Optionals.cases (Maps.lookup name (Graph.graphBoundTypes cx)) (Optionals.cases (Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives cx))) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+    Optionals.match (Maps.lookup name (Graph.graphBoundTypes cx)) (Optionals.match (Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives cx))) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {       Errors.noSuchBindingErrorName = name})))) (\scheme ->       let tsResult = Resolution.instantiateTypeScheme fcx scheme           ts = Pairs.first tsResult@@ -1020,7 +1046,7 @@ inferTypesOfTemporaryBindings fcx cx bins =        let emptyResult = Right (([], ([], (Substitution.idTypeSubst, Maps.empty))), fcx)-      in (Optionals.cases (Lists.uncons bins) emptyResult (\binsUc ->+      in (Optionals.match (Lists.uncons bins) emptyResult (\binsUc ->         let binding = Pairs.first binsUc             tl = Pairs.second binsUc             k = Core.bindingName binding@@ -1035,7 +1061,7 @@               u_prime = Typing.inferenceResultType result1               u = Typing.inferenceResultSubst result1               c1Inferred = Typing.inferenceResultClassConstraints result1-          in (Eithers.bind (Optionals.cases (Core.bindingTypeScheme binding) (Right Maps.empty) (\ts ->+          in (Eithers.bind (Optionals.match (Core.bindingTypeScheme binding) (Right Maps.empty) (\ts ->             let tsResult = Resolution.instantiateTypeScheme fcx2 ts                 instantiatedTs = Pairs.first tsResult                 freshConstraints = Optionals.withDefault Maps.empty (Core.typeSchemeConstraints instantiatedTs)@@ -1077,7 +1103,7 @@     Lists.foldl (\acc -> \pair ->       let k = Pairs.first pair           v = Pairs.second pair-      in (Optionals.cases (Maps.lookup k acc) (Maps.insert k v acc) (\existing ->+      in (Optionals.match (Maps.lookup k acc) (Maps.insert k v acc) (\existing ->         let merged =                 Core.TypeVariableConstraints {                   Core.typeVariableConstraintsClasses = (Lists.distinct (Lists.concat2 (Core.typeVariableConstraintsClasses existing) (Core.typeVariableConstraintsClasses v)))}
src/main/haskell/Hydra/Json/Bootstrap.hs view
@@ -15,7 +15,7 @@ import qualified Hydra.Typing as Typing import qualified Hydra.Util as Util 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
src/main/haskell/Hydra/Json/Decode.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 @@ -59,13 +59,13 @@     case ft of       Core.FloatTypeFloat32 -> case value of         Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 (LibLiterals.decimalToFloat32 v1))))-        Model.ValueString v1 -> Optionals.cases (parseSpecialFloat32 v1) (Left (Strings.concat [+        Model.ValueString v1 -> Optionals.match (parseSpecialFloat32 v1) (Left (Strings.concat [           "invalid float32 sentinel: ",           v1])) (\v -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat32 v))))         _ -> Left "expected number or special float string for float32"       Core.FloatTypeFloat64 -> case value of         Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 (LibLiterals.decimalToFloat64 v1))))-        Model.ValueString v1 -> Optionals.cases (parseSpecialFloat v1) (Left (Strings.concat [+        Model.ValueString v1 -> Optionals.match (parseSpecialFloat v1) (Left (Strings.concat [           "invalid float64 sentinel: ",           v1])) (\v -> Right (Core.TermLiteral (Core.LiteralFloat (Core.FloatValueFloat64 v))))         _ -> Left "expected number or special float string for float64"@@ -78,21 +78,21 @@         let strResult = expectString value         in (Eithers.either (\err -> Left err) (\s ->           let parsed = LibLiterals.readBigint s-          in (Optionals.cases parsed (Left (Strings.concat [+          in (Optionals.match parsed (Left (Strings.concat [             "invalid bigint: ",             s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueBigint v)))))) strResult)       Core.IntegerTypeInt64 ->         let strResult = expectString value         in (Eithers.either (\err -> Left err) (\s ->           let parsed = LibLiterals.readInt64 s-          in (Optionals.cases parsed (Left (Strings.concat [+          in (Optionals.match parsed (Left (Strings.concat [             "invalid int64: ",             s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueInt64 v)))))) strResult)       Core.IntegerTypeUint64 ->         let strResult = expectString value         in (Eithers.either (\err -> Left err) (\s ->           let parsed = LibLiterals.readUint64 s-          in (Optionals.cases parsed (Left (Strings.concat [+          in (Optionals.match parsed (Left (Strings.concat [             "invalid uint64: ",             s])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint64 v)))))) strResult)       Core.IntegerTypeInt8 ->@@ -114,7 +114,7 @@         Model.ValueNumber v1 -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 (LibLiterals.bigintToUint32 (LibLiterals.decimalToBigint v1)))))         Model.ValueString v1 ->           let parsed = LibLiterals.readUint32 v1-          in (Optionals.cases parsed (Left (Strings.concat [+          in (Optionals.match parsed (Left (Strings.concat [             "invalid uint32: ",             v1])) (\v -> Right (Core.TermLiteral (Core.LiteralInteger (Core.IntegerValueUint32 v)))))         _ -> Left "expected number or string for uint32"@@ -182,7 +182,7 @@                       Core.TypeForall v0 -> Right (Substitution.substInType (Substitution.singletonTypeSubst (Core.forallTypeParameter v0) arg) (Core.forallTypeBody v0))                       Core.TypeVariable v0 ->                         let lookedUp = Maps.lookup v0 types-                        in (Optionals.cases lookedUp (Left (Strings.concat [+                        in (Optionals.match lookedUp (Left (Strings.concat [                           "unknown type variable: ",                           (Core.unName v0)])) (\resolvedFn -> reduceApp (Core.ApplicationType {                           Core.applicationTypeFunction = resolvedFn,@@ -214,7 +214,7 @@                         _ -> False           in (Logic.ifElse isNestedMaybe (             let decodeJust =-                    \arr -> Optionals.cases (Lists.head arr) (Left "expected single-element array for Just") (\firstVal -> Eithers.map (\v -> Core.TermOptional (Just v)) (fromJson types compactMaps tname v0 firstVal))+                    \arr -> Optionals.match (Lists.head arr) (Left "expected single-element array for Just") (\firstVal -> Eithers.map (\v -> Core.TermOptional (Just v)) (fromJson types compactMaps tname v0 firstVal))                 decodeMaybeArray =                         \arr ->                           let len = Lists.length arr@@ -254,15 +254,15 @@                         Core.fieldName = (Core.Name key),                         Core.fieldTerm = v}})) decoded)               findAndDecode =-                      \key -> \val -> \fts -> Optionals.cases (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) key) fts) (Left (Strings.concat [+                      \key -> \val -> \fts -> Optionals.match (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) key) fts) (Left (Strings.concat [                         "unknown variant: ",                         key])) (\ft -> decodeVariant key val (Core.fieldTypeType ft))               decodeSingleKey =-                      \obj -> Optionals.cases (Lists.head (Maps.keys obj)) (Left "expected single-key object for union") (\k -> findAndDecode k (Maps.lookup k obj) v0)+                      \obj -> Optionals.match (Lists.head (Maps.keys obj)) (Left "expected single-key object for union") (\k -> findAndDecode k (Maps.lookup k obj) v0)               processUnion =                       \obj -> Logic.ifElse (Equality.equal (Lists.length (Maps.keys obj)) 1) (decodeSingleKey obj) (Left "expected single-key object for union")               decodeCompactString =-                      \s -> Optionals.cases (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) s) v0) (Left (Strings.concat [+                      \s -> Optionals.match (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) s) v0) (Left (Strings.concat [                         "unknown variant: ",                         s])) (\ft ->                         let ftypeStripped = Strip.deannotateType (Core.fieldTypeType ft)@@ -299,7 +299,7 @@                         in (Eithers.either (\err -> Left err) (\entryObj ->                           let keyJson = Maps.lookup "key" entryObj                               valJson = Maps.lookup "value" entryObj-                          in (Optionals.cases keyJson (Left "missing key in map entry") (\kj -> Optionals.cases valJson (Left "missing value in map entry") (\vj ->+                          in (Optionals.match keyJson (Left "missing key in map entry") (\kj -> Optionals.match valJson (Left "missing value in map entry") (\vj ->                             let decodedKey = fromJson types compactMaps tname keyType kj                                 decodedVal = fromJson types compactMaps tname valType vj                             in (Eithers.either (\err -> Left err) (\k -> Eithers.map (\v -> (k, v)) decodedVal) decodedKey))))) objResult)@@ -331,7 +331,7 @@           in (Eithers.either (\err -> Left err) (\obj ->             let firstJson = Maps.lookup "first" obj                 secondJson = Maps.lookup "second" obj-            in (Optionals.cases firstJson (Left "missing first in pair") (\fj -> Optionals.cases secondJson (Left "missing second in pair") (\sj ->+            in (Optionals.match firstJson (Left "missing first in pair") (\fj -> Optionals.match secondJson (Left "missing second in pair") (\sj ->               let decodedFirst = fromJson types compactMaps tname firstType fj                   decodedSecond = fromJson types compactMaps tname secondType sj               in (Eithers.either (\err -> Left err) (\f -> Eithers.map (\s -> Core.TermPair (f, s)) decodedSecond) decodedFirst))))) objResult)@@ -342,14 +342,14 @@           in (Eithers.either (\err -> Left err) (\obj ->             let leftJson = Maps.lookup "left" obj                 rightJson = Maps.lookup "right" obj-            in (Optionals.cases leftJson (Optionals.cases rightJson (Left "expected left or right in Either") (\rj ->+            in (Optionals.match leftJson (Optionals.match rightJson (Left "expected left or right in Either") (\rj ->               let decoded = fromJson types compactMaps tname rightType rj               in (Eithers.map (\v -> Core.TermEither (Right v)) decoded))) (\lj ->               let decoded = fromJson types compactMaps tname leftType lj               in (Eithers.map (\v -> Core.TermEither (Left v)) decoded)))) objResult)         Core.TypeVariable v0 ->           let lookedUp = Maps.lookup v0 types-          in (Optionals.cases lookedUp (Left (Strings.concat [+          in (Optionals.match lookedUp (Left (Strings.concat [             "unknown type variable: ",             (Core.unName v0)])) (\resolvedType -> fromJson types compactMaps v0 resolvedType value))         _ -> Left (Strings.concat [
src/main/haskell/Hydra/Json/Decoding.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.Map as M @@ -58,7 +58,7 @@ -- | Decode a required field from a JSON object decodeField :: (t0 -> Either String t1) -> String -> M.Map String t0 -> Either String t1 decodeField decodeValue name m =-    Eithers.bind (decodeOptionalField decodeValue name m) (\mf -> Optionals.cases mf (Left (Strings.concat2 "missing field: " name)) (\f -> Right f))+    Eithers.bind (decodeOptionalField decodeValue name m) (\mf -> Optionals.match mf (Left (Strings.concat2 "missing field: " name)) (\f -> Right f))  -- | Decode a JSON object value to a name-keyed map. Field order is not preserved; decoding looks fields up by name. decodeObject :: Model.Value -> Either String (M.Map String Model.Value)@@ -70,7 +70,7 @@ -- | Decode an optional field from a JSON object decodeOptionalField :: Ord t3 => ((t0 -> Either t1 t2) -> t3 -> M.Map t3 t0 -> Either t1 (Maybe t2)) decodeOptionalField decodeValue name m =-    Optionals.cases (Maps.lookup name m) (Right Nothing) (\v -> Eithers.map (\x -> Just x) (decodeValue v))+    Optionals.match (Maps.lookup name m) (Right Nothing) (\v -> Eithers.map (\x -> Just x) (decodeValue v))  -- | Decode a JSON string value decodeString :: Model.Value -> Either String String
src/main/haskell/Hydra/Json/Encode.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 @@ -111,7 +111,7 @@                       Core.TypeForall v0 -> Right (Substitution.substInType (Substitution.singletonTypeSubst (Core.forallTypeParameter v0) arg) (Core.forallTypeBody v0))                       Core.TypeVariable v0 ->                         let lookedUp = Maps.lookup v0 types-                        in (Optionals.cases lookedUp (Left (Strings.concat [+                        in (Optionals.match lookedUp (Left (Strings.concat [                           "unknown type variable: ",                           (Core.unName v0)])) (\resolvedFn -> reduceApp (Core.ApplicationType {                           Core.applicationTypeFunction = resolvedFn,@@ -143,7 +143,7 @@                         Core.TypeOptional _ -> True                         _ -> False           in case strippedTerm of-            Core.TermOptional v1 -> Optionals.cases v1 (Right Model.ValueNull) (\v ->+            Core.TermOptional v1 -> Optionals.match v1 (Right Model.ValueNull) (\v ->               let encoded = toJson types compactMaps tname v0 v               in (Logic.ifElse isNestedMaybe (Eithers.map (\ev -> Model.ValueArray [                 ev]) encoded) encoded))@@ -162,7 +162,7 @@                               fterm = Core.fieldTerm f                               ftype = Core.fieldTypeType ft                           in (Logic.ifElse (isSimpleMaybe ftype) (case (Strip.deannotateTerm fterm) of-                            Core.TermOptional v2 -> Optionals.cases v2 (Right Nothing) (\v ->+                            Core.TermOptional v2 -> Optionals.match v2 (Right Nothing) (\v ->                               let innerType =                                       case (Strip.deannotateType ftype) of                                         Core.TypeOptional v3 -> v3@@ -184,7 +184,7 @@                 fname = Core.unName (Core.fieldName field)                 fterm = Core.fieldTerm field                 ftypeResult =-                        Optionals.cases (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) fname) v0) (Left (Strings.concat [+                        Optionals.match (Lists.find (\ft -> Equality.equal (Core.unName (Core.fieldTypeName ft)) fname) v0) (Left (Strings.concat [                           "unknown variant: ",                           fname])) (\ft -> Right (Core.fieldTypeType ft))             in (Eithers.either (\err -> Left err) (\ftype ->@@ -261,7 +261,7 @@             _ -> Left "expected either term"         Core.TypeVariable v0 ->           let lookedUp = Maps.lookup v0 types-          in (Optionals.cases lookedUp (toJsonUntyped term) (\resolvedType -> toJson types compactMaps v0 resolvedType term))+          in (Optionals.match lookedUp (toJsonUntyped term) (\resolvedType -> toJson types compactMaps v0 resolvedType term))         _ -> Left (Strings.concat [           "unsupported type for JSON encoding: ",           (PrintCore.type_ typ)])@@ -280,7 +280,7 @@           let terms = Sets.toList v0               results = Eithers.mapList (\t -> toJsonUntyped t) terms           in (Eithers.map (\vs -> Model.ValueArray vs) results)-        Core.TermOptional v0 -> Optionals.cases v0 (Right Model.ValueNull) (\v ->+        Core.TermOptional v0 -> Optionals.match v0 (Right Model.ValueNull) (\v ->           let encodedMaybe = toJsonUntyped v           in (Eithers.map (\encoded -> Model.ValueArray [             encoded]) encodedMaybe))
src/main/haskell/Hydra/Json/Model.hs view
@@ -5,7 +5,7 @@ module Hydra.Json.Model 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 JSON value
src/main/haskell/Hydra/Json/Parser.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 import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals @@ -80,7 +80,7 @@ -- | Parse the optional exponent part of a JSON number jsonExponentPart :: Parsing.Parser (Maybe String) jsonExponentPart =-    Parsers.optional (Parsers.bind (Parsers.satisfy (\c -> Logic.or (Equality.equal c 101) (Equality.equal c 69))) (\_ -> Parsers.bind (Parsers.optional (Parsers.satisfy (\c -> Logic.or (Equality.equal c 43) (Equality.equal c 45)))) (\sign -> Parsers.map (\digits -> Strings.concat2 (Strings.concat2 "e" (Optionals.cases sign "" (\arg_ -> Strings.fromList (Lists.pure arg_)))) digits) digits)))+    Parsers.optional (Parsers.bind (Parsers.satisfy (\c -> Logic.or (Equality.equal c 101) (Equality.equal c 69))) (\_ -> Parsers.bind (Parsers.optional (Parsers.satisfy (\c -> Logic.or (Equality.equal c 43) (Equality.equal c 45)))) (\sign -> Parsers.map (\digits -> Strings.concat2 (Strings.concat2 "e" (Optionals.match sign "" (\arg_ -> Strings.fromList (Lists.pure arg_)))) digits) digits)))  -- | Parse the optional fractional part of a JSON number jsonFractionPart :: Parsing.Parser (Maybe String)@@ -89,7 +89,7 @@ -- | Parse the integer part of a JSON number (optional minus, then digits) jsonIntegerPart :: Parsing.Parser String jsonIntegerPart =-    Parsers.bind (Parsers.optional (Parsers.char 45)) (\sign -> Parsers.bind digits (\digits -> Parsers.pure (Optionals.cases sign digits (\_ -> Strings.concat2 "-" digits))))+    Parsers.bind (Parsers.optional (Parsers.char 45)) (\sign -> Parsers.bind digits (\digits -> Parsers.pure (Optionals.match sign digits (\_ -> Strings.concat2 "-" digits))))  -- | Parse a JSON object key-value pair jsonKeyValue :: Parsing.Parser (String, Model.Value)@@ -105,8 +105,8 @@ jsonNumber =     token (Parsers.bind jsonIntegerPart (\intPart -> Parsers.bind jsonFractionPart (\fracPart -> Parsers.bind jsonExponentPart (\expPart ->       let numStr =-              Strings.concat2 (Strings.concat2 intPart (Optionals.cases fracPart "" Functions.identity)) (Optionals.cases expPart "" Functions.identity)-      in (Parsers.pure (Model.ValueNumber (Optionals.cases (Literals.readDecimal numStr) (Literals.stringToDecimal "0.0") Functions.identity)))))))+              Strings.concat2 (Strings.concat2 intPart (Optionals.match fracPart "" Functions.identity)) (Optionals.match expPart "" Functions.identity)+      in (Parsers.pure (Model.ValueNumber (Optionals.match (Literals.readDecimal numStr) (Literals.stringToDecimal "0.0") Functions.identity)))))))  -- | Parse a JSON object jsonObject :: Parsing.Parser Model.Value@@ -137,7 +137,7 @@ -- | Parse a JSON document from a string parseJson :: String -> Parsing.ParseResult Model.Value parseJson input =-    Parsing.unParser (Parsers.bind whitespace (\_ -> Parsers.bind jsonValue (\v -> Parsers.bind whitespace (\_2 -> Parsers.bind Parsers.eof (\_3 -> Parsers.pure v))))) input+    Parsers.runParser (Parsers.bind whitespace (\_ -> Parsers.bind jsonValue (\v -> Parsers.bind whitespace (\_2 -> Parsers.bind Parsers.eof (\_3 -> Parsers.pure v))))) input  -- | Parse a token followed by optional whitespace token :: Parsing.Parser t0 -> Parsing.Parser t0
src/main/haskell/Hydra/Json/Writer.hs view
@@ -43,7 +43,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  -- | The colon operator used to separate keys and values in JSON objects
src/main/haskell/Hydra/Json/Yaml/Decode.hs view
@@ -39,7 +39,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 import qualified Data.Map as M
src/main/haskell/Hydra/Json/Yaml/Encode.hs view
@@ -39,7 +39,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 import qualified Data.Map as M
src/main/haskell/Hydra/Languages.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 Hydra Core, i.e. no constraints.
src/main/haskell/Hydra/Lexical.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 import qualified Data.Set as S@@ -110,7 +110,7 @@ -- | Look up a binding by name in a graph, returning Either an error or the binding dereferenceVariable :: Graph.Graph -> Core.Name -> Either Errors.Error Core.Binding dereferenceVariable graph name =-    Optionals.cases (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+    Optionals.match (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {       Errors.noSuchBindingErrorName = name})))) (\right_ -> Right right_)  -- | Create a graph from a parent graph, schema types, and list of element bindings@@ -163,7 +163,7 @@ -- | Look up a field by name in a record's field map and decode its value, failing if the field is missing getField :: M.Map Core.Name t0 -> Core.Name -> (t0 -> Either Errors.Error t1) -> Either Errors.Error t1 getField m fname decode =-    Optionals.cases (Maps.lookup fname m) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+    Optionals.match (Maps.lookup fname m) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {       Errors.noMatchingFieldErrorFieldName = fname})))) decode  -- | Reconstruct a list of Bindings from a Graph's boundTerms and boundTypes@@ -230,7 +230,7 @@                      let fname = Core.fieldName (Core.injectionField v0)                         val = Core.fieldTerm (Core.injectionField v0)-                    in (Optionals.cases (Maps.lookup fname mapping) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                    in (Optionals.match (Maps.lookup fname mapping) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {                       Errors.noMatchingFieldErrorFieldName = fname})))) (\f -> f val))           in (Logic.ifElse (Equality.equal (Core.unName (Core.injectionTypeName v0)) (Core.unName tname)) exp (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {             Errors.unexpectedShapeErrorExpected = (Strings.concat2 "injection for type " (Core.unName tname)),@@ -253,12 +253,12 @@                     "..."]) strings           errMsg =                   Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "no such element: " (Core.unName name)) ". Available elements: {") (Strings.join ", " (ellipsis (Lists.map Core.unName (Maps.keys (Graph.graphBoundTerms graph)))))) "}"-      in (Optionals.cases (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorOther (Errors.OtherResolutionError errMsg)))) (\x -> Right x))+      in (Optionals.match (lookupBinding graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorOther (Errors.OtherResolutionError errMsg)))) (\x -> Right x))  -- | Look up a primitive in a graph by name, failing if it is not registered requirePrimitive :: Graph.Graph -> Core.Name -> Either Errors.Error Graph.Primitive requirePrimitive graph name =-    Optionals.cases (lookupPrimitive graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {+    Optionals.match (lookupPrimitive graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {       Errors.noSuchPrimitiveErrorName = name})))) (\x -> Right x)  -- | Look up a primitive's type scheme in a graph by name, failing if the primitive is not registered@@ -267,13 +267,13 @@        let mts =               Optionals.map (\_p -> Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition _p))) (Maps.lookup name (Graph.graphPrimitives tx))-      in (Optionals.cases mts (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {+      in (Optionals.match mts (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchPrimitive (Errors.NoSuchPrimitiveError {         Errors.noSuchPrimitiveErrorName = name})))) (\ts -> Right ts))  -- | Resolve a name to a term in the graph, following variable references, and fail if the name is not bound requireTerm :: Graph.Graph -> Core.Name -> Either Errors.Error Core.Term requireTerm graph name =-    Optionals.cases (resolveTerm graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+    Optionals.match (resolveTerm graph name) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {       Errors.noSuchBindingErrorName = name})))) (\x -> Right x)  -- | TODO: distinguish between lambda-bound and let-bound variables@@ -286,7 +286,7 @@                 in case stripped of                   Core.TermVariable v0 -> resolveTerm graph v0                   _ -> Just term-      in (Optionals.cases (lookupTerm graph name) Nothing recurse)+      in (Optionals.match (lookupTerm graph name) Nothing recurse)  -- | Strip annotations and type lambdas/applications from a term, then follow variable references through the graph until a non-variable term is reached stripAndDereferenceTerm :: Graph.Graph -> Core.Term -> Either Errors.Error Core.Term
src/main/haskell/Hydra/Lib/Chars.hs view
@@ -33,7 +33,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  isAlpha :: Packaging.PrimitiveDefinition@@ -210,7 +210,7 @@         Packaging.entityMetadataDescription = (Just "Convert a character to lowercase."),         Packaging.entityMetadataComments = [           "Return the simple (one-to-one) Unicode lowercase mapping of the argument, or the argument itself if it has no lowercase mapping.",-          "This is a code-point-to-code-point mapping, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",+          "This is a code-point-to-code-point mapping, so it does not handle the string-changing match of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",           "The argument is interpreted as a Unicode code point.",           "Total. Corresponds to Haskell's Data.Char.toLower :: Char -> Char."],         Packaging.entityMetadataSeeAlso = [],@@ -238,7 +238,7 @@         Packaging.entityMetadataDescription = (Just "Convert a character to uppercase."),         Packaging.entityMetadataComments = [           "Return the simple (one-to-one) Unicode uppercase mapping of the argument, or the argument itself if it has no uppercase mapping.",-          "This is a code-point-to-code-point mapping, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",+          "This is a code-point-to-code-point mapping, so it does not handle the string-changing match of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",           "The argument is interpreted as a Unicode code point.",           "Total. Corresponds to Haskell's Data.Char.toUpper :: Char -> Char."],         Packaging.entityMetadataSeeAlso = [],
src/main/haskell/Hydra/Lib/Defaults.hs view
@@ -5,7 +5,7 @@ module Hydra.Lib.Defaults 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.Map as M @@ -277,7 +277,7 @@             Core.lambdaBody = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {-                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                 Core.applicationArgument = (Core.TermEither (Right (Core.TermOptional Nothing)))})),               Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -451,6 +451,53 @@                   Core.applicationArgument = (Core.TermVariable (Core.Name "x"))})),                 Core.applicationArgument = (Core.TermVariable (Core.Name "y"))}))}))}))}))),       (+        Core.Name "hydra.lib.functions.compose",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "g"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "f"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "x"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermVariable (Core.Name "g")),+                Core.applicationArgument = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))}))}))),+      (+        Core.Name "hydra.lib.functions.const",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "y"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))}))),+      (+        Core.Name "hydra.lib.functions.flip",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "f"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermLambda (Core.Lambda {+            Core.lambdaParameter = (Core.Name "x"),+            Core.lambdaDomain = Nothing,+            Core.lambdaBody = (Core.TermLambda (Core.Lambda {+              Core.lambdaParameter = (Core.Name "y"),+              Core.lambdaDomain = Nothing,+              Core.lambdaBody = (Core.TermApplication (Core.Application {+                Core.applicationFunction = (Core.TermApplication (Core.Application {+                  Core.applicationFunction = (Core.TermVariable (Core.Name "f")),+                  Core.applicationArgument = (Core.TermVariable (Core.Name "y"))})),+                Core.applicationArgument = (Core.TermVariable (Core.Name "x"))}))}))}))}))),+      (+        Core.Name "hydra.lib.functions.identity",+        (Core.TermLambda (Core.Lambda {+          Core.lambdaParameter = (Core.Name "x"),+          Core.lambdaDomain = Nothing,+          Core.lambdaBody = (Core.TermVariable (Core.Name "x"))}))),+      (         Core.Name "hydra.lib.lists.bind",         (Core.TermLambda (Core.Lambda {           Core.lambdaParameter = (Core.Name "xs"),@@ -733,7 +780,7 @@               Core.lambdaBody = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {                   Core.applicationFunction = (Core.TermApplication (Core.Application {-                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                    Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                     Core.applicationArgument = (Core.TermApplication (Core.Application {                       Core.applicationFunction = (Core.TermVariable (Core.Name "f")),                       Core.applicationArgument = (Core.TermApplication (Core.Application {@@ -963,7 +1010,7 @@             Core.lambdaBody = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {-                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                 Core.applicationArgument = (Core.TermOptional Nothing)})),               Core.applicationArgument = (Core.TermVariable (Core.Name "f"))}))}))}))),@@ -1040,7 +1087,7 @@                     Core.lambdaBody = (Core.TermApplication (Core.Application {                       Core.applicationFunction = (Core.TermApplication (Core.Application {                         Core.applicationFunction = (Core.TermApplication (Core.Application {-                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                          Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                           Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                         Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),                       Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -1061,7 +1108,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -1076,7 +1123,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -1094,7 +1141,7 @@             Core.lambdaBody = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {-                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                 Core.applicationArgument = (Core.TermOptional Nothing)})),               Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -1229,7 +1276,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermList [])})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -1248,7 +1295,7 @@             Core.lambdaBody = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {-                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                   Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                 Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})),               Core.applicationArgument = (Core.TermLambda (Core.Lambda {
src/main/haskell/Hydra/Lib/Effects.hs view
@@ -33,7 +33,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  apply :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Eithers.hs view
@@ -33,7 +33,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  apply :: Packaging.PrimitiveDefinition@@ -826,7 +826,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermEither (Right (Core.TermOptional Nothing)))})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {
src/main/haskell/Hydra/Lib/Equality.hs view
@@ -33,7 +33,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  equal :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Files.hs view
@@ -33,7 +33,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  appendFile :: Packaging.PrimitiveDefinition@@ -137,6 +137,38 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +createSymlink :: Packaging.PrimitiveDefinition+createSymlink =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.files.createSymlink"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Create a symbolic link."),+        Packaging.entityMetadataComments = [+          "createSymlink(target, link) describes an effectful computation which attempts to create a symbolic link at link, pointing to target (POSIX symlink). target is stored verbatim; it may be a relative path, and it need not exist. There is no force flag: if link already exists (including as a dangling symbolic link), the computation fails with left(alreadyExists); a caller that wants replace-if-exists semantics should compose status(false, link), removeFile, and createSymlink. A missing parent directory yields left(notFound); a host or file system which refuses to create the link (e.g. an unprivileged process on Windows, or an unsupported file system) yields left(permissionDenied) or left(other) as appropriate. A recoverable file-system failure is returned as left(error); success is returned as right(unit)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "target"),+            Typing.parameterDescription = (Just "the path that the new symbolic link will point to"),+            Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.file.FilePath")),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "link"),+            Typing.parameterDescription = (Just "the path of the symbolic link to create"),+            Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.file.FilePath")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEffect (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.error.file.FileError")),+            Core.eitherTypeRight = Core.TypeUnit})))}},+      Packaging.primitiveDefinitionIsPure = False,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ exists :: Packaging.PrimitiveDefinition exists =     Packaging.PrimitiveDefinition {@@ -218,6 +250,33 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} +readSymlink :: Packaging.PrimitiveDefinition+readSymlink =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.files.readSymlink"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "Read the target of a symbolic link."),+        Packaging.entityMetadataComments = [+          "readSymlink(path) describes an effectful computation which attempts to read the target of the symbolic link at path (POSIX readlink). This is a single-hop, unresolved read: the target is returned exactly as stored, with no chain resolution or canonicalization; a relative target is returned relative, and a dangling target (one that does not exist) is returned as-is. To resolve a chain of links to a canonical path, compose repeated calls to readSymlink and status. A missing path yields left(notFound); a path which exists but is not a symbolic link yields left(invalidPath). A recoverable file-system failure is returned as left(error); success is returned as right(target)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "path"),+            Typing.parameterDescription = (Just "the path of the symbolic link to read"),+            Typing.parameterType = (Core.TypeVariable (Core.Name "hydra.file.FilePath")),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeEffect (Core.TypeEither (Core.EitherType {+            Core.eitherTypeLeft = (Core.TypeVariable (Core.Name "hydra.error.file.FileError")),+            Core.eitherTypeRight = (Core.TypeVariable (Core.Name "hydra.file.FilePath"))})))}},+      Packaging.primitiveDefinitionIsPure = False,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ removeDirectory :: Packaging.PrimitiveDefinition removeDirectory =     Packaging.PrimitiveDefinition {@@ -316,12 +375,17 @@       Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {         Packaging.entityMetadataDescription = (Just "Retrieve metadata about a file or directory."),         Packaging.entityMetadataComments = [-          "status(path) describes an effectful computation which retrieves metadata about the file at path (POSIX stat), including its type, size, and modification time. Symbolic links are followed. A path which does not exist yields left(notFound); other recoverable file-system failures are also returned as left(error). Use exists for a boolean presence check that does not error on absence."],+          "status(followLinks, path) describes an effectful computation which retrieves metadata about the file system entry at path, including its type, size, and modification time. When followLinks is true, this corresponds to POSIX stat: if path is a symbolic link, the metadata describes the link's target, and a dangling link (whose target does not exist) yields left(notFound). When followLinks is false, this corresponds to POSIX lstat: the metadata describes the link itself, with fileType link, a size equal to the length of the stored target path, and the link's own timestamps; a dangling link is not an error in this mode. status(false, path) is the only way to observe fileType link; status(true, path) never produces it, since a followed link's metadata is always that of its (non-link) target. For paths that are not symbolic links, both modes report identical metadata. A path which does not exist yields left(notFound); other recoverable file-system failures are also returned as left(error). Use exists for a boolean presence check that does not error on absence."],         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = Nothing})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {         Typing.termSignatureTypeParameters = [],         Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "followLinks"),+            Typing.parameterDescription = (Just "whether to resolve symbolic links (true reproduces the previous, follow, behavior; false inspects the entry itself)"),+            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeBoolean),+            Typing.parameterIsLazy = False},           Typing.Parameter {             Typing.parameterName = (Core.Name "path"),             Typing.parameterDescription = (Just "the path to retrieve metadata for"),
src/main/haskell/Hydra/Lib/Functions.hs view
@@ -33,7 +33,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  compose :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Hashing.hs view
@@ -33,7 +33,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  sha256 :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Lists.hs view
@@ -33,7 +33,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  apply :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Literals.hs view
@@ -33,7 +33,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  base64ToBinary :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Logic.hs view
@@ -33,7 +33,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  and :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Maps.hs view
@@ -33,7 +33,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  alter :: Packaging.PrimitiveDefinition@@ -97,7 +97,7 @@             Core.lambdaBody = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {                 Core.applicationFunction = (Core.TermApplication (Core.Application {-                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                  Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                   Core.applicationArgument = (Core.TermApplication (Core.Application {                     Core.applicationFunction = (Core.TermVariable (Core.Name "f")),                     Core.applicationArgument = (Core.TermApplication (Core.Application {
src/main/haskell/Hydra/Lib/Math.hs view
@@ -33,7 +33,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  abs :: Packaging.PrimitiveDefinition@@ -276,7 +276,7 @@         Packaging.entityMetadataDescription = (Just "The two-argument arc tangent (atan2)."),         Packaging.entityMetadataComments = [           "atan2(y, x) returns the angle in radians, in (-\960, +\960], from the positive x-axis to the point (x, y), using the signs of both arguments to determine the quadrant.",-          "Special cases follow IEEE 754 \2681.2: atan2(\2832, +x>0) = \2832; atan2(\2832, -x<0) = \177\960; atan2(\177y>0, 0) = \177\960/2; atan2(\177y, +\8734) = \2832; atan2(\177y, -\8734) = \177\960; atan2(\177\8734, finite) = \177\960/2; atan2(\177\8734, +\8734) = \177\960/4; atan2(\177\8734, -\8734) = \2835\960/4; atan2 of any NaN argument is NaN.",+          "Special match follow IEEE 754 \2681.2: atan2(\2832, +x>0) = \2832; atan2(\2832, -x<0) = \177\960; atan2(\177y>0, 0) = \177\960/2; atan2(\177y, +\8734) = \2832; atan2(\177y, -\8734) = \177\960; atan2(\177\8734, finite) = \177\960/2; atan2(\177\8734, +\8734) = \177\960/4; atan2(\177\8734, -\8734) = \2835\960/4; atan2 of any NaN argument is NaN.",           "Corresponds to Haskell's atan2 :: Double -> Double -> Double."],         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = Nothing})),@@ -902,10 +902,10 @@     Packaging.PrimitiveDefinition {       Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.math.range"),       Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {-        Packaging.entityMetadataDescription = (Just "Construct the inclusive integer range from the first to the second argument."),+        Packaging.entityMetadataDescription = (Just "Construct the half-open integer range from the first argument up to (but excluding) the second."),         Packaging.entityMetadataComments = [-          "range(a, b) returns the list [a, a+1, ..., b]. The range is inclusive at both ends; if a > b the result is the empty list (i.e. the range does not count downward). For a = b the result is the singleton [a]. The length of the result is max(0, b - a + 1).",-          "Corresponds to Haskell's enumFromTo :: Int32 -> Int32 -> [Int32], equivalent to the list-comprehension form [a..b]."],+          "range(a, b) returns the list [a, a+1, ..., b-1]. The range is inclusive of the lower bound and exclusive of the upper bound; if a >= b the result is the empty list (i.e. the range does not count downward, and an empty range is the natural result of equal bounds). The length of the result is max(0, b - a).",+          "Does not directly correspond to Haskell's enumFromTo :: Int32 -> Int32 -> [Int32] (which is inclusive of both bounds, i.e. [a..b]); range(a, b) is equivalent to [a .. b-1]. This matches the half-open convention of Python's range, Rust's a..b, Go, and Java's IntStream.range."],         Packaging.entityMetadataSeeAlso = [],         Packaging.entityMetadataLifecycle = Nothing})),       Packaging.primitiveDefinitionSignature = Typing.TermSignature {@@ -918,7 +918,7 @@             Typing.parameterIsLazy = False},           Typing.Parameter {             Typing.parameterName = (Core.Name "b"),-            Typing.parameterDescription = (Just "the inclusive upper bound of the range"),+            Typing.parameterDescription = (Just "the exclusive upper bound of the range"),             Typing.parameterType = (Core.TypeLiteral (Core.LiteralTypeInteger Core.IntegerTypeInt32)),             Typing.parameterIsLazy = False}],         Typing.termSignatureResult = Typing.Result {@@ -1065,7 +1065,7 @@         Packaging.entityMetadataDescription = (Just "Numeric sign."),         Packaging.entityMetadataComments = [           "Constraint-polymorphic sign function over any type with a 'numeric' instance. For integer types, signum(x) returns -1 if x < 0, 0 if x = 0, and 1 if x > 0 (same width as the argument); unsigned integers return only 0 or 1. The function satisfies abs(x) * signum(x) = x for all integer instances except signed minBound (where the identity fails because +maxBound+1 is not representable).",-          "For floating-point, signum(x) returns \2833.0 for nonzero finite or infinite x (per IEEE 754 \2677.5.1); signum(\2832) = \2832 (the sign of the input zero is preserved, not collapsed to a single zero); signum(NaN) is NaN. A naive three-branch implementation (positive/negative/else- zero) gets both of these float cases wrong and must not be used.",+          "For floating-point, signum(x) returns \2833.0 for nonzero finite or infinite x (per IEEE 754 \2677.5.1); signum(\2832) = \2832 (the sign of the input zero is preserved, not collapsed to a single zero); signum(NaN) is NaN. A naive three-branch implementation (positive/negative/else- zero) gets both of these float match wrong and must not be used.",           "Requires a 'numeric' type-class constraint on the argument type.",           "Corresponds to Haskell's signum :: Num a => a -> a."],         Packaging.entityMetadataSeeAlso = [],
src/main/haskell/Hydra/Lib/Optionals.hs view
@@ -33,7 +33,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  apply :: Packaging.PrimitiveDefinition@@ -145,56 +145,11 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermOptional Nothing)})),             Core.applicationArgument = (Core.TermVariable (Core.Name "f"))}))}))})))} -cases :: Packaging.PrimitiveDefinition-cases =-    Packaging.PrimitiveDefinition {-      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.cases"),-      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {-        Packaging.entityMetadataDescription = (Just "Case analysis on an optional, with cases-style argument order."),-        Packaging.entityMetadataComments = [-          "cases(m, def, f) returns f(x) when m is given(x), and def when m is none.",-          "The fundamental eliminator for the optional type; every other primitive in this namespace can be derived from it. The optional value is the first argument, matching the convention for case-statement-like elimination.",-          "Total. Argument order is (m, def, f) rather than Haskell's maybe :: (def, f, m)."],-        Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),-      Packaging.primitiveDefinitionSignature = Typing.TermSignature {-        Typing.termSignatureTypeParameters = [-          Typing.TypeParameter {-            Typing.typeParameterName = (Core.Name "x"),-            Typing.typeParameterConstraints = []},-          Typing.TypeParameter {-            Typing.typeParameterName = (Core.Name "y"),-            Typing.typeParameterConstraints = []}],-        Typing.termSignatureParameters = [-          Typing.Parameter {-            Typing.parameterName = (Core.Name "m"),-            Typing.parameterDescription = (Just "the optional value to eliminate"),-            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),-            Typing.parameterIsLazy = False},-          Typing.Parameter {-            Typing.parameterName = (Core.Name "def"),-            Typing.parameterDescription = (Just "the value to return when the optional is none"),-            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),-            Typing.parameterIsLazy = True},-          Typing.Parameter {-            Typing.parameterName = (Core.Name "f"),-            Typing.parameterDescription = (Just "the function to apply to the contained value when the optional is given"),-            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {-              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),-              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),-            Typing.parameterIsLazy = False}],-        Typing.termSignatureResult = Typing.Result {-          Typing.resultDescription = Nothing,-          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},-      Packaging.primitiveDefinitionIsPure = True,-      Packaging.primitiveDefinitionIsTotal = True,-      Packaging.primitiveDefinitionDefaultImplementation = Nothing}- compose :: Packaging.PrimitiveDefinition compose =     Packaging.PrimitiveDefinition {@@ -384,7 +339,7 @@                   Core.lambdaBody = (Core.TermApplication (Core.Application {                     Core.applicationFunction = (Core.TermApplication (Core.Application {                       Core.applicationFunction = (Core.TermApplication (Core.Application {-                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                        Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                         Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),                       Core.applicationArgument = (Core.TermVariable (Core.Name "acc"))})),                     Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -431,7 +386,7 @@         Core.lambdaBody = (Core.TermApplication (Core.Application {           Core.applicationFunction = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {-              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),               Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),             Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean False))})),           Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -472,7 +427,7 @@         Core.lambdaBody = (Core.TermApplication (Core.Application {           Core.applicationFunction = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {-              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),               Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),             Core.applicationArgument = (Core.TermLiteral (Core.LiteralBoolean True))})),           Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -527,7 +482,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermOptional Nothing)})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -760,6 +715,51 @@                 Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.sets.toList")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "s"))}))}))}))}))})))} +match :: Packaging.PrimitiveDefinition+match =+    Packaging.PrimitiveDefinition {+      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.optionals.match"),+      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {+        Packaging.entityMetadataDescription = (Just "The fundamental eliminator for the optional type, scrutinee-first."),+        Packaging.entityMetadataComments = [+          "match(m, def, f) returns f(x) when m is given(x), and def when m is none.",+          "The fundamental eliminator for the optional type; every other primitive in this namespace can be derived from it. The optional value is the first argument, matching the convention for case-statement-like elimination.",+          "Total. Argument order is (m, def, f) rather than Haskell's maybe :: (def, f, m)."],+        Packaging.entityMetadataSeeAlso = [],+        Packaging.entityMetadataLifecycle = Nothing})),+      Packaging.primitiveDefinitionSignature = Typing.TermSignature {+        Typing.termSignatureTypeParameters = [+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "x"),+            Typing.typeParameterConstraints = []},+          Typing.TypeParameter {+            Typing.typeParameterName = (Core.Name "y"),+            Typing.typeParameterConstraints = []}],+        Typing.termSignatureParameters = [+          Typing.Parameter {+            Typing.parameterName = (Core.Name "m"),+            Typing.parameterDescription = (Just "the optional value to eliminate"),+            Typing.parameterType = (Core.TypeOptional (Core.TypeVariable (Core.Name "x"))),+            Typing.parameterIsLazy = False},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "def"),+            Typing.parameterDescription = (Just "the value to return when the optional is none"),+            Typing.parameterType = (Core.TypeVariable (Core.Name "y")),+            Typing.parameterIsLazy = True},+          Typing.Parameter {+            Typing.parameterName = (Core.Name "f"),+            Typing.parameterDescription = (Just "the function to apply to the contained value when the optional is given"),+            Typing.parameterType = (Core.TypeFunction (Core.FunctionType {+              Core.functionTypeDomain = (Core.TypeVariable (Core.Name "x")),+              Core.functionTypeCodomain = (Core.TypeVariable (Core.Name "y"))})),+            Typing.parameterIsLazy = False}],+        Typing.termSignatureResult = Typing.Result {+          Typing.resultDescription = Nothing,+          Typing.resultType = (Core.TypeVariable (Core.Name "y"))}},+      Packaging.primitiveDefinitionIsPure = True,+      Packaging.primitiveDefinitionIsTotal = True,+      Packaging.primitiveDefinitionDefaultImplementation = Nothing}+ pure :: Packaging.PrimitiveDefinition pure =     Packaging.PrimitiveDefinition {@@ -825,7 +825,7 @@         Core.lambdaBody = (Core.TermApplication (Core.Application {           Core.applicationFunction = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {-              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+              Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),               Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),             Core.applicationArgument = (Core.TermList [])})),           Core.applicationArgument = (Core.TermLambda (Core.Lambda {@@ -875,7 +875,7 @@           Core.lambdaBody = (Core.TermApplication (Core.Application {             Core.applicationFunction = (Core.TermApplication (Core.Application {               Core.applicationFunction = (Core.TermApplication (Core.Application {-                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.cases")),+                Core.applicationFunction = (Core.TermVariable (Core.Name "hydra.lib.optionals.match")),                 Core.applicationArgument = (Core.TermVariable (Core.Name "m"))})),               Core.applicationArgument = (Core.TermVariable (Core.Name "def"))})),             Core.applicationArgument = (Core.TermLambda (Core.Lambda {
src/main/haskell/Hydra/Lib/Ordering.hs view
@@ -33,7 +33,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  compare :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Pairs.hs view
@@ -33,7 +33,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  bimap :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Regex.hs view
@@ -33,7 +33,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  find :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Sets.hs view
@@ -33,7 +33,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  delete :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Strings.hs view
@@ -33,7 +33,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  charAt :: Packaging.PrimitiveDefinition@@ -209,33 +209,6 @@       Packaging.primitiveDefinitionIsTotal = True,       Packaging.primitiveDefinitionDefaultImplementation = Nothing} -lines :: Packaging.PrimitiveDefinition-lines =-    Packaging.PrimitiveDefinition {-      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.lines"),-      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {-        Packaging.entityMetadataDescription = (Just "Split a string into lines."),-        Packaging.entityMetadataComments = [-          "lines(s) splits s into a list of lines, splitting on newline characters (U+000A).",-          "The trailing newline is consumed but does not produce an empty trailing element (matching Haskell's lines behavior).",-          "Total. Corresponds to Haskell's lines :: String -> [String]."],-        Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),-      Packaging.primitiveDefinitionSignature = Typing.TermSignature {-        Typing.termSignatureTypeParameters = [],-        Typing.termSignatureParameters = [-          Typing.Parameter {-            Typing.parameterName = (Core.Name "s"),-            Typing.parameterDescription = (Just "the string to split into lines"),-            Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),-            Typing.parameterIsLazy = False}],-        Typing.termSignatureResult = Typing.Result {-          Typing.resultDescription = Nothing,-          Typing.resultType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString))}},-      Packaging.primitiveDefinitionIsPure = True,-      Packaging.primitiveDefinitionIsTotal = True,-      Packaging.primitiveDefinitionDefaultImplementation = Nothing}- null :: Packaging.PrimitiveDefinition null =     Packaging.PrimitiveDefinition {@@ -328,7 +301,7 @@         Packaging.entityMetadataDescription = (Just "Convert a string to lowercase."),         Packaging.entityMetadataComments = [           "toLower(s) returns s with each character replaced by its Unicode simple (one-to-one) lowercase mapping, or itself if it has no lowercase mapping.",-          "This is a code-point-by-code-point operation, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",+          "This is a code-point-by-code-point operation, so it does not handle the string-changing match of full Unicode case folding (e.g. U+00DF \"\223\" does not lowercase to \"ss\"; it returns itself).",           "For text intended for human-readable display in locales with non-trivial case mappings, prefer a host-specific full case-folding API.",           "Total."],         Packaging.entityMetadataSeeAlso = [],@@ -356,7 +329,7 @@         Packaging.entityMetadataDescription = (Just "Convert a string to uppercase."),         Packaging.entityMetadataComments = [           "toUpper(s) returns s with each character replaced by its Unicode simple (one-to-one) uppercase mapping, or itself if it has no uppercase mapping.",-          "This is a code-point-by-code-point operation, so it does not handle the string-changing cases of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",+          "This is a code-point-by-code-point operation, so it does not handle the string-changing match of full Unicode case folding (e.g. U+00DF \"\223\" does not uppercase to \"SS\"; it returns itself).",           "For text intended for human-readable display in locales with non-trivial case mappings, prefer a host-specific full case-folding API.",           "Total."],         Packaging.entityMetadataSeeAlso = [],@@ -368,32 +341,6 @@             Typing.parameterName = (Core.Name "s"),             Typing.parameterDescription = (Just "the string to convert to uppercase"),             Typing.parameterType = (Core.TypeLiteral Core.LiteralTypeString),-            Typing.parameterIsLazy = False}],-        Typing.termSignatureResult = Typing.Result {-          Typing.resultDescription = Nothing,-          Typing.resultType = (Core.TypeLiteral Core.LiteralTypeString)}},-      Packaging.primitiveDefinitionIsPure = True,-      Packaging.primitiveDefinitionIsTotal = True,-      Packaging.primitiveDefinitionDefaultImplementation = Nothing}--unlines :: Packaging.PrimitiveDefinition-unlines =-    Packaging.PrimitiveDefinition {-      Packaging.primitiveDefinitionName = (Core.Name "hydra.lib.strings.unlines"),-      Packaging.primitiveDefinitionMetadata = (Just (Packaging.EntityMetadata {-        Packaging.entityMetadataDescription = (Just "Join a list of strings with newlines, appending a trailing newline."),-        Packaging.entityMetadataComments = [-          "unlines(xs) returns the concatenation of every string in xs with a newline character (U+000A) appended after each, including the last. The inverse of lines for normalized input.",-          "Total. Corresponds to Haskell's unlines :: [String] -> String."],-        Packaging.entityMetadataSeeAlso = [],-        Packaging.entityMetadataLifecycle = Nothing})),-      Packaging.primitiveDefinitionSignature = Typing.TermSignature {-        Typing.termSignatureTypeParameters = [],-        Typing.termSignatureParameters = [-          Typing.Parameter {-            Typing.parameterName = (Core.Name "xs"),-            Typing.parameterDescription = (Just "the list of strings to join with newlines"),-            Typing.parameterType = (Core.TypeList (Core.TypeLiteral Core.LiteralTypeString)),             Typing.parameterIsLazy = False}],         Typing.termSignatureResult = Typing.Result {           Typing.resultDescription = Nothing,
src/main/haskell/Hydra/Lib/System.hs view
@@ -33,7 +33,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  execute :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Lib/Text.hs view
@@ -33,7 +33,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  decodeUtf8 :: Packaging.PrimitiveDefinition
src/main/haskell/Hydra/Literals.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  -- | Convert a bigint to an integer value of a given type (note: lossy)
src/main/haskell/Hydra/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 import qualified Data.Map as M import qualified Data.Set as S@@ -68,7 +68,7 @@       let qualName = qualifyName name           mns = Util.qualifiedNameModuleName qualName           local = Util.qualifiedNameLocal qualName-      in (Optionals.cases mns (Core.unName name) (\ns -> Optionals.cases (Maps.lookup ns namespaces) local (\pre -> Strings.concat [+      in (Optionals.match mns (Core.unName name) (\ns -> Optionals.match (Maps.lookup ns namespaces) local (\pre -> Strings.concat [         pre,         ":",         local])))@@ -86,7 +86,7 @@           prefixedResult = Core.Name (Strings.join "." (Lists.concat2 categoryPrefix [                 localName]))           noNamespaceResult = Logic.ifElse prefixWhenNoNamespace prefixedResult localResult-      in (Optionals.cases (Lists.init (Strings.splitOn "." (Core.unName n))) noNamespaceResult (\nsParts -> Optionals.cases (Lists.uncons nsParts) noNamespaceResult (\nsHeadTail ->+      in (Optionals.match (Lists.init (Strings.splitOn "." (Core.unName n))) noNamespaceResult (\nsParts -> Optionals.match (Lists.uncons nsParts) noNamespaceResult (\nsHeadTail ->         let categoryPrefixResolved =                 Logic.ifElse (Logic.or alwaysDropFirst (Equality.equal (Pairs.first nsHeadTail) "hydra")) (Lists.concat2 categoryPrefix (Pairs.second nsHeadTail)) (Lists.concat2 categoryPrefix nsParts)         in (Core.Name (Strings.join "." (Lists.concat2 categoryPrefixResolved [@@ -98,7 +98,7 @@        let parts = Strings.splitOn "." (Packaging.unModuleName ns)           fallback = Packaging.ModuleName (Strings.join "." (Lists.concat2 categoryPrefix parts))-      in (Optionals.cases (Lists.uncons parts) fallback (\ht -> Logic.ifElse (Logic.or alwaysDropFirst (Equality.equal (Pairs.first ht) "hydra")) (Packaging.ModuleName (Strings.join "." (Lists.concat2 categoryPrefix (Pairs.second ht)))) fallback))+      in (Optionals.match (Lists.uncons parts) fallback (\ht -> Logic.ifElse (Logic.or alwaysDropFirst (Equality.equal (Pairs.first ht) "hydra")) (Packaging.ModuleName (Strings.join "." (Lists.concat2 categoryPrefix (Pairs.second ht)))) fallback))  -- | Generate a fresh type variable name, threading InferenceContext freshName :: Typing.InferenceContext -> (Core.Name, Typing.InferenceContext)@@ -149,7 +149,7 @@           local = Util.qualifiedNameLocal qualName           nsToFilePath =                   \nsArg -> Strings.join "/" (Lists.map (\part -> Formatting.convertCase Util.CaseConventionCamel nsConv part) (Strings.splitOn "." (Packaging.unModuleName nsArg)))-          prefix = Optionals.cases ns "" (\n -> Strings.concat2 (nsToFilePath n) "/")+          prefix = Optionals.match ns "" (\n -> Strings.concat2 (nsToFilePath n) "/")           suffix = Formatting.convertCase Util.CaseConventionPascal localConv local       in (Strings.concat [         prefix,@@ -181,7 +181,7 @@ qualifyName name =        let parts = Lists.reverse (Strings.splitOn "." (Core.unName name))-      in (Optionals.cases (Lists.uncons parts) (Util.QualifiedName {+      in (Optionals.match (Lists.uncons parts) (Util.QualifiedName {         Util.qualifiedNameModuleName = Nothing,         Util.qualifiedNameLocal = (Core.unName name)}) (\uc ->         let localName = Pairs.first uc@@ -203,5 +203,5 @@ unqualifyName :: Util.QualifiedName -> Core.Name unqualifyName qname = -      let prefix = Optionals.cases (Util.qualifiedNameModuleName qname) "" (\n -> Strings.concat2 (Packaging.unModuleName n) ".")+      let prefix = Optionals.match (Util.qualifiedNameModuleName qname) "" (\n -> Strings.concat2 (Packaging.unModuleName n) ".")       in (Core.Name (Strings.concat2 prefix (Util.qualifiedNameLocal qname)))
src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Phantoms.hs view
@@ -85,11 +85,11 @@   --- | Apply a named case match to an argument--- Example: cases resultTypeName myResult Nothing [onSuccess, onError]+-- | Create an unapplied pattern match on a union term+-- Example: cases (Name "Result") (Just $ string "what?") ["success">: string "yay", "error">: string "boo"] -- See also: 'match'-cases :: Name -> TypedTerm a -> Maybe (TypedTerm b) -> [Field] -> TypedTerm b-cases name arg dflt fields = TypedTerm $ Terms.apply (Terms.match name (unTypedTerm <$> dflt) fields) (unTypedTerm arg)+cases :: AsName n => n -> Maybe (TypedTerm b) -> [Field] -> TypedTerm (a -> b)+cases n dflt fields = TypedTerm $ Terms.match (asName n) (unTypedTerm <$> dflt) fields  -- | Compose two functions (g then f) -- Example: compose (var "stringLength") (var "toString")@@ -313,10 +313,11 @@   where     fromTypedTerm (TypedTerm k, TypedTerm v) = (k, v) --- | Create a pattern match on a union term--- Example: match (Name "Result") (Just $ string "what?") ["success">: string "yay", "error">: string "boo"]-match :: AsName n => n -> Maybe (TypedTerm b) -> [Field] -> TypedTerm (a -> b)-match n dflt fields = TypedTerm $ Terms.match (asName n) (unTypedTerm <$> dflt) fields+-- | Apply a named case match to an argument+-- Example: match resultTypeName myResult Nothing [onSuccess, onError]+-- See also: 'cases'+match :: AsName n => n -> TypedTerm a -> Maybe (TypedTerm b) -> [Field] -> TypedTerm b+match n arg dflt fields = TypedTerm $ Terms.apply (Terms.match (asName n) (unTypedTerm <$> dflt) fields) (unTypedTerm arg)  -- | Lift a Haskell Name value to a phantom-typed TypedTerm Name nameLift :: Name -> TypedTerm Name@@ -333,7 +334,7 @@ opt mc = TypedTerm $ Terms.optional (unTypedTerm <$> mc)  optCases :: AsTerm f (a -> b) => TypedTerm (Maybe a) -> TypedTerm b -> f -> TypedTerm b-optCases arg ifNothing ifJust = primitive3 (Name "hydra.lib.optionals.cases") arg ifNothing (asTerm ifJust)+optCases arg ifNothing ifJust = primitive3 (Name "hydra.lib.optionals.match") arg ifNothing (asTerm ifJust)  -- | Create a pair -- Example: pair (string "age") (int32 32)
src/main/haskell/Hydra/Overlay/Haskell/Dsl/Typed/Testing.hs view
@@ -256,7 +256,7 @@ stringEvalPair cname = evalPair cname (Phantoms.lambda "s" (Phantoms.var "s"))  subgroup :: AsTerm t TestCaseWithMetadata => String -> [t] -> TypedTerm TestGroup-subgroup name cases = tgroup name Nothing [] (asTerm <$> cases)+subgroup name match = tgroup name Nothing [] (asTerm <$> match)  supergroup :: AsTerm t TestGroup => String -> [t] -> TypedTerm TestGroup supergroup name subgroups = tgroup name Nothing (asTerm <$> subgroups) []@@ -272,7 +272,7 @@ testGraphRef = TypedTerm $ TermVariable $ Name "hydra.test.testGraph.testGraph"  tgroup :: String -> Maybe String -> [TypedTerm TestGroup] -> [TypedTerm TestCaseWithMetadata] -> TypedTerm TestGroup-tgroup name mdesc subgroups cases = testGroup (Phantoms.string name) (opt (Phantoms.string <$> mdesc)) (Phantoms.list subgroups) (Phantoms.list cases)+tgroup name mdesc subgroups match = testGroup (Phantoms.string name) (opt (Phantoms.string <$> mdesc)) (Phantoms.list subgroups) (Phantoms.list match)  typeSchemeToFTypeRef :: TypedTerm (TypeScheme -> Type) typeSchemeToFTypeRef = TypedTerm $ TermVariable $ Name "hydra.scoping.typeSchemeToFType"@@ -478,11 +478,11 @@ testCaseWithMetadataTags = Phantoms.project _TestCaseWithMetadata _TestCaseWithMetadata_tags  testGroup :: TypedTerm String -> TypedTerm (Maybe String) -> TypedTerm [TestGroup] -> TypedTerm [TestCaseWithMetadata] -> TypedTerm TestGroup-testGroup name description subgroups cases = Phantoms.record _TestGroup [+testGroup name description subgroups match = Phantoms.record _TestGroup [   _TestGroup_name>>: name,   _TestGroup_description>>: description,   _TestGroup_subgroups>>: subgroups,-  _TestGroup_cases>>: cases]+  _TestGroup_cases>>: match]  -- | Convenience function for creating type reduction test cases typeRedCase :: String -> TypedTerm Type -> TypedTerm Type -> TypedTerm TestCaseWithMetadata@@ -529,12 +529,12 @@ -- 'validateCoreTermCaseWithProfile' instead. validateCoreTermCase :: String -> TypedTerm Bool -> TypedTerm Term -> TypedTerm (Maybe InvalidTermError) -> TypedTerm TestCaseWithMetadata validateCoreTermCase cname typed input expected = universalCase cname-  (retype $ Optionals.cases+  (retype $ Optionals.match     (Lists.head $ Validation.validationResultErrors $       validateCoreTermProfiledRef @@ kernelDefaultCoreProfileRef @@ typed @@ testGraphRef @@ input)     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidTermErrorRef @@ Phantoms.var "e")))-  (retype $ Optionals.cases+  (retype $ Optionals.match     expected     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidTermErrorRef @@ Phantoms.var "e")))@@ -547,11 +547,11 @@ -- the result against the expected Maybe InvalidModuleError. validatePackagingModuleCase :: String -> TypedTerm (Module -> Maybe InvalidModuleError) -> TypedTerm Module -> TypedTerm (Maybe InvalidModuleError) -> TypedTerm TestCaseWithMetadata validatePackagingModuleCase cname validator input expected = universalCase cname-  (retype $ Optionals.cases+  (retype $ Optionals.match     (validator @@ input)     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidModuleErrorRef @@ Phantoms.var "e")))-  (retype $ Optionals.cases+  (retype $ Optionals.match     expected     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidModuleErrorRef @@ Phantoms.var "e")))@@ -564,11 +564,11 @@ -- the result against the expected Maybe InvalidPackageError. validatePackagingPackageCase :: String -> TypedTerm (Package -> Maybe InvalidPackageError) -> TypedTerm Package -> TypedTerm (Maybe InvalidPackageError) -> TypedTerm TestCaseWithMetadata validatePackagingPackageCase cname validator input expected = universalCase cname-  (retype $ Optionals.cases+  (retype $ Optionals.match     (validator @@ input)     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidPackageErrorRef @@ Phantoms.var "e")))-  (retype $ Optionals.cases+  (retype $ Optionals.match     expected     (Phantoms.string "valid")     (Phantoms.lambda "e" (showInvalidPackageErrorRef @@ Phantoms.var "e")))
src/main/haskell/Hydra/Overlay/Haskell/Lib/Files.hs view
@@ -9,8 +9,9 @@ import qualified Hydra.Time as Time import qualified System.Directory as Dir import qualified System.IO.Error as IOE-import Data.Time.Clock (UTCTime)-import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds)+import qualified System.Posix.Files as Posix+import System.Posix.Types (EpochTime(..))+import Foreign.C.Types (CTime(..)) import Prelude hiding (appendFile, readFile, writeFile)  @@ -32,6 +33,10 @@       then Dir.createDirectoryIfMissing True (File.unFilePath path)       else Dir.createDirectory (File.unFilePath path) +createSymlink :: File.FilePath -> File.FilePath -> IO (Either FileError.FileError ())+createSymlink target link =+  withFileError link $ Posix.createSymbolicLink (File.unFilePath target) (File.unFilePath link)+ exists :: File.FilePath -> IO (Either FileError.FileError Bool) exists path =   withFileError path $ Dir.doesPathExist (File.unFilePath path)@@ -45,6 +50,15 @@ readFile path =   withFileError path $ BS.readFile (File.unFilePath path) +readSymlink :: File.FilePath -> IO (Either FileError.FileError File.FilePath)+readSymlink path =+  withFileError path $ do+    isLink <- Posix.isSymbolicLink <$> Posix.getSymbolicLinkStatus (File.unFilePath path)+    if isLink+      then File.FilePath <$> Posix.readSymbolicLink (File.unFilePath path)+      else E.throwIO (IOE.mkIOError IOE.illegalOperationErrorType "readSymlink" Nothing+             (Just (File.unFilePath path)))+ removeDirectory :: Bool -> File.FilePath -> IO (Either FileError.FileError ()) removeDirectory recursive path =   withFileError path $@@ -60,19 +74,18 @@ rename source destination =   withFileError source $ Dir.renamePath (File.unFilePath source) (File.unFilePath destination) -status :: File.FilePath -> IO (Either FileError.FileError File.FileStatus)-status path =+status :: Bool -> File.FilePath -> IO (Either FileError.FileError File.FileStatus)+status followLinks path =   withFileError path $ do     let p = File.unFilePath path-    isDir <- Dir.doesDirectoryExist p-    size <- Dir.getFileSize p-    mtime <- Dir.getModificationTime p+        getStatus = if followLinks then Posix.getFileStatus else Posix.getSymbolicLinkStatus+    st <- getStatus p     pure File.FileStatus {-      File.fileStatusFileType = if isDir then File.FileTypeDirectory else File.FileTypeRegular,-      File.fileStatusSize = fromInteger size,-      File.fileStatusModificationTime = utcToTimespec mtime,-      File.fileStatusAccessTime = Nothing,-      File.fileStatusStatusChangeTime = Nothing}+      File.fileStatusFileType = posixFileType st,+      File.fileStatusSize = fromIntegral (Posix.fileSize st),+      File.fileStatusModificationTime = epochToTimespec (Posix.modificationTime st),+      File.fileStatusAccessTime = Just (epochToTimespec (Posix.accessTime st)),+      File.fileStatusStatusChangeTime = Just (epochToTimespec (Posix.statusChangeTime st))}  writeFile :: File.FilePath -> BS.ByteString -> IO (Either FileError.FileError ()) writeFile path contents =@@ -93,15 +106,25 @@   | IOE.isIllegalOperation e = FileError.FileErrorInvalidPath (IOE.ioeGetErrorString e)   | otherwise = FileError.FileErrorOther (IOE.ioeGetErrorString e) --- | Convert a UTCTime to a hydra.time.Timespec (seconds + nanoseconds since the Unix Epoch).-utcToTimespec :: UTCTime -> Time.Timespec-utcToTimespec t =-  let picos = floor (toRational (utcTimeToPOSIXSeconds t) * 1000000000000) :: Integer-      (secs, subPicos) = picos `divMod` 1000000000000-      nanos = subPicos `div` 1000-  in Time.Timespec {-       Time.timespecSeconds = fromInteger secs,-       Time.timespecNanoseconds = fromInteger nanos}+-- | Classify a POSIX file status's file type as a hydra.file.FileType.+posixFileType :: Posix.FileStatus -> File.FileType+posixFileType st+  | Posix.isSymbolicLink st  = File.FileTypeLink+  | Posix.isDirectory st     = File.FileTypeDirectory+  | Posix.isRegularFile st   = File.FileTypeRegular+  | Posix.isBlockDevice st   = File.FileTypeBlock+  | Posix.isCharacterDevice st = File.FileTypeCharacter+  | Posix.isNamedPipe st     = File.FileTypeFifo+  | Posix.isSocket st        = File.FileTypeSocket+  | otherwise                = File.FileTypeRegular++-- | Convert a POSIX EpochTime (whole seconds since the Unix Epoch; sub-second resolution is not+-- exposed by the portable "unix" API) to a hydra.time.Timespec.+epochToTimespec :: EpochTime -> Time.Timespec+epochToTimespec (CTime secs) =+  Time.Timespec {+    Time.timespecSeconds = fromIntegral secs,+    Time.timespecNanoseconds = 0}  -- | Recursively copy a directory tree from source to destination. copyDirectoryRecursive :: FilePath -> FilePath -> IO ()
src/main/haskell/Hydra/Overlay/Haskell/Lib/Math.hs view
@@ -144,9 +144,9 @@ pow :: Double -> Double -> Double pow = (Prelude.**) --- | Generate a range of values from start to end (inclusive).-range :: Enum a => a -> a -> [a]-range start end = [start .. end]+-- | Generate a half-open range of values from start (inclusive) to end (exclusive).+range :: (Enum a, Ord a) => a -> a -> [a]+range start end = if start Prelude.>= end then [] else [start .. Prelude.pred end]  -- | Integer remainder, returning Nothing on division by zero. rem :: Int -> Int -> Maybe Int
src/main/haskell/Hydra/Overlay/Haskell/Lib/Optionals.hs view
@@ -16,10 +16,6 @@ bind :: Y.Maybe a -> (a -> Y.Maybe b) -> Y.Maybe b bind = (>>=) --- | Handle an optional value with the absent-case value as the first argument.-cases :: Y.Maybe a -> b -> (a -> b) -> b-cases m n j = Y.maybe n j m- -- | Compose two optional-returning functions (Kleisli composition). compose :: (a -> Y.Maybe b) -> (b -> Y.Maybe c) -> (a -> Y.Maybe c) compose f g = \x -> f x >>= g@@ -55,6 +51,10 @@ -- | Traverse a set in the optional monad. mapSet :: Ord b => (a -> Y.Maybe b) -> S.Set a -> Y.Maybe (S.Set b) mapSet f s = fmap S.fromList (CM.mapM f (S.toList s))++-- | Handle an optional value with the absent-case value as the first argument.+match :: Y.Maybe a -> b -> (a -> b) -> b+match m n j = Y.maybe n j m  -- | Lift a value into the optional type. pure :: a -> Y.Maybe a
src/main/haskell/Hydra/Overlay/Haskell/Lib/Strings.hs view
@@ -34,10 +34,6 @@ length :: String -> Int length = L.length --- | Split a string into lines.-lines :: String -> [String]-lines = L.lines- -- | Check whether a string is empty. null :: String -> Bool null = L.null@@ -57,7 +53,3 @@ -- | Convert a string to uppercase. toUpper :: String -> String toUpper = fmap C.toUpper---- | Join a list of strings with newlines, appending a trailing newline.-unlines :: [String] -> String-unlines = L.unlines
src/main/haskell/Hydra/Overlay/Haskell/Libraries.hs view
@@ -113,9 +113,11 @@     unsupportedEffectPrimitive DefFiles.appendFile,     unsupportedEffectPrimitive DefFiles.copy,     unsupportedEffectPrimitive DefFiles.createDirectory,+    unsupportedEffectPrimitive DefFiles.createSymlink,     unsupportedEffectPrimitive DefFiles.exists,     unsupportedEffectPrimitive DefFiles.listDirectory,     unsupportedEffectPrimitive DefFiles.readFile,+    unsupportedEffectPrimitive DefFiles.readSymlink,     unsupportedEffectPrimitive DefFiles.removeDirectory,     unsupportedEffectPrimitive DefFiles.removeFile,     unsupportedEffectPrimitive DefFiles.rename,@@ -372,7 +374,7 @@ hydraLibOptionals = standardLibrary [     prim2     DefOptionals.apply     Optionals.apply        (optional $ funT x_ y_) (optional x_) (optional y_),     prim2     DefOptionals.bind      Optionals.bind         (optional x_) (fun x_ (optional y_)) (optional y_),-    prim3 DefOptionals.cases     Optionals.cases        (optional x_) y_ (funT x_ y_) y_,+    prim3 DefOptionals.match     Optionals.match        (optional x_) y_ (funT x_ y_) y_,     prim1     DefOptionals.givens       Optionals.givens          (list $ optional x_) (list x_),     prim3     DefOptionals.compose   Optionals.compose      (fun x_ $ optional y_) (fun y_ $ optional z_) x_ (optional z_),     prim3     DefOptionals.foldList  Optionals.foldList     (fun x_ (fun y_ (optional x_))) x_ (list y_) (optional x_),@@ -432,14 +434,12 @@   prim2 DefStrings.join Strings.join string (list string) string,   prim2 DefStrings.join        Strings.join        string (list string) string,   prim1 DefStrings.length      Strings.length      string int32,-  prim1 DefStrings.lines       Strings.lines       string (list string),   prim2 DefStrings.charAt Strings.charAt int32 string (optional int32),   prim1 DefStrings.null        Strings.null        string boolean,   prim2 DefStrings.splitOn     Strings.splitOn     string string (list string),   prim1 DefStrings.toList      Strings.toList      string (list int32),   prim1 DefStrings.toLower     Strings.toLower     string string,-  prim1 DefStrings.toUpper     Strings.toUpper     string string,-  prim1 DefStrings.unlines     Strings.unlines     (list string) string]+  prim1 DefStrings.toUpper     Strings.toUpper     string string]  hydraLibSystem :: Library hydraLibSystem = standardLibrary [
src/main/haskell/Hydra/Packaging.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  -- | A definition, which may be either a term, type, or primitive definition
src/main/haskell/Hydra/Parse/Docs.hs view
@@ -38,7 +38,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  -- | Parse the content between the doc-escape delimiters into an EntityReference. The input is the inner content (tag and optional rhs), e.g. "type hydra.core.Lambda". Returns nothing for unrecognized tags.@@ -63,7 +63,7 @@                         inner = Optionals.withDefault "" (Lists.head subparts)                         after = Strings.join "}" (Lists.drop 1 subparts)                         mref = parseDocAnnotation inner-                    in (Optionals.cases mref [+                    in (Optionals.match mref [                       Docs.DocSegmentText (Strings.concat2 "{@" part)] (\ref -> Optionals.givens [                       Just (Docs.DocSegmentRef ref),                       (Logic.ifElse (Equality.equal after "") Nothing (Just (Docs.DocSegmentText after)))]))
src/main/haskell/Hydra/Parse/Regex.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  -- | Parse an alternation of sequences separated by |. When there is more than one branch, each branch must be non-empty; empty branches (a|, |b, a||b, and the nested (a|)) are rejected at every level. A single empty branch is the legal empty case (empty whole pattern / empty group).@@ -66,7 +66,7 @@ characterClass :: Parsing.Parser Regex.Atom characterClass =     Parsers.bind (Parsers.char 91) (\_ -> Parsers.bind (Parsers.optional (Parsers.char 94)) (\neg -> Parsers.bind (Parsers.some classItem) (\items -> Parsers.bind (Parsers.char 93) (\_2 -> Parsers.pure (Regex.AtomClass (Regex.CharacterClass {-      Regex.characterClassNegated = (Optionals.cases neg False (\_3 -> True)),+      Regex.characterClassNegated = (Optionals.match neg False (\_3 -> True)),       Regex.characterClassItems = items}))))))  -- | Parse one member of a character class: a range like a-z, or a single character (escapes allowed).@@ -111,7 +111,7 @@ parseRegex :: String -> Maybe [[Regex.Quantified]] parseRegex input =     (\x -> case x of-      Parsing.ParseResultSuccess v0 -> Logic.ifElse (Equality.equal (Parsing.parseSuccessRemainder v0) "") (Just (Parsing.parseSuccessValue v0)) Nothing+      Parsing.ParseResultSuccess v0 -> Logic.ifElse (Lists.null (Parsing.parseSuccessRemainder v0)) (Just (Parsing.parseSuccessValue v0)) Nothing       Parsing.ParseResultFailure _ -> Nothing) (Parsers.runParser regex input)  -- | Parse an atom followed by an optional quantifier.@@ -128,7 +128,7 @@       Parsers.bind (Parsers.char 42) (\_ -> Parsers.pure Regex.QuantifierZeroOrMore),       (Parsers.bind (Parsers.char 43) (\_ -> Parsers.pure Regex.QuantifierOneOrMore)),       (Parsers.bind (Parsers.char 63) (\_ -> Parsers.pure Regex.QuantifierZeroOrOne)),-      (Parsers.bind (Parsers.char 123) (\_ -> Parsers.bind unsignedInt (\n -> Parsers.bind (Parsers.optional (Parsers.char 44)) (\comma -> Optionals.cases comma (Parsers.bind (Parsers.char 125) (\_2 -> Parsers.pure (Regex.QuantifierExactly n))) (\_2 -> Parsers.bind (Parsers.optional unsignedInt) (\mm -> Parsers.bind (Parsers.char 125) (\_3 -> Optionals.cases mm (Parsers.pure (Regex.QuantifierAtLeast n)) (\m -> Parsers.pure (Regex.QuantifierRange_ (Regex.QuantifierRange {+      (Parsers.bind (Parsers.char 123) (\_ -> Parsers.bind unsignedInt (\n -> Parsers.bind (Parsers.optional (Parsers.char 44)) (\comma -> Optionals.match comma (Parsers.bind (Parsers.char 125) (\_2 -> Parsers.pure (Regex.QuantifierExactly n))) (\_2 -> Parsers.bind (Parsers.optional unsignedInt) (\mm -> Parsers.bind (Parsers.char 125) (\_3 -> Optionals.match mm (Parsers.pure (Regex.QuantifierAtLeast n)) (\m -> Parsers.pure (Regex.QuantifierRange_ (Regex.QuantifierRange {         Regex.quantifierRangeMin = n,         Regex.quantifierRangeMax = m}))))))))))]) (Parsers.pure Regex.QuantifierOne)
src/main/haskell/Hydra/Parsers.hs view
@@ -21,6 +21,7 @@ import qualified Hydra.Overlay.Haskell.Lib.Lists as Lists import qualified Hydra.Overlay.Haskell.Lib.Logic as Logic import qualified Hydra.Overlay.Haskell.Lib.Optionals as Optionals+import qualified Hydra.Overlay.Haskell.Lib.Pairs as Pairs import qualified Hydra.Overlay.Haskell.Lib.Strings as Strings import qualified Hydra.Packaging as Packaging import qualified Hydra.Parsing as Parsing@@ -38,7 +39,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  -- | Try the first parser; if it fails without consuming input, try the second@@ -94,9 +95,9 @@ -- | A parser that succeeds only at the end of input eof :: Parsing.Parser () eof =-    Parsing.Parser (\input -> Logic.ifElse (Equality.equal input "") (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+    Parsing.Parser (\input -> Logic.ifElse (Lists.null input) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {       Parsing.parseSuccessValue = (),-      Parsing.parseSuccessRemainder = ""})) (Parsing.ParseResultFailure (Parsing.ParseError {+      Parsing.parseSuccessRemainder = input})) (Parsing.ParseResultFailure (Parsing.ParseError {       Parsing.parseErrorMessage = "expected end of input",       Parsing.parseErrorRemainder = input}))) @@ -113,8 +114,20 @@  -- | Parse zero or more occurrences of the given parser many :: Parsing.Parser t0 -> Parsing.Parser [t0]-many p = alt (some p) (pure [])+many p = +      let parse = \input -> manyLoop p input []+      in (Parsing.Parser parse)++-- | Repeatedly apply a parser, accumulating results, until it fails+manyLoop :: Parsing.Parser t0 -> [Int] -> [t0] -> Parsing.ParseResult [t0]+manyLoop p input acc =+    (\x -> case x of+      Parsing.ParseResultSuccess v0 -> manyLoop p (Parsing.parseSuccessRemainder v0) (Lists.cons (Parsing.parseSuccessValue v0) acc)+      Parsing.ParseResultFailure _ -> Parsing.ParseResultSuccess (Parsing.ParseSuccess {+        Parsing.parseSuccessValue = (Lists.reverse acc),+        Parsing.parseSuccessRemainder = input})) (Parsing.unParser p input)+ -- | Apply a function to the result of a parser map :: (t0 -> t1) -> Parsing.Parser t0 -> Parsing.Parser t1 map f pa =@@ -138,26 +151,25 @@       Parsing.parseSuccessValue = a,       Parsing.parseSuccessRemainder = input})) --- | Run a parser on the given input string+-- | Run a parser on the given input string. The string is converted to a codepoint list once, up front, so that the parser itself can consume characters in constant time. runParser :: Parsing.Parser t0 -> String -> Parsing.ParseResult t0-runParser p input = Parsing.unParser p input+runParser p input = Parsing.unParser p (Strings.toList input)  -- | Parse a character (codepoint) that satisfies the given predicate satisfy :: (Int -> Bool) -> Parsing.Parser Int satisfy pred =        let parse =-              \input ->-                let codes = Strings.toList input-                in (Optionals.cases (Lists.head codes) (Parsing.ParseResultFailure (Parsing.ParseError {-                  Parsing.parseErrorMessage = "unexpected end of input",-                  Parsing.parseErrorRemainder = input})) (\c ->-                  let rest = Strings.fromList (Lists.drop 1 codes)-                  in (Logic.ifElse (pred c) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {-                    Parsing.parseSuccessValue = c,-                    Parsing.parseSuccessRemainder = rest})) (Parsing.ParseResultFailure (Parsing.ParseError {-                    Parsing.parseErrorMessage = "character did not satisfy predicate",-                    Parsing.parseErrorRemainder = input})))))+              \input -> Optionals.match (Lists.uncons input) (Parsing.ParseResultFailure (Parsing.ParseError {+                Parsing.parseErrorMessage = "unexpected end of input",+                Parsing.parseErrorRemainder = input})) (\uc ->+                let c = Pairs.first uc+                    rest = Pairs.second uc+                in (Logic.ifElse (pred c) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+                  Parsing.parseSuccessValue = c,+                  Parsing.parseSuccessRemainder = rest})) (Parsing.ParseResultFailure (Parsing.ParseError {+                  Parsing.parseErrorMessage = "character did not satisfy predicate",+                  Parsing.parseErrorRemainder = input}))))       in (Parsing.Parser parse)  -- | Parse zero or more occurrences separated by a separator@@ -175,13 +187,13 @@ -- | Parse a specific string string :: String -> Parsing.Parser String string str =-    Parsing.Parser (\input ->+       let strCodes = Strings.toList str-          inputCodes = Strings.toList input           strLen = Lists.length strCodes-          inputPrefix = Lists.take strLen inputCodes-      in (Logic.ifElse (Equality.equal strCodes inputPrefix) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {-        Parsing.parseSuccessValue = str,-        Parsing.parseSuccessRemainder = (Strings.fromList (Lists.drop strLen inputCodes))})) (Parsing.ParseResultFailure (Parsing.ParseError {-        Parsing.parseErrorMessage = (Strings.concat2 "expected: " str),-        Parsing.parseErrorRemainder = input}))))+      in (Parsing.Parser (\input ->+        let inputPrefix = Lists.take strLen input+        in (Logic.ifElse (Equality.equal strCodes inputPrefix) (Parsing.ParseResultSuccess (Parsing.ParseSuccess {+          Parsing.parseSuccessValue = str,+          Parsing.parseSuccessRemainder = (Lists.drop strLen input)})) (Parsing.ParseResultFailure (Parsing.ParseError {+          Parsing.parseErrorMessage = (Strings.concat2 "expected: " str),+          Parsing.parseErrorRemainder = input})))))
src/main/haskell/Hydra/Parsing.hs view
@@ -5,7 +5,7 @@ module Hydra.Parsing 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 error which occurred while parsing@@ -13,8 +13,8 @@   ParseError {     -- | An error message     parseErrorMessage :: String,-    -- | The remaining input at the point of failure-    parseErrorRemainder :: String}+    -- | The remaining input (as codepoints) at the point of failure+    parseErrorRemainder :: [Int]}   deriving (Eq, Ord, Read, Show)  _ParseError = Core.Name "hydra.parsing.ParseError"@@ -42,8 +42,8 @@   ParseSuccess {     -- | The parsed value     parseSuccessValue :: a,-    -- | The remaining unparsed input-    parseSuccessRemainder :: String}+    -- | The remaining unparsed input, as codepoints. Represented as a list rather than a string+    parseSuccessRemainder :: [Int]}   deriving (Eq, Ord, Read, Show)  _ParseSuccess = Core.Name "hydra.parsing.ParseSuccess"@@ -52,9 +52,9 @@  _ParseSuccess_remainder = Core.Name "remainder" --- | A parser which consumes characters from a string and produces a value+-- | A parser which consumes characters from a codepoint list and produces a value. The input is a list, rather than a string, so that consuming one character is a constant-time operation rather than a linear-time string copy. newtype Parser a =   Parser {-    unParser :: (String -> ParseResult a)}+    unParser :: ([Int] -> ParseResult a)}  _Parser = Core.Name "hydra.parsing.Parser"
src/main/haskell/Hydra/Paths.hs view
@@ -5,7 +5,7 @@ module Hydra.Paths 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 edge in a subterm graph, connecting two nodes via a path
src/main/haskell/Hydra/Predicates.hs view
@@ -52,7 +52,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 @@ -62,7 +62,7 @@        let term = Core.bindingTerm b           mts = Core.bindingTypeScheme b-      in (Optionals.cases mts (isComplexTerm tc term) (\ts ->+      in (Optionals.match mts (isComplexTerm tc term) (\ts ->         let isPolymorphic = Logic.not (Lists.null (Core.typeSchemeVariables ts))             isNonNullary = Ordering.gt (Arity.typeArity (Core.typeSchemeBody ts)) 0             isComplex = isComplexTerm tc term@@ -85,9 +85,9 @@       let metaLookup = Maps.lookup name (Graph.graphMetadata tc)       in (Logic.ifElse (Optionals.isGiven metaLookup) True (Logic.ifElse (Sets.member name (Graph.graphLambdaVariables tc)) True (         let typeLookup = Maps.lookup name (Graph.graphBoundTypes tc)-        in (Optionals.cases typeLookup (+        in (Optionals.match typeLookup (           let primLookup = Maps.lookup name (Graph.graphPrimitives tc)-          in (Optionals.cases primLookup True (\prim -> Ordering.gt (Arity.typeSchemeArity (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))) 0))) (\ts -> Ordering.gt (Arity.typeSchemeArity ts) 0)))))+          in (Optionals.match primLookup True (\prim -> Ordering.gt (Arity.typeSchemeArity (Scoping.termSignatureToTypeScheme (Packaging.primitiveDefinitionSignature (Graph.primitiveDefinition prim)))) 0))) (\ts -> Ordering.gt (Arity.typeSchemeArity ts) 0)))))  -- | Determines whether a given term is an encoded term (meta-level term) isEncodedTerm :: Core.Term -> Bool@@ -169,7 +169,7 @@           Core.TermProject _ -> isTrivialTerm arg           Core.TermUnwrap _ -> isTrivialTerm arg           _ -> False-      Core.TermOptional v0 -> Optionals.cases v0 True (\inner -> isTrivialTerm inner)+      Core.TermOptional v0 -> Optionals.match v0 True (\inner -> isTrivialTerm inner)       Core.TermRecord v0 -> Lists.foldl (\acc -> \fld -> Logic.and acc (isTrivialTerm (Core.fieldTerm fld))) True (Core.recordFields v0)       Core.TermWrap v0 -> isTrivialTerm (Core.wrappedTermBody v0)       Core.TermTypeApplication v0 -> isTrivialTerm (Core.typeApplicationTermBody v0)
src/main/haskell/Hydra/Print/Core.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 import qualified Data.Map as M import qualified Data.Set as S@@ -54,7 +54,7 @@       let name = Core.unName (Core.bindingName el)           t = Core.bindingTerm el           typeStr =-                  Optionals.cases (Core.bindingTypeScheme el) "" (\ts -> Strings.concat [+                  Optionals.match (Core.bindingTypeScheme el) "" (\ts -> Strings.concat [                     ":(",                     (typeScheme ts),                     ")"])@@ -76,7 +76,7 @@                     Core.fieldName = (Core.caseAlternativeName alt),                     Core.fieldTerm = (Core.caseAlternativeHandler alt)}) csCases           defaultField =-                  Optionals.cases mdef [] (\d -> [+                  Optionals.match mdef [] (\d -> [                     Core.Field {                       Core.fieldName = (Core.Name "[default]"),                       Core.fieldTerm = d}])@@ -189,7 +189,7 @@       let v = Core.unName (Core.lambdaParameter l)           mt = Core.lambdaDomain l           body = Core.lambdaBody l-          typeStr = Optionals.cases mt "" (\t -> Strings.concat2 ":" (type_ t))+          typeStr = Optionals.match mt "" (\t -> Strings.concat2 ":" (type_ t))       in (Strings.concat [         "\955",         v,@@ -258,7 +258,7 @@  -- | Show an optional value using a given function to show the element optional :: (t0 -> String) -> Maybe t0 -> String-optional f mx = Optionals.cases mx "none" (\x -> Strings.concat2 "given(" (Strings.concat2 (f x) ")"))+optional f mx = Optionals.match mx "none" (\x -> Strings.concat2 "given(" (Strings.concat2 (f x) ")"))  -- | Show a pair using given functions to show each element pair :: (t0 -> String) -> (t1 -> String) -> (t0, t1) -> String@@ -344,7 +344,7 @@             "{",             (Strings.join ", " (Lists.map entry (Maps.toList v0))),             "}"])-        Core.TermOptional v0 -> Optionals.cases v0 "none" (\t2 -> Strings.concat [+        Core.TermOptional v0 -> Optionals.match v0 "none" (\t2 -> Strings.concat [           "given(",           (term t2),           ")"])@@ -524,7 +524,7 @@                     (Core.unName v)]           toConstraintPairs =                   \p -> Lists.map (toConstraintPair (Pairs.first p)) (Core.typeVariableConstraintsClasses (Pairs.second p))-          tc = Optionals.cases (Core.typeSchemeConstraints ts) [] (\m -> Lists.concat (Lists.map toConstraintPairs (Maps.toList m)))+          tc = Optionals.match (Core.typeSchemeConstraints ts) [] (\m -> Lists.concat (Lists.map toConstraintPairs (Maps.toList m)))       in (Strings.concat [         "(",         fa,
src/main/haskell/Hydra/Print/Docs.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  -- | Render a DefinitionReference as its fully-qualified name
src/main/haskell/Hydra/Print/Emacs/Regex.hs view
@@ -38,7 +38,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  -- | Render an alternation, joining its branches with Emacs's \| operator.
src/main/haskell/Hydra/Print/Error/Core.hs view
@@ -38,7 +38,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  -- | Show a constant condition error as a string
src/main/haskell/Hydra/Print/Error/Packaging.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  -- | Show a conflicting module namespace error as a string
src/main/haskell/Hydra/Print/Errors.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  -- | Show a checking error as a string
src/main/haskell/Hydra/Print/Graph.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  -- | Show a list of bindings as a string
src/main/haskell/Hydra/Print/Paths.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 @@ -122,7 +122,7 @@                             nodeBindingPairs = Lists.zip nodes1 bindings                             stateAfterBindings = Lists.foldl addBindingTerm ((Lists.concat2 nodes1 nodes, edges), visited1) nodeBindingPairs                         in (helper ids1 mroot nextPath stateAfterBindings (Paths.SubtermStepLetBody, env))-                      Core.TermVariable v0 -> Optionals.cases mroot state (\root -> Optionals.cases (Maps.lookup v0 ids) state (\node ->+                      Core.TermVariable v0 -> Optionals.match mroot state (\root -> Optionals.match (Maps.lookup v0 ids) state (\node ->                         let edge =                                 Paths.SubtermEdge {                                   Paths.subtermEdgeSource = root,
src/main/haskell/Hydra/Print/Pcre/Regex.hs view
@@ -38,7 +38,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  -- | Render an alternation, joining its branches with the | operator.
src/main/haskell/Hydra/Print/Posix/Regex.hs view
@@ -38,7 +38,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  -- | Render an alternation, joining its branches with the | operator.
src/main/haskell/Hydra/Print/Regex.hs view
@@ -38,7 +38,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  -- | Render an alternation, joining its branches with the | operator.
src/main/haskell/Hydra/Print/Typing.hs view
@@ -38,7 +38,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  -- | Show a type constraint as a string
src/main/haskell/Hydra/Print/Util.hs view
@@ -33,7 +33,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  -- | Show a case convention as a string
src/main/haskell/Hydra/Print/Variants.hs view
@@ -33,7 +33,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  -- | Show a term variant as a string
src/main/haskell/Hydra/Query.hs view
@@ -5,7 +5,7 @@ module Hydra.Query 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  -- | One of several comparison operators
src/main/haskell/Hydra/Reduction.hs view
@@ -60,7 +60,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  -- | Alpha convert a variable in a term@@ -141,17 +141,17 @@                     Core.TermLet v0 -> termArityWithContext (Scoping.extendGraphForLet (\_ -> \_2 -> Nothing) tx v0) (Core.letBody v0)                     Core.TermTypeLambda v0 -> termArityWithContext (Scoping.extendGraphForTypeLambda tx v0) (Core.typeLambdaBody v0)                     Core.TermTypeApplication v0 -> termArityWithContext tx (Core.typeApplicationTermBody v0)-                    Core.TermVariable v0 -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))) (Optionals.cases (Maps.lookup v0 primTypes) 0 Arity.typeSchemeArity) Arity.typeArity+                    Core.TermVariable v0 -> Optionals.match (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx))) (Optionals.match (Maps.lookup v0 primTypes) 0 Arity.typeSchemeArity) Arity.typeArity                     _ -> 0           domainTypes =-                  \n -> \mt -> Logic.ifElse (Ordering.lte n 0) [] (Optionals.cases mt (Lists.map (\_ -> Nothing) (Math.range 1 n)) (\typ -> case typ of+                  \n -> \mt -> Logic.ifElse (Ordering.lte n 0) [] (Optionals.match mt (Lists.map (\_ -> Nothing) (Math.range 0 n)) (\typ -> case typ of                     Core.TypeFunction v0 -> Lists.cons (Just (Core.functionTypeDomain v0)) (domainTypes (Math.sub n 1) (Just (Core.functionTypeCodomain v0)))                     Core.TypeAnnotated v0 -> domainTypes n (Just (Core.annotatedTypeBody v0))                     Core.TypeApplication v0 -> domainTypes n (Just (Core.applicationTypeFunction v0))-                    Core.TypeForall _ -> Lists.map (\_2 -> Nothing) (Math.range 1 n)-                    _ -> Lists.map (\_ -> Nothing) (Math.range 1 n)))+                    Core.TypeForall _ -> Lists.map (\_2 -> Nothing) (Math.range 0 n)+                    _ -> Lists.map (\_ -> Nothing) (Math.range 0 n)))           peelFunctionDomains =-                  \mtyp -> \n -> Logic.ifElse (Ordering.lte n 0) mtyp (Optionals.cases mtyp Nothing (\typ -> case typ of+                  \mtyp -> \n -> Logic.ifElse (Ordering.lte n 0) mtyp (Optionals.match mtyp Nothing (\typ -> case typ of                     Core.TypeFunction v0 -> peelFunctionDomains (Just (Core.functionTypeCodomain v0)) (Math.sub n 1)                     Core.TypeAnnotated v0 -> peelFunctionDomains (Just (Core.annotatedTypeBody v0)) n                     Core.TypeApplication v0 -> peelFunctionDomains (Just (Core.applicationTypeFunction v0)) n@@ -166,7 +166,7 @@                         numArgs = Lists.length args                         needed = Math.sub arity numArgs                     in (Logic.ifElse (Logic.and (Ordering.gt needed 0) (Logic.or alwaysPad (Ordering.gt numArgs 0))) (-                      let indices = Math.range 1 needed+                      let indices = Math.range 1 (Math.add needed 1)                           remainingType = peelFunctionDomains headTyp numArgs                           domains = domainTypes needed remainingType                           codomainType = peelFunctionDomains remainingType needed@@ -177,7 +177,7 @@                                       Core.applicationFunction = body,                                       Core.applicationArgument = (Core.TermVariable vn)}))) applied indices                           fullyApplied =-                                  Optionals.cases codomainType fullyAppliedRaw (\ct -> Core.TermAnnotated (Core.AnnotatedTerm {+                                  Optionals.match codomainType fullyAppliedRaw (\ct -> Core.TermAnnotated (Core.AnnotatedTerm {                                     Core.annotatedTermBody = fullyAppliedRaw,                                     Core.annotatedTermAnnotation = (Annotations.wrapAnnotationMap (Maps.singleton (Core.Name "type") (EncodeCore.type_ ct)))}))                           indexedDomains = Lists.zip indices domains@@ -371,11 +371,12 @@                                 Core.TermTypeLambda v0 ->                                   let txt = Scoping.extendGraphForTypeLambda tx2 v0                                   in (arityOf txt (Core.typeLambdaBody v0))-                                Core.TermVariable v0 -> Optionals.cases (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx2))) (Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx2 [] (Core.TermVariable v0))) (\t -> Right (Arity.typeArity t))+                                Core.TermVariable v0 -> Optionals.match (Optionals.map Scoping.typeSchemeToFType (Maps.lookup v0 (Graph.graphBoundTypes tx2))) (Eithers.map (\_tc -> Arity.typeArity (Pairs.first _tc)) (Checking.typeOf cx tx2 [] (Core.TermVariable v0))) (\t -> Right (Arity.typeArity t))                                 _ -> dflt-                    extraVariables = \n -> Lists.map (\i -> Core.Name (Strings.concat2 "v" (Literals.showInt32 i))) (Math.range 1 n)+                    extraVariables =+                            \n -> Lists.map (\i -> Core.Name (Strings.concat2 "v" (Literals.showInt32 i))) (Math.range 1 (Math.add n 1))                     pad =-                            \vars -> \body -> Optionals.cases (Lists.uncons vars) body (\uc ->+                            \vars -> \body -> Optionals.match (Lists.uncons vars) body (\uc ->                               let v0 = Pairs.first uc                                   vrest = Pairs.second uc                               in (Core.TermLambda (Core.Lambda {@@ -451,7 +452,7 @@       Core.TermUnwrap _ -> 1       Core.TermTypeLambda v0 -> etaExpansionArity graph (Core.typeLambdaBody v0)       Core.TermTypeApplication v0 -> etaExpansionArity graph (Core.typeApplicationTermBody v0)-      Core.TermVariable v0 -> Optionals.cases (Optionals.bind (Lexical.lookupBinding graph v0) (\b -> Core.bindingTypeScheme b)) 0 (\ts -> Arity.typeArity (Core.typeSchemeBody ts))+      Core.TermVariable v0 -> Optionals.match (Optionals.bind (Lexical.lookupBinding graph v0) (\b -> Core.bindingTypeScheme b)) 0 (\ts -> Arity.typeArity (Core.typeSchemeBody ts))       _ -> 0  -- | Eta-reduce a term by removing redundant lambda abstractions@@ -504,20 +505,20 @@                     in (Logic.and eager2 isNonLambdaTerm)           reduceArg = \eager2 -> \arg -> Logic.ifElse eager2 (Right arg) (reduce False arg)           applyToArguments =-                  \fun -> \args -> Optionals.cases (Lists.uncons args) fun (\uc -> applyToArguments (Core.TermApplication (Core.Application {+                  \fun -> \args -> Optionals.match (Lists.uncons args) fun (\uc -> applyToArguments (Core.TermApplication (Core.Application {                     Core.applicationFunction = fun,                     Core.applicationArgument = (Pairs.first uc)})) (Pairs.second uc))           mapErrorToString = \e -> Errors.ErrorOther (Errors.OtherError (PrintErrors.error e))           applyProjection =                   \proj -> \reducedArg -> Eithers.bind (ExtractCore.record (Core.projectionTypeName proj) graph (Strip.deannotateTerm reducedArg)) (\fields ->                     let matching = Lists.find (\f -> Equality.equal (Core.fieldName f) (Core.projectionFieldName proj)) fields-                    in (Optionals.cases matching (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                    in (Optionals.match matching (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {                       Errors.noMatchingFieldErrorFieldName = (Core.projectionFieldName proj)})))) (\mf -> Right (Core.fieldTerm mf))))           applyCases =                   \cs -> \reducedArg -> Eithers.bind (ExtractCore.injection (Core.caseStatementTypeName cs) graph reducedArg) (\field ->                     let matching =                             Lists.find (\f -> Equality.equal (Core.caseAlternativeName f) (Core.fieldName field)) (Core.caseStatementCases cs)-                    in (Optionals.cases matching (Optionals.cases (Core.caseStatementDefault cs) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {+                    in (Optionals.match matching (Optionals.match (Core.caseStatementDefault cs) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {                       Errors.noMatchingFieldErrorFieldName = (Core.fieldName field)})))) (\x -> Right x)) (\mf -> Right (Core.TermApplication (Core.Application {                       Core.applicationFunction = (Core.caseAlternativeHandler mf),                       Core.applicationArgument = (Core.fieldTerm field)})))))@@ -525,17 +526,17 @@                   \eager2 -> \original -> \args ->                     let stripped = Strip.deannotateTerm original                         forProjection =-                                \proj -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                \proj -> \args2 -> Optionals.match (Lists.uncons args2) (Right original) (\uc ->                                   let arg = Pairs.first uc                                       remainingArgs = Pairs.second uc                                   in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (applyProjection proj reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))                         forCases =-                                \cs -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                \cs -> \args2 -> Optionals.match (Lists.uncons args2) (Right original) (\uc ->                                   let arg = Pairs.first uc                                       remainingArgs = Pairs.second uc                                   in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (applyCases cs reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))                         forUnwrap =-                                \name -> \args2 -> Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                \name -> \args2 -> Optionals.match (Lists.uncons args2) (Right original) (\uc ->                                   let arg = Pairs.first uc                                       remainingArgs = Pairs.second uc                                   in (Eithers.bind (reduceArg eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (Eithers.bind (ExtractCore.wrap name graph reducedArg) (reduce eager2)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs))))@@ -543,7 +544,7 @@                                 \l -> \args2 ->                                   let param = Core.lambdaParameter l                                       body = Core.lambdaBody l-                                  in (Optionals.cases (Lists.uncons args2) (Right original) (\uc ->+                                  in (Optionals.match (Lists.uncons args2) (Right original) (\uc ->                                     let arg = Pairs.first uc                                         remainingArgs = Pairs.second uc                                     in (Eithers.bind (reduce eager2 (Strip.deannotateTerm arg)) (\reducedArg -> Eithers.bind (reduce eager2 (Variables.replaceFreeTermVariable param reducedArg body)) (\reducedResult -> applyIfNullary eager2 reducedResult remainingArgs)))))@@ -562,9 +563,9 @@                       Core.TermLambda v0 -> Logic.ifElse (Lists.null args) (Right original) (forLambda v0 args)                       Core.TermVariable v0 ->                         let mBinding = Lexical.lookupBinding graph v0-                        in (Optionals.cases mBinding (+                        in (Optionals.match mBinding (                           let mPrim = Lexical.lookupPrimitive graph v0-                          in (Optionals.cases mPrim (Right (applyToArguments original args)) (\prim ->+                          in (Optionals.match mPrim (Right (applyToArguments original args)) (\prim ->                             let arity = Arity.primitiveArity prim                             in (Logic.ifElse (Ordering.gt arity (Lists.length args)) (Right (applyToArguments original args)) (forPrimitive prim arity args))))) (\binding -> applyIfNullary eager2 (Core.bindingTerm binding) args))                       Core.TermLet v0 ->@@ -605,7 +606,7 @@                   \alts -> Lists.foldl (\b -> \a -> Logic.and b (termIsValue (Core.caseAlternativeHandler a))) True alts       in case (Strip.deannotateTerm term) of         Core.TermApplication _ -> False-        Core.TermCases v0 -> Logic.and (checkCaseAlternatives (Core.caseStatementCases v0)) (Optionals.cases (Core.caseStatementDefault v0) True termIsValue)+        Core.TermCases v0 -> Logic.and (checkCaseAlternatives (Core.caseStatementCases v0)) (Optionals.match (Core.caseStatementDefault v0) True termIsValue)         Core.TermEither v0 -> Eithers.either (\l -> termIsValue l) (\r -> termIsValue r) v0         Core.TermLambda v0 -> termIsValue (Core.lambdaBody v0)         Core.TermLiteral _ -> True@@ -613,7 +614,7 @@         Core.TermUnwrap _ -> True         Core.TermList v0 -> forList v0         Core.TermMap v0 -> Lists.foldl (\b -> \kv -> Logic.and b (Logic.and (termIsValue (Pairs.first kv)) (termIsValue (Pairs.second kv)))) True (Maps.toList v0)-        Core.TermOptional v0 -> Optionals.cases v0 True termIsValue+        Core.TermOptional v0 -> Optionals.match v0 True termIsValue         Core.TermRecord v0 -> checkFields (Core.recordFields v0)         Core.TermSet v0 -> forList (Sets.toList v0)         Core.TermInject v0 -> checkField (Core.injectionField v0)
src/main/haskell/Hydra/Reflect.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  -- | Find the precision of a given floating-point type
src/main/haskell/Hydra/Refs.hs view
@@ -39,7 +39,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 import qualified Data.Set as S
src/main/haskell/Hydra/Regex.hs view
@@ -5,7 +5,7 @@ module Hydra.Regex 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 non-empty list of alternative sequences, joined by the | operator. Matches if any alternative matches.
src/main/haskell/Hydra/Relational.hs view
@@ -5,7 +5,7 @@ module Hydra.Relational 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.Map as M import qualified Data.Set as S
src/main/haskell/Hydra/Resolution.hs view
@@ -51,7 +51,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 @@ -60,7 +60,7 @@ dereferenceType cx graph name =        let mel = Lexical.lookupBinding graph name-      in (Optionals.cases mel (Right Nothing) (\el -> Eithers.map Optionals.pure (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      in (Optionals.match mel (Right Nothing) (\el -> Eithers.map Optionals.pure (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = "type",         Errors.unexpectedShapeErrorActual = (Errors.unDecodingError _e)}))) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm el))))) @@ -95,7 +95,7 @@         Core.TypeForall v0 -> fieldTypes cx graph (Core.forallTypeBody v0)         Core.TypeRecord v0 -> Right (toMap v0)         Core.TypeUnion v0 -> Right (toMap v0)-        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Eithers.bind (Lexical.requireBinding graph v0) (\el -> Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Eithers.bind (Lexical.requireBinding graph v0) (\el -> Eithers.bind (Eithers.bimap (\_e -> Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "type",           Errors.unexpectedShapeErrorActual = (Errors.unDecodingError _e)}))) (\_a -> _a) (DecodeCore.type_ graph (Core.bindingTerm el))) (\decodedType -> fieldTypes cx graph decodedType))) (\ts -> fieldTypes cx graph (Core.typeSchemeBody ts))         _ -> Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {@@ -110,7 +110,7 @@           noMatch =                   Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {                     Errors.noMatchingFieldErrorFieldName = fname})))-      in (Logic.ifElse (Lists.null matchingFields) noMatch (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.cases (Lists.head matchingFields) noMatch (\ft -> Right (Core.fieldTypeType ft))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleFields (Errors.MultipleFieldsError {+      in (Logic.ifElse (Lists.null matchingFields) noMatch (Logic.ifElse (Equality.equal (Lists.length matchingFields) 1) (Optionals.match (Lists.head matchingFields) noMatch (\ft -> Right (Core.fieldTypeType ft))) (Left (Errors.ErrorExtraction (Errors.ExtractionErrorMultipleFields (Errors.MultipleFieldsError {         Errors.multipleFieldsErrorFieldName = fname}))))))  -- | Fully strip a type of forall quantifiers, normalizing bound variable names for alpha-equivalence comparison@@ -197,20 +197,20 @@                 Core.TypeAnnotated v0 -> rawType (Core.annotatedTypeBody v0)                 Core.TypeForall v0 -> rawType (Core.forallTypeBody v0)                 _ -> t-      in (Eithers.bind (requireType cx graph name) (\t -> Optionals.cases (getter (rawType t)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+      in (Eithers.bind (requireType cx graph name) (\t -> Optionals.match (getter (rawType t)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {         Errors.unexpectedShapeErrorExpected = (Strings.concat2 label " type"),         Errors.unexpectedShapeErrorActual = (Strings.concat2 (Core.unName name) (Strings.concat2 ": " (PrintCore.type_ t)))})))) (\x -> Right x)))  -- | Look up a schema type and instantiate it, threading InferenceContext requireSchemaType :: Typing.InferenceContext -> M.Map Core.Name Core.TypeScheme -> Core.Name -> Either Errors.Error (Core.TypeScheme, Typing.InferenceContext) requireSchemaType cx types tname =-    Optionals.cases (Maps.lookup tname types) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+    Optionals.match (Maps.lookup tname types) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {       Errors.noSuchBindingErrorName = tname})))) (\ts -> Right (instantiateTypeScheme cx (Strip.deannotateTypeSchemeRecursive ts)))  -- | Require a type by name requireType :: t0 -> Graph.Graph -> Core.Name -> Either Errors.Error Core.Type requireType cx graph name =-    Optionals.cases (Maps.lookup name (Graph.graphSchemaTypes graph)) (Optionals.cases (Maps.lookup name (Graph.graphBoundTypes graph)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {+    Optionals.match (Maps.lookup name (Graph.graphSchemaTypes graph)) (Optionals.match (Maps.lookup name (Graph.graphBoundTypes graph)) (Left (Errors.ErrorResolution (Errors.ResolutionErrorNoSuchBinding (Errors.NoSuchBindingError {       Errors.noSuchBindingErrorName = name})))) (\ts -> Right (Scoping.typeSchemeToFType ts))) (\ts -> Right (Scoping.typeSchemeToFType ts))  -- | Require a field type from a union type@@ -222,7 +222,7 @@                 let noMatchErr =                         Left (Errors.ErrorResolution (Errors.ResolutionErrorNoMatchingField (Errors.NoMatchingFieldError {                           Errors.noMatchingFieldErrorFieldName = fname})))-                in (Optionals.cases (Lists.find (\ft -> Equality.equal (Core.fieldTypeName ft) fname) rt) noMatchErr (\ft -> Right (Core.fieldTypeType ft)))+                in (Optionals.match (Lists.find (\ft -> Equality.equal (Core.fieldTypeName ft) fname) rt) noMatchErr (\ft -> Right (Core.fieldTypeType ft)))       in (Eithers.bind (requireUnionType cx graph tname) withRowType)  -- | Require a name to resolve to a union type@@ -241,7 +241,7 @@        let stripped = Strip.deannotateType typ       in case stripped of-        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 types) stripped (\resolved -> resolveBaseType types resolved)+        Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 types) stripped (\resolved -> resolveBaseType types resolved)         Core.TypeWrap v0 -> resolveBaseType types v0         _ -> stripped @@ -249,7 +249,7 @@ resolveType :: Graph.Graph -> Core.Type -> Maybe Core.Type resolveType graph typ =     case (Strip.deannotateType typ) of-      Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Optionals.map (\ts -> Scoping.typeSchemeToFType ts) (Maps.lookup v0 (Graph.graphBoundTypes graph))) (\ts -> Just (Scoping.typeSchemeToFType ts))+      Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 (Graph.graphSchemaTypes graph)) (Optionals.map (\ts -> Scoping.typeSchemeToFType ts) (Maps.lookup v0 (Graph.graphBoundTypes graph))) (\ts -> Just (Scoping.typeSchemeToFType ts))       _ -> Just typ  -- | Convert a (System F -style) type to a type scheme
src/main/haskell/Hydra/Rewriting.hs view
@@ -6,6 +6,7 @@  import qualified Hydra.Ast as Ast import qualified Hydra.Coders as Coders+import qualified Hydra.Constants as Constants import qualified Hydra.Core as Core import qualified Hydra.Docs as Docs import qualified Hydra.Error.Checking as Checking@@ -41,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  -- | Apply a term-level function inside any leading type lambdas@@ -157,7 +158,7 @@                         Core.applicationArgument = (Pairs.second rrhs)})))                   Core.TermCases v0 ->                     let rmd = Optionals.map (recurse val0) (Core.caseStatementDefault v0)-                        val1 = Optionals.cases rmd val0 Pairs.first+                        val1 = Optionals.match rmd val0 Pairs.first                         rcases = forCaseAlternatives val1 (Core.caseStatementCases v0)                     in (                       Pairs.first rcases,@@ -185,7 +186,7 @@                       Core.letBody = (Pairs.second renv)})) (Pairs.first renv) (Core.letBindings v0))                   Core.TermList v0 -> forMany recurse (\x -> Core.TermList x) val0 v0                   Core.TermMap v0 -> forMany forPair (\pairs -> Core.TermMap (Maps.fromList pairs)) val0 (Maps.toList v0)-                  Core.TermOptional v0 -> Optionals.cases v0 dflt (\t -> forSingle recurse (\t1 -> Core.TermOptional (Just t1)) val0 t)+                  Core.TermOptional v0 -> Optionals.match v0 dflt (\t -> forSingle recurse (\t1 -> Core.TermOptional (Just t1)) val0 t)                   Core.TermPair v0 ->                     let rf = recurse val0 (Pairs.first v0)                         rs = recurse (Pairs.first rf) (Pairs.second v0)@@ -326,7 +327,7 @@                     let rmd =                             Optionals.map (\def -> recurse (Lists.concat2 path [                               Paths.SubtermStepUnionCasesDefault]) val0 def) (Core.caseStatementDefault v0)-                        val1 = Optionals.cases rmd val0 Pairs.first+                        val1 = Optionals.match rmd val0 Pairs.first                         rcases =                                 forManyWithAccessors recurse (\x -> x) val1 (Lists.map (\f2 -> (Paths.SubtermStepUnionCasesBranch (Core.caseAlternativeName f2), (Core.caseAlternativeHandler f2))) (Core.caseStatementCases v0))                     in (@@ -383,7 +384,7 @@                                             Paths.SubtermStepMapValue (Pairs.first r)]) (Pairs.first rk) (Pairs.second kv)                                   in (Math.add (Pairs.first r) 1, (Pairs.first rv, (Lists.cons (Pairs.second rk, (Pairs.second rv)) (Pairs.second (Pairs.second r)))))) (idx, (val0, [])) (Maps.toList v0)                     in (Pairs.first (Pairs.second rr), (Core.TermMap (Maps.fromList (Lists.reverse (Pairs.second (Pairs.second rr))))))-                  Core.TermOptional v0 -> Optionals.cases v0 dflt (\t -> forSingleWithAccessor recurse (\t1 -> Core.TermOptional (Just t1)) Paths.SubtermStepOptionalTerm val0 t)+                  Core.TermOptional v0 -> Optionals.match v0 dflt (\t -> forSingleWithAccessor recurse (\t1 -> Core.TermOptional (Just t1)) Paths.SubtermStepOptionalTerm val0 t)                   Core.TermPair v0 ->                     let rf = recurse (Lists.concat2 path [                           Paths.SubtermStepProductTerm 0]) val0 (Pairs.first v0)@@ -533,7 +534,7 @@                     let n = Core.caseStatementTypeName v0                         def = Core.caseStatementDefault v0                         csCases = Core.caseStatementCases v0-                    in (Eithers.bind (Optionals.cases def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {+                    in (Eithers.bind (Optionals.match def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {                       Core.caseStatementTypeName = n,                       Core.caseStatementDefault = rdef,                       Core.caseStatementCases = rcases})) (Eithers.mapList forCaseAlternative csCases)))@@ -699,7 +700,7 @@                     let n = Core.caseStatementTypeName v0                         def = Core.caseStatementDefault v0                         csCases = Core.caseStatementCases v0-                    in (Eithers.bind (Optionals.cases def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {+                    in (Eithers.bind (Optionals.match def (Right Nothing) (\t -> Eithers.map Optionals.pure (recurse t))) (\rdef -> Eithers.map (\rcases -> Core.TermCases (Core.CaseStatement {                       Core.caseStatementTypeName = n,                       Core.caseStatementDefault = rdef,                       Core.caseStatementCases = rcases})) (Eithers.mapList forCaseAlternative csCases)))@@ -888,7 +889,7 @@       Core.TermApplication v0 -> [         Core.applicationFunction v0,         (Core.applicationArgument v0)]-      Core.TermCases v0 -> Lists.concat2 (Optionals.cases (Core.caseStatementDefault v0) [] (\t -> [+      Core.TermCases v0 -> Lists.concat2 (Optionals.match (Core.caseStatementDefault v0) [] (\t -> [         t])) (Lists.map Core.caseAlternativeHandler (Core.caseStatementCases v0))       Core.TermEither v0 -> Eithers.either (\l -> [         l]) (\r -> [@@ -901,7 +902,7 @@       Core.TermMap v0 -> Lists.concat (Lists.map (\p -> [         Pairs.first p,         (Pairs.second p)]) (Maps.toList v0))-      Core.TermOptional v0 -> Optionals.cases v0 [] (\t -> [+      Core.TermOptional v0 -> Optionals.match v0 [] (\t -> [         t])       Core.TermPair v0 -> [         Pairs.first v0,@@ -930,7 +931,7 @@       Core.TermApplication v0 -> [         (Paths.SubtermStepApplicationFunction, (Core.applicationFunction v0)),         (Paths.SubtermStepApplicationArgument, (Core.applicationArgument v0))]-      Core.TermCases v0 -> Lists.concat2 (Optionals.cases (Core.caseStatementDefault v0) [] (\t -> [+      Core.TermCases v0 -> Lists.concat2 (Optionals.match (Core.caseStatementDefault v0) [] (\t -> [         (Paths.SubtermStepUnionCasesDefault, t)])) (Lists.map (\f -> (Paths.SubtermStepUnionCasesBranch (Core.caseAlternativeName f), (Core.caseAlternativeHandler f))) (Core.caseStatementCases v0))       Core.TermEither v0 -> [         (Paths.SubtermStepSumTerm, (Eithers.either (\l -> l) (\r -> r) v0))]@@ -946,7 +947,7 @@         (Paths.SubtermStepMapValue (Pairs.first ip), (Pairs.second (Pairs.second ip)))]) (Lists.reverse (Pairs.second (Lists.foldl (\r -> \el ->         let idx = Pairs.first r         in (Math.add idx 1, (Lists.cons (idx, el) (Pairs.second r)))) (0, []) (Maps.toList v0)))))-      Core.TermOptional v0 -> Optionals.cases v0 [] (\t -> [+      Core.TermOptional v0 -> Optionals.match v0 [] (\t -> [         (Paths.SubtermStepOptionalTerm, t)])       Core.TermPair v0 -> [         (Paths.SubtermStepProductTerm 0, (Pairs.first v0)),@@ -1007,3 +1008,21 @@       Core.TypeVoid -> []       Core.TypeWrap v0 -> [         v0]++-- | Convert a wrapped (newtype) term to an equivalent single-field record term, for target languages without a newtype concept+wrapTermToRecord :: Core.Name -> Core.Term -> Core.Term+wrapTermToRecord tname body =+    Core.TermRecord (Core.Record {+      Core.recordTypeName = tname,+      Core.recordFields = [+        Core.Field {+          Core.fieldName = (Core.Name Constants.fieldNameValue),+          Core.fieldTerm = body}]})++-- | Convert a wrapped (newtype) type to an equivalent single-field record type, for target languages without a newtype concept+wrapTypeToRecord :: Core.Type -> Core.Type+wrapTypeToRecord t =+    Core.TypeRecord [+      Core.FieldType {+        Core.fieldTypeName = (Core.Name Constants.fieldNameValue),+        Core.fieldTypeType = t}]
src/main/haskell/Hydra/Scoping.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  -- | Extend a graph by descending into a lambda body@@ -52,7 +52,7 @@       let var = Core.lambdaParameter lam       in Graph.Graph {         Graph.graphBoundTerms = (Graph.graphBoundTerms g),-        Graph.graphBoundTypes = (Optionals.cases (Core.lambdaDomain lam) (Graph.graphBoundTypes g) (\dom -> Maps.insert var (fTypeToTypeScheme dom) (Graph.graphBoundTypes g))),+        Graph.graphBoundTypes = (Optionals.match (Core.lambdaDomain lam) (Graph.graphBoundTypes g) (\dom -> Maps.insert var (fTypeToTypeScheme dom) (Graph.graphBoundTypes g))),         Graph.graphClassConstraints = (Graph.graphClassConstraints g),         Graph.graphLambdaVariables = (Sets.insert var (Graph.graphLambdaVariables g)),         Graph.graphMetadata = (Maps.delete var (Graph.graphMetadata g)),@@ -73,7 +73,7 @@         Graph.graphLambdaVariables = (Lists.foldl (\s -> \b -> Sets.delete (Core.bindingName b) s) (Graph.graphLambdaVariables g) bindings),         Graph.graphMetadata = (Graph.graphMetadata (Lists.foldl (\gAcc -> \b ->           let m = Graph.graphMetadata gAcc-              newMeta = Optionals.cases (forBinding gAcc b) (Maps.delete (Core.bindingName b) m) (\t -> Maps.insert (Core.bindingName b) t m)+              newMeta = Optionals.match (forBinding gAcc b) (Maps.delete (Core.bindingName b) m) (\t -> Maps.insert (Core.bindingName b) t m)           in Graph.Graph {             Graph.graphBoundTerms = (Graph.graphBoundTerms gAcc),             Graph.graphBoundTypes = (Graph.graphBoundTypes gAcc),@@ -180,7 +180,7 @@           typeParams =                   Lists.map (\v -> Typing.TypeParameter {                     Typing.typeParameterName = v,-                    Typing.typeParameterConstraints = (Optionals.cases (Maps.lookup v constraintsMap) [] (\tvm -> Core.typeVariableConstraintsClasses tvm))}) variables+                    Typing.typeParameterConstraints = (Optionals.match (Maps.lookup v constraintsMap) [] (\tvm -> Core.typeVariableConstraintsClasses tvm))}) variables           peel =                   \acc -> \t -> case t of                     Core.TypeFunction v0 -> peel (Lists.cons (Core.functionTypeDomain v0) acc) (Core.functionTypeCodomain v0)
src/main/haskell/Hydra/Serialization.hs view
@@ -15,6 +15,7 @@ import qualified Hydra.Error.System as ErrorSystem import qualified Hydra.Errors as Errors import qualified Hydra.File as File+import qualified Hydra.Formatting as Formatting import qualified Hydra.Graph as Graph import qualified Hydra.Json.Model as Model import qualified Hydra.Overlay.Haskell.Lib.Equality as Equality@@ -42,7 +43,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  -- | Angle bracket pair `<` `>` for use with `brackets`@@ -114,7 +115,7 @@ -- | Indent every non-empty line of `s` by `idt`. Empty lines stay empty (no trailing whitespace) so downstream byte-identity checks don't care about indent depth. customIndent :: String -> String -> String customIndent idt s =-    Strings.concat (Lists.intersperse "\n" (Lists.map (\line -> Logic.ifElse (Equality.equal line "") line (Strings.concat2 idt line)) (Strings.lines s)))+    Strings.concat (Lists.intersperse "\n" (Lists.map (\line -> Logic.ifElse (Equality.equal line "") line (Strings.concat2 idt line)) (Formatting.lines s)))  -- | Render a list of expressions as a block whose first element starts where the surrounding context placed it and subsequent elements break onto fresh lines indented by the given prefix customIndentBlock :: String -> [Ast.Expr] -> Ast.Expr@@ -128,7 +129,7 @@                   Ast.paddingRight = (Ast.WsBreakAndIndent idt)},                 Ast.opPrecedence = (Ast.Precedence 0),                 Ast.opAssociativity = Ast.AssociativityNone}-      in (Optionals.cases (Lists.head els) (cst "") (\head -> Logic.ifElse (Equality.equal (Lists.length els) 1) head (ifx idtOp head (newlineSep (Lists.drop 1 els)))))+      in (Optionals.match (Lists.head els) (cst "") (\head -> Logic.ifElse (Equality.equal (Lists.length els) 1) head (ifx idtOp head (newlineSep (Lists.drop 1 els)))))  -- | Separate elements with a dot and no surrounding whitespace dotSep :: [Ast.Expr] -> Ast.Expr@@ -170,7 +171,7 @@                     Ast.WsDoubleBreak -> 10000           blockStyleLength =                   \style ->-                    let mindentLen = Optionals.cases (Ast.blockStyleIndent style) 0 Strings.length+                    let mindentLen = Optionals.match (Ast.blockStyleIndent style) 0 Strings.length                         nlBeforeLen = Logic.ifElse (Ast.blockStyleNewlineBeforeContent style) 1 0                         nlAfterLen = Logic.ifElse (Ast.blockStyleNewlineAfterContent style) 1 0                     in (Math.add mindentLen (Math.add nlBeforeLen nlAfterLen))@@ -341,7 +342,7 @@ orSep style l =        let newlines = Ast.blockStyleNewlineBeforeContent style-      in (Optionals.cases (Lists.head l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx (orOp newlines) acc el) h (Lists.drop 1 l)))+      in (Optionals.match (Lists.head l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx (orOp newlines) acc el) h (Lists.drop 1 l)))  -- | Comma-separate the elements inside parentheses; switches to a half-block style when newlines are requested and there is more than one element. Renders as `()` when empty. parenList :: Bool -> [Ast.Expr] -> Ast.Expr@@ -460,7 +461,7 @@         Ast.ExprIndent v0 ->           let style = Ast.indentedExpressionStyle v0               expr = Ast.indentedExpressionExpr v0-              lns = Strings.lines (printExpr expr)+              lns = Formatting.lines (printExpr expr)               indentLine = \pre -> \line -> Logic.ifElse (Equality.equal line "") line (Strings.concat2 pre line)               ilns =                       case style of@@ -485,7 +486,7 @@               spadrIsNewline = isNewlineWs spadr               joinElements =                       \acc -> \el ->-                        let elStartsWithNewline = Optionals.cases (Strings.charAt 0 el) False (\c -> Equality.equal c 10)+                        let elStartsWithNewline = Optionals.match (Strings.charAt 0 el) False (\c -> Equality.equal c 10)                             elIsEmpty = Equality.equal el ""                             padlEff =                                     Logic.ifElse (Logic.or (Logic.and elStartsWithNewline (Logic.not spadlIsNewline)) (Logic.and elIsEmpty (Equality.equal ssym ""))) "" (pad spadl)@@ -497,7 +498,7 @@                           ssym,                           padrEff,                           el])-          in (Optionals.cases (Lists.head printedElements) "" (\h -> Lists.foldl joinElements h (Lists.drop 1 printedElements)))+          in (Optionals.match (Lists.head printedElements) "" (\h -> Lists.foldl joinElements h (Lists.drop 1 printedElements)))         Ast.ExprOp v0 ->           let op = Ast.opExprOp v0               sym = Ast.unSymbol (Ast.opSymbol op)@@ -522,7 +523,7 @@               padlEffective =                       Logic.ifElse (Logic.and (Logic.not padlIsNewline) (Logic.and (Equality.equal sym "") (Logic.or padrIsNewline (Equality.equal rhs "")))) "" (pad padl)               padrPad = pad padr-              rhsStartsWithNewline = Optionals.cases (Strings.charAt 0 rhs) False (\c -> Equality.equal c 10)+              rhsStartsWithNewline = Optionals.match (Strings.charAt 0 rhs) False (\c -> Equality.equal c 10)               padrEffective = Logic.ifElse (Logic.and rhsStartsWithNewline (Logic.not padrIsNewline)) "" padrPad           in (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 lhs padlEffective) sym) padrEffective) rhs)         Ast.ExprBrackets v0 ->@@ -535,7 +536,7 @@               doIndent = Ast.blockStyleIndent style               nlBefore = Ast.blockStyleNewlineBeforeContent style               nlAfter = Ast.blockStyleNewlineAfterContent style-              ibody = Optionals.cases doIndent body (\pre -> customIndent pre body)+              ibody = Optionals.match doIndent body (\pre -> customIndent pre body)               pre = Logic.ifElse nlBefore "\n" ""               suf = Logic.ifElse nlAfter "\n" ""           in (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 l pre) ibody) suf) r)@@ -546,7 +547,7 @@  -- | Combine a list of expressions into a single OpExpr chain using the given operator. Returns the empty constant for an empty list. sep :: Ast.Op -> [Ast.Expr] -> Ast.Expr-sep op els = Optionals.cases (Lists.head els) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx op acc el) h (Lists.drop 1 els))+sep op els = Optionals.match (Lists.head els) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx op acc el) h (Lists.drop 1 els))  -- | Space-separate elements (no break between them) spaceSep :: [Ast.Expr] -> Ast.Expr@@ -624,7 +625,7 @@                       Ast.paddingRight = break},                     Ast.opPrecedence = (Ast.Precedence 0),                     Ast.opAssociativity = Ast.AssociativityNone}-      in (Optionals.cases (Lists.head l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx commaOp acc el) h (Lists.drop 1 l)))+      in (Optionals.match (Lists.head l) (cst "") (\h -> Lists.foldl (\acc -> \el -> ifx commaOp acc el) h (Lists.drop 1 l)))  -- | Indent every line of an expression by four spaces tabIndent :: Ast.Expr -> Ast.Expr
src/main/haskell/Hydra/Sorting.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 import qualified Data.Map as M import qualified Data.Set as S@@ -55,7 +55,7 @@     Lists.foldl (\mp -> \p ->       let k = Pairs.first p           vs = Pairs.second p-          existing = Optionals.cases (Maps.lookup k mp) [] Functions.identity+          existing = Optionals.match (Maps.lookup k mp) [] Functions.identity       in (Maps.insert k (Lists.concat2 existing vs) mp)) Maps.empty pairs  -- | Given a list of adjacency lists represented as (key, [key]) pairs, construct a graph along with a function mapping each vertex (an Int) back to its original key (Nothing for unknown vertices).@@ -127,7 +127,7 @@ popStackUntil v st0 =        let go =-              \acc -> \st -> Optionals.cases (Lists.uncons (Topology.tarjanStateStack st)) (Lists.reverse acc, st) (\uc ->+              \acc -> \st -> Optionals.match (Lists.uncons (Topology.tarjanStateStack st)) (Lists.reverse acc, st) (\uc ->                 let x = Pairs.first uc                     xs = Pairs.second uc                     newSt =@@ -159,8 +159,8 @@           allNodes = Sets.toList (Sets.fromList (Lists.concat2 (Lists.map Pairs.first edges) (Lists.map Pairs.first nodeTags)))           getTagsForNode =                   \node ->-                    let reachable = findReachableNodes (\n -> Sets.fromList (Optionals.cases (Maps.lookup n adjMap) [] Functions.identity)) node-                    in (Sets.unions (Lists.map (\n -> Optionals.cases (Maps.lookup n tagMap) Sets.empty Functions.identity) (Sets.toList reachable)))+                    let reachable = findReachableNodes (\n -> Sets.fromList (Optionals.match (Maps.lookup n adjMap) [] Functions.identity)) node+                    in (Sets.unions (Lists.map (\n -> Optionals.match (Maps.lookup n tagMap) Sets.empty Functions.identity) (Sets.toList reachable)))       in (Lists.map (\n -> (n, (getTagsForNode n))) allNodes)  -- | Visit a vertex and recursively explore its successors
src/main/haskell/Hydra/Strip.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  -- | Strip type annotations from the top levels of a term
src/main/haskell/Hydra/Substitution.hs view
@@ -41,7 +41,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 @@ -70,13 +70,13 @@ singletonTypeSubst :: Core.Name -> Core.Type -> Typing.TypeSubst singletonTypeSubst v t = Typing.TypeSubst (Maps.singleton v t) --- | Apply a type substitution to class constraints, propagating to free variables+-- | Apply a type substitution to class constraints, propagating to free variables or retaining on concrete resolution substInClassConstraints :: Typing.TypeSubst -> M.Map Core.Name Core.TypeVariableConstraints -> M.Map Core.Name Core.TypeVariableConstraints substInClassConstraints subst constraints =        let substMap = Typing.unTypeSubst subst           insertOrMerge =-                  \varName -> \metadata -> \acc -> Optionals.cases (Maps.lookup varName acc) (Maps.insert varName metadata acc) (\existing ->+                  \varName -> \metadata -> \acc -> Optionals.match (Maps.lookup varName acc) (Maps.insert varName metadata acc) (\existing ->                     let merged =                             Core.TypeVariableConstraints {                               Core.typeVariableConstraintsClasses = (Lists.distinct (Lists.concat2 (Core.typeVariableConstraintsClasses existing) (Core.typeVariableConstraintsClasses metadata)))}@@ -84,9 +84,9 @@       in (Lists.foldl (\acc -> \pair ->         let varName = Pairs.first pair             metadata = Pairs.second pair-        in (Optionals.cases (Maps.lookup varName substMap) (insertOrMerge varName metadata acc) (\targetType ->+        in (Optionals.match (Maps.lookup varName substMap) (insertOrMerge varName metadata acc) (\targetType ->           let freeVars = Sets.toList (Variables.freeVariablesInType targetType)-          in (Lists.foldl (\acc2 -> \freeVar -> insertOrMerge freeVar metadata acc2) acc freeVars)))) Maps.empty (Maps.toList constraints))+          in (Logic.ifElse (Lists.null freeVars) (insertOrMerge varName metadata acc) (Lists.foldl (\acc2 -> \freeVar -> insertOrMerge freeVar metadata acc2) acc freeVars))))) Maps.empty (Maps.toList constraints))  -- | Apply a type substitution to a graph's bound types and class constraints substInContext :: Typing.TypeSubst -> Graph.Graph -> Graph.Graph@@ -124,10 +124,10 @@        let rewrite =               \recurse -> \typ -> case typ of-                Core.TypeForall v0 -> Optionals.cases (Maps.lookup (Core.forallTypeParameter v0) (Typing.unTypeSubst subst)) (recurse typ) (\styp -> Core.TypeForall (Core.ForallType {+                Core.TypeForall v0 -> Optionals.match (Maps.lookup (Core.forallTypeParameter v0) (Typing.unTypeSubst subst)) (recurse typ) (\styp -> Core.TypeForall (Core.ForallType {                   Core.forallTypeParameter = (Core.forallTypeParameter v0),                   Core.forallTypeBody = (substInType (removeVar (Core.forallTypeParameter v0)) (Core.forallTypeBody v0))}))-                Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 (Typing.unTypeSubst subst)) typ (\styp -> styp)+                Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 (Typing.unTypeSubst subst)) typ (\styp -> styp)                 _ -> recurse typ           removeVar = \v -> Typing.TypeSubst (Maps.delete v (Typing.unTypeSubst subst))       in (Rewriting.rewriteType rewrite typ0)@@ -235,6 +235,6 @@                     in case term of                       Core.TermLambda v0 -> withLambda v0                       Core.TermLet v0 -> withLet v0-                      Core.TermVariable v0 -> Optionals.cases (Maps.lookup v0 s) (recurse term) (\sterm -> sterm)+                      Core.TermVariable v0 -> Optionals.match (Maps.lookup v0 s) (recurse term) (\sterm -> sterm)                       _ -> recurse term       in (Rewriting.rewriteTerm rewrite term0)
src/main/haskell/Hydra/System.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.File as File-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.Map as M
src/main/haskell/Hydra/Tabular.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.Relational as Relational-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 column type, consisting of a name and a value type
src/main/haskell/Hydra/Templates.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 import qualified Data.Map as M import qualified Hydra.Overlay.Haskell.Lib.Literals as Literals@@ -112,7 +112,7 @@             Core.recordFields = dfields}))))         Core.TypeSet v0 -> Logic.ifElse minimal (Right (Core.TermSet Sets.empty)) (Eithers.bind (inst tname v0) (\e -> Right (Core.TermSet (Sets.fromList [           e]))))-        Core.TypeVariable v0 -> Optionals.cases (Maps.lookup v0 schema) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {+        Core.TypeVariable v0 -> Optionals.match (Maps.lookup v0 schema) (Left (Errors.ErrorResolution (Errors.ResolutionErrorUnexpectedShape (Errors.UnexpectedShapeError {           Errors.unexpectedShapeErrorExpected = "bound type variable",           Errors.unexpectedShapeErrorActual = (Strings.concat2 "unbound variable " (Core.unName v0))})))) (inst v0)         Core.TypeWrap v0 -> Eithers.bind (inst tname v0) (\e -> Right (Core.TermWrap (Core.WrappedTerm {
src/main/haskell/Hydra/Test/Transform.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  -- | Add generation namespace prefix
src/main/haskell/Hydra/Test/Utils.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  -- | Run type inference on a single term
src/main/haskell/Hydra/Testing.hs view
@@ -5,7 +5,7 @@ module Hydra.Testing 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 effectful test case: the actual value is a thunk producing an effect, which the test runner interprets (performing host interactions, e.g. file I/O within a per-case empty temporary directory) to obtain a result string; the expected value is a thunk producing a string.
src/main/haskell/Hydra/Time.hs view
@@ -5,7 +5,7 @@ module Hydra.Time 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/Topology.hs view
@@ -5,7 +5,7 @@ module Hydra.Topology 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.Map as M import qualified Data.Set as S
src/main/haskell/Hydra/Typed.hs view
@@ -5,7 +5,7 @@ module Hydra.Typed 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 association of a named term (element) with a phantom type
src/main/haskell/Hydra/Typing.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.Paths as Paths-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/Unification.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 @@ -162,7 +162,7 @@                               Core.TypeWrap _ -> True                               _ -> False                     tryBindOrSchema =-                            \v -> \t -> Optionals.cases (Maps.lookup v schemaTypes) (tryBinding v t) (\ts -> Logic.ifElse (isNominalSchemaType ts) (Left (Errors.UnificationError {+                            \v -> \t -> Optionals.match (Maps.lookup v schemaTypes) (tryBinding v t) (\ts -> Logic.ifElse (isNominalSchemaType ts) (Left (Errors.UnificationError {                               Errors.unificationErrorLeftType = sleft,                               Errors.unificationErrorRightType = sright,                               Errors.unificationErrorMessage = (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "Cannot unify schema name " (Core.unName v)) " with type ") (PrintCore.type_ t)) " (") comment) ")")})) (tryBinding v t))@@ -182,7 +182,7 @@                       Errors.unificationErrorMessage = (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 (Strings.concat2 "Attempted to unify schema names " (Core.unName v0)) " and ") (Core.unName v1)) " (") comment) ")")})) (bind v1 sleft)) (bind v0 sright))                     _ -> tryBindOrSchema v0 sright                   _ -> dflt-      in (Optionals.cases (Lists.uncons constraints) (Right Substitution.idTypeSubst) (\uc -> withConstraint (Pairs.first uc) (Pairs.second uc)))+      in (Optionals.match (Lists.uncons constraints) (Right Substitution.idTypeSubst) (\uc -> withConstraint (Pairs.first uc) (Pairs.second uc)))  -- | Unify two lists of types pairwise, producing a single substitution that satisfies every pair. The lists must have the same length; the comment is attached to each generated constraint for diagnostics. unifyTypeLists :: t0 -> M.Map Core.Name Core.TypeScheme -> [Core.Type] -> [Core.Type] -> String -> Either Errors.UnificationError Typing.TypeSubst
src/main/haskell/Hydra/Util.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core 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 import qualified Data.Map as M
src/main/haskell/Hydra/Validate/Core.hs view
@@ -47,14 +47,14 @@ 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.Set as S  -- | Append a rule-tagged InvalidTermError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds. appendFinding :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0 appendFinding p acc finding =-    Optionals.cases finding acc (\rp ->+    Optionals.match finding acc (\rp ->       let ruleName = Pairs.first rp           payload = Pairs.second rp           errs = Validation.validationResultErrors acc@@ -68,7 +68,7 @@ -- | Append a rule-tagged InvalidTypeError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds. appendFindingType :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0 appendFindingType p acc finding =-    Optionals.cases finding acc (\rp ->+    Optionals.match finding acc (\rp ->       let ruleName = Pairs.first rp           payload = Pairs.second rp           errs = Validation.validationResultErrors acc@@ -95,7 +95,7 @@        let names = Lists.map Core.fieldTypeName fields           dup = findDuplicateFieldType names-      in (Optionals.cases dup Nothing (\name -> mkError name))+      in (Optionals.match dup Nothing (\name -> mkError name))  -- | Check for duplicate field names in a list of fields checkDuplicateFields :: Paths.SubtermPath -> [Core.Name] -> Maybe ErrorCore.InvalidTermError@@ -120,7 +120,7 @@ checkShadowing path cx names =        let result =-              Lists.foldl (\acc -> \name -> Optionals.cases acc (Logic.ifElse (Logic.or (Optionals.isGiven (Maps.lookup name (Graph.graphBoundTerms cx))) (Sets.member name (Graph.graphLambdaVariables cx))) (Just (ErrorCore.InvalidTermErrorTermVariableShadowing (ErrorCore.TermVariableShadowingError {+              Lists.foldl (\acc -> \name -> Optionals.match acc (Logic.ifElse (Logic.or (Optionals.isGiven (Maps.lookup name (Graph.graphBoundTerms cx))) (Sets.member name (Graph.graphLambdaVariables cx))) (Just (ErrorCore.InvalidTermErrorTermVariableShadowing (ErrorCore.TermVariableShadowingError {                 ErrorCore.termVariableShadowingErrorLocation = path,                 ErrorCore.termVariableShadowingErrorName = name}))) Nothing) (\_ -> acc)) Nothing names       in result@@ -186,24 +186,24 @@           Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {             ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,           (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.duplicateField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.duplicateField", f)) (checkDuplicateFields path (Lists.map Core.fieldName flds))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = tname}))) (\_ -> Nothing))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeRecord _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,               ErrorCore.nominalTypeKindMismatchErrorTypeName = tname,               ErrorCore.nominalTypeKindMismatchErrorExpectedVariant = Variants.TypeVariantRecord,               ErrorCore.nominalTypeKindMismatchErrorActualVariant = (Reflect.typeVariant typ)}))))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.missingRecordFields")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.missingRecordFields", f)) (Optionals.cases (resolveRecordFields cx tname) Nothing (\declFields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.missingRecordFields")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.missingRecordFields", f)) (Optionals.match (resolveRecordFields cx tname) Nothing (\declFields ->             let declNames = Sets.fromList (Lists.map Core.fieldTypeName declFields)                 missing = Sets.difference declNames suppliedNames             in (Logic.ifElse (Sets.null missing) Nothing (Just (ErrorCore.InvalidTermErrorMissingRecordFields (ErrorCore.MissingRecordFieldsError {               ErrorCore.missingRecordFieldsErrorLocation = path,               ErrorCore.missingRecordFieldsErrorTypeName = tname,               ErrorCore.missingRecordFieldsErrorFieldNames = (Sets.toList missing)}))))))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.extraRecordFields")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.extraRecordFields", f)) (Optionals.cases (resolveRecordFields cx tname) Nothing (\declFields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.extraRecordFields")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.extraRecordFields", f)) (Optionals.match (resolveRecordFields cx tname) Nothing (\declFields ->             let declNames = Sets.fromList (Lists.map Core.fieldTypeName declFields)                 extra = Sets.difference suppliedNames declNames             in (Logic.ifElse (Sets.null extra) Nothing (Just (ErrorCore.InvalidTermErrorExtraRecordFields (ErrorCore.ExtraRecordFieldsError {@@ -221,7 +221,7 @@           (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.invalidLetBindingName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.invalidLetBindingName", f)) (firstError (Lists.map (\bname -> Logic.ifElse (isValidName bname) Nothing (Just (ErrorCore.InvalidTermErrorInvalidLetBindingName (ErrorCore.InvalidLetBindingNameError {             ErrorCore.invalidLetBindingNameErrorLocation = path,             ErrorCore.invalidLetBindingNameErrorName = bname})))) names))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType", f)) (Logic.ifElse typed (firstError (Lists.map (\b -> Optionals.cases (Core.bindingTypeScheme b) Nothing (\ts -> checkUndefinedTypeVariablesInTypeScheme path cx ts (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType (ErrorCore.UndefinedTypeVariableInBindingTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInBindingType", f)) (Logic.ifElse typed (firstError (Lists.map (\b -> Optionals.match (Core.bindingTypeScheme b) Nothing (\ts -> checkUndefinedTypeVariablesInTypeScheme path cx ts (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInBindingType (ErrorCore.UndefinedTypeVariableInBindingTypeError {             ErrorCore.undefinedTypeVariableInBindingTypeErrorLocation = path,             ErrorCore.undefinedTypeVariableInBindingTypeErrorName = uvName}))))) bindings)) Nothing)) Nothing)])       Core.TermInject v0 ->@@ -231,17 +231,17 @@         in (firstFinding [           Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {             ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = tname}))) (\_ -> Nothing))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeUnion _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,               ErrorCore.nominalTypeKindMismatchErrorTypeName = tname,               ErrorCore.nominalTypeKindMismatchErrorExpectedVariant = Variants.TypeVariantUnion,               ErrorCore.nominalTypeKindMismatchErrorActualVariant = (Reflect.typeVariant typ)}))))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undeclaredVariant")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undeclaredVariant", f)) (Optionals.cases (resolveUnionFields cx tname) Nothing (\declFields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undeclaredVariant")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undeclaredVariant", f)) (Optionals.match (resolveUnionFields cx tname) Nothing (\declFields ->             let declNames = Sets.fromList (Lists.map Core.fieldTypeName declFields)             in (Logic.ifElse (Sets.member variantName declNames) Nothing (Just (ErrorCore.InvalidTermErrorUndeclaredVariant (ErrorCore.UndeclaredVariantError {               ErrorCore.undeclaredVariantErrorLocation = path,@@ -256,7 +256,7 @@           (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.invalidLambdaParameterName")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.invalidLambdaParameterName", f)) (Logic.ifElse (isValidName paramName) Nothing (Just (ErrorCore.InvalidTermErrorInvalidLambdaParameterName (ErrorCore.InvalidLambdaParameterNameError {             ErrorCore.invalidLambdaParameterNameErrorLocation = path,             ErrorCore.invalidLambdaParameterNameErrorName = paramName}))))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain", f)) (Logic.ifElse typed (Optionals.cases (Core.lambdaDomain v0) Nothing (\dom -> checkUndefinedTypeVariablesInType path cx dom (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain (ErrorCore.UndefinedTypeVariableInLambdaDomainError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.undefinedTypeVariableInLambdaDomain", f)) (Logic.ifElse typed (Optionals.match (Core.lambdaDomain v0) Nothing (\dom -> checkUndefinedTypeVariablesInType path cx dom (\uvName -> Just (ErrorCore.InvalidTermErrorUndefinedTypeVariableInLambdaDomain (ErrorCore.UndefinedTypeVariableInLambdaDomainError {             ErrorCore.undefinedTypeVariableInLambdaDomainErrorLocation = path,             ErrorCore.undefinedTypeVariableInLambdaDomainErrorName = uvName}))))) Nothing)) Nothing)])       Core.TermProject v0 ->@@ -266,17 +266,17 @@         in (firstFinding [           Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {             ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = tname}))) (\_ -> Nothing))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeRecord _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,               ErrorCore.nominalTypeKindMismatchErrorTypeName = tname,               ErrorCore.nominalTypeKindMismatchErrorExpectedVariant = Variants.TypeVariantRecord,               ErrorCore.nominalTypeKindMismatchErrorActualVariant = (Reflect.typeVariant typ)}))))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unknownProjectedField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unknownProjectedField", f)) (Optionals.cases (resolveRecordFields cx tname) Nothing (\declFields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unknownProjectedField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unknownProjectedField", f)) (Optionals.match (resolveRecordFields cx tname) Nothing (\declFields ->             let declNames = Sets.fromList (Lists.map Core.fieldTypeName declFields)             in (Logic.ifElse (Sets.member fname declNames) Nothing (Just (ErrorCore.InvalidTermErrorUnknownProjectedField (ErrorCore.UnknownProjectedFieldError {               ErrorCore.unknownProjectedFieldErrorLocation = path,@@ -292,10 +292,10 @@         in (firstFinding [           Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {             ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = tname}))) (\_ -> Nothing))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeUnion _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,@@ -306,17 +306,17 @@             ErrorCore.emptyCaseStatementErrorLocation = path,             ErrorCore.emptyCaseStatementErrorTypeName = tname}))) Nothing)) Nothing),           (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.duplicateField")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.duplicateField", f)) (checkDuplicateFields path (Lists.map Core.caseAlternativeName csCases))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.missingCaseBranches")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.missingCaseBranches", f)) (Logic.ifElse (Optionals.isNone csDefault) (Optionals.cases unionFields Nothing (\fields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.missingCaseBranches")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.missingCaseBranches", f)) (Logic.ifElse (Optionals.isNone csDefault) (Optionals.match unionFields Nothing (\fields ->             let variantNames = Sets.fromList (Lists.map Core.fieldTypeName fields)                 uncovered = Sets.difference variantNames altNames             in (Logic.ifElse (Sets.null uncovered) Nothing (Just (ErrorCore.InvalidTermErrorMissingCaseBranches (ErrorCore.MissingCaseBranchesError {               ErrorCore.missingCaseBranchesErrorLocation = path,               ErrorCore.missingCaseBranchesErrorTypeName = tname,               ErrorCore.missingCaseBranchesErrorVariantNames = (Sets.toList uncovered)})))))) Nothing)) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unknownCaseAlternative")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unknownCaseAlternative", f)) (Optionals.cases unionFields Nothing (\fields ->+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unknownCaseAlternative")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unknownCaseAlternative", f)) (Optionals.match unionFields Nothing (\fields ->             let variantNames = Sets.fromList (Lists.map Core.fieldTypeName fields)                 unknown = Sets.difference altNames variantNames-            in (Optionals.cases (Lists.head (Sets.toList unknown)) Nothing (\firstUnknown -> Just (ErrorCore.InvalidTermErrorUnknownCaseAlternative (ErrorCore.UnknownCaseAlternativeError {+            in (Optionals.match (Lists.head (Sets.toList unknown)) Nothing (\firstUnknown -> Just (ErrorCore.InvalidTermErrorUnknownCaseAlternative (ErrorCore.UnknownCaseAlternativeError {               ErrorCore.unknownCaseAlternativeErrorLocation = path,               ErrorCore.unknownCaseAlternativeErrorTypeName = tname,               ErrorCore.unknownCaseAlternativeErrorName = firstUnknown}))))))) Nothing)])@@ -341,10 +341,10 @@         in (firstFinding [           Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.emptyTypeNameInTerm", f)) (Logic.ifElse (Equality.equal (Core.unName tname) "") (Just (ErrorCore.InvalidTermErrorEmptyTypeNameInTerm (ErrorCore.EmptyTypeNameInTermError {             ErrorCore.emptyTypeNameInTermErrorLocation = path}))) Nothing)) Nothing,-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = tname}))) (\_ -> Nothing))) Nothing),-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeWrap _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,@@ -354,10 +354,10 @@       Core.TermUnwrap v0 ->         let resolved = resolveNominalType cx v0         in (firstFinding [-          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.cases resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {+          Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.unresolvedNominalType", f)) (Optionals.match resolved (Just (ErrorCore.InvalidTermErrorUnresolvedNominalType (ErrorCore.UnresolvedNominalTypeError {             ErrorCore.unresolvedNominalTypeErrorLocation = path,             ErrorCore.unresolvedNominalTypeErrorTypeName = v0}))) (\_ -> Nothing))) Nothing,-          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.cases resolved Nothing (\typ -> case typ of+          (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTermError.nominalTypeKindMismatch", f)) (Optionals.match resolved Nothing (\typ -> case typ of             Core.TypeWrap _ -> Nothing             _ -> Just (ErrorCore.InvalidTermErrorNominalTypeKindMismatch (ErrorCore.NominalTypeKindMismatchError {               ErrorCore.nominalTypeKindMismatchErrorLocation = path,@@ -373,7 +373,7 @@       let freeVars = Variables.freeVariablesInType typ           resolvedNames = Sets.union (Graph.graphTypeVariables cx) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx)))           undefined = Sets.difference freeVars resolvedNames-      in (Optionals.cases (Lists.head (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))+      in (Optionals.match (Lists.head (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))  -- | Check a type scheme for type variables not bound by the scheme or the current scope checkUndefinedTypeVariablesInTypeScheme :: t0 -> Graph.Graph -> Core.TypeScheme -> (Core.Name -> Maybe t1) -> Maybe t1@@ -382,7 +382,7 @@       let freeVars = Variables.freeVariablesInTypeScheme ts           resolvedNames = Sets.union (Graph.graphTypeVariables cx) (Sets.fromList (Maps.keys (Graph.graphSchemaTypes cx)))           undefined = Sets.difference freeVars resolvedNames-      in (Optionals.cases (Lists.head (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))+      in (Optionals.match (Lists.head (Sets.toList undefined)) Nothing (\firstUndefined -> mkError firstUndefined))  -- | Return an error if the given type is TypeVoid checkVoid :: Core.Type -> Maybe ErrorCore.InvalidTypeError@@ -405,7 +405,7 @@               Lists.foldl (\acc -> \name ->                 let seen = Pairs.first acc                     dup = Pairs.second acc-                in (Optionals.cases dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names+                in (Optionals.match dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names       in (Pairs.second result)  -- | Find the first duplicate name in a list (for field type validation)@@ -416,24 +416,24 @@               Lists.foldl (\acc -> \name ->                 let seen = Pairs.first acc                     dup = Pairs.second acc-                in (Optionals.cases dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names+                in (Optionals.match dup (Logic.ifElse (Sets.member name seen) (seen, (Just name)) (Sets.insert name seen, Nothing)) (\_ -> acc))) (Sets.empty, Nothing) names       in (Pairs.second result)  -- | Return the first error from a list of optional errors, or nothing if all are valid firstError :: [Maybe t0] -> Maybe t0-firstError checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+firstError checks = Lists.foldl (\acc -> \check -> Optionals.match acc check (\_ -> acc)) Nothing checks  -- | Return the first rule-tagged finding from a list, or nothing if all are valid firstFinding :: [Maybe t0] -> Maybe t0-firstFinding checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+firstFinding checks = Lists.foldl (\acc -> \check -> Optionals.match acc check (\_ -> acc)) Nothing checks  -- | Return the first rule-tagged type finding from a list, or nothing if all are valid firstFindingType :: [Maybe t0] -> Maybe t0-firstFindingType checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+firstFindingType checks = Lists.foldl (\acc -> \check -> Optionals.match acc check (\_ -> acc)) Nothing checks  -- | Return the first type error from a list of optional errors, or nothing if all are valid firstTypeError :: [Maybe t0] -> Maybe t0-firstTypeError checks = Lists.foldl (\acc -> \check -> Optionals.cases acc check (\_ -> acc)) Nothing checks+firstTypeError checks = Lists.foldl (\acc -> \check -> Optionals.match acc check (\_ -> acc)) Nothing checks  -- | Check whether a name is valid at an introduction site. Currently rejects empty strings. isValidName :: Core.Name -> Bool@@ -497,12 +497,12 @@ resolveNominalType cx tname =        let toType = \ts -> Just (Strip.deannotateType (Core.typeSchemeBody ts))-      in (Optionals.cases (Maps.lookup tname (Graph.graphSchemaTypes cx)) (Optionals.cases (Maps.lookup tname (Graph.graphBoundTypes cx)) Nothing toType) toType)+      in (Optionals.match (Maps.lookup tname (Graph.graphSchemaTypes cx)) (Optionals.match (Maps.lookup tname (Graph.graphBoundTypes cx)) Nothing toType) toType)  -- | Resolve a type name to the field list of the record type it names, or Nothing if it does not resolve to a record type. resolveRecordFields :: Graph.Graph -> Core.Name -> Maybe [Core.FieldType] resolveRecordFields cx tname =-    Optionals.cases (resolveNominalType cx tname) Nothing (\typ -> case typ of+    Optionals.match (resolveNominalType cx tname) Nothing (\typ -> case typ of       Core.TypeRecord v0 -> Just v0       _ -> Nothing) @@ -516,7 +516,7 @@                 in case stripped of                   Core.TypeUnion v0 -> Just v0                   _ -> Nothing-      in (Optionals.cases (Maps.lookup tname (Graph.graphSchemaTypes cx)) (Optionals.cases (Maps.lookup tname (Graph.graphBoundTypes cx)) Nothing toFields) toFields)+      in (Optionals.match (Maps.lookup tname (Graph.graphSchemaTypes cx)) (Optionals.match (Maps.lookup tname (Graph.graphBoundTypes cx)) Nothing toFields) toFields)  -- | Validate a term against the given ValidationProfile, returning a ValidationResult. Errors hard-stop traversal once maxErrors is reached; warnings are bounded by maxWarnings without causing termination. term :: Validation.ValidationProfile -> Bool -> Graph.Graph -> Core.Term -> Validation.ValidationResult ErrorCore.InvalidTermError@@ -620,7 +620,7 @@       Core.TypeUnion v0 -> firstFindingType [         Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.emptyUnionType")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.emptyUnionType", f)) (Logic.ifElse (Lists.null v0) (Just (ErrorCore.InvalidTypeErrorEmptyUnionType (ErrorCore.EmptyUnionTypeError {           ErrorCore.emptyUnionTypeErrorLocation = (Paths.SubtermPath [])}))) Nothing)) Nothing,-        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion", f)) (Logic.ifElse (Equality.equal (Lists.length v0) 1) (Optionals.cases (Lists.head v0) Nothing (\singleField -> Just (ErrorCore.InvalidTypeErrorSingleVariantUnion (ErrorCore.SingleVariantUnionError {+        (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.singleVariantUnion", f)) (Logic.ifElse (Equality.equal (Lists.length v0) 1) (Optionals.match (Lists.head v0) Nothing (\singleField -> Just (ErrorCore.InvalidTypeErrorSingleVariantUnion (ErrorCore.SingleVariantUnionError {           ErrorCore.singleVariantUnionErrorLocation = (Paths.SubtermPath []),           ErrorCore.singleVariantUnionErrorFieldName = (Core.fieldTypeName singleField)})))) Nothing)) Nothing),         (Logic.ifElse (enabled p (Core.Name "hydra.error.core.InvalidTypeError.duplicateUnionTypeFieldNames")) (Optionals.map (\f -> (Core.Name "hydra.error.core.InvalidTypeError.duplicateUnionTypeFieldNames", f)) (checkDuplicateFieldTypes v0 (\dupName -> Just (ErrorCore.InvalidTypeErrorDuplicateUnionTypeFieldNames (ErrorCore.DuplicateUnionTypeFieldNamesError {
src/main/haskell/Hydra/Validate/Packaging.hs view
@@ -49,7 +49,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@@ -57,7 +57,7 @@ -- | Append a rule-tagged InvalidModuleError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds. appendFindingModule :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0 appendFindingModule p acc finding =-    Optionals.cases finding acc (\rp ->+    Optionals.match finding acc (\rp ->       let ruleName = Pairs.first rp           payload = Pairs.second rp           errs = Validation.validationResultErrors acc@@ -71,7 +71,7 @@ -- | Append a rule-tagged InvalidPackageError finding to a ValidationResult, classifying as error or warning per the profile and respecting maxErrors/maxWarnings bounds. appendFindingPackage :: Validation.ValidationProfile -> Validation.ValidationResult t0 -> Maybe (Core.Name, t0) -> Validation.ValidationResult t0 appendFindingPackage p acc finding =-    Optionals.cases finding acc (\rp ->+    Optionals.match finding acc (\rp ->       let ruleName = Pairs.first rp           payload = Pairs.second rp           errs = Validation.validationResultErrors acc@@ -90,11 +90,11 @@               Lists.foldl (\acc -> \mod ->                 let seen = Pairs.first acc                     err = Pairs.second acc-                in (Optionals.cases err (+                in (Optionals.match err (                   let ns = Packaging.moduleName mod                       key = Strings.toLower (Packaging.unModuleName ns)                       existing = Maps.lookup key seen-                  in (Optionals.cases existing (Maps.insert key ns seen, Nothing) (\first -> (+                  in (Optionals.match existing (Maps.insert key ns seen, Nothing) (\first -> (                     seen,                     (Just (ErrorPackaging.InvalidPackageErrorConflictingModuleName (ErrorPackaging.ConflictingModuleNameError {                       ErrorPackaging.conflictingModuleNameErrorFirst = first,@@ -108,13 +108,13 @@       let ns = Packaging.moduleName mod           defs = Packaging.moduleDefinitions mod           defNames = Lists.foldl (\acc -> \def -> Sets.insert (Names.localNameOf (definitionName def)) acc) Sets.empty defs-      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (case def of+      in (Lists.foldl (\acc -> \def -> Optionals.match acc (case def of         Packaging.DefinitionType v0 ->           let typeName = Packaging.typeDefinitionName v0               localTypeName = Names.localNameOf typeName               typ = Core.typeSchemeBody (Packaging.typeDefinitionBody v0)           in case typ of-            Core.TypeUnion v1 -> Lists.foldl (\innerAcc -> \field -> Optionals.cases innerAcc (+            Core.TypeUnion v1 -> Lists.foldl (\innerAcc -> \field -> Optionals.match innerAcc (               let fieldName = Core.fieldTypeName field                   localFieldName = Names.localNameOf fieldName                   constructorName = Strings.concat2 (Formatting.capitalize localTypeName) (Formatting.capitalize localFieldName)@@ -131,7 +131,7 @@ checkDefinitionDocumentation mod =        let ns = Packaging.moduleName mod-      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+      in (Lists.foldl (\acc -> \def -> Optionals.match acc (         let name = definitionName def             documented =                     case def of@@ -145,7 +145,7 @@                         in case typ of                           Core.TypeAnnotated v1 -> Annotations.hasDescription (Annotations.getAnnotationMap (Core.annotatedTypeAnnotation v1))                           _ -> False-                      Packaging.DefinitionPrimitive v0 -> Optionals.cases (Packaging.primitiveDefinitionMetadata v0) False (\em -> Logic.not (Equality.equal (Optionals.withDefault "" (Packaging.entityMetadataDescription em)) ""))+                      Packaging.DefinitionPrimitive v0 -> Optionals.match (Packaging.primitiveDefinitionMetadata v0) False (\em -> Logic.not (Equality.equal (Optionals.withDefault "" (Packaging.entityMetadataDescription em)) ""))                       _ -> False         in (Logic.ifElse documented Nothing (Just (ErrorPackaging.InvalidModuleErrorMissingDocumentation (ErrorPackaging.MissingDocumentationError {           ErrorPackaging.missingDocumentationErrorModuleName = ns,@@ -158,7 +158,7 @@       let ns = Packaging.moduleName mod           prefix = Strings.concat2 (Packaging.unModuleName ns) "."           prefixLen = Strings.length prefix-      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+      in (Lists.foldl (\acc -> \def -> Optionals.match acc (         let name = definitionName def             nameStr = Core.unName name             namePrefix = Lists.take prefixLen (Strings.toList nameStr)@@ -171,7 +171,7 @@ checkDefinitionNameConvention mod =        let ns = Packaging.moduleName mod-      in (Lists.foldl (\acc -> \def -> Optionals.cases acc (+      in (Lists.foldl (\acc -> \def -> Optionals.match acc (         let name = definitionName def             local = Names.localNameOf name             expected =@@ -200,10 +200,10 @@                   Lists.foldl (\acc -> \def ->                     let prev = Pairs.first acc                         err = Pairs.second acc-                    in (Optionals.cases err (+                    in (Optionals.match err (                       let currName = definitionName def                           currLocal = Names.localNameOf currName-                      in (Optionals.cases prev (Just currName, Nothing) (\prevName ->+                      in (Optionals.match prev (Just currName, Nothing) (\prevName ->                         let prevLocal = Names.localNameOf prevName                         in (Logic.ifElse (Ordering.lt prevLocal currLocal) (Just currName, Nothing) (                           Just currName,@@ -222,7 +222,7 @@                   Lists.foldl (\acc -> \def ->                     let seen = Pairs.first acc                         err = Pairs.second acc-                    in (Optionals.cases err (+                    in (Optionals.match err (                       let name = definitionName def                       in (Logic.ifElse (Sets.member name seen) (                         seen,@@ -239,7 +239,7 @@               Lists.foldl (\acc -> \mod ->                 let seen = Pairs.first acc                     err = Pairs.second acc-                in (Optionals.cases err (+                in (Optionals.match err (                   let ns = Packaging.moduleName mod                   in (Logic.ifElse (Sets.member ns seen) (                     seen,
src/main/haskell/Hydra/Validation.hs view
@@ -6,7 +6,7 @@  import qualified Hydra.Core as Core import qualified Hydra.Error.Core as ErrorCore-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/Variables.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 import qualified Data.Set as S@@ -62,14 +62,14 @@                         dflt = allOf (Lists.map recurse (Rewriting.subterms term))                     in case term of                       Core.TermLambda v0 ->-                        let domt = Optionals.cases (Core.lambdaDomain v0) Sets.empty (tryType vars)+                        let domt = Optionals.match (Core.lambdaDomain v0) Sets.empty (tryType vars)                         in (Sets.union domt (recurse (Core.lambdaBody v0)))                       Core.TermLet v0 ->                         let forBinding =                                 \b ->                                   let newVars =-                                          Optionals.cases (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))-                                  in (Sets.union (getAll newVars (Core.bindingTerm b)) (Optionals.cases (Core.bindingTypeScheme b) Sets.empty (\ts -> tryType newVars (Core.typeSchemeBody ts))))+                                          Optionals.match (Core.bindingTypeScheme b) vars (\ts -> Sets.union vars (Sets.fromList (Core.typeSchemeVariables ts)))+                                  in (Sets.union (getAll newVars (Core.bindingTerm b)) (Optionals.match (Core.bindingTypeScheme b) Sets.empty (\ts -> tryType newVars (Core.typeSchemeBody ts))))                         in (Sets.union (allOf (Lists.map forBinding (Core.letBindings v0))) (recurse (Core.letBody v0)))                       Core.TermTypeApplication v0 -> Sets.union (tryType vars (Core.typeApplicationTermType v0)) (recurse (Core.typeApplicationTermBody v0))                       Core.TermTypeLambda v0 -> Sets.union (tryType vars (Core.TypeVariable (Core.typeLambdaParameter v0))) (recurse (Core.typeLambdaBody v0))@@ -169,7 +169,7 @@                                     let bindings0 = Core.letBindings v0                                         body0 = Core.letBody v0                                         step =-                                                \acc -> \bs -> Optionals.cases (Lists.uncons bs) (Lists.reverse acc) (\uc ->+                                                \acc -> \bs -> Optionals.match (Lists.uncons bs) (Lists.reverse acc) (\uc ->                                                   let b = Pairs.first uc                                                       tl = Pairs.second uc                                                       noType =@@ -211,7 +211,7 @@                                                                                 Core.typeSchemeBody = (substType newSubst typ),                                                                                 Core.typeSchemeConstraints = newConstraints}))}                                                                 in (step (Lists.cons b1 acc) tl)-                                                  in (Optionals.cases (Core.bindingTypeScheme b) noType (\ts -> withType ts)))+                                                  in (Optionals.match (Core.bindingTypeScheme b) noType (\ts -> withType ts)))                                         bindings1 = step [] bindings0                                     in (Core.TermLet (Core.Let {                                       Core.letBindings = bindings1,@@ -280,7 +280,7 @@       let replace =               \recurse -> \term2 -> case term2 of                 Core.TermVariable v0 -> Core.TermVariable (Optionals.withDefault v0 (Maps.lookup v0 subst))-                Core.TermLambda v0 -> Optionals.cases (Maps.lookup (Core.lambdaParameter v0) subst) (recurse term2) (\_ -> term2)+                Core.TermLambda v0 -> Optionals.match (Maps.lookup (Core.lambdaParameter v0) subst) (recurse term2) (\_ -> term2)                 _ -> recurse term2       in (Rewriting.rewriteTerm replace term) @@ -314,6 +314,6 @@                                 let bname = Core.bindingName b                                 in (Logic.ifElse (Maps.member bname acc) acc (Maps.insert bname bname acc))) m (Core.letBindings v0)                       in (recurse m2 term)-                    Core.TermVariable v0 -> Core.TermVariable (Optionals.cases (Maps.lookup v0 m) v0 (\renamed -> renamed))+                    Core.TermVariable v0 -> Core.TermVariable (Optionals.match (Maps.lookup v0 m) v0 (\renamed -> renamed))                     _ -> recurse m term       in (Rewriting.rewriteTermWithContext f Maps.empty term0)
src/main/haskell/Hydra/Variants.hs view
@@ -5,7 +5,7 @@ module Hydra.Variants 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 identifier of a literal constructor
src/main/haskell/Hydra/Yaml/Model.hs view
@@ -9,7 +9,7 @@ module Hydra.Yaml.Model 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.Map as M